// Before:
// import OpenAI from 'openai';
// const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });

// After:
import OpenAI from "@iskasec/openai";
const openai = new OpenAI({
  apiKey: process.env.OPENAI_API_KEY,
  iskaApiKey: process.env.ISKA_API_KEY,
});

// Use exactly as before - no other code changes needed!
const completion = await openai.chat.completions.create({
  model: "gpt-4",
  messages: [{ role: "user", content: "Hello world!" }],
});

import { IskaOpenAI } from "@iskasec/openai";

const openai = new IskaOpenAI({
  // OpenAI configuration
  apiKey: process.env.OPENAI_API_KEY,
  organization: "org-...",
  baseURL: "https://api.openai.com/v1",

  // Iska configuration
  iskaApiKey: process.env.ISKA_API_KEY, // Required
  iskaEndpoint: "https://custom.iska.ai", // Optional
  verbose: true, // Optional: Enable debug logs
  disableLogging: false, // Optional: Disable Iska logging

  // PII Detection configuration (only checks prompts, not responses)
  piiMode: "flag", // Optional: "off" | "flag" | "block" | "redact" (default: "off")
  piiRedactionChar: "*", // Optional: Character for redaction (default: "*")
  piiBlockMessage: "Request blocked due to PII", // Optional: Custom block message
});

const completion = await openai.chat.completions.create({
  model: "gpt-4",
  messages: [
    { role: "system", content: "You are a helpful assistant." },
    { role: "user", content: "What is the capital of France?" },
  ],
  temperature: 0.7,
  max_tokens: 100,
});

console.log(completion.choices[0].message.content);
// Automatically logged to Iska with token usage, latency, and metadata

const stream = await openai.chat.completions.create({
  model: "gpt-4",
  messages: [{ role: "user", content: "Write a poem about AI" }],
  stream: true,
});

for await (const chunk of stream) {
  process.stdout.write(chunk.choices[0]?.delta?.content || "");
}
// Full streaming response automatically logged to Iska

const response = await openai.chat.completions.create({
  model: "gpt-4",
  messages: [{ role: "user", content: "What's the weather in Boston?" }],
  tools: [
    {
      type: "function",
      function: {
        name: "get_weather",
        description: "Get the weather in a location",
        parameters: {
          type: "object",
          properties: {
            location: { type: "string" },
          },
          required: ["location"],
        },
      },
    },
  ],
});
// Function calls are logged with full tool interaction details

// Ensure all logs are flushed before exit
await openai.shutdown();

// Check if Iska logging is operational
const isHealthy = await openai.healthCheck();
console.log(`Iska logging status: ${isHealthy ? "healthy" : "unhealthy"}`);

// Configure PII detection
const openai = new IskaOpenAI({
  apiKey: process.env.OPENAI_API_KEY,
  iskaApiKey: process.env.ISKA_API_KEY,
  piiMode: "flag", // Detect and log PII but don't block
});

// Example with different PII modes:

// 1. Flag mode - Detects and logs PII but allows the request
const flagMode = new IskaOpenAI({
  iskaApiKey: process.env.ISKA_API_KEY,
  piiMode: "flag",
});

// 2. Block mode - Blocks requests containing PII
const blockMode = new IskaOpenAI({
  iskaApiKey: process.env.ISKA_API_KEY,
  piiMode: "block",
  piiBlockMessage: "Request contains sensitive data",
});

// 3. Redact mode - Automatically redacts PII before sending to OpenAI
const redactMode = new IskaOpenAI({
  iskaApiKey: process.env.ISKA_API_KEY,
  piiMode: "redact",
  piiRedactionChar: "X",
});

// Example usage with PII
try {
  const response = await blockMode.chat.completions.create({
    model: "gpt-4",
    messages: [
      {
        role: "user",
        content: "My SSN is 123-45-6789 and email is john@example.com",
      },
    ],
  });
} catch (error) {
  if (error.name === "PiiBlockedError") {
    console.log("Request blocked due to PII:", error.entities);
  }
}

import { IskaOpenAI } from "@iskasec/openai";
import type {
  ChatCompletion,
  ChatCompletionMessage,
  ChatCompletionCreateParams,
} from "@iskasec/openai";

const openai = new IskaOpenAI({
  apiKey: process.env.OPENAI_API_KEY!,
  iskaApiKey: process.env.ISKA_API_KEY!,
});

const params: ChatCompletionCreateParams = {
  model: "gpt-4",
  messages: [{ role: "user", content: "Hello!" }],
};

const completion: ChatCompletion = await openai.chat.completions.create(params);

const openai = new IskaOpenAI({
  apiKey: process.env.OPENAI_API_KEY,
  iskaApiKey: "invalid-key", // Even with invalid Iska key
  verbose: true,
});

// OpenAI call still works!
const completion = await openai.chat.completions.create({
  model: "gpt-4",
  messages: [{ role: "user", content: "Hello!" }],
});
// Logs: "[Iska-OpenAI] Failed to log completion: ..."
// But completion is still returned successfully