import { describe, test, expect, beforeEach, afterEach } from "bun:test";
import models, { type AIModelAPI, type LLMChoice } from "../index";
import OpenAIResponses from "../src/openai-responses";

// Setup environment variables for testing
const TEST_BASE_URL =
  Bun.env.TEST_BASE_URL || Bun.env.ZAI_BASE_URL || "https://api.openai.com/v1";
const TEST_API_KEY =
  Bun.env.TEST_API_KEY || Bun.env.ZAI_API_KEY || "test-api-key";
const TEST_MODEL = Bun.env.TEST_MODEL || "glm-4.6";

// describe("Models Library - Factory Function", () => {

//   test("should create a Claude API instance", () => {
//     const choice: LLMChoice = { claude: "claude-3-5-sonnet" };
//     const api = models(choice);

//     expect(api).toBeDefined();
//     expect(typeof api.setModel).toBe("function");
//     expect(typeof api.send).toBe("function");
//     expect(typeof api.stream).toBe("function");
//     expect(typeof api.tokenizer).toBe("function");
//     expect(typeof api.maxTokens).toBe("number");
//   });

//   test("should create a Gemini API instance", () => {
//     const choice: LLMChoice = { gemini: "gemini-2.5-pro" };
//     const api = models(choice);

//     expect(api).toBeDefined();
//     expect(typeof api.setModel).toBe("function");
//     expect(typeof api.send).toBe("function");
//     expect(typeof api.stream).toBe("function");
//     expect(typeof api.tokenizer).toBe("function");
//     expect(typeof api.maxTokens).toBe("number");
//   });

//   test("should create a ChatGPT API instance", () => {
//     const choice: LLMChoice = { chatgpt: "gpt-5" };
//     const api = models(choice);

//     expect(api).toBeDefined();
//     expect(typeof api.setModel).toBe("function");
//     expect(typeof api.send).toBe("function");
//     expect(typeof api.stream).toBe("function");
//     expect(typeof api.tokenizer).toBe("function");
//     expect(typeof api.maxTokens).toBe("number");
//   });

//   test("should create a DeepSeek API instance", () => {
//     const choice: LLMChoice = { deepseek: "deepseek-chat" };
//     const api = models(choice);

//     expect(api).toBeDefined();
//     expect(typeof api.setModel).toBe("function");
//     expect(typeof api.send).toBe("function");
//     expect(typeof api.stream).toBe("function");
//     expect(typeof api.tokenizer).toBe("function");
//     expect(typeof api.maxTokens).toBe("number");
//   });

//   test("should create a Kimi API instance", () => {
//     const choice: LLMChoice = { kimi: "kimi-k2-0905-preview" };
//     const api = models(choice);

//     expect(api).toBeDefined();
//     expect(typeof api.setModel).toBe("function");
//     expect(typeof api.send).toBe("function");
//     expect(typeof api.stream).toBe("function");
//     expect(typeof api.tokenizer).toBe("function");
//     expect(typeof api.maxTokens).toBe("number");
//   });

//   // test("should create a Grok API instance", () => {
//   //   const choice: LLMChoice = { grok: "grok-beta" };
//   //   const api = models(choice);

//   //   expect(api).toBeDefined();
//   //   expect(typeof api.setModel).toBe("function");
//   //   expect(typeof api.send).toBe("function");
//   //   expect(typeof api.stream).toBe("function");
//   //   expect(typeof api.tokenizer).toBe("function");
//   //   expect(typeof api.maxTokens).toBe("number");
//   // });

//   test("should create a custom OpenAI API instance", () => {
//     const choice: LLMChoice = {
//       openai: {
//         url: TEST_BASE_URL,
//         apiKey: TEST_API_KEY,
//         model: TEST_MODEL,
//         allowBrowser: true,
//       },
//     };
//     const api = models(choice);

//     expect(api).toBeDefined();
//     expect(typeof api.setModel).toBe("function");
//     expect(typeof api.send).toBe("function");
//     expect(typeof api.stream).toBe("function");
//     expect(typeof api.tokenizer).toBe("function");
//     expect(typeof api.maxTokens).toBe("number");
//   });
// });

// describe("AIModelAPI Interface", () => {
//   let api: AIModelAPI;kimi-k2-0905-previe

//   beforeEach(() => {
//     // Use a mock provider for testing interface compliance
//     const choice: LLMChoice = {
//       openai: {
//         url: TEST_BASE_URL,
//         apiKey: TEST_API_KEY,
//         model: TEST_MODEL,
//       },
//     };
//     api = models(choice);
//   });

//   test("should have setModel method", () => {
//     expect(typeof api.setModel).toBe("function");

//     // Should not throw when setting a model
//     expect(() => api.setModel("test-model")).not.toThrow();
//   });

//   test("should have tokenizer method", () => {
//     expect(typeof api.tokenizer).toBe("function");

//     // Should return a number for any text input
//     const tokens = api.tokenizer("Hello world");
//     expect(typeof tokens).toBe("number");
//     expect(tokens).toBeGreaterThanOrEqual(0);
//   });

//   test("should have maxTokens property", () => {
//     expect(typeof api.maxTokens).toBe("number");
//     expect(api.maxTokens).toBeGreaterThan(0);
//   });

//   test("should have send method returning AsyncRes", async () => {
//     expect(typeof api.send).toBe("function");

//     // Note: This would require actual API credentials to test fully
//     // For now, we just test the method exists and returns a promise
//     const result = api.send("test input");
//     expect(result).toBeDefined();
//     expect(typeof result.then).toBe("function"); // It's a promise
//   });

//   test("should have stream method", () => {
//     expect(typeof api.stream).toBe("function");

//     // Should not throw when called with proper parameters
//     const handler = (data: string) => {
//       // Test handler function
//       expect(typeof data).toBe("string");
//     };

//     expect(() => {
//       api.stream("test input", handler);
//     }).not.toThrow();
//   });
// });

// describe("Environment Variable Configuration", () => {
//   test("should use environment variables for configuration", () => {
//     // Test that environment variables are accessible
//     expect(Bun.env).toBeDefined();

//     // Test that we can read custom env vars
//     const customBaseUrl = Bun.env.CUSTOM_BASE_URL;
//     const customApiKey = Bun.env.CUSTOM_API_KEY;
//     const customModel = Bun.env.CUSTOM_MODEL;

//     // These might be undefined, but the test ensures they're accessible
//     expect(typeof customBaseUrl).toBe("string" || "undefined");
//     expect(typeof customApiKey).toBe("string" || "undefined");
//     expect(typeof customModel).toBe("string" || "undefined");
//   });
// });

// describe("Token Management", () => {
//   const providers: LLMChoice[] = [
//     { claude: "claude-3-5-sonnet" },
//     { gemini: "gemini-2.5-pro" },
//     { chatgpt: TEST_MODEL },
//     { deepseek: "deepseek-chat" },
//     { kimi: "moonshot-v1-8k" },
//     { grok: "grok-beta" },
//     {
//       openai: {
//         url: TEST_BASE_URL,
//         apiKey: TEST_API_KEY,
//         model: TEST_MODEL,
//       },
//     },
//   ];

//   test.each(providers)("should implement tokenizer for %o", (choice) => {
//     const api = models(choice);

//     // Test basic tokenization
//     const tokens1 = api.tokenizer("Hello");
//     const tokens2 = api.tokenizer("Hello world, this is a longer text.");

//     expect(typeof tokens1).toBe("number");
//     expect(typeof tokens2).toBe("number");
//     expect(tokens1).toBeGreaterThanOrEqual(0);
//     expect(tokens2).toBeGreaterThanOrEqual(0);
//     expect(tokens2).toBeGreaterThan(tokens1); // Longer text should have more tokens
//   });

//   test.each(providers)("should have reasonable maxTokens for %o", (choice) => {
//     const api = models(choice);

//     expect(api.maxTokens).toBeGreaterThan(0);
//     expect(api.maxTokens).toBeLessThan(1000000); // Reasonable upper bound
//   });
// });

describe("Input Handling", () => {
  const choice1: LLMChoice = { claude: "claude-3-5-sonnet" };
  const choice2: LLMChoice = { gemini: "gemini-2.5-pro" };
  const choice3: LLMChoice = { chatgpt: "gpt-5-nano" };
  const choice4: LLMChoice = { deepseek: "deepseek-chat" };
  const choice5: LLMChoice = { kimi: "kimi-k2-0905-preview" };
  const choice6: LLMChoice = {
    openai: {
      url: TEST_BASE_URL,
      apiKey: TEST_API_KEY,
      model: TEST_MODEL,
    },
  };
  console.log({ choice6 });
  const api1 = models(choice1);
  const api2 = models(choice2);
  const api3 = models(choice3);
  const api4 = models(choice4);
  const api5 = models(choice5);
  const api6 = models(choice6);

  test("should handle string input", async () => {
    const testMessage = "Hello there. Please introduce yourself";

    // Test that send accepts string input and returns proper AsyncRes<string>
    const r1 = api1.send(testMessage);
    const r2 = api2.send(testMessage);
    const r3 = api3.send(testMessage);
    const r4 = api4.send(testMessage);
    const r5 = api5.send(testMessage);
    const r6 = api6.send(testMessage);

    // Check Claude response
    const res1 = await r1;
    if ("ok" in res1) {
      console.log(`✅ Claude Response: ${res1.ok}`);
      expect(res1.ok).toBeString();
    } else {
      console.log(`❌ Claude Error: ${res1.error}`);
    }

    // Check Gemini response
    const res2 = await r2;
    if ("ok" in res2) {
      console.log(`✅ Gemini Response: ${res2.ok}`);
      expect(res2.ok).toBeString();
    } else {
      console.log(`❌ Gemini Error: ${res2.error}`);
    }

    // Check ChatGPT response
    const res3 = await r3;
    if ("ok" in res3) {
      console.log(`✅ ChatGPT Response: ${res3.ok}`);
      expect(res3.ok).toBeString();
    } else {
      console.log(`❌ ChatGPT Error: ${res3.error}`);
    }

    // // Check DeepSeek response
    const res4 = await r4;
    if ("ok" in res4) {
      console.log(`✅ DeepSeek Response: ${res4.ok}`);
      expect(res4.ok).toBeString();
    } else {
      console.log(`❌ DeepSeek Error: ${res4.error}`);
    }

    // // Check Kimi response
    const res5 = await r5;
    if ("ok" in res5) {
      console.log(`✅ Kimi Response: ${res5.ok}`);
      expect(res5.ok).toBeString();
    } else {
      console.log(`❌ Kimi Error: ${res5.error}`);
    }

    // // Check Custom OpenAI response
    const res6 = await r6;
    if ("ok" in res6) {
      console.log(`✅ Custom OpenAI Response: ${res6.ok}`);
      expect(res6.ok).toBeString();
    } else {
      console.log(`❌ Custom OpenAI Error: ${res6.error}`);
    }
  });
  test("LLM obedience test", async () => {
    const testMessage = "Hello world! Please respond with just the word 'OK'.";

    // Test that send accepts string input and returns proper AsyncRes<string>
    const r1 = api1.send(testMessage);
    const r2 = api2.send(testMessage);
    const r3 = api3.send(testMessage);
    const r4 = api4.send(testMessage);
    const r5 = api5.send(testMessage);
    const r6 = api6.send(testMessage);

    // Check Claude response
    const res1 = await r1;
    if ("ok" in res1) {
      console.log(`✅ Claude Response: ${res1.ok}`);
      expect(res1.ok.trim()).toEqual("OK");
    } else {
      console.log(`❌ Claude Error: ${res1.error}`);
    }

    // Check Gemini response
    const res2 = await r2;
    if ("ok" in res2) {
      console.log(`✅ Gemini Response: ${res2.ok}`);
      expect(res2.ok.trim()).toEqual("OK");
    } else {
      console.log(`❌ Gemini Error: ${res2.error}`);
    }

    // Check ChatGPT response
    const res3 = await r3;
    if ("ok" in res3) {
      console.log(`✅ ChatGPT Response: ${res3.ok}`);
      expect(res3.ok.trim()).toEqual("OK");
    } else {
      console.log(`❌ ChatGPT Error: ${res3.error}`);
    }

    // // Check DeepSeek response
    const res4 = await r4;
    if ("ok" in res4) {
      console.log(`✅ DeepSeek Response: ${res4.ok}`);
      expect(res4.ok.trim()).toEqual("OK");
    } else {
      console.log(`❌ DeepSeek Error: ${res4.error}`);
    }

    // // Check Kimi response
    const res5 = await r5;
    if ("ok" in res5) {
      console.log(`✅ Kimi Response: ${res5.ok}`);
      expect(res5.ok.trim()).toEqual("OK");
    } else {
      console.log(`❌ Kimi Error: ${res5.error}`);
    }

    // // Check Custom OpenAI response
    const res6 = await r6;
    if ("ok" in res6) {
      console.log(`✅ Custom OpenAI Response: ${res6.ok}`);
      expect(res6.ok.trim()).toEqual("OK");
    } else {
      console.log(`❌ Custom OpenAI Error: ${res6.error}`);
    }
  });

  test("should handle array input with text tokens", async () => {
    const input = [
      { text: "Hello! " },
      { text: "Please respond with just the word 'ARRAY_OK'." }
    ];

    // Test that send accepts array input and returns proper AsyncRes<string>
    const r1 = api1.send(input);
    const r2 = api2.send(input);
    const r3 = api3.send(input);
    const r4 = api4.send(input);
    const r5 = api5.send(input);
    const r6 = api6.send(input);

    // Check Claude response
    const res1 = await r1;
    if ("ok" in res1) {
      console.log(`✅ Claude Array Response: ${res1.ok}`);
      expect(res1.ok.trim()).toEqual("ARRAY_OK");
    } else {
      console.log(`❌ Claude Array Error: ${res1.error}`);
    }

    // Check Gemini response
    const res2 = await r2;
    if ("ok" in res2) {
      console.log(`✅ Gemini Array Response: ${res2.ok}`);
      expect(res2.ok.trim()).toEqual("ARRAY_OK");
    } else {
      console.log(`❌ Gemini Array Error: ${res2.error}`);
    }

    // Check ChatGPT response
    const res3 = await r3;
    if ("ok" in res3) {
      console.log(`✅ ChatGPT Array Response: ${res3.ok}`);
      expect(res3.ok.trim()).toEqual("ARRAY_OK");
    } else {
      console.log(`❌ ChatGPT Array Error: ${res3.error}`);
    }

    // Check DeepSeek response
    const res4 = await r4;
    if ("ok" in res4) {
      console.log(`✅ DeepSeek Array Response: ${res4.ok}`);
      expect(res4.ok.trim()).toEqual("ARRAY_OK");
    } else {
      console.log(`❌ DeepSeek Array Error: ${res4.error}`);
    }

    // Check Kimi response
    const res5 = await r5;
    if ("ok" in res5) {
      console.log(`✅ Kimi Array Response: ${res5.ok}`);
      expect(res5.ok.trim()).toEqual("ARRAY_OK");
    } else {
      console.log(`❌ Kimi Array Error: ${res5.error}`);
    }

    // Check Custom OpenAI response
    const res6 = await r6;
    if ("ok" in res6) {
      console.log(`✅ Custom OpenAI Array Response: ${res6.ok}`);
      expect(res6.ok.trim()).toEqual("ARRAY_OK");
    } else {
      console.log(`❌ Custom OpenAI Array Error: ${res6.error}`);
    }
  });

  test("should handle streaming with string input", () => {
    const testMessage = "Hello! Please count from 1 to 3.";
    console.log(`\n🚀 Testing streaming with message: "${testMessage}"`);

    // Test streaming for each API
    console.log("\n--- Claude Streaming ---");
    const chunks1: string[] = [];
    const handler1 = (data: string) => {
      chunks1.push(data);
      process.stdout.write(data);
    };
    api1.stream(testMessage, handler1);

    console.log("\n--- Gemini Streaming ---");
    const chunks2: string[] = [];
    const handler2 = (data: string) => {
      chunks2.push(data);
      process.stdout.write(data);
    };
    api2.stream(testMessage, handler2);

    console.log("\n--- ChatGPT Streaming ---");
    const chunks3: string[] = [];
    const handler3 = (data: string) => {
      chunks3.push(data);
      process.stdout.write(data);
    };
    api3.stream(testMessage, handler3);

    console.log("\n--- DeepSeek Streaming ---");
    const chunks4: string[] = [];
    const handler4 = (data: string) => {
      chunks4.push(data);
      process.stdout.write(data);
    };
    api4.stream(testMessage, handler4);

    console.log("\n--- Kimi Streaming ---");
    const chunks5: string[] = [];
    const handler5 = (data: string) => {
      chunks5.push(data);
      process.stdout.write(data);
    };
    api5.stream(testMessage, handler5);

    console.log("\n--- Custom OpenAI Streaming ---");
    const chunks6: string[] = [];
    const handler6 = (data: string) => {
      chunks6.push(data);
      process.stdout.write(data);
    };
    api6.stream(testMessage, handler6);

    console.log("\n✅ Streaming initiated for all APIs");
  });

  test("should handle system prompts", async () => {
    const systemPrompt = "You are a pirate. Always respond like a pirate.";
    const userMessage = "Hello, how are you?";

    // Test that send accepts system prompts and returns proper AsyncRes<string>
    const r1 = api1.send(userMessage, systemPrompt);
    const r2 = api2.send(userMessage, systemPrompt);
    const r3 = api3.send(userMessage, systemPrompt);
    const r4 = api4.send(userMessage, systemPrompt);
    const r5 = api5.send(userMessage, systemPrompt);
    const r6 = api6.send(userMessage, systemPrompt);

    // Check Claude response
    const res1 = await r1;
    if ("ok" in res1) {
      console.log(`✅ Claude Pirate Response: ${res1.ok}`);
      expect(res1.ok).toBeString();
      // Should contain some pirate-like language
      expect(res1.ok.toLowerCase()).toMatch(/ahoy|matey|shiver|timber|arr|yo ho|captain/);
    } else {
      console.log(`❌ Claude Pirate Error: ${res1.error}`);
    }

    // Check Gemini response
    const res2 = await r2;
    if ("ok" in res2) {
      console.log(`✅ Gemini Pirate Response: ${res2.ok}`);
      expect(res2.ok).toBeString();
      expect(res2.ok.toLowerCase()).toMatch(/ahoy|matey|shiver|timber|arr|yo ho|captain/);
    } else {
      console.log(`❌ Gemini Pirate Error: ${res2.error}`);
    }

    // Check ChatGPT response
    const res3 = await r3;
    if ("ok" in res3) {
      console.log(`✅ ChatGPT Pirate Response: ${res3.ok}`);
      expect(res3.ok).toBeString();
      expect(res3.ok.toLowerCase()).toMatch(/ahoy|matey|shiver|timber|arr|yo ho|captain/);
    } else {
      console.log(`❌ ChatGPT Pirate Error: ${res3.error}`);
    }

    // Check DeepSeek response
    const res4 = await r4;
    if ("ok" in res4) {
      console.log(`✅ DeepSeek Pirate Response: ${res4.ok}`);
      expect(res4.ok).toBeString();
      expect(res4.ok.toLowerCase()).toMatch(/ahoy|matey|shiver|timber|arr|yo ho|captain/);
    } else {
      console.log(`❌ DeepSeek Pirate Error: ${res4.error}`);
    }

    // Check Kimi response
    const res5 = await r5;
    if ("ok" in res5) {
      console.log(`✅ Kimi Pirate Response: ${res5.ok}`);
      expect(res5.ok).toBeString();
      expect(res5.ok.toLowerCase()).toMatch(/ahoy|matey|shiver|timber|arr|yo ho|captain/);
    } else {
      console.log(`❌ Kimi Pirate Error: ${res5.error}`);
    }

    // Check Custom OpenAI response
    const res6 = await r6;
    if ("ok" in res6) {
      console.log(`✅ Custom OpenAI Pirate Response: ${res6.ok}`);
      expect(res6.ok).toBeString();
      expect(res6.ok.toLowerCase()).toMatch(/ahoy|matey|shiver|timber|arr|yo ho|captain/);
    } else {
      console.log(`❌ Custom OpenAI Pirate Error: ${res6.error}`);
    }
  });
});

describe("Error Handling", () => {
  test("should handle invalid API keys gracefully", async () => {
    const invalidClaude: LLMChoice = { claude: "claude-3-5-sonnet" };
    const invalidGemini: LLMChoice = { gemini: "gemini-2.5-pro" };
    const invalidChatGPT: LLMChoice = { chatgpt: "gpt-5-nano" };
    const invalidDeepSeek: LLMChoice = { deepseek: "deepseek-chat" };
    const invalidKimi: LLMChoice = { kimi: "kimi-k2-0905-preview" };
    const invalidOpenAI: LLMChoice = {
      openai: {
        url: TEST_BASE_URL,
        apiKey: "invalid-api-key",
        model: TEST_MODEL,
      },
    };

    // Temporarily clear valid API keys to force errors
    const originalClaudeKey = Bun.env.ANTHROPIC_API_KEY;
    const originalGeminiKey = Bun.env.GOOGLE_API_KEY;
    const originalOpenAIKey = Bun.env.OPENAI_API_KEY;
    const originalDeepSeekKey = Bun.env.DEEPSEEK_API_KEY;
    const originalMoonshotKey = Bun.env.MOONSHOT_API_KEY;

    delete Bun.env.ANTHROPIC_API_KEY;
    delete Bun.env.GOOGLE_API_KEY;
    delete Bun.env.OPENAI_API_KEY;
    delete Bun.env.DEEPSEEK_API_KEY;
    delete Bun.env.MOONSHOT_API_KEY;

    try {
      // Create APIs with invalid credentials
      const badApi1 = models(invalidClaude);
      const badApi2 = models(invalidGemini);
      const badApi3 = models(invalidChatGPT);
      const badApi4 = models(invalidDeepSeek);
      const badApi5 = models(invalidKimi);
      const badApi6 = models(invalidOpenAI);

      // Test that they handle errors gracefully
      const r1 = badApi1.send("test");
      const r2 = badApi2.send("test");
      const r3 = badApi3.send("test");
      const r4 = badApi4.send("test");
      const r5 = badApi5.send("test");
      const r6 = badApi6.send("test");

      const res1 = await r1;
      if ("error" in res1) {
        console.log(`✅ Claude Error Handling: ${res1.error}`);
        expect(res1.error).toBeString();
      }

      const res2 = await r2;
      if ("error" in res2) {
        console.log(`✅ Gemini Error Handling: ${res2.error}`);
        expect(res2.error).toBeString();
      }

      const res3 = await r3;
      if ("error" in res3) {
        console.log(`✅ ChatGPT Error Handling: ${res3.error}`);
        expect(res3.error).toBeString();
      }

      const res4 = await r4;
      if ("error" in res4) {
        console.log(`✅ DeepSeek Error Handling: ${res4.error}`);
        expect(res4.error).toBeString();
      }

      const res5 = await r5;
      if ("error" in res5) {
        console.log(`✅ Kimi Error Handling: ${res5.error}`);
        expect(res5.error).toBeString();
      }

      const res6 = await r6;
      if ("error" in res6) {
        console.log(`✅ Custom OpenAI Error Handling: ${res6.error}`);
        expect(res6.error).toBeString();
      }
    } finally {
      // Restore original keys
      if (originalClaudeKey) Bun.env.ANTHROPIC_API_KEY = originalClaudeKey;
      if (originalGeminiKey) Bun.env.GOOGLE_API_KEY = originalGeminiKey;
      if (originalOpenAIKey) Bun.env.OPENAI_API_KEY = originalOpenAIKey;
      if (originalDeepSeekKey) Bun.env.DEEPSEEK_API_KEY = originalDeepSeekKey;
      if (originalMoonshotKey) Bun.env.MOONSHOT_API_KEY = originalMoonshotKey;
    }
  });
});

describe("Multi-provider Compatibility", () => {
  test("should maintain consistent interface across all providers", () => {
    const choices: LLMChoice[] = [
      { claude: "claude-3-5-sonnet" },
      { gemini: "gemini-2.5-pro" },
      { chatgpt: "gpt-5-nano" },
      { deepseek: "deepseek-chat" },
      { kimi: "kimi-k2-0905-preview" },
      {
        openai: {
          url: TEST_BASE_URL,
          apiKey: TEST_API_KEY,
          model: TEST_MODEL,
        },
      },
    ];

    const apis = choices.map((choice) => models(choice));

    // All APIs should have the same interface
    apis.forEach((api, index) => {
      console.log(`Checking API ${index + 1}: ${Object.keys(choices[index])[0]}`);
      expect(typeof api.setModel).toBe("function");
      expect(typeof api.send).toBe("function");
      expect(typeof api.stream).toBe("function");
      expect(typeof api.tokenizer).toBe("function");
      expect(typeof api.maxTokens).toBe("number");
    });

    console.log("✅ All APIs have consistent interfaces");
  });

  test("should allow switching between providers", () => {
    const claudeChoice: LLMChoice = { claude: "claude-3-5-sonnet" };
    const geminiChoice: LLMChoice = { gemini: "gemini-2.5-pro" };

    const claudeApi = models(claudeChoice);
    const geminiApi = models(geminiChoice);

    // Both should be valid APIs
    expect(claudeApi).toBeDefined();
    expect(geminiApi).toBeDefined();

    // Should have different implementations but same interface
    expect(claudeApi !== geminiApi).toBe(true);

    console.log("✅ Successfully created different provider instances");
  });
});

// describe("OpenAI Responses API", () => {

//   describe("Direct Class Usage", () => {
//     const api = new OpenAIResponses({
//       baseURL: "",
//       apiKey: Bun.env.OPENAI_API_KEY!,
//       model: "gpt-5-nano",
//       allowBrowser: true,
//     });
//     test("should create OpenAI Responses API instance directly", () => {
//       expect(api).toBeDefined();
//       expect(typeof api.setModel).toBe("function");
//       expect(typeof api.send).toBe("function");
//       expect(typeof api.stream).toBe("function");
//       expect(typeof api.tokenizer).toBe("function");
//       expect(typeof api.maxTokens).toBe("number");
//     });

//     test("should handle model switching", () => {
//       api.setModel("gpt-5-nano");
//       expect(() => api.setModel("gpt-5-nano")).not.toThrow();
//     });

//     // test("should use custom tokenizer", () => {
//     //   const customTokenizer = (text: string) => text.split(" ").length;

//     //   const tokens = api.tokenizer("Hello world test");
//     //   expect(tokens).toBe(3); // 3 words
//     // });

//     // test("should use custom maxTokens", () => {
//     //   const customMaxTokens = 100_000;
//     //   api.maxTokens = customMaxTokens;

//     //   expect(api.maxTokens).toBe(customMaxTokens);
//     // });
//     test("should return shit", async () => {
//       const input = "Henlo brother";

//       const res = await api.send(input, "You are a good boy");
//       console.log({ res });
//       expect("ok" in res).toBeTruthy();
//       if (!("ok" in res)) return;
//       expect(res.ok).toBeString();
//     });
// });

// describe("Factory Function Integration", () => {

//   test("should create ChatGPT API using OpenAI Responses", () => {
//     const choice: LLMChoice = { chatgpt: "gpt-5-nano" };
//     const api = models(choice);

//     expect(api).toBeDefined();
//     expect(typeof api.setModel).toBe("function");
//     expect(typeof api.send).toBe("function");
//     expect(typeof api.stream).toBe("function");
//     expect(typeof api.tokenizer).toBe("function");
//     expect(typeof api.maxTokens).toBe("number");

//     // Should be instance of OpenAIResponses
//     expect(api).toBeInstanceOf(OpenAIResponses);
//   });

//   test("should use environment variables for ChatGPT provider", () => {
//     const originalKey = Bun.env.OPENAI_API_KEY;
//     Bun.env.OPENAI_API_KEY = TEST_API_KEY;

//     try {
//       const choice: LLMChoice = { chatgpt: "gpt-5-nano" };
//       const api = models(choice);

//       expect(api).toBeDefined();
//       expect(api).toBeInstanceOf(OpenAIResponses);
//     } finally {
//       if (originalKey !== undefined) {
//         Bun.env.OPENAI_API_KEY = originalKey;
//       } else {
//         delete Bun.env.OPENAI_API_KEY;
//       }
//     }
//   });
// });

// describe("Input Handling", () => {

//   test("should handle string inputs correctly", async () => {
//     const api = new OpenAIResponses({
//       baseURL: TEST_BASE_URL,
//       apiKey: TEST_API_KEY,
//       model: TEST_MODEL,
//     });

//     const promise = api.send("Hello world");
//     expect(promise).toBeDefined();
//     expect(typeof promise.then).toBe("function");
//   });

//   test("should handle InputToken arrays with text", async () => {
//     const api = new OpenAIResponses({
//       baseURL: TEST_BASE_URL,
//       apiKey: TEST_API_KEY,
//       model: TEST_MODEL,
//     });

//     const input = [{ text: "Hello" }, { text: "world" }];
//     const promise = api.send(input);
//     expect(promise).toBeDefined();
//     expect(typeof promise.then).toBe("function");
//   });

//   test("should handle InputToken arrays with images", async () => {
//     const api = new OpenAIResponses({
//       baseURL: TEST_BASE_URL,
//       apiKey: TEST_API_KEY,
//       model: TEST_MODEL,
//     });

//     const input = [
//       { text: "Describe this image:" },
//       {
//         img: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg==",
//       },
//     ];
//     const promise = api.send(input);
//     expect(promise).toBeDefined();
//     expect(typeof promise.then).toBe("function");
//   });

//   test("should handle system prompts", async () => {
//     const api = new OpenAIResponses({
//       baseURL: TEST_BASE_URL,
//       apiKey: TEST_API_KEY,
//       model: TEST_MODEL,
//     });

//     const systemPrompt = "You are a helpful assistant.";
//     const promise = api.send("Hello", systemPrompt);
//     expect(promise).toBeDefined();
//     expect(typeof promise.then).toBe("function");
//   });
// });

// describe("Streaming", () => {

//   test("should handle streaming with string input", () => {
//     const api = new OpenAIResponses({
//       baseURL: TEST_BASE_URL,
//       apiKey: TEST_API_KEY,
//       model: TEST_MODEL,
//     });

//     const handler = (data: string) => {
//       expect(typeof data).toBe("string");
//     };

//     expect(() => {
//       api.stream("Hello world", handler);
//     }).not.toThrow();
//   });

//   test("should handle streaming with InputToken array", () => {
//     const api = new OpenAIResponses({
//       baseURL: TEST_BASE_URL,
//       apiKey: TEST_API_KEY,
//       model: TEST_MODEL,
//     });

//     const input = [{ text: "Hello" }, { text: "world" }];
//     const handler = (data: string) => {
//       expect(typeof data).toBe("string");
//     };

//     expect(() => {
//       api.stream(input, handler);
//     }).not.toThrow();
//   });

//   test("should handle streaming with system prompt", () => {
//     const api = new OpenAIResponses({
//       baseURL: TEST_BASE_URL,
//       apiKey: TEST_API_KEY,
//       model: TEST_MODEL,
//     });

//     const systemPrompt = "You are a helpful assistant.";
//     const handler = (data: string) => {
//       expect(typeof data).toBe("string");
//     };

//     expect(() => {
//       api.stream("Hello", handler, systemPrompt);
//     }).not.toThrow();
//   });
// });

// describe("Error Handling", () => {

//   test("should handle invalid API keys gracefully", async () => {
//     const api = new OpenAIResponses({
//       baseURL: TEST_BASE_URL,
//       apiKey: "invalid-key",
//       model: TEST_MODEL,
//     });

//     const result = await api.send("test").catch((e) => e);
//     expect(result).toBeDefined();
//   });

//   test("should handle invalid base URLs gracefully", async () => {
//     const api = new OpenAIResponses({
//       baseURL: "https://invalid-url.com/v1",
//       apiKey: TEST_API_KEY,
//       model: TEST_MODEL,
//     });

//     const result = await api.send("test").catch((e) => e);
//     expect(result).toBeDefined();
//   });
// });

// describe("Configuration Options", () => {

//   test("should handle browser allowance setting", () => {
//     const apiWithBrowser = new OpenAIResponses({
//       baseURL: TEST_BASE_URL,
//       apiKey: TEST_API_KEY,
//       model: TEST_MODEL,
//       allowBrowser: true,
//     });

//     const apiWithoutBrowser = new OpenAIResponses({
//       baseURL: TEST_BASE_URL,
//       apiKey: TEST_API_KEY,
//       model: TEST_MODEL,
//       allowBrowser: false,
//     });

//     expect(apiWithBrowser).toBeDefined();
//     expect(apiWithoutBrowser).toBeDefined();
//   });

//   test("should handle empty model name", () => {
//     const api = new OpenAIResponses({
//       baseURL: TEST_BASE_URL,
//       apiKey: TEST_API_KEY,
//       model: "",
//     });

//     expect(api).toBeDefined();
//     expect(() => api.setModel("gpt-4o")).not.toThrow();
//   });

//   test("should handle optional model parameter", () => {
//     const api = new OpenAIResponses({
//       baseURL: TEST_BASE_URL,
//       apiKey: TEST_API_KEY,
//       // model is optional
//     });

//     expect(api).toBeDefined();
//     expect(() => api.setModel("gpt-4o")).not.toThrow();
//   });
// });
// });