# Create a virtual environment
python -m venv venv
source venv/bin/activate  # On Windows use: venv\Scripts\activate

# Install necessary libraries
pip install openai python-dotenv pydantic requests

# Initialize project
npm init -y

# Install dependencies
npm install openai dotenv zod axios

import os
from typing import List, Dict
from openai import OpenAI
from dotenv import load_dotenv
from pydantic import BaseModel, Field

# Load environment variables from .env file
load_dotenv()

# Initialize client
client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))

# Data structure for structured verification
class VerificationResult(BaseModel):
    is_accurate: bool = Field(description="True if the statement matches the provided facts")
    confidence_score: float = Field(description="Score between 0 and 1")
    corrections: List[str] = Field(description="List of specific errors found")

def generate_ai_response(user_query: str) -> str:
    """Generates the initial response."""
    response = client.chat.completions.create(
        model="gpt-4-turbo-preview",
        messages=[{"role": "user", "content": user_query}]
    )
    return response.choices[0].message.content

def verify_response(original_query: str, ai_response: str, factual_context: str) -> VerificationResult:
    """
    The 'Judge' pattern: Uses a separate prompt to verify 
    the response against trusted context.
    """
    prompt = f"""
    You are a legal compliance auditor. 
    Verify the 'AI Response' against the 'Factual Context' provided below.
    
    Factual Context: {factual_context}
    AI Response: {ai_response}
    
    If the AI response contains any information not present in or contradicting 
    the context, mark is_accurate as False.
    """
    
    # Using structured output (Beta feature) to ensure reliability
    completion = client.beta.chat.completions.parse(
        model="gpt-4o-2024-08-06",
        messages=[{"role": "system", "content": "You are a fact-checker."},
                  {"role": "user", "content": prompt}],
        response_format=VerificationResult,
    )
    
    return completion.choices[0].message.parsed

def safe_ai_pipeline(query: str, context: str):
    """The main execution pipeline with error handling."""
    try:
        print(f"[*] Generating response for: {query}")
        raw_answer = generate_ai_response(query)
        
        print("[*] Verifying against facts...")
        verification = verify_response(query, raw_answer, context)
        
        if verification.is_accurate and verification.confidence_score > 0.8:
            return {
                "status": "success",
                "content": raw_answer,
                "metadata": {"confidence": verification.confidence_score}
            }
        else:
            # Fallback: Do not show potentially false info to user
            return {
                "status": "error",
                "content": "I'm sorry, I cannot verify the accuracy of that information. Please consult a primary source.",
                "errors": verification.corrections
            }
            
    except Exception as e:
        print(f"[!] Critical System Error: {e}")
        return {"status": "error", "content": "System unavailable."}

# --- TEST EXECUTION ---
if __name__ == "__main__":
    # Mock context (In production, this comes from a Search API or Database)
    trusted_context = "The German court ruled on October 2024 that Google is liable for AI errors."
    user_question = "What did the German court rule about Google?"

    result = safe_ai_pipeline(user_question, trusted_context)
    print("\n--- FINAL OUTPUT ---")
    print(result)

import OpenAI from 'openai';
import 'dotenv/config';
import { z } from 'zod';

const openai = new OpenAI({
  apiKey: process.env.OPENAI_API_KEY,
});

// Define the schema for verification using Zod
const VerificationSchema = z.object({
  is_accurate: z.boolean(),
  confidence_score: z.number(),
  corrections: z.array(z.string()),
});

type VerificationResult = z.infer<typeof VerificationSchema>;

async function safeAIPipeline(query: string, context: string) {
  try {
    // 1. Generation Phase
    const completion = await openai.chat.completions.create({
      model: "gpt-4o",
      messages: [{ role: "user", content: query }],
    });

    const aiResponse = completion.choices[0].message.content || "";

    // 2. Verification Phase (The Guardrail)
    const verificationCompletion = await openai.chat.completions.create({
      model: "gpt-4o",
      messages: [
        { 
          role: "system", 
          content: `Verify if the response matches the context. Context: ${context}` 
        },
        { role: "user", content: aiResponse }
      ],
      // Using JSON mode for reliable parsing
      response_format: { type: "json_object" } 
    });

    const verification: VerificationResult = JSON.parse(
      verificationCompletion.choices[0].message.content || "{}"
    );

    // 3. Decision Logic
    if (verification.is_accurate && verification.confidence_score > 0.8) {
      return {
        status: "success",
        data: aiResponse
      };
    } else {
      return {
        status: "blocked",
        reason: "Potential misinformation detected",
        details: verification.corrections
      };
    }

  } catch (error) {
    console.error("Pipeline Error:", error);
    return { status: "error", message: "Internal processing error" };
  }
}

// --- TEST EXECUTION ---
const context = "Google is liable for AI statements in Germany as of late 2024.";
const query = "Is Google liable for AI in Germany?";

safeAIPipeline(query, context).then(console.log);

# OpenAI API Key
OPENAI_API_KEY=sk-proj-your-actual-key-here

# Environment Setting
NODE_ENV=production

# Threshold for confidence (0.0 to 1.0)
# Lowering this increases risk; raising it increases "I don't know" responses.
VERIFICATION_THRESHOLD=0.85