@oai2lmapi/opencode-provider 0.3.11 → 0.3.12

package/dist/index.js

@@ -2157,6 +2157,1031 @@ function wrapWithEnhancements(baseModel, modelId, override) {
   return baseModel;
 }
 
+// src/clients/geminiClient.ts
+var idCounter2 = 0;
+function generateId2() {
+  return `gemini_${Date.now()}_${++idCounter2}`;
+}
+function normalizeGeminiEndpoint(endpoint) {
+  let normalized = endpoint.replace(/\/+$/, "");
+  if (normalized.endsWith("/v1")) {
+    normalized = normalized.slice(0, -3);
+  }
+  return normalized;
+}
+function convertMessagesToGemini(messages) {
+  const contents = [];
+  let systemInstruction;
+  for (const message of messages) {
+    if (message.role === "system") {
+      systemInstruction = (systemInstruction || "") + message.content;
+    } else if (message.role === "user") {
+      const parts = [];
+      for (const part of message.content) {
+        if (part.type === "text") {
+          parts.push({ text: part.text });
+        } else if (part.type === "file") {
+          const filePart = part;
+          if (filePart.mediaType.startsWith("image/")) {
+            if (typeof filePart.data === "string") {
+              if (filePart.data.startsWith("data:")) {
+                const match = filePart.data.match(/^data:([^;]+);base64,(.+)$/);
+                if (match) {
+                  parts.push({
+                    inlineData: {
+                      mimeType: match[1],
+                      data: match[2]
+                    }
+                  });
+                }
+              } else if (filePart.data.startsWith("http")) {
+                parts.push({ text: `[Image URL: ${filePart.data}]` });
+              } else {
+                parts.push({
+                  inlineData: {
+                    mimeType: filePart.mediaType,
+                    data: filePart.data
+                  }
+                });
+              }
+            } else if (filePart.data instanceof URL) {
+              parts.push({ text: `[Image URL: ${filePart.data.toString()}]` });
+            } else if (filePart.data instanceof Uint8Array) {
+              const base64 = Buffer.from(filePart.data).toString("base64");
+              parts.push({
+                inlineData: {
+                  mimeType: filePart.mediaType,
+                  data: base64
+                }
+              });
+            }
+          }
+        }
+      }
+      if (parts.length > 0) {
+        contents.push({ role: "user", parts });
+      }
+    } else if (message.role === "assistant") {
+      const parts = [];
+      for (const part of message.content) {
+        if (part.type === "text") {
+          parts.push({ text: part.text });
+        } else if (part.type === "tool-call") {
+          const input = part.input;
+          parts.push({
+            functionCall: {
+              name: part.toolName,
+              args: input
+            }
+          });
+        }
+      }
+      if (parts.length > 0) {
+        contents.push({ role: "model", parts });
+      }
+    } else if (message.role === "tool") {
+      const parts = [];
+      for (const part of message.content) {
+        if (part.type === "tool-result") {
+          let response;
+          const output = part.output;
+          if (output.type === "text" || output.type === "error-text") {
+            response = { result: output.value };
+          } else if (output.type === "json" || output.type === "error-json") {
+            response = typeof output.value === "object" && output.value !== null ? output.value : { result: output.value };
+          } else if (output.type === "content") {
+            const text = output.value.map(
+              (c) => c.type === "text" ? c.text : "[media]"
+            ).join("\n");
+            response = { result: text };
+          } else {
+            response = { result: String(output) };
+          }
+          parts.push({
+            functionResponse: {
+              name: part.toolName,
+              response
+            }
+          });
+        }
+      }
+      if (parts.length > 0) {
+        contents.push({ role: "user", parts });
+      }
+    }
+  }
+  return { contents, systemInstruction };
+}
+function convertToolsToGemini(tools) {
+  if (!tools || tools.length === 0) {
+    return void 0;
+  }
+  return tools.map((tool) => ({
+    name: tool.name,
+    description: tool.description,
+    parameters: tool.inputSchema
+  }));
+}
+function mapFinishReason(geminiReason) {
+  switch (geminiReason) {
+    case "STOP":
+      return "stop";
+    case "MAX_TOKENS":
+      return "length";
+    case "SAFETY":
+    case "RECITATION":
+    case "OTHER":
+      return "content-filter";
+    case "FUNCTION_CALL":
+      return "tool-calls";
+    default:
+      return "stop";
+  }
+}
+var GeminiClient = class {
+  baseURL;
+  apiKey;
+  headers;
+  constructor(config) {
+    this.baseURL = normalizeGeminiEndpoint(config.baseURL);
+    this.apiKey = config.apiKey;
+    this.headers = config.headers || {};
+  }
+  /**
+   * Generate content (non-streaming)
+   */
+  async doGenerate(modelId, options) {
+    const { contents, systemInstruction } = convertMessagesToGemini(
+      options.prompt
+    );
+    const tools = convertToolsToGemini(
+      options.tools?.filter(
+        (t) => t.type === "function"
+      )
+    );
+    const modelPath = modelId.startsWith("models/") ? modelId : `models/${modelId}`;
+    const url = `${this.baseURL}/v1beta/${modelPath}:generateContent`;
+    const request = { contents };
+    if (systemInstruction) {
+      request.systemInstruction = { parts: [{ text: systemInstruction }] };
+    }
+    if (tools && tools.length > 0) {
+      request.tools = [{ functionDeclarations: tools }];
+      request.toolConfig = {
+        functionCallingConfig: {
+          mode: options.toolChoice?.type === "required" ? "ANY" : options.toolChoice?.type === "none" ? "NONE" : "AUTO"
+        }
+      };
+    }
+    const generationConfig = {};
+    if (options.maxOutputTokens) {
+      generationConfig.maxOutputTokens = options.maxOutputTokens;
+    }
+    if (options.temperature !== void 0) {
+      generationConfig.temperature = options.temperature;
+    }
+    if (options.topP !== void 0) {
+      generationConfig.topP = options.topP;
+    }
+    if (options.topK !== void 0) {
+      generationConfig.topK = options.topK;
+    }
+    if (options.stopSequences && options.stopSequences.length > 0) {
+      generationConfig.stopSequences = options.stopSequences;
+    }
+    if (Object.keys(generationConfig).length > 0) {
+      request.generationConfig = generationConfig;
+    }
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "X-Goog-Api-Key": this.apiKey,
+        ...this.headers
+      },
+      body: JSON.stringify(request),
+      signal: options.abortSignal
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(
+        `Gemini API error: ${response.status} ${response.statusText} - ${errorText}`
+      );
+    }
+    const data = await response.json();
+    const candidate = data.candidates?.[0];
+    const parts = candidate?.content?.parts || [];
+    const content = [];
+    for (const part of parts) {
+      if (part.thought && part.text) {
+        content.push({ type: "reasoning", text: part.text });
+      } else if (part.text) {
+        content.push({ type: "text", text: part.text });
+      } else if (part.functionCall) {
+        content.push({
+          type: "tool-call",
+          toolCallId: generateId2(),
+          toolName: part.functionCall.name,
+          input: JSON.stringify(part.functionCall.args)
+        });
+      }
+    }
+    return {
+      content,
+      finishReason: mapFinishReason(candidate?.finishReason),
+      usage: {
+        inputTokens: data.usageMetadata?.promptTokenCount,
+        outputTokens: data.usageMetadata?.candidatesTokenCount
+      }
+    };
+  }
+  /**
+   * Stream content generation
+   */
+  async doStream(modelId, options) {
+    const { contents, systemInstruction } = convertMessagesToGemini(
+      options.prompt
+    );
+    const tools = convertToolsToGemini(
+      options.tools?.filter(
+        (t) => t.type === "function"
+      )
+    );
+    const modelPath = modelId.startsWith("models/") ? modelId : `models/${modelId}`;
+    const url = `${this.baseURL}/v1beta/${modelPath}:streamGenerateContent?alt=sse`;
+    const request = { contents };
+    if (systemInstruction) {
+      request.systemInstruction = { parts: [{ text: systemInstruction }] };
+    }
+    if (tools && tools.length > 0) {
+      request.tools = [{ functionDeclarations: tools }];
+      request.toolConfig = {
+        functionCallingConfig: {
+          mode: options.toolChoice?.type === "required" ? "ANY" : options.toolChoice?.type === "none" ? "NONE" : "AUTO"
+        }
+      };
+    }
+    const generationConfig = {};
+    if (options.maxOutputTokens) {
+      generationConfig.maxOutputTokens = options.maxOutputTokens;
+    }
+    if (options.temperature !== void 0) {
+      generationConfig.temperature = options.temperature;
+    }
+    if (options.topP !== void 0) {
+      generationConfig.topP = options.topP;
+    }
+    if (options.topK !== void 0) {
+      generationConfig.topK = options.topK;
+    }
+    if (options.stopSequences && options.stopSequences.length > 0) {
+      generationConfig.stopSequences = options.stopSequences;
+    }
+    if (Object.keys(generationConfig).length > 0) {
+      request.generationConfig = generationConfig;
+    }
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "X-Goog-Api-Key": this.apiKey,
+        ...this.headers
+      },
+      body: JSON.stringify(request),
+      signal: options.abortSignal
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(
+        `Gemini API error: ${response.status} ${response.statusText} - ${errorText}`
+      );
+    }
+    if (!response.body) {
+      throw new Error("Response body is null");
+    }
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    const stream = new ReadableStream({
+      async start(controller) {
+        let buffer = "";
+        let textId;
+        let reasoningId;
+        let hasEmittedTextStart = false;
+        let hasEmittedReasoningStart = false;
+        const toolCalls = [];
+        let finishReason = "stop";
+        let usage = { inputTokens: void 0, outputTokens: void 0 };
+        try {
+          while (true) {
+            const { done, value } = await reader.read();
+            if (done) {
+              break;
+            }
+            buffer += decoder.decode(value, { stream: true });
+            const events = buffer.split(/\n\n/);
+            buffer = events.pop() || "";
+            for (const event of events) {
+              const lines = event.split("\n");
+              for (const line of lines) {
+                if (line.startsWith("data: ")) {
+                  const jsonStr = line.substring(6).trim();
+                  if (!jsonStr || jsonStr === "[DONE]") {
+                    continue;
+                  }
+                  try {
+                    const chunk = JSON.parse(jsonStr);
+                    const candidate = chunk.candidates?.[0];
+                    const parts = candidate?.content?.parts;
+                    if (chunk.usageMetadata) {
+                      usage = {
+                        inputTokens: chunk.usageMetadata.promptTokenCount,
+                        outputTokens: chunk.usageMetadata.candidatesTokenCount
+                      };
+                    }
+                    if (candidate?.finishReason) {
+                      finishReason = mapFinishReason(candidate.finishReason);
+                    }
+                    if (parts) {
+                      for (const part of parts) {
+                        if (part.thought && part.text) {
+                          if (!hasEmittedReasoningStart) {
+                            reasoningId = generateId2();
+                            controller.enqueue({
+                              type: "reasoning-start",
+                              id: reasoningId
+                            });
+                            hasEmittedReasoningStart = true;
+                          }
+                          controller.enqueue({
+                            type: "reasoning-delta",
+                            id: reasoningId,
+                            delta: part.text
+                          });
+                        } else if (part.text && !part.thought) {
+                          if (!hasEmittedTextStart) {
+                            textId = generateId2();
+                            controller.enqueue({
+                              type: "text-start",
+                              id: textId
+                            });
+                            hasEmittedTextStart = true;
+                          }
+                          controller.enqueue({
+                            type: "text-delta",
+                            id: textId,
+                            delta: part.text
+                          });
+                        } else if (part.functionCall) {
+                          const callId = generateId2();
+                          toolCalls.push({
+                            id: callId,
+                            name: part.functionCall.name,
+                            args: part.functionCall.args
+                          });
+                        }
+                      }
+                    }
+                  } catch {
+                  }
+                }
+              }
+            }
+          }
+          if (hasEmittedReasoningStart && reasoningId) {
+            controller.enqueue({ type: "reasoning-end", id: reasoningId });
+          }
+          if (hasEmittedTextStart && textId) {
+            controller.enqueue({ type: "text-end", id: textId });
+          }
+          if (toolCalls.length > 0) {
+            finishReason = "tool-calls";
+            for (const tc of toolCalls) {
+              const inputJson = JSON.stringify(tc.args);
+              controller.enqueue({
+                type: "tool-input-start",
+                id: tc.id,
+                toolName: tc.name
+              });
+              controller.enqueue({
+                type: "tool-input-delta",
+                id: tc.id,
+                delta: inputJson
+              });
+              controller.enqueue({
+                type: "tool-input-end",
+                id: tc.id
+              });
+              controller.enqueue({
+                type: "tool-call",
+                toolCallId: tc.id,
+                toolName: tc.name,
+                input: inputJson
+              });
+            }
+          }
+          controller.enqueue({
+            type: "finish",
+            finishReason,
+            usage: {
+              inputTokens: usage.inputTokens,
+              outputTokens: usage.outputTokens,
+              totalTokens: usage.inputTokens !== void 0 && usage.outputTokens !== void 0 ? usage.inputTokens + usage.outputTokens : void 0
+            }
+          });
+          controller.close();
+        } catch (error) {
+          controller.error(error);
+        }
+      }
+    });
+    return { stream };
+  }
+};
+
+// src/clients/claudeClient.ts
+var idCounter3 = 0;
+function generateId3() {
+  return `claude_${Date.now()}_${++idCounter3}`;
+}
+function normalizeClaudeEndpoint(endpoint) {
+  let normalized = endpoint.replace(/\/+$/, "");
+  if (normalized.endsWith("/v1")) {
+    normalized = normalized.slice(0, -3);
+  }
+  return normalized;
+}
+function convertMessagesToClaude(messages) {
+  const claudeMessages = [];
+  let systemContent;
+  for (const message of messages) {
+    if (message.role === "system") {
+      systemContent = (systemContent || "") + message.content;
+    } else if (message.role === "user") {
+      const content = [];
+      for (const part of message.content) {
+        if (part.type === "text") {
+          content.push({ type: "text", text: part.text });
+        } else if (part.type === "file") {
+          const filePart = part;
+          if (filePart.mediaType.startsWith("image/")) {
+            if (typeof filePart.data === "string") {
+              if (filePart.data.startsWith("data:")) {
+                const match = filePart.data.match(/^data:([^;]+);base64,(.+)$/);
+                if (match) {
+                  content.push({
+                    type: "image",
+                    source: {
+                      type: "base64",
+                      media_type: match[1],
+                      data: match[2]
+                    }
+                  });
+                }
+              } else {
+                content.push({
+                  type: "image",
+                  source: {
+                    type: "base64",
+                    media_type: filePart.mediaType,
+                    data: filePart.data
+                  }
+                });
+              }
+            } else if (filePart.data instanceof Uint8Array) {
+              const base64 = Buffer.from(filePart.data).toString("base64");
+              content.push({
+                type: "image",
+                source: {
+                  type: "base64",
+                  media_type: filePart.mediaType,
+                  data: base64
+                }
+              });
+            }
+          }
+        }
+      }
+      if (content.length > 0) {
+        claudeMessages.push({
+          role: "user",
+          content: content.length === 1 && content[0].type === "text" ? content[0].text : content
+        });
+      }
+    } else if (message.role === "assistant") {
+      const content = [];
+      for (const part of message.content) {
+        if (part.type === "text") {
+          content.push({ type: "text", text: part.text });
+        } else if (part.type === "reasoning") {
+          content.push({ type: "thinking", thinking: part.text });
+        } else if (part.type === "tool-call") {
+          const input = part.input;
+          content.push({
+            type: "tool_use",
+            id: part.toolCallId,
+            name: part.toolName,
+            input
+          });
+        }
+      }
+      if (content.length > 0) {
+        claudeMessages.push({ role: "assistant", content });
+      }
+    } else if (message.role === "tool") {
+      const content = [];
+      for (const part of message.content) {
+        if (part.type === "tool-result") {
+          let resultContent;
+          const output = part.output;
+          if (output.type === "text" || output.type === "error-text") {
+            resultContent = output.value;
+          } else if (output.type === "json" || output.type === "error-json") {
+            resultContent = JSON.stringify(output.value);
+          } else if (output.type === "content") {
+            resultContent = output.value.map(
+              (c) => c.type === "text" ? c.text : "[media]"
+            ).join("\n");
+          } else {
+            resultContent = String(output);
+          }
+          const isError = output.type === "error-text" || output.type === "error-json";
+          content.push({
+            type: "tool_result",
+            tool_use_id: part.toolCallId,
+            content: resultContent,
+            is_error: isError
+          });
+        }
+      }
+      if (content.length > 0) {
+        claudeMessages.push({ role: "user", content });
+      }
+    }
+  }
+  return { messages: claudeMessages, system: systemContent };
+}
+function convertToolsToClaude(tools) {
+  if (!tools || tools.length === 0) {
+    return void 0;
+  }
+  return tools.map((tool) => ({
+    name: tool.name,
+    description: tool.description,
+    input_schema: tool.inputSchema
+  }));
+}
+function mapFinishReason2(claudeReason) {
+  switch (claudeReason) {
+    case "end_turn":
+    case "stop_sequence":
+      return "stop";
+    case "max_tokens":
+      return "length";
+    case "tool_use":
+      return "tool-calls";
+    default:
+      return "stop";
+  }
+}
+var ClaudeClient = class {
+  baseURL;
+  apiKey;
+  headers;
+  constructor(config) {
+    this.baseURL = normalizeClaudeEndpoint(config.baseURL);
+    this.apiKey = config.apiKey;
+    this.headers = config.headers || {};
+  }
+  /**
+   * Generate content (non-streaming)
+   */
+  async doGenerate(modelId, options) {
+    const { messages, system } = convertMessagesToClaude(options.prompt);
+    const tools = convertToolsToClaude(
+      options.tools?.filter(
+        (t) => t.type === "function"
+      )
+    );
+    const url = `${this.baseURL}/v1/messages`;
+    const request = {
+      model: modelId,
+      messages,
+      max_tokens: options.maxOutputTokens || 8192,
+      stream: false
+    };
+    if (system) {
+      request.system = system;
+    }
+    if (tools && tools.length > 0) {
+      request.tools = tools;
+      if (options.toolChoice?.type === "required") {
+        request.tool_choice = { type: "any" };
+      } else if (options.toolChoice?.type === "none") {
+        delete request.tools;
+      } else if (options.toolChoice?.type === "tool") {
+        request.tool_choice = {
+          type: "tool",
+          name: options.toolChoice.toolName
+        };
+      } else {
+        request.tool_choice = { type: "auto" };
+      }
+    }
+    if (options.temperature !== void 0) {
+      request.temperature = options.temperature;
+    }
+    if (options.topP !== void 0) {
+      request.top_p = options.topP;
+    }
+    if (options.topK !== void 0) {
+      request.top_k = options.topK;
+    }
+    if (options.stopSequences && options.stopSequences.length > 0) {
+      request.stop_sequences = options.stopSequences;
+    }
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "x-api-key": this.apiKey,
+        "anthropic-version": "2023-06-01",
+        ...this.headers
+      },
+      body: JSON.stringify(request),
+      signal: options.abortSignal
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(
+        `Claude API error: ${response.status} ${response.statusText} - ${errorText}`
+      );
+    }
+    const data = await response.json();
+    const content = [];
+    for (const block of data.content) {
+      if (block.type === "text") {
+        content.push({ type: "text", text: block.text });
+      } else if (block.type === "thinking") {
+        content.push({ type: "reasoning", text: block.thinking });
+      } else if (block.type === "tool_use") {
+        content.push({
+          type: "tool-call",
+          toolCallId: block.id,
+          toolName: block.name,
+          input: JSON.stringify(block.input)
+        });
+      }
+    }
+    return {
+      content,
+      finishReason: mapFinishReason2(data.stop_reason),
+      usage: {
+        inputTokens: data.usage?.input_tokens,
+        outputTokens: data.usage?.output_tokens
+      }
+    };
+  }
+  /**
+   * Stream content generation
+   */
+  async doStream(modelId, options) {
+    const { messages, system } = convertMessagesToClaude(options.prompt);
+    const tools = convertToolsToClaude(
+      options.tools?.filter(
+        (t) => t.type === "function"
+      )
+    );
+    const url = `${this.baseURL}/v1/messages`;
+    const request = {
+      model: modelId,
+      messages,
+      max_tokens: options.maxOutputTokens || 8192,
+      stream: true
+    };
+    if (system) {
+      request.system = system;
+    }
+    if (tools && tools.length > 0) {
+      request.tools = tools;
+      if (options.toolChoice?.type === "required") {
+        request.tool_choice = { type: "any" };
+      } else if (options.toolChoice?.type === "none") {
+        delete request.tools;
+      } else if (options.toolChoice?.type === "tool") {
+        request.tool_choice = {
+          type: "tool",
+          name: options.toolChoice.toolName
+        };
+      } else {
+        request.tool_choice = { type: "auto" };
+      }
+    }
+    if (options.temperature !== void 0) {
+      request.temperature = options.temperature;
+    }
+    if (options.topP !== void 0) {
+      request.top_p = options.topP;
+    }
+    if (options.topK !== void 0) {
+      request.top_k = options.topK;
+    }
+    if (options.stopSequences && options.stopSequences.length > 0) {
+      request.stop_sequences = options.stopSequences;
+    }
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "x-api-key": this.apiKey,
+        "anthropic-version": "2023-06-01",
+        ...this.headers
+      },
+      body: JSON.stringify(request),
+      signal: options.abortSignal
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(
+        `Claude API error: ${response.status} ${response.statusText} - ${errorText}`
+      );
+    }
+    if (!response.body) {
+      throw new Error("Response body is null");
+    }
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    const stream = new ReadableStream({
+      async start(controller) {
+        let buffer = "";
+        let textId;
+        let reasoningId;
+        let hasEmittedTextStart = false;
+        let hasEmittedReasoningStart = false;
+        const toolCalls = /* @__PURE__ */ new Map();
+        let finishReason = "stop";
+        let usage = { inputTokens: void 0, outputTokens: void 0 };
+        try {
+          while (true) {
+            const { done, value } = await reader.read();
+            if (done) {
+              break;
+            }
+            buffer += decoder.decode(value, { stream: true });
+            const lines = buffer.split("\n");
+            buffer = lines.pop() || "";
+            for (const line of lines) {
+              if (line.startsWith("data: ")) {
+                const jsonStr = line.substring(6).trim();
+                if (!jsonStr || jsonStr === "[DONE]") {
+                  continue;
+                }
+                try {
+                  const event = JSON.parse(jsonStr);
+                  switch (event.type) {
+                    case "message_start":
+                      if (event.message?.usage) {
+                        usage.inputTokens = event.message.usage.input_tokens;
+                      }
+                      break;
+                    case "content_block_start":
+                      if (event.content_block) {
+                        if (event.content_block.type === "text") {
+                          if (!hasEmittedTextStart) {
+                            textId = generateId3();
+                            controller.enqueue({
+                              type: "text-start",
+                              id: textId
+                            });
+                            hasEmittedTextStart = true;
+                          }
+                        } else if (event.content_block.type === "thinking") {
+                          if (!hasEmittedReasoningStart) {
+                            reasoningId = generateId3();
+                            controller.enqueue({
+                              type: "reasoning-start",
+                              id: reasoningId
+                            });
+                            hasEmittedReasoningStart = true;
+                          }
+                        } else if (event.content_block.type === "tool_use") {
+                          const block = event.content_block;
+                          toolCalls.set(event.index, {
+                            id: block.id,
+                            name: block.name,
+                            inputJson: ""
+                          });
+                          controller.enqueue({
+                            type: "tool-input-start",
+                            id: block.id,
+                            toolName: block.name
+                          });
+                        }
+                      }
+                      break;
+                    case "content_block_delta":
+                      if (event.delta) {
+                        if (event.delta.type === "text_delta" && event.delta.text) {
+                          if (!hasEmittedTextStart) {
+                            textId = generateId3();
+                            controller.enqueue({
+                              type: "text-start",
+                              id: textId
+                            });
+                            hasEmittedTextStart = true;
+                          }
+                          controller.enqueue({
+                            type: "text-delta",
+                            id: textId,
+                            delta: event.delta.text
+                          });
+                        } else if (event.delta.type === "thinking_delta" && event.delta.thinking) {
+                          if (!hasEmittedReasoningStart) {
+                            reasoningId = generateId3();
+                            controller.enqueue({
+                              type: "reasoning-start",
+                              id: reasoningId
+                            });
+                            hasEmittedReasoningStart = true;
+                          }
+                          controller.enqueue({
+                            type: "reasoning-delta",
+                            id: reasoningId,
+                            delta: event.delta.thinking
+                          });
+                        } else if (event.delta.type === "input_json_delta" && event.delta.partial_json !== void 0) {
+                          const tc2 = toolCalls.get(event.index);
+                          if (tc2) {
+                            tc2.inputJson += event.delta.partial_json;
+                            controller.enqueue({
+                              type: "tool-input-delta",
+                              id: tc2.id,
+                              delta: event.delta.partial_json
+                            });
+                          }
+                        }
+                      }
+                      break;
+                    case "content_block_stop":
+                      const tc = toolCalls.get(event.index);
+                      if (tc) {
+                        controller.enqueue({
+                          type: "tool-input-end",
+                          id: tc.id
+                        });
+                        controller.enqueue({
+                          type: "tool-call",
+                          toolCallId: tc.id,
+                          toolName: tc.name,
+                          input: tc.inputJson
+                        });
+                      }
+                      break;
+                    case "message_delta":
+                      if (event.delta && "stop_reason" in event.delta) {
+                        finishReason = mapFinishReason2(
+                          event.delta.stop_reason
+                        );
+                      }
+                      if (event.usage) {
+                        usage.outputTokens = event.usage.output_tokens;
+                      }
+                      break;
+                    case "message_stop":
+                      break;
+                  }
+                } catch {
+                }
+              }
+            }
+          }
+          if (hasEmittedReasoningStart && reasoningId) {
+            controller.enqueue({ type: "reasoning-end", id: reasoningId });
+          }
+          if (hasEmittedTextStart && textId) {
+            controller.enqueue({ type: "text-end", id: textId });
+          }
+          controller.enqueue({
+            type: "finish",
+            finishReason,
+            usage: {
+              inputTokens: usage.inputTokens,
+              outputTokens: usage.outputTokens,
+              totalTokens: usage.inputTokens !== void 0 && usage.outputTokens !== void 0 ? usage.inputTokens + usage.outputTokens : void 0
+            }
+          });
+          controller.close();
+        } catch (error) {
+          controller.error(error);
+        }
+      }
+    });
+    return { stream };
+  }
+};
+
+// src/apiAdapters.ts
+var GeminiLanguageModel = class {
+  specificationVersion = "v2";
+  modelId;
+  provider = "gemini";
+  client;
+  _override;
+  constructor(modelId, config, override) {
+    this.modelId = modelId;
+    this.client = new GeminiClient(config);
+    this._override = override;
+  }
+  get supportsStructuredOutputs() {
+    return true;
+  }
+  get supportedUrls() {
+    return {};
+  }
+  get defaultObjectGenerationMode() {
+    return "json";
+  }
+  async doGenerate(options) {
+    const result = await this.client.doGenerate(this.modelId, options);
+    return {
+      content: result.content,
+      finishReason: result.finishReason,
+      usage: {
+        inputTokens: result.usage.inputTokens,
+        outputTokens: result.usage.outputTokens,
+        totalTokens: result.usage.inputTokens !== void 0 && result.usage.outputTokens !== void 0 ? result.usage.inputTokens + result.usage.outputTokens : void 0
+      },
+      rawCall: { rawPrompt: null, rawSettings: {} },
+      rawResponse: { headers: {} },
+      request: { body: JSON.stringify({}) },
+      response: {
+        id: `gemini_${Date.now()}`,
+        timestamp: /* @__PURE__ */ new Date(),
+        modelId: this.modelId
+      },
+      warnings: []
+    };
+  }
+  async doStream(options) {
+    return this.client.doStream(this.modelId, options);
+  }
+};
+var ClaudeLanguageModel = class {
+  specificationVersion = "v2";
+  modelId;
+  provider = "claude";
+  client;
+  _override;
+  constructor(modelId, config, override) {
+    this.modelId = modelId;
+    this.client = new ClaudeClient(config);
+    this._override = override;
+  }
+  get supportsStructuredOutputs() {
+    return true;
+  }
+  get supportedUrls() {
+    return {};
+  }
+  get defaultObjectGenerationMode() {
+    return "tool";
+  }
+  async doGenerate(options) {
+    const result = await this.client.doGenerate(this.modelId, options);
+    return {
+      content: result.content,
+      finishReason: result.finishReason,
+      usage: {
+        inputTokens: result.usage.inputTokens,
+        outputTokens: result.usage.outputTokens,
+        totalTokens: result.usage.inputTokens !== void 0 && result.usage.outputTokens !== void 0 ? result.usage.inputTokens + result.usage.outputTokens : void 0
+      },
+      rawCall: { rawPrompt: null, rawSettings: {} },
+      rawResponse: { headers: {} },
+      request: { body: JSON.stringify({}) },
+      response: {
+        id: `claude_${Date.now()}`,
+        timestamp: /* @__PURE__ */ new Date(),
+        modelId: this.modelId
+      },
+      warnings: []
+    };
+  }
+  async doStream(options) {
+    return this.client.doStream(this.modelId, options);
+  }
+};
+function createApiAdapter(apiType, modelId, config, override) {
+  switch (apiType) {
+    case "gemini":
+      return new GeminiLanguageModel(modelId, config, override);
+    case "claude":
+      return new ClaudeLanguageModel(modelId, config, override);
+    case "openai":
+    default:
+      return void 0;
+  }
+}
+
 // src/index.ts
 var modelCache = /* @__PURE__ */ new WeakMap();
 function mergeWithConfig(options, config) {
@@ -2203,8 +3228,19 @@ function createOai2lm(options = {}) {
   try {
     let getOverride2 = function(modelId) {
       return findModelOverride(modelId, mergedOptions.modelOverrides);
+    }, createModel2 = function(modelId) {
+      const override = getOverride2(modelId);
+      const apiType = override?.apiType;
+      if (apiType && apiType !== "openai") {
+        const adapter = createApiAdapter(apiType, modelId, apiConfig, override);
+        if (adapter) {
+          return wrapWithEnhancements(adapter, modelId, override);
+        }
+      }
+      const baseModel = baseProvider.languageModel(modelId);
+      return wrapWithEnhancements(baseModel, modelId, override);
     };
-    var getOverride = getOverride2;
+    var getOverride = getOverride2, createModel = createModel2;
     const config = options.useConfigFile !== false ? loadConfig() : void 0;
     const mergedOptions = mergeWithConfig(options, config);
     if (!mergedOptions.baseURL) {
@@ -2270,20 +3306,19 @@ function createOai2lm(options = {}) {
       }
       return cache;
     }
+    const apiConfig = {
+      baseURL,
+      apiKey: mergedOptions.apiKey || "",
+      headers: mergedOptions.headers
+    };
     const provider = function(modelId) {
-      const baseModel = baseProvider(modelId);
-      const override = getOverride2(modelId);
-      return wrapWithEnhancements(baseModel, modelId, override);
+      return createModel2(modelId);
     };
     provider.languageModel = (modelId) => {
-      const baseModel = baseProvider.languageModel(modelId);
-      const override = getOverride2(modelId);
-      return wrapWithEnhancements(baseModel, modelId, override);
+      return createModel2(modelId);
     };
     provider.chatModel = (modelId) => {
-      const baseModel = baseProvider.chatModel(modelId);
-      const override = getOverride2(modelId);
-      return wrapWithEnhancements(baseModel, modelId, override);
+      return createModel2(modelId);
     };
     provider.completionModel = (modelId) => baseProvider.completionModel(modelId);
     provider.textEmbeddingModel = (modelId) => baseProvider.textEmbeddingModel(modelId);
@@ -2308,7 +3343,10 @@ function createOai2lm(options = {}) {
 var createOpenAICompatible = createOai2lm;
 var index_default = createOai2lm;
 export {
+  ClaudeLanguageModel,
   EnhancedLanguageModel,
+  GeminiLanguageModel,
+  createApiAdapter,
   createOai2lm,
   createOpenAICompatible,
   index_default as default,