@yourgpt/llm-sdk 1.2.7 → 1.3.1

package/dist/index.js

@@ -539,2291 +539,302 @@ var DEFAULT_CAPABILITIES = {
   supportedImageTypes: []
 };
 
-// src/providers/openai/provider.ts
-var OPENAI_MODELS = {
-  // GPT-4o series
-  "gpt-4o": { vision: true, tools: true, jsonMode: true, maxTokens: 128e3 },
-  "gpt-4o-mini": {
-    vision: true,
-    tools: true,
-    jsonMode: true,
-    maxTokens: 128e3
-  },
-  "gpt-4o-2024-11-20": {
-    vision: true,
-    tools: true,
-    jsonMode: true,
-    maxTokens: 128e3
-  },
-  "gpt-4o-2024-08-06": {
-    vision: true,
-    tools: true,
-    jsonMode: true,
-    maxTokens: 128e3
-  },
-  // GPT-4 Turbo
-  "gpt-4-turbo": {
-    vision: true,
-    tools: true,
-    jsonMode: true,
-    maxTokens: 128e3
-  },
-  "gpt-4-turbo-preview": {
-    vision: false,
-    tools: true,
-    jsonMode: true,
-    maxTokens: 128e3
-  },
-  // GPT-4
-  "gpt-4": { vision: false, tools: true, jsonMode: false, maxTokens: 8192 },
-  "gpt-4-32k": {
-    vision: false,
-    tools: true,
-    jsonMode: false,
-    maxTokens: 32768
-  },
-  // GPT-3.5
-  "gpt-3.5-turbo": {
-    vision: false,
-    tools: true,
-    jsonMode: true,
-    maxTokens: 16385
-  },
-  // O1 series (reasoning)
-  o1: { vision: true, tools: false, jsonMode: false, maxTokens: 128e3 },
-  "o1-mini": { vision: true, tools: false, jsonMode: false, maxTokens: 128e3 },
-  "o1-preview": {
-    vision: true,
-    tools: false,
-    jsonMode: false,
-    maxTokens: 128e3
-  },
-  // O3 series
-  "o3-mini": { vision: true, tools: false, jsonMode: false, maxTokens: 128e3 }
-};
-function openai(modelId, options = {}) {
-  const apiKey = options.apiKey ?? process.env.OPENAI_API_KEY;
-  const baseURL = options.baseURL ?? "https://api.openai.com/v1";
-  let client = null;
-  async function getClient() {
-    if (!client) {
-      const { default: OpenAI } = await import('openai');
-      client = new OpenAI({
-        apiKey,
-        baseURL,
-        organization: options.organization,
-        defaultHeaders: options.headers
-      });
-    }
-    return client;
-  }
-  const modelConfig = OPENAI_MODELS[modelId] ?? OPENAI_MODELS["gpt-4o"];
-  return {
-    provider: "openai",
-    modelId,
-    capabilities: {
-      supportsVision: modelConfig.vision,
-      supportsTools: modelConfig.tools,
-      supportsStreaming: true,
-      supportsJsonMode: modelConfig.jsonMode,
-      supportsThinking: false,
-      supportsPDF: false,
-      maxTokens: modelConfig.maxTokens,
-      supportedImageTypes: modelConfig.vision ? ["image/png", "image/jpeg", "image/gif", "image/webp"] : []
-    },
-    async doGenerate(params) {
-      const client2 = await getClient();
-      const messages = formatMessagesForOpenAI(params.messages);
-      const response = await client2.chat.completions.create({
-        model: modelId,
-        messages,
-        tools: params.tools,
-        temperature: params.temperature,
-        max_tokens: params.maxTokens
-      });
-      const choice = response.choices[0];
-      const message = choice.message;
-      const toolCalls = (message.tool_calls ?? []).map(
-        (tc) => ({
-          id: tc.id,
-          name: tc.function.name,
-          args: JSON.parse(tc.function.arguments || "{}")
-        })
-      );
-      return {
-        text: message.content ?? "",
-        toolCalls,
-        finishReason: mapFinishReason(choice.finish_reason),
-        usage: {
-          promptTokens: response.usage?.prompt_tokens ?? 0,
-          completionTokens: response.usage?.completion_tokens ?? 0,
-          totalTokens: response.usage?.total_tokens ?? 0
-        },
-        rawResponse: response
-      };
-    },
-    async *doStream(params) {
-      const client2 = await getClient();
-      const messages = formatMessagesForOpenAI(params.messages);
-      const stream = await client2.chat.completions.create({
-        model: modelId,
-        messages,
-        tools: params.tools,
-        temperature: params.temperature,
-        max_tokens: params.maxTokens,
-        stream: true
-      });
-      let currentToolCall = null;
-      let totalPromptTokens = 0;
-      let totalCompletionTokens = 0;
-      for await (const chunk of stream) {
-        if (params.signal?.aborted) {
-          yield { type: "error", error: new Error("Aborted") };
-          return;
-        }
-        const choice = chunk.choices[0];
-        const delta = choice?.delta;
-        if (delta?.content) {
-          yield { type: "text-delta", text: delta.content };
-        }
-        if (delta?.tool_calls) {
-          for (const tc of delta.tool_calls) {
-            if (tc.id) {
-              if (currentToolCall) {
-                yield {
-                  type: "tool-call",
-                  toolCall: {
-                    id: currentToolCall.id,
-                    name: currentToolCall.name,
-                    args: JSON.parse(currentToolCall.arguments || "{}")
-                  }
-                };
-              }
-              currentToolCall = {
-                id: tc.id,
-                name: tc.function?.name ?? "",
-                arguments: tc.function?.arguments ?? ""
-              };
-            } else if (currentToolCall && tc.function?.arguments) {
-              currentToolCall.arguments += tc.function.arguments;
-            }
-          }
-        }
-        if (choice?.finish_reason) {
-          if (currentToolCall) {
-            yield {
-              type: "tool-call",
-              toolCall: {
-                id: currentToolCall.id,
-                name: currentToolCall.name,
-                args: JSON.parse(currentToolCall.arguments || "{}")
-              }
-            };
-            currentToolCall = null;
-          }
-          if (chunk.usage) {
-            totalPromptTokens = chunk.usage.prompt_tokens;
-            totalCompletionTokens = chunk.usage.completion_tokens;
-          }
-          yield {
-            type: "finish",
-            finishReason: mapFinishReason(choice.finish_reason),
-            usage: {
-              promptTokens: totalPromptTokens,
-              completionTokens: totalCompletionTokens,
-              totalTokens: totalPromptTokens + totalCompletionTokens
-            }
-          };
-        }
-      }
-    }
-  };
-}
-function mapFinishReason(reason) {
-  switch (reason) {
-    case "stop":
-      return "stop";
-    case "length":
-      return "length";
-    case "tool_calls":
-    case "function_call":
-      return "tool-calls";
-    case "content_filter":
-      return "content-filter";
-    default:
-      return "unknown";
-  }
-}
-function formatMessagesForOpenAI(messages) {
-  return messages.map((msg) => {
-    switch (msg.role) {
-      case "system":
-        return { role: "system", content: msg.content };
-      case "user":
-        if (typeof msg.content === "string") {
-          return { role: "user", content: msg.content };
-        }
-        return {
-          role: "user",
-          content: msg.content.map((part) => {
-            if (part.type === "text") {
-              return { type: "text", text: part.text };
-            }
-            if (part.type === "image") {
-              const imageData = typeof part.image === "string" ? part.image : Buffer.from(part.image).toString("base64");
-              const url = imageData.startsWith("data:") ? imageData : `data:${part.mimeType ?? "image/png"};base64,${imageData}`;
-              return { type: "image_url", image_url: { url, detail: "auto" } };
-            }
-            return { type: "text", text: "" };
-          })
-        };
-      case "assistant":
-        const assistantMsg = {
-          role: "assistant",
-          content: msg.content
-        };
-        if (msg.toolCalls && msg.toolCalls.length > 0) {
-          assistantMsg.tool_calls = msg.toolCalls.map((tc) => ({
-            id: tc.id,
-            type: "function",
-            function: {
-              name: tc.name,
-              arguments: JSON.stringify(tc.args)
-            }
-          }));
-        }
-        return assistantMsg;
-      case "tool":
-        return {
-          role: "tool",
-          tool_call_id: msg.toolCallId,
-          content: msg.content
-        };
-      default:
-        return msg;
-    }
-  });
-}
-
-// src/providers/anthropic/provider.ts
-var ANTHROPIC_MODELS = {
-  // Claude 4 series
-  "claude-sonnet-4-20250514": {
-    vision: true,
-    tools: true,
-    thinking: true,
-    pdf: true,
-    maxTokens: 2e5
-  },
-  "claude-opus-4-20250514": {
-    vision: true,
-    tools: true,
-    thinking: true,
-    pdf: true,
-    maxTokens: 2e5
-  },
-  // Claude 3.7 series
-  "claude-3-7-sonnet-20250219": {
-    vision: true,
-    tools: true,
-    thinking: true,
-    pdf: true,
-    maxTokens: 2e5
-  },
-  "claude-3-7-sonnet-latest": {
-    vision: true,
-    tools: true,
-    thinking: true,
-    pdf: true,
-    maxTokens: 2e5
-  },
-  // Claude 3.5 series
-  "claude-3-5-sonnet-20241022": {
-    vision: true,
-    tools: true,
-    thinking: false,
-    pdf: true,
-    maxTokens: 2e5
-  },
-  "claude-3-5-sonnet-latest": {
-    vision: true,
-    tools: true,
-    thinking: false,
-    pdf: true,
-    maxTokens: 2e5
-  },
-  "claude-3-5-haiku-20241022": {
-    vision: true,
-    tools: true,
-    thinking: false,
-    pdf: false,
-    maxTokens: 2e5
-  },
-  "claude-3-5-haiku-latest": {
-    vision: true,
-    tools: true,
-    thinking: false,
-    pdf: false,
-    maxTokens: 2e5
-  },
-  // Claude 3 series
-  "claude-3-opus-20240229": {
-    vision: true,
-    tools: true,
-    thinking: false,
-    pdf: false,
-    maxTokens: 2e5
-  },
-  "claude-3-sonnet-20240229": {
-    vision: true,
-    tools: true,
-    thinking: false,
-    pdf: false,
-    maxTokens: 2e5
-  },
-  "claude-3-haiku-20240307": {
-    vision: true,
-    tools: true,
-    thinking: false,
-    pdf: false,
-    maxTokens: 2e5
-  }
-};
-function anthropic(modelId, options = {}) {
-  const apiKey = options.apiKey ?? process.env.ANTHROPIC_API_KEY;
-  let client = null;
-  async function getClient() {
-    if (!client) {
-      const { default: Anthropic } = await import('@anthropic-ai/sdk');
-      client = new Anthropic({
-        apiKey,
-        baseURL: options.baseURL
-      });
-    }
-    return client;
-  }
-  const modelConfig = ANTHROPIC_MODELS[modelId] ?? ANTHROPIC_MODELS["claude-3-5-sonnet-latest"];
-  return {
-    provider: "anthropic",
-    modelId,
-    capabilities: {
-      supportsVision: modelConfig.vision,
-      supportsTools: modelConfig.tools,
-      supportsStreaming: true,
-      supportsJsonMode: false,
-      supportsThinking: modelConfig.thinking,
-      supportsPDF: modelConfig.pdf,
-      maxTokens: modelConfig.maxTokens,
-      supportedImageTypes: modelConfig.vision ? ["image/png", "image/jpeg", "image/gif", "image/webp"] : []
-    },
-    async doGenerate(params) {
-      const client2 = await getClient();
-      const { system, messages } = formatMessagesForAnthropic(params.messages);
-      const requestOptions = {
-        model: modelId,
-        max_tokens: params.maxTokens ?? 4096,
-        system: system || void 0,
-        messages,
-        tools: params.tools
-      };
-      if (params.temperature !== void 0) {
-        requestOptions.temperature = params.temperature;
-      }
-      if (options.thinking?.enabled && modelConfig.thinking) {
-        requestOptions.thinking = {
-          type: "enabled",
-          budget_tokens: options.thinking.budgetTokens ?? 1e4
-        };
-      }
-      const response = await client2.messages.create(requestOptions);
-      let text = "";
-      const toolCalls = [];
-      for (const block of response.content) {
-        if (block.type === "text") {
-          text += block.text;
-        } else if (block.type === "tool_use") {
-          toolCalls.push({
-            id: block.id,
-            name: block.name,
-            args: block.input
-          });
-        }
-      }
-      return {
-        text,
-        toolCalls,
-        finishReason: mapFinishReason2(response.stop_reason),
-        usage: {
-          promptTokens: response.usage?.input_tokens ?? 0,
-          completionTokens: response.usage?.output_tokens ?? 0,
-          totalTokens: (response.usage?.input_tokens ?? 0) + (response.usage?.output_tokens ?? 0)
-        },
-        rawResponse: response
-      };
-    },
-    async *doStream(params) {
-      const client2 = await getClient();
-      const { system, messages } = formatMessagesForAnthropic(params.messages);
-      const requestOptions = {
-        model: modelId,
-        max_tokens: params.maxTokens ?? 4096,
-        system: system || void 0,
-        messages,
-        tools: params.tools
-      };
-      if (params.temperature !== void 0) {
-        requestOptions.temperature = params.temperature;
-      }
-      if (options.thinking?.enabled && modelConfig.thinking) {
-        requestOptions.thinking = {
-          type: "enabled",
-          budget_tokens: options.thinking.budgetTokens ?? 1e4
-        };
-      }
-      const stream = await client2.messages.stream(requestOptions);
-      let currentToolUse = null;
-      let inputTokens = 0;
-      let outputTokens = 0;
-      for await (const event of stream) {
-        if (params.signal?.aborted) {
-          yield { type: "error", error: new Error("Aborted") };
-          return;
-        }
-        switch (event.type) {
-          case "message_start":
-            if (event.message?.usage) {
-              inputTokens = event.message.usage.input_tokens ?? 0;
-            }
-            break;
-          case "content_block_start":
-            if (event.content_block?.type === "tool_use") {
-              currentToolUse = {
-                id: event.content_block.id,
-                name: event.content_block.name,
-                input: ""
-              };
-            }
-            break;
-          case "content_block_delta":
-            if (event.delta?.type === "text_delta") {
-              yield { type: "text-delta", text: event.delta.text };
-            } else if (event.delta?.type === "input_json_delta" && currentToolUse) {
-              currentToolUse.input += event.delta.partial_json;
-            }
-            break;
-          case "content_block_stop":
-            if (currentToolUse) {
-              yield {
-                type: "tool-call",
-                toolCall: {
-                  id: currentToolUse.id,
-                  name: currentToolUse.name,
-                  args: JSON.parse(currentToolUse.input || "{}")
-                }
-              };
-              currentToolUse = null;
-            }
-            break;
-          case "message_delta":
-            if (event.usage) {
-              outputTokens = event.usage.output_tokens ?? 0;
-            }
-            if (event.delta?.stop_reason) {
-              yield {
-                type: "finish",
-                finishReason: mapFinishReason2(event.delta.stop_reason),
-                usage: {
-                  promptTokens: inputTokens,
-                  completionTokens: outputTokens,
-                  totalTokens: inputTokens + outputTokens
-                }
-              };
-            }
-            break;
-        }
-      }
-    }
-  };
-}
-function mapFinishReason2(reason) {
-  switch (reason) {
-    case "end_turn":
-    case "stop_sequence":
-      return "stop";
-    case "max_tokens":
-      return "length";
-    case "tool_use":
-      return "tool-calls";
-    default:
-      return "unknown";
-  }
-}
-function formatMessagesForAnthropic(messages) {
-  let system = "";
-  const formatted = [];
-  const pendingToolResults = [];
-  for (const msg of messages) {
-    if (msg.role === "system") {
-      system += (system ? "\n" : "") + msg.content;
-      continue;
-    }
-    if (msg.role === "assistant" && pendingToolResults.length > 0) {
-      formatted.push({
-        role: "user",
-        content: pendingToolResults.map((tr) => ({
-          type: "tool_result",
-          tool_use_id: tr.toolCallId,
-          content: tr.content
-        }))
-      });
-      pendingToolResults.length = 0;
-    }
-    if (msg.role === "user") {
-      if (pendingToolResults.length > 0) {
-        formatted.push({
-          role: "user",
-          content: pendingToolResults.map((tr) => ({
-            type: "tool_result",
-            tool_use_id: tr.toolCallId,
-            content: tr.content
-          }))
-        });
-        pendingToolResults.length = 0;
-      }
-      if (typeof msg.content === "string") {
-        formatted.push({ role: "user", content: msg.content });
-      } else {
-        const content = [];
-        for (const part of msg.content) {
-          if (part.type === "text") {
-            content.push({ type: "text", text: part.text });
-          } else if (part.type === "image") {
-            const imageData = typeof part.image === "string" ? part.image : Buffer.from(part.image).toString("base64");
-            if (imageData.startsWith("http")) {
-              content.push({
-                type: "image",
-                source: { type: "url", url: imageData }
-              });
-            } else {
-              const base64 = imageData.startsWith("data:") ? imageData.split(",")[1] : imageData;
-              content.push({
-                type: "image",
-                source: {
-                  type: "base64",
-                  media_type: part.mimeType ?? "image/png",
-                  data: base64
-                }
-              });
-            }
-          }
-        }
-        formatted.push({ role: "user", content });
-      }
-    } else if (msg.role === "assistant") {
-      const content = [];
-      if (msg.content) {
-        content.push({ type: "text", text: msg.content });
-      }
-      if (msg.toolCalls && msg.toolCalls.length > 0) {
-        for (const tc of msg.toolCalls) {
-          content.push({
-            type: "tool_use",
-            id: tc.id,
-            name: tc.name,
-            input: tc.args
-          });
-        }
-      }
-      if (content.length > 0) {
-        formatted.push({ role: "assistant", content });
-      }
-    } else if (msg.role === "tool") {
-      pendingToolResults.push({
-        toolCallId: msg.toolCallId,
-        content: msg.content
-      });
-    }
-  }
-  if (pendingToolResults.length > 0) {
-    formatted.push({
-      role: "user",
-      content: pendingToolResults.map((tr) => ({
-        type: "tool_result",
-        tool_use_id: tr.toolCallId,
-        content: tr.content
-      }))
-    });
-  }
-  return { system, messages: formatted };
-}
-
-// src/providers/xai/provider.ts
-var XAI_MODELS = {
-  // Grok 4.1 Fast (Latest - December 2025)
-  "grok-4-1-fast-reasoning": { vision: false, tools: true, maxTokens: 2e6 },
-  "grok-4-1-fast-non-reasoning": {
-    vision: false,
-    tools: true,
-    maxTokens: 2e6
-  },
-  // Grok 4 Fast (September 2025)
-  "grok-4-fast-reasoning": { vision: false, tools: true, maxTokens: 2e6 },
-  "grok-4-fast-non-reasoning": {
-    vision: false,
-    tools: true,
-    maxTokens: 2e6
-  },
-  // Grok 4 (July 2025)
-  "grok-4": { vision: true, tools: true, maxTokens: 256e3 },
-  "grok-4-0709": { vision: true, tools: true, maxTokens: 256e3 },
-  // Grok 3 (February 2025) - Stable
-  "grok-3-beta": { vision: true, tools: true, maxTokens: 131072 },
-  "grok-3-fast-beta": { vision: false, tools: true, maxTokens: 131072 },
-  "grok-3-mini-beta": { vision: false, tools: true, maxTokens: 32768 },
-  "grok-3-mini-fast-beta": { vision: false, tools: true, maxTokens: 32768 },
-  // Grok Code Fast (August 2025)
-  "grok-code-fast-1": { vision: false, tools: true, maxTokens: 256e3 },
-  // Grok 2 (Legacy)
-  "grok-2": { vision: true, tools: true, maxTokens: 131072 },
-  "grok-2-latest": { vision: true, tools: true, maxTokens: 131072 },
-  "grok-2-mini": { vision: false, tools: true, maxTokens: 131072 }
-};
-function xai(modelId, options = {}) {
-  const apiKey = options.apiKey ?? process.env.XAI_API_KEY;
-  const baseURL = options.baseURL ?? "https://api.x.ai/v1";
-  let client = null;
-  async function getClient() {
-    if (!client) {
-      const { default: OpenAI } = await import('openai');
-      client = new OpenAI({
-        apiKey,
-        baseURL
-      });
-    }
-    return client;
-  }
-  const modelConfig = XAI_MODELS[modelId] ?? XAI_MODELS["grok-3-fast-beta"];
-  return {
-    provider: "xai",
-    modelId,
-    capabilities: {
-      supportsVision: modelConfig.vision,
-      supportsTools: modelConfig.tools,
-      supportsStreaming: true,
-      supportsJsonMode: false,
-      // xAI doesn't support JSON mode yet
-      supportsThinking: false,
-      supportsPDF: false,
-      maxTokens: modelConfig.maxTokens,
-      supportedImageTypes: modelConfig.vision ? ["image/png", "image/jpeg", "image/gif", "image/webp"] : []
-    },
-    async doGenerate(params) {
-      const client2 = await getClient();
-      const messages = formatMessagesForXAI(params.messages);
-      const response = await client2.chat.completions.create({
-        model: modelId,
-        messages,
-        tools: params.tools,
-        temperature: params.temperature,
-        max_tokens: params.maxTokens
-      });
-      const choice = response.choices[0];
-      const message = choice.message;
-      const toolCalls = (message.tool_calls ?? []).map(
-        (tc) => ({
-          id: tc.id,
-          name: tc.function.name,
-          args: JSON.parse(tc.function.arguments || "{}")
-        })
-      );
-      return {
-        text: message.content ?? "",
-        toolCalls,
-        finishReason: mapFinishReason3(choice.finish_reason),
-        usage: {
-          promptTokens: response.usage?.prompt_tokens ?? 0,
-          completionTokens: response.usage?.completion_tokens ?? 0,
-          totalTokens: response.usage?.total_tokens ?? 0
-        },
-        rawResponse: response
-      };
-    },
-    async *doStream(params) {
-      const client2 = await getClient();
-      const messages = formatMessagesForXAI(params.messages);
-      const stream = await client2.chat.completions.create({
-        model: modelId,
-        messages,
-        tools: params.tools,
-        temperature: params.temperature,
-        max_tokens: params.maxTokens,
-        stream: true
-      });
-      let currentToolCall = null;
-      let totalPromptTokens = 0;
-      let totalCompletionTokens = 0;
-      for await (const chunk of stream) {
-        if (params.signal?.aborted) {
-          yield { type: "error", error: new Error("Aborted") };
-          return;
-        }
-        const choice = chunk.choices[0];
-        const delta = choice?.delta;
-        if (delta?.content) {
-          yield { type: "text-delta", text: delta.content };
-        }
-        if (delta?.tool_calls) {
-          for (const tc of delta.tool_calls) {
-            if (tc.id) {
-              if (currentToolCall) {
-                yield {
-                  type: "tool-call",
-                  toolCall: {
-                    id: currentToolCall.id,
-                    name: currentToolCall.name,
-                    args: JSON.parse(currentToolCall.arguments || "{}")
-                  }
-                };
-              }
-              currentToolCall = {
-                id: tc.id,
-                name: tc.function?.name ?? "",
-                arguments: tc.function?.arguments ?? ""
-              };
-            } else if (currentToolCall && tc.function?.arguments) {
-              currentToolCall.arguments += tc.function.arguments;
-            }
-          }
-        }
-        if (choice?.finish_reason) {
-          if (currentToolCall) {
-            yield {
-              type: "tool-call",
-              toolCall: {
-                id: currentToolCall.id,
-                name: currentToolCall.name,
-                args: JSON.parse(currentToolCall.arguments || "{}")
-              }
-            };
-            currentToolCall = null;
-          }
-          if (chunk.usage) {
-            totalPromptTokens = chunk.usage.prompt_tokens;
-            totalCompletionTokens = chunk.usage.completion_tokens;
-          }
-          yield {
-            type: "finish",
-            finishReason: mapFinishReason3(choice.finish_reason),
-            usage: {
-              promptTokens: totalPromptTokens,
-              completionTokens: totalCompletionTokens,
-              totalTokens: totalPromptTokens + totalCompletionTokens
-            }
-          };
-        }
-      }
-    }
-  };
-}
-function mapFinishReason3(reason) {
-  switch (reason) {
-    case "stop":
-      return "stop";
-    case "length":
-      return "length";
-    case "tool_calls":
-    case "function_call":
-      return "tool-calls";
-    case "content_filter":
-      return "content-filter";
-    default:
-      return "unknown";
-  }
-}
-function formatMessagesForXAI(messages) {
-  return messages.map((msg) => {
-    switch (msg.role) {
-      case "system":
-        return { role: "system", content: msg.content };
-      case "user":
-        if (typeof msg.content === "string") {
-          return { role: "user", content: msg.content };
-        }
-        return {
-          role: "user",
-          content: msg.content.map((part) => {
-            if (part.type === "text") {
-              return { type: "text", text: part.text };
-            }
-            if (part.type === "image") {
-              const imageData = typeof part.image === "string" ? part.image : Buffer.from(part.image).toString("base64");
-              const url = imageData.startsWith("data:") ? imageData : `data:${part.mimeType ?? "image/png"};base64,${imageData}`;
-              return { type: "image_url", image_url: { url, detail: "auto" } };
-            }
-            return { type: "text", text: "" };
-          })
-        };
-      case "assistant":
-        const assistantMsg = {
-          role: "assistant",
-          content: msg.content
-        };
-        if (msg.toolCalls && msg.toolCalls.length > 0) {
-          assistantMsg.tool_calls = msg.toolCalls.map((tc) => ({
-            id: tc.id,
-            type: "function",
-            function: {
-              name: tc.name,
-              arguments: JSON.stringify(tc.args)
-            }
-          }));
-        }
-        return assistantMsg;
-      case "tool":
-        return {
-          role: "tool",
-          tool_call_id: msg.toolCallId,
-          content: msg.content
-        };
-      default:
-        return msg;
-    }
-  });
-}
-
-// src/providers/google/provider.ts
-var GOOGLE_MODELS = {
-  // Gemini 2.5 (Experimental)
-  "gemini-2.5-pro-preview-05-06": {
-    vision: true,
-    tools: true,
-    audio: true,
-    video: true,
-    maxTokens: 1048576
-  },
-  "gemini-2.5-flash-preview-05-20": {
-    vision: true,
-    tools: true,
-    audio: true,
-    video: true,
-    maxTokens: 1048576
-  },
-  // Gemini 2.0
-  "gemini-2.0-flash": {
-    vision: true,
-    tools: true,
-    audio: true,
-    video: true,
-    maxTokens: 1048576
-  },
-  "gemini-2.0-flash-exp": {
-    vision: true,
-    tools: true,
-    audio: true,
-    video: true,
-    maxTokens: 1048576
-  },
-  "gemini-2.0-flash-lite": {
-    vision: true,
-    tools: true,
-    audio: false,
-    video: false,
-    maxTokens: 1048576
-  },
-  "gemini-2.0-flash-thinking-exp": {
-    vision: true,
-    tools: false,
-    audio: false,
-    video: false,
-    maxTokens: 32767
-  },
-  // Gemini 1.5
-  "gemini-1.5-pro": {
-    vision: true,
-    tools: true,
-    audio: true,
-    video: true,
-    maxTokens: 2097152
-  },
-  "gemini-1.5-pro-latest": {
-    vision: true,
-    tools: true,
-    audio: true,
-    video: true,
-    maxTokens: 2097152
-  },
-  "gemini-1.5-flash": {
-    vision: true,
-    tools: true,
-    audio: true,
-    video: true,
-    maxTokens: 1048576
-  },
-  "gemini-1.5-flash-latest": {
-    vision: true,
-    tools: true,
-    audio: true,
-    video: true,
-    maxTokens: 1048576
-  },
-  "gemini-1.5-flash-8b": {
-    vision: true,
-    tools: true,
-    audio: false,
-    video: false,
-    maxTokens: 1048576
-  }
-};
-function google(modelId, options = {}) {
-  const apiKey = options.apiKey ?? process.env.GOOGLE_API_KEY ?? process.env.GEMINI_API_KEY;
-  const baseURL = options.baseURL ?? "https://generativelanguage.googleapis.com/v1beta/openai/";
-  let client = null;
-  async function getClient() {
-    if (!client) {
-      const { default: OpenAI } = await import('openai');
-      client = new OpenAI({
-        apiKey,
-        baseURL
-      });
-    }
-    return client;
-  }
-  const modelConfig = GOOGLE_MODELS[modelId] ?? GOOGLE_MODELS["gemini-2.0-flash"];
-  return {
-    provider: "google",
-    modelId,
-    capabilities: {
-      supportsVision: modelConfig.vision,
-      supportsTools: modelConfig.tools,
-      supportsStreaming: true,
-      supportsJsonMode: true,
-      supportsThinking: modelId.includes("thinking"),
-      supportsPDF: true,
-      maxTokens: modelConfig.maxTokens,
-      supportedImageTypes: modelConfig.vision ? ["image/png", "image/jpeg", "image/gif", "image/webp"] : []
-    },
-    async doGenerate(params) {
-      const client2 = await getClient();
-      const messages = formatMessagesForGoogle(params.messages);
-      const response = await client2.chat.completions.create({
-        model: modelId,
-        messages,
-        tools: params.tools,
-        temperature: params.temperature,
-        max_tokens: params.maxTokens
-      });
-      const choice = response.choices[0];
-      const message = choice.message;
-      const toolCalls = (message.tool_calls ?? []).map(
-        (tc) => ({
-          id: tc.id,
-          name: tc.function.name,
-          args: JSON.parse(tc.function.arguments || "{}")
-        })
-      );
-      return {
-        text: message.content ?? "",
-        toolCalls,
-        finishReason: mapFinishReason4(choice.finish_reason),
-        usage: {
-          promptTokens: response.usage?.prompt_tokens ?? 0,
-          completionTokens: response.usage?.completion_tokens ?? 0,
-          totalTokens: response.usage?.total_tokens ?? 0
-        },
-        rawResponse: response
-      };
-    },
-    async *doStream(params) {
-      const client2 = await getClient();
-      const messages = formatMessagesForGoogle(params.messages);
-      const stream = await client2.chat.completions.create({
-        model: modelId,
-        messages,
-        tools: params.tools,
-        temperature: params.temperature,
-        max_tokens: params.maxTokens,
-        stream: true
-      });
-      let currentToolCall = null;
-      let totalPromptTokens = 0;
-      let totalCompletionTokens = 0;
-      for await (const chunk of stream) {
-        if (params.signal?.aborted) {
-          yield { type: "error", error: new Error("Aborted") };
-          return;
-        }
-        const choice = chunk.choices[0];
-        const delta = choice?.delta;
-        if (delta?.content) {
-          yield { type: "text-delta", text: delta.content };
-        }
-        if (delta?.tool_calls) {
-          for (const tc of delta.tool_calls) {
-            if (tc.id) {
-              if (currentToolCall) {
-                yield {
-                  type: "tool-call",
-                  toolCall: {
-                    id: currentToolCall.id,
-                    name: currentToolCall.name,
-                    args: JSON.parse(currentToolCall.arguments || "{}")
-                  }
-                };
-              }
-              currentToolCall = {
-                id: tc.id,
-                name: tc.function?.name ?? "",
-                arguments: tc.function?.arguments ?? ""
-              };
-            } else if (currentToolCall && tc.function?.arguments) {
-              currentToolCall.arguments += tc.function.arguments;
-            }
-          }
-        }
-        if (choice?.finish_reason) {
-          if (currentToolCall) {
-            yield {
-              type: "tool-call",
-              toolCall: {
-                id: currentToolCall.id,
-                name: currentToolCall.name,
-                args: JSON.parse(currentToolCall.arguments || "{}")
-              }
-            };
-            currentToolCall = null;
-          }
-          if (chunk.usage) {
-            totalPromptTokens = chunk.usage.prompt_tokens;
-            totalCompletionTokens = chunk.usage.completion_tokens;
-          }
-          yield {
-            type: "finish",
-            finishReason: mapFinishReason4(choice.finish_reason),
-            usage: {
-              promptTokens: totalPromptTokens,
-              completionTokens: totalCompletionTokens,
-              totalTokens: totalPromptTokens + totalCompletionTokens
-            }
-          };
-        }
-      }
-    }
-  };
-}
-function mapFinishReason4(reason) {
-  switch (reason) {
-    case "stop":
-      return "stop";
-    case "length":
-      return "length";
-    case "tool_calls":
-    case "function_call":
-      return "tool-calls";
-    case "content_filter":
-      return "content-filter";
-    default:
-      return "unknown";
-  }
-}
-function formatMessagesForGoogle(messages) {
-  return messages.map((msg) => {
-    switch (msg.role) {
-      case "system":
-        return { role: "system", content: msg.content };
-      case "user":
-        if (typeof msg.content === "string") {
-          return { role: "user", content: msg.content };
-        }
-        return {
-          role: "user",
-          content: msg.content.map((part) => {
-            if (part.type === "text") {
-              return { type: "text", text: part.text };
-            }
-            if (part.type === "image") {
-              const imageData = typeof part.image === "string" ? part.image : Buffer.from(part.image).toString("base64");
-              const url = imageData.startsWith("data:") ? imageData : `data:${part.mimeType ?? "image/png"};base64,${imageData}`;
-              return { type: "image_url", image_url: { url, detail: "auto" } };
-            }
-            return { type: "text", text: "" };
-          })
-        };
-      case "assistant":
-        const assistantMsg = {
-          role: "assistant",
-          content: msg.content
-        };
-        if (msg.toolCalls && msg.toolCalls.length > 0) {
-          assistantMsg.tool_calls = msg.toolCalls.map((tc) => ({
-            id: tc.id,
-            type: "function",
-            function: {
-              name: tc.name,
-              arguments: JSON.stringify(tc.args)
-            }
-          }));
-        }
-        return assistantMsg;
-      case "tool":
-        return {
-          role: "tool",
-          tool_call_id: msg.toolCallId,
-          content: msg.content
-        };
-      default:
-        return msg;
-    }
-  });
-}
-
-// src/adapters/base.ts
-function formatMessages(messages, systemPrompt) {
-  const formatted = [];
-  if (systemPrompt) {
-    formatted.push({ role: "system", content: systemPrompt });
-  }
-  for (const msg of messages) {
-    formatted.push({
-      role: msg.role,
-      content: msg.content ?? ""
-    });
-  }
-  return formatted;
-}
-function parameterToJsonSchema(param) {
-  const schema = {
-    type: param.type
-  };
-  if (param.description) {
-    schema.description = param.description;
-  }
-  if (param.enum) {
-    schema.enum = param.enum;
-  }
-  if (param.type === "array" && param.items) {
-    schema.items = parameterToJsonSchema(
-      param.items
-    );
-  }
-  if (param.type === "object" && param.properties) {
-    schema.properties = Object.fromEntries(
-      Object.entries(param.properties).map(([key, prop]) => [
-        key,
-        parameterToJsonSchema(
-          prop
-        )
-      ])
-    );
-  }
-  return schema;
-}
-function formatTools(actions) {
-  return actions.map((action) => ({
-    type: "function",
-    function: {
-      name: action.name,
-      description: action.description,
-      parameters: {
-        type: "object",
-        properties: action.parameters ? Object.fromEntries(
-          Object.entries(action.parameters).map(([key, param]) => [
-            key,
-            parameterToJsonSchema(param)
-          ])
-        ) : {},
-        required: action.parameters ? Object.entries(action.parameters).filter(([, param]) => param.required).map(([key]) => key) : []
-      }
-    }
-  }));
-}
-function hasImageAttachments(message) {
-  const attachments = message.metadata?.attachments;
-  return attachments?.some((a) => a.type === "image") ?? false;
-}
-function hasMediaAttachments(message) {
-  const attachments = message.metadata?.attachments;
-  return attachments?.some(
-    (a) => a.type === "image" || a.type === "file" && a.mimeType === "application/pdf"
-  ) ?? false;
-}
-function attachmentToAnthropicImage(attachment) {
-  if (attachment.type !== "image") return null;
-  if (attachment.url) {
-    return {
-      type: "image",
-      source: {
-        type: "url",
-        url: attachment.url
-      }
-    };
-  }
-  if (!attachment.data) return null;
-  let base64Data = attachment.data;
-  if (base64Data.startsWith("data:")) {
-    const commaIndex = base64Data.indexOf(",");
-    if (commaIndex !== -1) {
-      base64Data = base64Data.slice(commaIndex + 1);
-    }
-  }
-  return {
-    type: "image",
-    source: {
-      type: "base64",
-      media_type: attachment.mimeType || "image/png",
-      data: base64Data
-    }
-  };
-}
-function attachmentToOpenAIImage(attachment) {
-  if (attachment.type !== "image") return null;
-  let imageUrl;
-  if (attachment.url) {
-    imageUrl = attachment.url;
-  } else if (attachment.data) {
-    imageUrl = attachment.data.startsWith("data:") ? attachment.data : `data:${attachment.mimeType || "image/png"};base64,${attachment.data}`;
-  } else {
-    return null;
-  }
-  return {
-    type: "image_url",
-    image_url: {
-      url: imageUrl,
-      detail: "auto"
-    }
-  };
-}
-function attachmentToAnthropicDocument(attachment) {
-  if (attachment.type !== "file" || attachment.mimeType !== "application/pdf") {
-    return null;
-  }
-  if (attachment.url) {
-    return {
-      type: "document",
-      source: {
-        type: "url",
-        url: attachment.url
-      }
-    };
-  }
-  if (!attachment.data) return null;
-  let base64Data = attachment.data;
-  if (base64Data.startsWith("data:")) {
-    const commaIndex = base64Data.indexOf(",");
-    if (commaIndex !== -1) {
-      base64Data = base64Data.slice(commaIndex + 1);
-    }
-  }
-  return {
-    type: "document",
-    source: {
-      type: "base64",
-      media_type: "application/pdf",
-      data: base64Data
-    }
-  };
-}
-function messageToAnthropicContent(message) {
-  const attachments = message.metadata?.attachments;
-  const content = message.content ?? "";
-  if (!hasMediaAttachments(message)) {
-    return content;
-  }
-  const blocks = [];
-  if (attachments) {
-    for (const attachment of attachments) {
-      const imageBlock = attachmentToAnthropicImage(attachment);
-      if (imageBlock) {
-        blocks.push(imageBlock);
-        continue;
-      }
-      const docBlock = attachmentToAnthropicDocument(attachment);
-      if (docBlock) {
-        blocks.push(docBlock);
-      }
-    }
-  }
-  if (content) {
-    blocks.push({ type: "text", text: content });
-  }
-  return blocks;
-}
-function messageToOpenAIContent(message) {
-  const attachments = message.metadata?.attachments;
-  const content = message.content ?? "";
-  if (!hasImageAttachments(message)) {
-    return content;
-  }
-  const blocks = [];
-  if (content) {
-    blocks.push({ type: "text", text: content });
-  }
-  if (attachments) {
-    for (const attachment of attachments) {
-      const imageBlock = attachmentToOpenAIImage(attachment);
-      if (imageBlock) {
-        blocks.push(imageBlock);
-      }
-    }
-  }
-  return blocks;
-}
-function formatMessagesForAnthropic2(messages, systemPrompt) {
-  const formatted = [];
-  for (let i = 0; i < messages.length; i++) {
-    const msg = messages[i];
-    if (msg.role === "system") continue;
-    if (msg.role === "assistant") {
-      const content = [];
-      if (msg.content) {
-        content.push({ type: "text", text: msg.content });
-      }
-      if (msg.tool_calls && msg.tool_calls.length > 0) {
-        for (const tc of msg.tool_calls) {
-          content.push({
-            type: "tool_use",
-            id: tc.id,
-            name: tc.function.name,
-            input: JSON.parse(tc.function.arguments)
-          });
-        }
-      }
-      formatted.push({
-        role: "assistant",
-        content: content.length === 1 && content[0].type === "text" ? content[0].text : content
-      });
-    } else if (msg.role === "tool" && msg.tool_call_id) {
-      const toolResults = [
-        {
-          type: "tool_result",
-          tool_use_id: msg.tool_call_id,
-          content: msg.content ?? ""
-        }
-      ];
-      while (i + 1 < messages.length && messages[i + 1].role === "tool") {
-        i++;
-        const nextTool = messages[i];
-        if (nextTool.tool_call_id) {
-          toolResults.push({
-            type: "tool_result",
-            tool_use_id: nextTool.tool_call_id,
-            content: nextTool.content ?? ""
-          });
-        }
-      }
-      formatted.push({
-        role: "user",
-        content: toolResults
-      });
-    } else if (msg.role === "user") {
-      formatted.push({
-        role: "user",
-        content: messageToAnthropicContent(msg)
-      });
-    }
-  }
-  return {
-    system: "",
-    messages: formatted
-  };
-}
-function formatMessagesForOpenAI2(messages, systemPrompt) {
-  const formatted = [];
-  if (systemPrompt) {
-    formatted.push({ role: "system", content: systemPrompt });
-  }
-  for (const msg of messages) {
-    if (msg.role === "system") {
-      formatted.push({ role: "system", content: msg.content ?? "" });
-    } else if (msg.role === "user") {
-      formatted.push({
-        role: "user",
-        content: messageToOpenAIContent(msg)
-      });
-    } else if (msg.role === "assistant") {
-      const assistantMsg = {
-        role: "assistant",
-        content: msg.content
-      };
-      if (msg.tool_calls && msg.tool_calls.length > 0) {
-        assistantMsg.tool_calls = msg.tool_calls;
-      }
-      formatted.push(assistantMsg);
-    } else if (msg.role === "tool" && msg.tool_call_id) {
-      formatted.push({
-        role: "tool",
-        content: msg.content ?? "",
-        tool_call_id: msg.tool_call_id
-      });
-    }
-  }
-  return formatted;
-}
-var OpenAIAdapter = class {
-  constructor(config) {
-    this.provider = "openai";
-    this.config = config;
-    this.model = config.model || "gpt-4o";
-  }
-  async getClient() {
-    if (!this.client) {
-      const { default: OpenAI } = await import('openai');
-      this.client = new OpenAI({
-        apiKey: this.config.apiKey,
-        baseURL: this.config.baseUrl
-      });
-    }
-    return this.client;
-  }
-  async *stream(request) {
-    const client = await this.getClient();
-    let messages;
-    if (request.rawMessages && request.rawMessages.length > 0) {
-      const processedMessages = request.rawMessages.map((msg) => {
-        const hasAttachments = msg.attachments && Array.isArray(msg.attachments) && msg.attachments.length > 0;
-        if (hasAttachments) {
-          const content = [];
-          if (msg.content) {
-            content.push({ type: "text", text: msg.content });
-          }
-          for (const attachment of msg.attachments) {
-            if (attachment.type === "image") {
-              let imageUrl;
-              if (attachment.url) {
-                imageUrl = attachment.url;
-              } else if (attachment.data) {
-                imageUrl = attachment.data.startsWith("data:") ? attachment.data : `data:${attachment.mimeType || "image/png"};base64,${attachment.data}`;
-              } else {
-                continue;
-              }
-              content.push({
-                type: "image_url",
-                image_url: { url: imageUrl, detail: "auto" }
-              });
-            }
-          }
-          return { ...msg, content, attachments: void 0 };
-        }
-        return msg;
-      });
-      if (request.systemPrompt) {
-        const hasSystem = processedMessages.some((m) => m.role === "system");
-        if (!hasSystem) {
-          messages = [
-            { role: "system", content: request.systemPrompt },
-            ...processedMessages
-          ];
-        } else {
-          messages = processedMessages;
-        }
-      } else {
-        messages = processedMessages;
-      }
-    } else {
-      messages = formatMessagesForOpenAI2(
-        request.messages,
-        request.systemPrompt
-      );
-    }
-    const tools = request.actions?.length ? formatTools(request.actions) : void 0;
-    const messageId = core.generateMessageId();
-    yield { type: "message:start", id: messageId };
-    try {
-      const stream = await client.chat.completions.create({
-        model: request.config?.model || this.model,
-        messages,
-        tools,
-        temperature: request.config?.temperature ?? this.config.temperature,
-        max_tokens: request.config?.maxTokens ?? this.config.maxTokens,
-        stream: true
-      });
-      let currentToolCall = null;
-      for await (const chunk of stream) {
-        if (request.signal?.aborted) {
-          break;
-        }
-        const delta = chunk.choices[0]?.delta;
-        if (delta?.content) {
-          yield { type: "message:delta", content: delta.content };
-        }
-        if (delta?.tool_calls) {
-          for (const toolCall of delta.tool_calls) {
-            if (toolCall.id) {
-              if (currentToolCall) {
-                yield {
-                  type: "action:args",
-                  id: currentToolCall.id,
-                  args: currentToolCall.arguments
-                };
-              }
-              currentToolCall = {
-                id: toolCall.id,
-                name: toolCall.function?.name || "",
-                arguments: toolCall.function?.arguments || ""
-              };
-              yield {
-                type: "action:start",
-                id: currentToolCall.id,
-                name: currentToolCall.name
-              };
-            } else if (currentToolCall && toolCall.function?.arguments) {
-              currentToolCall.arguments += toolCall.function.arguments;
-            }
-          }
-        }
-        if (chunk.choices[0]?.finish_reason) {
-          if (currentToolCall) {
-            yield {
-              type: "action:args",
-              id: currentToolCall.id,
-              args: currentToolCall.arguments
-            };
-          }
-        }
-      }
-      yield { type: "message:end" };
-      yield { type: "done" };
-    } catch (error) {
-      yield {
-        type: "error",
-        message: error instanceof Error ? error.message : "Unknown error",
-        code: "OPENAI_ERROR"
-      };
-    }
-  }
-};
-function createOpenAIAdapter(config) {
-  return new OpenAIAdapter(config);
-}
-var AnthropicAdapter = class {
-  constructor(config) {
-    this.provider = "anthropic";
-    this.config = config;
-    this.model = config.model || "claude-3-5-sonnet-latest";
-  }
-  async getClient() {
-    if (!this.client) {
-      const { default: Anthropic } = await import('@anthropic-ai/sdk');
-      this.client = new Anthropic({
-        apiKey: this.config.apiKey
-      });
-    }
-    return this.client;
-  }
-  /**
-   * Convert OpenAI-style messages to Anthropic format
-   *
-   * OpenAI format:
-   * - { role: "assistant", content: "...", tool_calls: [...] }
-   * - { role: "tool", tool_call_id: "...", content: "..." }
-   *
-   * Anthropic format:
-   * - { role: "assistant", content: [{ type: "text", text: "..." }, { type: "tool_use", id: "...", name: "...", input: {...} }] }
-   * - { role: "user", content: [{ type: "tool_result", tool_use_id: "...", content: "..." }] }
-   */
-  convertToAnthropicMessages(rawMessages) {
-    const messages = [];
-    const pendingToolResults = [];
-    for (const msg of rawMessages) {
-      if (msg.role === "system") continue;
-      if (msg.role === "assistant") {
-        if (pendingToolResults.length > 0) {
-          messages.push({
-            role: "user",
-            content: pendingToolResults.map((tr) => ({
-              type: "tool_result",
-              tool_use_id: tr.tool_use_id,
-              content: tr.content
-            }))
-          });
-          pendingToolResults.length = 0;
-        }
-        const content = [];
-        if (msg.content && typeof msg.content === "string" && msg.content.trim()) {
-          content.push({ type: "text", text: msg.content });
-        }
-        const toolCalls = msg.tool_calls;
-        if (toolCalls && toolCalls.length > 0) {
-          for (const tc of toolCalls) {
-            let input = {};
-            try {
-              input = JSON.parse(tc.function.arguments);
-            } catch {
-            }
-            content.push({
-              type: "tool_use",
-              id: tc.id,
-              name: tc.function.name,
-              input
-            });
-          }
-        }
-        if (content.length > 0) {
-          messages.push({ role: "assistant", content });
-        }
-      } else if (msg.role === "tool") {
-        pendingToolResults.push({
-          tool_use_id: msg.tool_call_id,
-          content: typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content)
-        });
-      } else if (msg.role === "user") {
-        if (pendingToolResults.length > 0) {
-          messages.push({
-            role: "user",
-            content: pendingToolResults.map((tr) => ({
-              type: "tool_result",
-              tool_use_id: tr.tool_use_id,
-              content: tr.content
-            }))
-          });
-          pendingToolResults.length = 0;
-        }
-        if (msg.attachments && Array.isArray(msg.attachments) && msg.attachments.length > 0) {
-          const content = [];
-          if (msg.content && typeof msg.content === "string") {
-            content.push({ type: "text", text: msg.content });
-          }
-          for (const attachment of msg.attachments) {
-            if (attachment.type === "image") {
-              if (attachment.url) {
-                content.push({
-                  type: "image",
-                  source: {
-                    type: "url",
-                    url: attachment.url
-                  }
-                });
-              } else if (attachment.data) {
-                let base64Data = attachment.data;
-                if (base64Data.startsWith("data:")) {
-                  const commaIndex = base64Data.indexOf(",");
-                  if (commaIndex !== -1) {
-                    base64Data = base64Data.slice(commaIndex + 1);
-                  }
-                }
-                content.push({
-                  type: "image",
-                  source: {
-                    type: "base64",
-                    media_type: attachment.mimeType || "image/png",
-                    data: base64Data
-                  }
-                });
-              }
-            } else if (attachment.type === "file" && attachment.mimeType === "application/pdf") {
-              if (attachment.url) {
-                content.push({
-                  type: "document",
-                  source: {
-                    type: "url",
-                    url: attachment.url
-                  }
-                });
-              } else if (attachment.data) {
-                let base64Data = attachment.data;
-                if (base64Data.startsWith("data:")) {
-                  const commaIndex = base64Data.indexOf(",");
-                  if (commaIndex !== -1) {
-                    base64Data = base64Data.slice(commaIndex + 1);
-                  }
-                }
-                content.push({
-                  type: "document",
-                  source: {
-                    type: "base64",
-                    media_type: "application/pdf",
-                    data: base64Data
-                  }
-                });
-              }
-            }
-          }
-          messages.push({ role: "user", content });
-        } else {
-          messages.push({
-            role: "user",
-            content: typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content)
-          });
-        }
-      }
-    }
-    if (pendingToolResults.length > 0) {
-      messages.push({
-        role: "user",
-        content: pendingToolResults.map((tr) => ({
-          type: "tool_result",
-          tool_use_id: tr.tool_use_id,
-          content: tr.content
-        }))
-      });
-    }
-    return messages;
-  }
-  /**
-   * Build common request options for both streaming and non-streaming
-   */
-  buildRequestOptions(request) {
-    const systemMessage = request.systemPrompt || "";
-    let messages;
-    if (request.rawMessages && request.rawMessages.length > 0) {
-      messages = this.convertToAnthropicMessages(request.rawMessages);
-    } else {
-      const formatted = formatMessagesForAnthropic2(request.messages);
-      messages = formatted.messages;
-    }
-    const tools = request.actions?.map((action) => ({
-      name: action.name,
-      description: action.description,
-      input_schema: {
-        type: "object",
-        properties: action.parameters ? Object.fromEntries(
-          Object.entries(action.parameters).map(([key, param]) => [
-            key,
-            {
-              type: param.type,
-              description: param.description,
-              enum: param.enum
-            }
-          ])
-        ) : {},
-        required: action.parameters ? Object.entries(action.parameters).filter(([, param]) => param.required).map(([key]) => key) : []
-      }
-    }));
-    const options = {
-      model: request.config?.model || this.model,
-      max_tokens: request.config?.maxTokens || this.config.maxTokens || 4096,
-      system: systemMessage,
-      messages,
-      tools: tools?.length ? tools : void 0
-    };
-    if (this.config.thinking?.type === "enabled") {
-      options.thinking = {
-        type: "enabled",
-        budget_tokens: this.config.thinking.budgetTokens || 1e4
-      };
-    }
-    return { options, messages };
-  }
-  /**
-   * Non-streaming completion (for debugging/comparison with original studio-ai)
-   */
-  async complete(request) {
-    const client = await this.getClient();
-    const { options } = this.buildRequestOptions(request);
-    const nonStreamingOptions = {
-      ...options,
-      stream: false
-    };
-    try {
-      const response = await client.messages.create(nonStreamingOptions);
-      let content = "";
-      let thinking = "";
-      const toolCalls = [];
-      for (const block of response.content) {
-        if (block.type === "text") {
-          content += block.text;
-        } else if (block.type === "thinking") {
-          thinking += block.thinking;
-        } else if (block.type === "tool_use") {
-          toolCalls.push({
-            id: block.id,
-            name: block.name,
-            args: block.input
-          });
-        }
-      }
-      return {
-        content,
-        toolCalls,
-        thinking: thinking || void 0,
-        rawResponse: response
-      };
-    } catch (error) {
-      throw error;
-    }
-  }
-  async *stream(request) {
-    const client = await this.getClient();
-    const { options } = this.buildRequestOptions(request);
-    const messageId = core.generateMessageId();
-    yield { type: "message:start", id: messageId };
-    try {
-      const stream = await client.messages.stream(options);
-      let currentToolUse = null;
-      let isInThinkingBlock = false;
-      for await (const event of stream) {
-        if (request.signal?.aborted) {
-          break;
-        }
-        switch (event.type) {
-          case "content_block_start":
-            if (event.content_block.type === "tool_use") {
-              currentToolUse = {
-                id: event.content_block.id,
-                name: event.content_block.name,
-                input: ""
-              };
-              yield {
-                type: "action:start",
-                id: currentToolUse.id,
-                name: currentToolUse.name
-              };
-            } else if (event.content_block.type === "thinking") {
-              isInThinkingBlock = true;
-              yield { type: "thinking:start" };
-            }
-            break;
-          case "content_block_delta":
-            if (event.delta.type === "text_delta") {
-              yield { type: "message:delta", content: event.delta.text };
-            } else if (event.delta.type === "thinking_delta") {
-              yield { type: "thinking:delta", content: event.delta.thinking };
-            } else if (event.delta.type === "input_json_delta" && currentToolUse) {
-              currentToolUse.input += event.delta.partial_json;
-            }
-            break;
-          case "content_block_stop":
-            if (currentToolUse) {
-              yield {
-                type: "action:args",
-                id: currentToolUse.id,
-                args: currentToolUse.input
-              };
-              currentToolUse = null;
-            }
-            if (isInThinkingBlock) {
-              yield { type: "thinking:end" };
-              isInThinkingBlock = false;
-            }
-            break;
-          case "message_stop":
-            break;
-        }
-      }
-      yield { type: "message:end" };
-      yield { type: "done" };
-    } catch (error) {
-      yield {
-        type: "error",
-        message: error instanceof Error ? error.message : "Unknown error",
-        code: "ANTHROPIC_ERROR"
-      };
-    }
-  }
-};
-function createAnthropicAdapter(config) {
-  return new AnthropicAdapter(config);
-}
-var OllamaAdapter = class {
-  constructor(config = {}) {
-    this.provider = "ollama";
-    this.config = config;
-    this.model = config.model || "llama3";
-    this.baseUrl = config.baseUrl || "http://localhost:11434";
-  }
-  async *stream(request) {
-    const messages = formatMessages(request.messages, request.systemPrompt);
-    const messageId = core.generateMessageId();
-    yield { type: "message:start", id: messageId };
-    try {
-      const response = await fetch(`${this.baseUrl}/api/chat`, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify({
-          model: request.config?.model || this.model,
-          messages,
-          stream: true,
-          options: {
-            temperature: request.config?.temperature ?? this.config.temperature,
-            num_predict: request.config?.maxTokens ?? this.config.maxTokens
-          }
-        }),
-        signal: request.signal
-      });
-      if (!response.ok) {
-        throw new Error(`Ollama API error: ${response.status}`);
-      }
-      if (!response.body) {
-        throw new Error("No response body");
-      }
-      const reader = response.body.getReader();
-      const decoder = new TextDecoder();
-      let buffer = "";
-      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.trim()) continue;
-          try {
-            const chunk = JSON.parse(line);
-            if (chunk.message?.content) {
-              yield { type: "message:delta", content: chunk.message.content };
-            }
-            if (chunk.done) {
-              break;
-            }
-          } catch {
-          }
-        }
-      }
-      yield { type: "message:end" };
-      yield { type: "done" };
-    } catch (error) {
-      if (error.name === "AbortError") {
-        yield { type: "done" };
-      } else {
-        yield {
-          type: "error",
-          message: error instanceof Error ? error.message : "Unknown error",
-          code: "OLLAMA_ERROR"
-        };
-      }
-    }
-  }
-};
-function createOllamaAdapter(config) {
-  return new OllamaAdapter(config);
-}
-function attachmentToGeminiPart(attachment) {
-  if (!attachment.data) {
-    console.warn(
-      "Gemini adapter: URL-based attachments not supported, skipping"
-    );
-    return null;
-  }
-  if (attachment.type === "image") {
-    let base64Data = attachment.data;
-    if (base64Data.startsWith("data:")) {
-      const commaIndex = base64Data.indexOf(",");
-      if (commaIndex !== -1) {
-        base64Data = base64Data.slice(commaIndex + 1);
-      }
-    }
-    return {
-      inlineData: {
-        mimeType: attachment.mimeType || "image/png",
-        data: base64Data
-      }
-    };
-  }
-  if (attachment.type === "audio" || attachment.type === "video") {
-    let base64Data = attachment.data;
-    if (base64Data.startsWith("data:")) {
-      const commaIndex = base64Data.indexOf(",");
-      if (commaIndex !== -1) {
-        base64Data = base64Data.slice(commaIndex + 1);
-      }
-    }
-    return {
-      inlineData: {
-        mimeType: attachment.mimeType || (attachment.type === "audio" ? "audio/mp3" : "video/mp4"),
-        data: base64Data
-      }
-    };
+// src/adapters/base.ts
+function formatMessages(messages, systemPrompt) {
+  const formatted = [];
+  if (systemPrompt) {
+    formatted.push({ role: "system", content: systemPrompt });
   }
-  return null;
-}
-function messageToGeminiContent(msg) {
-  if (msg.role === "system") return null;
-  const parts = [];
-  if (msg.role === "tool" && msg.tool_call_id) {
-    let responseData;
-    try {
-      responseData = JSON.parse(msg.content || "{}");
-    } catch {
-      responseData = { result: msg.content || "" };
-    }
-    const toolName = msg.metadata?.toolName || "tool";
-    parts.push({
-      functionResponse: {
-        name: toolName,
-        response: responseData
-      }
+  for (const msg of messages) {
+    formatted.push({
+      role: msg.role,
+      content: msg.content ?? ""
     });
-    return { role: "user", parts };
   }
-  if (msg.content) {
-    parts.push({ text: msg.content });
+  return formatted;
+}
+function parameterToJsonSchema(param) {
+  const schema = {
+    type: param.type
+  };
+  if (param.description) {
+    schema.description = param.description;
   }
-  const attachments = msg.metadata?.attachments;
-  if (attachments && Array.isArray(attachments)) {
-    for (const attachment of attachments) {
-      const part = attachmentToGeminiPart(attachment);
-      if (part) {
-        parts.push(part);
-      }
-    }
+  if (param.enum) {
+    schema.enum = param.enum;
   }
-  if (msg.role === "assistant" && msg.tool_calls && msg.tool_calls.length > 0) {
-    for (const tc of msg.tool_calls) {
-      let args = {};
-      try {
-        args = JSON.parse(tc.function.arguments);
-      } catch {
-      }
-      parts.push({
-        functionCall: {
-          name: tc.function.name,
-          args
-        }
-      });
-    }
+  if (param.type === "array" && param.items) {
+    schema.items = parameterToJsonSchema(
+      param.items
+    );
   }
-  if (parts.length === 0) return null;
-  return {
-    role: msg.role === "assistant" ? "model" : "user",
-    parts
-  };
+  if (param.type === "object" && param.properties) {
+    schema.properties = Object.fromEntries(
+      Object.entries(param.properties).map(([key, prop]) => [
+        key,
+        parameterToJsonSchema(
+          prop
+        )
+      ])
+    );
+  }
+  return schema;
 }
-function formatToolsForGemini(actions) {
-  if (!actions || actions.length === 0) return void 0;
-  return {
-    functionDeclarations: actions.map((action) => ({
+function formatTools(actions) {
+  return actions.map((action) => ({
+    type: "function",
+    function: {
       name: action.name,
       description: action.description,
-      parameters: action.parameters ? {
+      parameters: {
         type: "object",
-        properties: Object.fromEntries(
+        properties: action.parameters ? Object.fromEntries(
           Object.entries(action.parameters).map(([key, param]) => [
             key,
-            {
-              type: param.type,
-              description: param.description,
-              enum: param.enum
-            }
+            parameterToJsonSchema(param)
           ])
-        ),
-        required: Object.entries(action.parameters).filter(([, param]) => param.required).map(([key]) => key)
-      } : void 0
-    }))
-  };
+        ) : {},
+        required: action.parameters ? Object.entries(action.parameters).filter(([, param]) => param.required).map(([key]) => key) : []
+      }
+    }
+  }));
 }
-var GoogleAdapter = class {
-  constructor(config) {
-    this.provider = "google";
-    this.config = config;
-    this.model = config.model || "gemini-2.0-flash";
+function hasImageAttachments(message) {
+  const attachments = message.metadata?.attachments;
+  return attachments?.some((a) => a.type === "image") ?? false;
+}
+function hasMediaAttachments(message) {
+  const attachments = message.metadata?.attachments;
+  return attachments?.some(
+    (a) => a.type === "image" || a.type === "file" && a.mimeType === "application/pdf"
+  ) ?? false;
+}
+function attachmentToAnthropicImage(attachment) {
+  if (attachment.type !== "image") return null;
+  if (attachment.url) {
+    return {
+      type: "image",
+      source: {
+        type: "url",
+        url: attachment.url
+      }
+    };
   }
-  async getClient() {
-    if (!this.client) {
-      const { GoogleGenerativeAI } = await import('@google/generative-ai');
-      this.client = new GoogleGenerativeAI(this.config.apiKey);
+  if (!attachment.data) return null;
+  let base64Data = attachment.data;
+  if (base64Data.startsWith("data:")) {
+    const commaIndex = base64Data.indexOf(",");
+    if (commaIndex !== -1) {
+      base64Data = base64Data.slice(commaIndex + 1);
     }
-    return this.client;
   }
-  async *stream(request) {
-    const client = await this.getClient();
-    const modelId = request.config?.model || this.model;
-    const model = client.getGenerativeModel({
-      model: modelId,
-      safetySettings: this.config.safetySettings
-    });
-    let contents = [];
-    let systemInstruction;
-    if (request.rawMessages && request.rawMessages.length > 0) {
-      for (const msg of request.rawMessages) {
-        if (msg.role === "system") {
-          systemInstruction = (systemInstruction || "") + (msg.content || "");
-          continue;
-        }
-        const content = messageToGeminiContent(msg);
-        if (content) {
-          contents.push(content);
-        }
-      }
-      if (request.systemPrompt && !systemInstruction) {
-        systemInstruction = request.systemPrompt;
-      }
-    } else {
-      for (const msg of request.messages) {
-        if (msg.role === "system") {
-          systemInstruction = (systemInstruction || "") + (msg.content || "");
-          continue;
-        }
-        const content = messageToGeminiContent(msg);
-        if (content) {
-          contents.push(content);
-        }
-      }
-      if (request.systemPrompt) {
-        systemInstruction = request.systemPrompt;
-      }
+  return {
+    type: "image",
+    source: {
+      type: "base64",
+      media_type: attachment.mimeType || "image/png",
+      data: base64Data
     }
-    if (contents.length === 0 || contents[0].role !== "user") {
-      contents = [{ role: "user", parts: [{ text: "" }] }, ...contents];
+  };
+}
+function attachmentToOpenAIImage(attachment) {
+  if (attachment.type !== "image") return null;
+  let imageUrl;
+  if (attachment.url) {
+    imageUrl = attachment.url;
+  } else if (attachment.data) {
+    imageUrl = attachment.data.startsWith("data:") ? attachment.data : `data:${attachment.mimeType || "image/png"};base64,${attachment.data}`;
+  } else {
+    return null;
+  }
+  return {
+    type: "image_url",
+    image_url: {
+      url: imageUrl,
+      detail: "auto"
     }
-    const mergedContents = [];
-    for (const content of contents) {
-      const last = mergedContents[mergedContents.length - 1];
-      if (last && last.role === content.role) {
-        last.parts.push(...content.parts);
-      } else {
-        mergedContents.push({ ...content, parts: [...content.parts] });
+  };
+}
+function attachmentToAnthropicDocument(attachment) {
+  if (attachment.type !== "file" || attachment.mimeType !== "application/pdf") {
+    return null;
+  }
+  if (attachment.url) {
+    return {
+      type: "document",
+      source: {
+        type: "url",
+        url: attachment.url
       }
+    };
+  }
+  if (!attachment.data) return null;
+  let base64Data = attachment.data;
+  if (base64Data.startsWith("data:")) {
+    const commaIndex = base64Data.indexOf(",");
+    if (commaIndex !== -1) {
+      base64Data = base64Data.slice(commaIndex + 1);
     }
-    const tools = formatToolsForGemini(request.actions);
-    const messageId = core.generateMessageId();
-    yield { type: "message:start", id: messageId };
-    try {
-      const chat = model.startChat({
-        history: mergedContents.slice(0, -1),
-        // All but the last message
-        systemInstruction: systemInstruction ? { parts: [{ text: systemInstruction }] } : void 0,
-        tools: tools ? [tools] : void 0,
-        generationConfig: {
-          temperature: request.config?.temperature ?? this.config.temperature,
-          maxOutputTokens: request.config?.maxTokens ?? this.config.maxTokens
-        }
-      });
-      const lastMessage = mergedContents[mergedContents.length - 1];
-      const result = await chat.sendMessageStream(lastMessage.parts);
-      let currentToolCall = null;
-      for await (const chunk of result.stream) {
-        if (request.signal?.aborted) {
-          break;
-        }
-        const candidate = chunk.candidates?.[0];
-        if (!candidate?.content?.parts) continue;
-        for (const part of candidate.content.parts) {
-          if ("text" in part && part.text) {
-            yield { type: "message:delta", content: part.text };
-          }
-          if ("functionCall" in part && part.functionCall) {
-            const fc = part.functionCall;
-            const toolId = core.generateToolCallId();
-            if (currentToolCall) {
-              yield {
-                type: "action:args",
-                id: currentToolCall.id,
-                args: JSON.stringify(currentToolCall.args)
-              };
-            }
-            currentToolCall = {
-              id: toolId,
-              name: fc.name,
-              args: fc.args || {}
-            };
-            yield {
-              type: "action:start",
-              id: toolId,
-              name: fc.name
-            };
-          }
-        }
-        if (candidate.finishReason) {
-          if (currentToolCall) {
-            yield {
-              type: "action:args",
-              id: currentToolCall.id,
-              args: JSON.stringify(currentToolCall.args)
-            };
-          }
-        }
-      }
-      yield { type: "message:end" };
-      yield { type: "done" };
-    } catch (error) {
-      yield {
-        type: "error",
-        message: error instanceof Error ? error.message : "Unknown error",
-        code: "GOOGLE_ERROR"
-      };
+  }
+  return {
+    type: "document",
+    source: {
+      type: "base64",
+      media_type: "application/pdf",
+      data: base64Data
     }
+  };
+}
+function messageToAnthropicContent(message) {
+  const attachments = message.metadata?.attachments;
+  const content = message.content ?? "";
+  if (!hasMediaAttachments(message)) {
+    return content;
   }
-  /**
-   * Non-streaming completion (optional, for debugging)
-   */
-  async complete(request) {
-    const client = await this.getClient();
-    const modelId = request.config?.model || this.model;
-    const model = client.getGenerativeModel({
-      model: modelId,
-      safetySettings: this.config.safetySettings
-    });
-    let contents = [];
-    let systemInstruction;
-    for (const msg of request.messages) {
-      if (msg.role === "system") {
-        systemInstruction = (systemInstruction || "") + (msg.content || "");
+  const blocks = [];
+  if (attachments) {
+    for (const attachment of attachments) {
+      const imageBlock = attachmentToAnthropicImage(attachment);
+      if (imageBlock) {
+        blocks.push(imageBlock);
         continue;
       }
-      const content = messageToGeminiContent(msg);
-      if (content) {
-        contents.push(content);
+      const docBlock = attachmentToAnthropicDocument(attachment);
+      if (docBlock) {
+        blocks.push(docBlock);
       }
     }
-    if (request.systemPrompt) {
-      systemInstruction = request.systemPrompt;
-    }
-    if (contents.length === 0 || contents[0].role !== "user") {
-      contents = [{ role: "user", parts: [{ text: "" }] }, ...contents];
+  }
+  if (content) {
+    blocks.push({ type: "text", text: content });
+  }
+  return blocks;
+}
+function messageToOpenAIContent(message) {
+  const attachments = message.metadata?.attachments;
+  const content = message.content ?? "";
+  if (!hasImageAttachments(message)) {
+    return content;
+  }
+  const blocks = [];
+  if (content) {
+    blocks.push({ type: "text", text: content });
+  }
+  if (attachments) {
+    for (const attachment of attachments) {
+      const imageBlock = attachmentToOpenAIImage(attachment);
+      if (imageBlock) {
+        blocks.push(imageBlock);
+      }
     }
-    const mergedContents = [];
-    for (const content of contents) {
-      const last = mergedContents[mergedContents.length - 1];
-      if (last && last.role === content.role) {
-        last.parts.push(...content.parts);
-      } else {
-        mergedContents.push({ ...content, parts: [...content.parts] });
+  }
+  return blocks;
+}
+function formatMessagesForAnthropic(messages, systemPrompt) {
+  const formatted = [];
+  for (let i = 0; i < messages.length; i++) {
+    const msg = messages[i];
+    if (msg.role === "system") continue;
+    if (msg.role === "assistant") {
+      const content = [];
+      if (msg.content) {
+        content.push({ type: "text", text: msg.content });
       }
-    }
-    const tools = formatToolsForGemini(request.actions);
-    const chat = model.startChat({
-      history: mergedContents.slice(0, -1),
-      systemInstruction: systemInstruction ? { parts: [{ text: systemInstruction }] } : void 0,
-      tools: tools ? [tools] : void 0,
-      generationConfig: {
-        temperature: request.config?.temperature ?? this.config.temperature,
-        maxOutputTokens: request.config?.maxTokens ?? this.config.maxTokens
+      if (msg.tool_calls && msg.tool_calls.length > 0) {
+        for (const tc of msg.tool_calls) {
+          content.push({
+            type: "tool_use",
+            id: tc.id,
+            name: tc.function.name,
+            input: JSON.parse(tc.function.arguments)
+          });
+        }
       }
-    });
-    const lastMessage = mergedContents[mergedContents.length - 1];
-    const result = await chat.sendMessage(lastMessage.parts);
-    const response = result.response;
-    let textContent = "";
-    const toolCalls = [];
-    const candidate = response.candidates?.[0];
-    if (candidate?.content?.parts) {
-      for (const part of candidate.content.parts) {
-        if ("text" in part && part.text) {
-          textContent += part.text;
+      formatted.push({
+        role: "assistant",
+        content: content.length === 1 && content[0].type === "text" ? content[0].text : content
+      });
+    } else if (msg.role === "tool" && msg.tool_call_id) {
+      const toolResults = [
+        {
+          type: "tool_result",
+          tool_use_id: msg.tool_call_id,
+          content: msg.content ?? ""
         }
-        if ("functionCall" in part && part.functionCall) {
-          toolCalls.push({
-            id: core.generateToolCallId(),
-            name: part.functionCall.name,
-            args: part.functionCall.args || {}
+      ];
+      while (i + 1 < messages.length && messages[i + 1].role === "tool") {
+        i++;
+        const nextTool = messages[i];
+        if (nextTool.tool_call_id) {
+          toolResults.push({
+            type: "tool_result",
+            tool_use_id: nextTool.tool_call_id,
+            content: nextTool.content ?? ""
           });
         }
       }
+      formatted.push({
+        role: "user",
+        content: toolResults
+      });
+    } else if (msg.role === "user") {
+      formatted.push({
+        role: "user",
+        content: messageToAnthropicContent(msg)
+      });
     }
-    return {
-      content: textContent,
-      toolCalls,
-      rawResponse: response
-    };
   }
-};
-function createGoogleAdapter(config) {
-  return new GoogleAdapter(config);
+  return {
+    system: "",
+    messages: formatted
+  };
+}
+function formatMessagesForOpenAI(messages, systemPrompt) {
+  const formatted = [];
+  if (systemPrompt) {
+    formatted.push({ role: "system", content: systemPrompt });
+  }
+  for (const msg of messages) {
+    if (msg.role === "system") {
+      formatted.push({ role: "system", content: msg.content ?? "" });
+    } else if (msg.role === "user") {
+      formatted.push({
+        role: "user",
+        content: messageToOpenAIContent(msg)
+      });
+    } else if (msg.role === "assistant") {
+      const assistantMsg = {
+        role: "assistant",
+        content: msg.content
+      };
+      if (msg.tool_calls && msg.tool_calls.length > 0) {
+        assistantMsg.tool_calls = msg.tool_calls;
+      }
+      formatted.push(assistantMsg);
+    } else if (msg.role === "tool" && msg.tool_call_id) {
+      formatted.push({
+        role: "tool",
+        content: msg.content ?? "",
+        tool_call_id: msg.tool_call_id
+      });
+    }
+  }
+  return formatted;
 }
-var XAI_BASE_URL = "https://api.x.ai/v1";
-var XAIAdapter = class {
+
+// src/adapters/openai.ts
+var OpenAIAdapter = class {
   constructor(config) {
-    this.provider = "xai";
+    this.provider = "openai";
     this.config = config;
-    this.model = config.model || "grok-2";
+    this.model = config.model || "gpt-4o";
   }
   async getClient() {
     if (!this.client) {
       const { default: OpenAI } = await import('openai');
       this.client = new OpenAI({
         apiKey: this.config.apiKey,
-        baseURL: this.config.baseUrl || XAI_BASE_URL
+        baseURL: this.config.baseUrl
       });
     }
     return this.client;
@@ -2841,9 +852,13 @@ var XAIAdapter = class {
           }
           for (const attachment of msg.attachments) {
             if (attachment.type === "image") {
-              let imageUrl = attachment.data;
-              if (!imageUrl.startsWith("data:")) {
-                imageUrl = `data:${attachment.mimeType || "image/png"};base64,${attachment.data}`;
+              let imageUrl;
+              if (attachment.url) {
+                imageUrl = attachment.url;
+              } else if (attachment.data) {
+                imageUrl = attachment.data.startsWith("data:") ? attachment.data : `data:${attachment.mimeType || "image/png"};base64,${attachment.data}`;
+              } else {
+                continue;
               }
               content.push({
                 type: "image_url",
@@ -2869,7 +884,7 @@ var XAIAdapter = class {
         messages = processedMessages;
       }
     } else {
-      messages = formatMessagesForOpenAI2(
+      messages = formatMessagesForOpenAI(
         request.messages,
         request.systemPrompt
       );
@@ -2905,216 +920,348 @@ var XAIAdapter = class {
                   args: currentToolCall.arguments
                 };
               }
-              currentToolCall = {
-                id: toolCall.id,
-                name: toolCall.function?.name || "",
-                arguments: toolCall.function?.arguments || ""
-              };
-              yield {
-                type: "action:start",
-                id: currentToolCall.id,
-                name: currentToolCall.name
-              };
-            } else if (currentToolCall && toolCall.function?.arguments) {
-              currentToolCall.arguments += toolCall.function.arguments;
+              currentToolCall = {
+                id: toolCall.id,
+                name: toolCall.function?.name || "",
+                arguments: toolCall.function?.arguments || ""
+              };
+              yield {
+                type: "action:start",
+                id: currentToolCall.id,
+                name: currentToolCall.name
+              };
+            } else if (currentToolCall && toolCall.function?.arguments) {
+              currentToolCall.arguments += toolCall.function.arguments;
+            }
+          }
+        }
+        if (chunk.choices[0]?.finish_reason) {
+          if (currentToolCall) {
+            yield {
+              type: "action:args",
+              id: currentToolCall.id,
+              args: currentToolCall.arguments
+            };
+          }
+        }
+      }
+      yield { type: "message:end" };
+      yield { type: "done" };
+    } catch (error) {
+      yield {
+        type: "error",
+        message: error instanceof Error ? error.message : "Unknown error",
+        code: "OPENAI_ERROR"
+      };
+    }
+  }
+};
+function createOpenAIAdapter(config) {
+  return new OpenAIAdapter(config);
+}
+var AnthropicAdapter = class {
+  constructor(config) {
+    this.provider = "anthropic";
+    this.config = config;
+    this.model = config.model || "claude-3-5-sonnet-latest";
+  }
+  async getClient() {
+    if (!this.client) {
+      const { default: Anthropic } = await import('@anthropic-ai/sdk');
+      this.client = new Anthropic({
+        apiKey: this.config.apiKey
+      });
+    }
+    return this.client;
+  }
+  /**
+   * Convert OpenAI-style messages to Anthropic format
+   *
+   * OpenAI format:
+   * - { role: "assistant", content: "...", tool_calls: [...] }
+   * - { role: "tool", tool_call_id: "...", content: "..." }
+   *
+   * Anthropic format:
+   * - { role: "assistant", content: [{ type: "text", text: "..." }, { type: "tool_use", id: "...", name: "...", input: {...} }] }
+   * - { role: "user", content: [{ type: "tool_result", tool_use_id: "...", content: "..." }] }
+   */
+  convertToAnthropicMessages(rawMessages) {
+    const messages = [];
+    const pendingToolResults = [];
+    for (const msg of rawMessages) {
+      if (msg.role === "system") continue;
+      if (msg.role === "assistant") {
+        if (pendingToolResults.length > 0) {
+          messages.push({
+            role: "user",
+            content: pendingToolResults.map((tr) => ({
+              type: "tool_result",
+              tool_use_id: tr.tool_use_id,
+              content: tr.content
+            }))
+          });
+          pendingToolResults.length = 0;
+        }
+        const content = [];
+        if (msg.content && typeof msg.content === "string" && msg.content.trim()) {
+          content.push({ type: "text", text: msg.content });
+        }
+        const toolCalls = msg.tool_calls;
+        if (toolCalls && toolCalls.length > 0) {
+          for (const tc of toolCalls) {
+            let input = {};
+            try {
+              input = JSON.parse(tc.function.arguments);
+            } catch {
+            }
+            content.push({
+              type: "tool_use",
+              id: tc.id,
+              name: tc.function.name,
+              input
+            });
+          }
+        }
+        if (content.length > 0) {
+          messages.push({ role: "assistant", content });
+        }
+      } else if (msg.role === "tool") {
+        pendingToolResults.push({
+          tool_use_id: msg.tool_call_id,
+          content: typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content)
+        });
+      } else if (msg.role === "user") {
+        if (pendingToolResults.length > 0) {
+          messages.push({
+            role: "user",
+            content: pendingToolResults.map((tr) => ({
+              type: "tool_result",
+              tool_use_id: tr.tool_use_id,
+              content: tr.content
+            }))
+          });
+          pendingToolResults.length = 0;
+        }
+        if (msg.attachments && Array.isArray(msg.attachments) && msg.attachments.length > 0) {
+          const content = [];
+          if (msg.content && typeof msg.content === "string") {
+            content.push({ type: "text", text: msg.content });
+          }
+          for (const attachment of msg.attachments) {
+            if (attachment.type === "image") {
+              if (attachment.url) {
+                content.push({
+                  type: "image",
+                  source: {
+                    type: "url",
+                    url: attachment.url
+                  }
+                });
+              } else if (attachment.data) {
+                let base64Data = attachment.data;
+                if (base64Data.startsWith("data:")) {
+                  const commaIndex = base64Data.indexOf(",");
+                  if (commaIndex !== -1) {
+                    base64Data = base64Data.slice(commaIndex + 1);
+                  }
+                }
+                content.push({
+                  type: "image",
+                  source: {
+                    type: "base64",
+                    media_type: attachment.mimeType || "image/png",
+                    data: base64Data
+                  }
+                });
+              }
+            } else if (attachment.type === "file" && attachment.mimeType === "application/pdf") {
+              if (attachment.url) {
+                content.push({
+                  type: "document",
+                  source: {
+                    type: "url",
+                    url: attachment.url
+                  }
+                });
+              } else if (attachment.data) {
+                let base64Data = attachment.data;
+                if (base64Data.startsWith("data:")) {
+                  const commaIndex = base64Data.indexOf(",");
+                  if (commaIndex !== -1) {
+                    base64Data = base64Data.slice(commaIndex + 1);
+                  }
+                }
+                content.push({
+                  type: "document",
+                  source: {
+                    type: "base64",
+                    media_type: "application/pdf",
+                    data: base64Data
+                  }
+                });
+              }
             }
           }
-        }
-        if (chunk.choices[0]?.finish_reason) {
-          if (currentToolCall) {
-            yield {
-              type: "action:args",
-              id: currentToolCall.id,
-              args: currentToolCall.arguments
-            };
-          }
+          messages.push({ role: "user", content });
+        } else {
+          messages.push({
+            role: "user",
+            content: typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content)
+          });
         }
       }
-      yield { type: "message:end" };
-      yield { type: "done" };
-    } catch (error) {
-      yield {
-        type: "error",
-        message: error instanceof Error ? error.message : "Unknown error",
-        code: "XAI_ERROR"
-      };
     }
+    if (pendingToolResults.length > 0) {
+      messages.push({
+        role: "user",
+        content: pendingToolResults.map((tr) => ({
+          type: "tool_result",
+          tool_use_id: tr.tool_use_id,
+          content: tr.content
+        }))
+      });
+    }
+    return messages;
   }
   /**
-   * Non-streaming completion (optional, for debugging)
+   * Build common request options for both streaming and non-streaming
    */
-  async complete(request) {
-    const client = await this.getClient();
+  buildRequestOptions(request) {
+    const systemMessage = request.systemPrompt || "";
     let messages;
     if (request.rawMessages && request.rawMessages.length > 0) {
-      messages = request.rawMessages;
-      if (request.systemPrompt) {
-        const hasSystem = messages.some((m) => m.role === "system");
-        if (!hasSystem) {
-          messages = [
-            { role: "system", content: request.systemPrompt },
-            ...messages
-          ];
-        }
-      }
+      messages = this.convertToAnthropicMessages(request.rawMessages);
     } else {
-      messages = formatMessagesForOpenAI2(
-        request.messages,
-        request.systemPrompt
-      );
+      const formatted = formatMessagesForAnthropic(request.messages);
+      messages = formatted.messages;
     }
-    const tools = request.actions?.length ? formatTools(request.actions) : void 0;
-    const response = await client.chat.completions.create({
+    const tools = request.actions?.map((action) => ({
+      name: action.name,
+      description: action.description,
+      input_schema: {
+        type: "object",
+        properties: action.parameters ? Object.fromEntries(
+          Object.entries(action.parameters).map(([key, param]) => [
+            key,
+            {
+              type: param.type,
+              description: param.description,
+              enum: param.enum
+            }
+          ])
+        ) : {},
+        required: action.parameters ? Object.entries(action.parameters).filter(([, param]) => param.required).map(([key]) => key) : []
+      }
+    }));
+    const options = {
       model: request.config?.model || this.model,
+      max_tokens: request.config?.maxTokens || this.config.maxTokens || 4096,
+      system: systemMessage,
       messages,
-      tools,
-      temperature: request.config?.temperature ?? this.config.temperature,
-      max_tokens: request.config?.maxTokens ?? this.config.maxTokens
-    });
-    const choice = response.choices[0];
-    const message = choice?.message;
-    const toolCalls = (message?.tool_calls || []).map((tc) => ({
-      id: tc.id,
-      name: tc.function.name,
-      args: JSON.parse(tc.function.arguments || "{}")
-    }));
-    return {
-      content: message?.content || "",
-      toolCalls,
-      rawResponse: response
+      tools: tools?.length ? tools : void 0
     };
-  }
-};
-function createXAIAdapter(config) {
-  return new XAIAdapter(config);
-}
-var DEFAULT_API_VERSION = "2024-08-01-preview";
-function buildAzureEndpoint(resourceName, deploymentName, apiVersion) {
-  return `https://${resourceName}.openai.azure.com/openai/deployments/${deploymentName}`;
-}
-var AzureAdapter = class {
-  constructor(config) {
-    this.provider = "azure";
-    this.config = config;
-    this.model = config.deploymentName;
-  }
-  async getClient() {
-    if (!this.client) {
-      const { AzureOpenAI } = await import('openai');
-      const apiVersion = this.config.apiVersion || DEFAULT_API_VERSION;
-      const endpoint = this.config.baseUrl || buildAzureEndpoint(
-        this.config.resourceName,
-        this.config.deploymentName);
-      this.client = new AzureOpenAI({
-        apiKey: this.config.apiKey,
-        endpoint,
-        apiVersion,
-        deployment: this.config.deploymentName
-      });
+    if (this.config.thinking?.type === "enabled") {
+      options.thinking = {
+        type: "enabled",
+        budget_tokens: this.config.thinking.budgetTokens || 1e4
+      };
     }
-    return this.client;
+    return { options, messages };
   }
-  async *stream(request) {
+  /**
+   * Non-streaming completion (for debugging/comparison with original studio-ai)
+   */
+  async complete(request) {
     const client = await this.getClient();
-    let messages;
-    if (request.rawMessages && request.rawMessages.length > 0) {
-      const processedMessages = request.rawMessages.map((msg) => {
-        const hasAttachments = msg.attachments && Array.isArray(msg.attachments) && msg.attachments.length > 0;
-        if (hasAttachments) {
-          const content = [];
-          if (msg.content) {
-            content.push({ type: "text", text: msg.content });
-          }
-          for (const attachment of msg.attachments) {
-            if (attachment.type === "image") {
-              let imageUrl = attachment.data;
-              if (!imageUrl.startsWith("data:")) {
-                imageUrl = `data:${attachment.mimeType || "image/png"};base64,${attachment.data}`;
-              }
-              content.push({
-                type: "image_url",
-                image_url: { url: imageUrl, detail: "auto" }
-              });
-            }
-          }
-          return { ...msg, content, attachments: void 0 };
-        }
-        return msg;
-      });
-      if (request.systemPrompt) {
-        const hasSystem = processedMessages.some((m) => m.role === "system");
-        if (!hasSystem) {
-          messages = [
-            { role: "system", content: request.systemPrompt },
-            ...processedMessages
-          ];
-        } else {
-          messages = processedMessages;
+    const { options } = this.buildRequestOptions(request);
+    const nonStreamingOptions = {
+      ...options,
+      stream: false
+    };
+    try {
+      const response = await client.messages.create(nonStreamingOptions);
+      let content = "";
+      let thinking = "";
+      const toolCalls = [];
+      for (const block of response.content) {
+        if (block.type === "text") {
+          content += block.text;
+        } else if (block.type === "thinking") {
+          thinking += block.thinking;
+        } else if (block.type === "tool_use") {
+          toolCalls.push({
+            id: block.id,
+            name: block.name,
+            args: block.input
+          });
         }
-      } else {
-        messages = processedMessages;
       }
-    } else {
-      messages = formatMessagesForOpenAI2(
-        request.messages,
-        request.systemPrompt
-      );
+      return {
+        content,
+        toolCalls,
+        thinking: thinking || void 0,
+        rawResponse: response
+      };
+    } catch (error) {
+      throw error;
     }
-    const tools = request.actions?.length ? formatTools(request.actions) : void 0;
+  }
+  async *stream(request) {
+    const client = await this.getClient();
+    const { options } = this.buildRequestOptions(request);
     const messageId = core.generateMessageId();
     yield { type: "message:start", id: messageId };
     try {
-      const stream = await client.chat.completions.create({
-        // Azure uses deployment name, not model name
-        model: this.config.deploymentName,
-        messages,
-        tools,
-        temperature: request.config?.temperature ?? this.config.temperature,
-        max_tokens: request.config?.maxTokens ?? this.config.maxTokens,
-        stream: true
-      });
-      let currentToolCall = null;
-      for await (const chunk of stream) {
+      const stream = await client.messages.stream(options);
+      let currentToolUse = null;
+      let isInThinkingBlock = false;
+      for await (const event of stream) {
         if (request.signal?.aborted) {
           break;
         }
-        const delta = chunk.choices[0]?.delta;
-        if (delta?.content) {
-          yield { type: "message:delta", content: delta.content };
-        }
-        if (delta?.tool_calls) {
-          for (const toolCall of delta.tool_calls) {
-            if (toolCall.id) {
-              if (currentToolCall) {
-                yield {
-                  type: "action:args",
-                  id: currentToolCall.id,
-                  args: currentToolCall.arguments
-                };
-              }
-              currentToolCall = {
-                id: toolCall.id,
-                name: toolCall.function?.name || "",
-                arguments: toolCall.function?.arguments || ""
+        switch (event.type) {
+          case "content_block_start":
+            if (event.content_block.type === "tool_use") {
+              currentToolUse = {
+                id: event.content_block.id,
+                name: event.content_block.name,
+                input: ""
+              };
+              yield {
+                type: "action:start",
+                id: currentToolUse.id,
+                name: currentToolUse.name
               };
+            } else if (event.content_block.type === "thinking") {
+              isInThinkingBlock = true;
+              yield { type: "thinking:start" };
+            }
+            break;
+          case "content_block_delta":
+            if (event.delta.type === "text_delta") {
+              yield { type: "message:delta", content: event.delta.text };
+            } else if (event.delta.type === "thinking_delta") {
+              yield { type: "thinking:delta", content: event.delta.thinking };
+            } else if (event.delta.type === "input_json_delta" && currentToolUse) {
+              currentToolUse.input += event.delta.partial_json;
+            }
+            break;
+          case "content_block_stop":
+            if (currentToolUse) {
               yield {
-                type: "action:start",
-                id: currentToolCall.id,
-                name: currentToolCall.name
+                type: "action:args",
+                id: currentToolUse.id,
+                args: currentToolUse.input
               };
-            } else if (currentToolCall && toolCall.function?.arguments) {
-              currentToolCall.arguments += toolCall.function.arguments;
+              currentToolUse = null;
             }
-          }
-        }
-        if (chunk.choices[0]?.finish_reason) {
-          if (currentToolCall) {
-            yield {
-              type: "action:args",
-              id: currentToolCall.id,
-              args: currentToolCall.arguments
-            };
-          }
+            if (isInThinkingBlock) {
+              yield { type: "thinking:end" };
+              isInThinkingBlock = false;
+            }
+            break;
+          case "message_stop":
+            break;
         }
       }
       yield { type: "message:end" };
@@ -3123,57 +1270,88 @@ var AzureAdapter = class {
       yield {
         type: "error",
         message: error instanceof Error ? error.message : "Unknown error",
-        code: "AZURE_ERROR"
+        code: "ANTHROPIC_ERROR"
       };
     }
   }
-  /**
-   * Non-streaming completion (optional, for debugging)
-   */
-  async complete(request) {
-    const client = await this.getClient();
-    let messages;
-    if (request.rawMessages && request.rawMessages.length > 0) {
-      messages = request.rawMessages;
-      if (request.systemPrompt) {
-        const hasSystem = messages.some((m) => m.role === "system");
-        if (!hasSystem) {
-          messages = [
-            { role: "system", content: request.systemPrompt },
-            ...messages
-          ];
+};
+function createAnthropicAdapter(config) {
+  return new AnthropicAdapter(config);
+}
+var OllamaAdapter = class {
+  constructor(config = {}) {
+    this.provider = "ollama";
+    this.config = config;
+    this.model = config.model || "llama3";
+    this.baseUrl = config.baseUrl || "http://localhost:11434";
+  }
+  async *stream(request) {
+    const messages = formatMessages(request.messages, request.systemPrompt);
+    const messageId = core.generateMessageId();
+    yield { type: "message:start", id: messageId };
+    try {
+      const response = await fetch(`${this.baseUrl}/api/chat`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          model: request.config?.model || this.model,
+          messages,
+          stream: true,
+          options: {
+            temperature: request.config?.temperature ?? this.config.temperature,
+            num_predict: request.config?.maxTokens ?? this.config.maxTokens
+          }
+        }),
+        signal: request.signal
+      });
+      if (!response.ok) {
+        throw new Error(`Ollama API error: ${response.status}`);
+      }
+      if (!response.body) {
+        throw new Error("No response body");
+      }
+      const reader = response.body.getReader();
+      const decoder = new TextDecoder();
+      let buffer = "";
+      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.trim()) continue;
+          try {
+            const chunk = JSON.parse(line);
+            if (chunk.message?.content) {
+              yield { type: "message:delta", content: chunk.message.content };
+            }
+            if (chunk.done) {
+              break;
+            }
+          } catch {
+          }
         }
       }
-    } else {
-      messages = formatMessagesForOpenAI2(
-        request.messages,
-        request.systemPrompt
-      );
+      yield { type: "message:end" };
+      yield { type: "done" };
+    } catch (error) {
+      if (error.name === "AbortError") {
+        yield { type: "done" };
+      } else {
+        yield {
+          type: "error",
+          message: error instanceof Error ? error.message : "Unknown error",
+          code: "OLLAMA_ERROR"
+        };
+      }
     }
-    const tools = request.actions?.length ? formatTools(request.actions) : void 0;
-    const response = await client.chat.completions.create({
-      model: this.config.deploymentName,
-      messages,
-      tools,
-      temperature: request.config?.temperature ?? this.config.temperature,
-      max_tokens: request.config?.maxTokens ?? this.config.maxTokens
-    });
-    const choice = response.choices[0];
-    const message = choice?.message;
-    const toolCalls = (message?.tool_calls || []).map((tc) => ({
-      id: tc.id,
-      name: tc.function.name,
-      args: JSON.parse(tc.function.arguments || "{}")
-    }));
-    return {
-      content: message?.content || "",
-      toolCalls,
-      rawResponse: response
-    };
   }
 };
-function createAzureAdapter(config) {
-  return new AzureAdapter(config);
+function createOllamaAdapter(config) {
+  return new OllamaAdapter(config);
 }
 
 // src/server/streaming.ts
@@ -4411,766 +2589,6 @@ function createNodeHandler(config) {
   return app.fetch;
 }
 
-// src/providers/registry.ts
-var providerFactories = /* @__PURE__ */ new Map();
-function registerProvider(name, factory) {
-  providerFactories.set(name, factory);
-}
-function getProvider(name, config) {
-  const factory = providerFactories.get(name);
-  if (!factory) {
-    return void 0;
-  }
-  return factory(config);
-}
-function hasProvider(name) {
-  return providerFactories.has(name);
-}
-function listProviders() {
-  return Array.from(providerFactories.keys());
-}
-function getAvailableProviders() {
-  const result = [];
-  for (const [name, factory] of providerFactories) {
-    try {
-      const provider = factory();
-      result.push({
-        name,
-        models: provider.supportedModels
-      });
-    } catch {
-      result.push({
-        name,
-        models: []
-      });
-    }
-  }
-  return result;
-}
-function getModelCapabilities(providerName, modelId) {
-  const provider = getProvider(providerName);
-  if (!provider) {
-    return void 0;
-  }
-  return provider.getCapabilities(modelId);
-}
-
-// src/providers/openai/index.ts
-var OPENAI_MODELS2 = {
-  // GPT-4o series
-  "gpt-4o": {
-    vision: true,
-    tools: true,
-    audio: true,
-    jsonMode: true,
-    maxTokens: 128e3
-  },
-  "gpt-4o-mini": {
-    vision: true,
-    tools: true,
-    audio: false,
-    jsonMode: true,
-    maxTokens: 128e3
-  },
-  "gpt-4o-2024-11-20": {
-    vision: true,
-    tools: true,
-    audio: true,
-    jsonMode: true,
-    maxTokens: 128e3
-  },
-  "gpt-4o-2024-08-06": {
-    vision: true,
-    tools: true,
-    audio: false,
-    jsonMode: true,
-    maxTokens: 128e3
-  },
-  // GPT-4 Turbo series
-  "gpt-4-turbo": {
-    vision: true,
-    tools: true,
-    audio: false,
-    jsonMode: true,
-    maxTokens: 128e3
-  },
-  "gpt-4-turbo-preview": {
-    vision: false,
-    tools: true,
-    audio: false,
-    jsonMode: true,
-    maxTokens: 128e3
-  },
-  // GPT-4 series
-  "gpt-4": {
-    vision: false,
-    tools: true,
-    audio: false,
-    jsonMode: false,
-    maxTokens: 8192
-  },
-  "gpt-4-32k": {
-    vision: false,
-    tools: true,
-    audio: false,
-    jsonMode: false,
-    maxTokens: 32768
-  },
-  // GPT-3.5 series
-  "gpt-3.5-turbo": {
-    vision: false,
-    tools: true,
-    audio: false,
-    jsonMode: true,
-    maxTokens: 16385
-  },
-  "gpt-3.5-turbo-16k": {
-    vision: false,
-    tools: true,
-    audio: false,
-    jsonMode: true,
-    maxTokens: 16385
-  },
-  // O1 reasoning series
-  o1: {
-    vision: true,
-    tools: false,
-    // O1 doesn't support tools yet
-    audio: false,
-    jsonMode: false,
-    maxTokens: 128e3
-  },
-  "o1-mini": {
-    vision: true,
-    tools: false,
-    audio: false,
-    jsonMode: false,
-    maxTokens: 128e3
-  },
-  "o1-preview": {
-    vision: true,
-    tools: false,
-    audio: false,
-    jsonMode: false,
-    maxTokens: 128e3
-  },
-  // O3 reasoning series
-  "o3-mini": {
-    vision: true,
-    tools: false,
-    audio: false,
-    jsonMode: false,
-    maxTokens: 128e3
-  }
-};
-function createOpenAI(config = {}) {
-  const apiKey = config.apiKey ?? process.env.OPENAI_API_KEY ?? "";
-  return {
-    name: "openai",
-    supportedModels: Object.keys(OPENAI_MODELS2),
-    languageModel(modelId) {
-      return createOpenAIAdapter({
-        apiKey,
-        model: modelId,
-        baseUrl: config.baseUrl
-      });
-    },
-    getCapabilities(modelId) {
-      const model = OPENAI_MODELS2[modelId] ?? OPENAI_MODELS2["gpt-4o"];
-      return {
-        supportsVision: model.vision,
-        supportsTools: model.tools,
-        supportsThinking: false,
-        // OpenAI doesn't have extended thinking
-        supportsStreaming: true,
-        supportsPDF: false,
-        // OpenAI doesn't support PDFs directly
-        supportsAudio: model.audio,
-        supportsVideo: false,
-        maxTokens: model.maxTokens,
-        supportedImageTypes: model.vision ? ["image/png", "image/jpeg", "image/gif", "image/webp"] : [],
-        supportedAudioTypes: model.audio ? ["audio/mp3", "audio/wav", "audio/webm"] : [],
-        supportsJsonMode: model.jsonMode,
-        supportsSystemMessages: true
-      };
-    }
-  };
-}
-
-// src/providers/anthropic/index.ts
-var ANTHROPIC_MODELS2 = {
-  // Claude 4 series (latest)
-  "claude-sonnet-4-20250514": {
-    vision: true,
-    tools: true,
-    thinking: true,
-    maxTokens: 64e3
-  },
-  "claude-opus-4-20250514": {
-    vision: true,
-    tools: true,
-    thinking: true,
-    maxTokens: 32e3
-  },
-  // Claude 3.5 series
-  "claude-3-5-sonnet-latest": {
-    vision: true,
-    tools: true,
-    thinking: true,
-    maxTokens: 2e5
-  },
-  "claude-3-5-sonnet-20241022": {
-    vision: true,
-    tools: true,
-    thinking: true,
-    maxTokens: 2e5
-  },
-  "claude-3-5-haiku-latest": {
-    vision: true,
-    tools: true,
-    thinking: false,
-    maxTokens: 2e5
-  },
-  "claude-3-5-haiku-20241022": {
-    vision: true,
-    tools: true,
-    thinking: false,
-    maxTokens: 2e5
-  },
-  // Claude 3 series
-  "claude-3-opus-latest": {
-    vision: true,
-    tools: true,
-    thinking: true,
-    maxTokens: 2e5
-  },
-  "claude-3-opus-20240229": {
-    vision: true,
-    tools: true,
-    thinking: true,
-    maxTokens: 2e5
-  },
-  "claude-3-sonnet-20240229": {
-    vision: true,
-    tools: true,
-    thinking: false,
-    maxTokens: 2e5
-  },
-  "claude-3-haiku-20240307": {
-    vision: true,
-    tools: true,
-    thinking: false,
-    maxTokens: 2e5
-  }
-};
-function createAnthropic(config = {}) {
-  const apiKey = config.apiKey ?? process.env.ANTHROPIC_API_KEY ?? "";
-  return {
-    name: "anthropic",
-    supportedModels: Object.keys(ANTHROPIC_MODELS2),
-    languageModel(modelId) {
-      return createAnthropicAdapter({
-        apiKey,
-        model: modelId,
-        baseUrl: config.baseUrl,
-        thinking: config.thinkingBudget ? { type: "enabled", budgetTokens: config.thinkingBudget } : void 0
-      });
-    },
-    getCapabilities(modelId) {
-      const model = ANTHROPIC_MODELS2[modelId] ?? ANTHROPIC_MODELS2["claude-3-5-sonnet-latest"];
-      return {
-        supportsVision: model.vision,
-        supportsTools: model.tools,
-        supportsThinking: model.thinking,
-        supportsStreaming: true,
-        supportsPDF: true,
-        // Claude supports PDFs
-        supportsAudio: false,
-        supportsVideo: false,
-        maxTokens: model.maxTokens,
-        supportedImageTypes: [
-          "image/png",
-          "image/jpeg",
-          "image/gif",
-          "image/webp"
-        ],
-        supportsJsonMode: false,
-        // Anthropic doesn't have JSON mode
-        supportsSystemMessages: true
-      };
-    }
-  };
-}
-
-// src/providers/ollama/index.ts
-var OLLAMA_MODELS = {
-  // Llama series
-  llama3: {
-    vision: false,
-    tools: true,
-    maxTokens: 8192
-  },
-  "llama3:70b": {
-    vision: false,
-    tools: true,
-    maxTokens: 8192
-  },
-  "llama3.2": {
-    vision: false,
-    tools: true,
-    maxTokens: 8192
-  },
-  "llama3.2-vision": {
-    vision: true,
-    tools: true,
-    maxTokens: 8192
-  },
-  // Mistral series
-  mistral: {
-    vision: false,
-    tools: true,
-    maxTokens: 8192
-  },
-  "mistral-nemo": {
-    vision: false,
-    tools: true,
-    maxTokens: 128e3
-  },
-  mixtral: {
-    vision: false,
-    tools: true,
-    maxTokens: 32768
-  },
-  // CodeLlama
-  codellama: {
-    vision: false,
-    tools: false,
-    maxTokens: 16384
-  },
-  // Phi series
-  phi3: {
-    vision: false,
-    tools: true,
-    maxTokens: 4096
-  },
-  "phi3:medium": {
-    vision: false,
-    tools: true,
-    maxTokens: 4096
-  },
-  // Gemma series
-  gemma2: {
-    vision: false,
-    tools: false,
-    maxTokens: 8192
-  },
-  "gemma2:27b": {
-    vision: false,
-    tools: false,
-    maxTokens: 8192
-  },
-  // Qwen series
-  qwen2: {
-    vision: false,
-    tools: true,
-    maxTokens: 32768
-  },
-  "qwen2.5-coder": {
-    vision: false,
-    tools: true,
-    maxTokens: 32768
-  },
-  // LLaVA (vision)
-  llava: {
-    vision: true,
-    tools: false,
-    maxTokens: 4096
-  },
-  // DeepSeek
-  deepseek: {
-    vision: false,
-    tools: true,
-    maxTokens: 16384
-  },
-  "deepseek-coder": {
-    vision: false,
-    tools: false,
-    maxTokens: 16384
-  }
-};
-var DEFAULT_MODEL_CAPS = {
-  vision: false,
-  tools: false,
-  maxTokens: 4096
-};
-function createOllama(config = {}) {
-  const baseUrl = config.baseUrl ?? "http://localhost:11434";
-  return {
-    name: "ollama",
-    supportedModels: Object.keys(OLLAMA_MODELS),
-    languageModel(modelId) {
-      return createOllamaAdapter({
-        model: modelId,
-        baseUrl
-      });
-    },
-    getCapabilities(modelId) {
-      const baseModelName = modelId.split(":")[0];
-      const model = OLLAMA_MODELS[modelId] ?? OLLAMA_MODELS[baseModelName] ?? DEFAULT_MODEL_CAPS;
-      return {
-        supportsVision: model.vision,
-        supportsTools: model.tools,
-        supportsThinking: false,
-        supportsStreaming: true,
-        supportsPDF: false,
-        supportsAudio: false,
-        supportsVideo: false,
-        maxTokens: model.maxTokens,
-        supportedImageTypes: model.vision ? ["image/png", "image/jpeg", "image/gif"] : [],
-        supportsJsonMode: false,
-        supportsSystemMessages: true
-      };
-    }
-  };
-}
-
-// src/providers/google/index.ts
-var GOOGLE_MODELS2 = {
-  // Gemini 2.0 series (latest)
-  "gemini-2.0-flash": {
-    vision: true,
-    tools: true,
-    audio: true,
-    video: true,
-    pdf: true,
-    maxTokens: 1e6,
-    outputTokens: 8192
-  },
-  "gemini-2.0-flash-lite": {
-    vision: true,
-    tools: true,
-    audio: false,
-    video: false,
-    pdf: true,
-    maxTokens: 1e6,
-    outputTokens: 8192
-  },
-  // Gemini 2.5 series (experimental)
-  "gemini-2.5-pro-preview-05-06": {
-    vision: true,
-    tools: true,
-    audio: true,
-    video: true,
-    pdf: true,
-    maxTokens: 1e6,
-    outputTokens: 65536
-  },
-  "gemini-2.5-flash-preview-05-20": {
-    vision: true,
-    tools: true,
-    audio: true,
-    video: true,
-    pdf: true,
-    maxTokens: 1e6,
-    outputTokens: 65536
-  },
-  // Gemini 1.5 series
-  "gemini-1.5-pro": {
-    vision: true,
-    tools: true,
-    audio: true,
-    video: true,
-    pdf: true,
-    maxTokens: 2e6,
-    outputTokens: 8192
-  },
-  "gemini-1.5-pro-latest": {
-    vision: true,
-    tools: true,
-    audio: true,
-    video: true,
-    pdf: true,
-    maxTokens: 2e6,
-    outputTokens: 8192
-  },
-  "gemini-1.5-flash": {
-    vision: true,
-    tools: true,
-    audio: true,
-    video: true,
-    pdf: true,
-    maxTokens: 1e6,
-    outputTokens: 8192
-  },
-  "gemini-1.5-flash-latest": {
-    vision: true,
-    tools: true,
-    audio: true,
-    video: true,
-    pdf: true,
-    maxTokens: 1e6,
-    outputTokens: 8192
-  },
-  "gemini-1.5-flash-8b": {
-    vision: true,
-    tools: true,
-    audio: false,
-    video: false,
-    pdf: true,
-    maxTokens: 1e6,
-    outputTokens: 8192
-  },
-  // Gemini 1.0 series (legacy)
-  "gemini-1.0-pro": {
-    vision: false,
-    tools: true,
-    audio: false,
-    video: false,
-    pdf: false,
-    maxTokens: 30720,
-    outputTokens: 2048
-  }
-};
-function createGoogle(config = {}) {
-  const apiKey = config.apiKey ?? process.env.GOOGLE_API_KEY ?? "";
-  return {
-    name: "google",
-    supportedModels: Object.keys(GOOGLE_MODELS2),
-    languageModel(modelId) {
-      return createGoogleAdapter({
-        apiKey,
-        model: modelId,
-        baseUrl: config.baseUrl,
-        safetySettings: config.safetySettings
-      });
-    },
-    getCapabilities(modelId) {
-      const model = GOOGLE_MODELS2[modelId] ?? GOOGLE_MODELS2["gemini-2.0-flash"];
-      return {
-        supportsVision: model.vision,
-        supportsTools: model.tools,
-        supportsThinking: false,
-        // Gemini doesn't have extended thinking like Claude
-        supportsStreaming: true,
-        supportsPDF: model.pdf,
-        supportsAudio: model.audio,
-        supportsVideo: model.video,
-        maxTokens: model.maxTokens,
-        supportedImageTypes: model.vision ? [
-          "image/png",
-          "image/jpeg",
-          "image/gif",
-          "image/webp",
-          "image/heic",
-          "image/heif"
-        ] : [],
-        supportedAudioTypes: model.audio ? [
-          "audio/mp3",
-          "audio/wav",
-          "audio/aiff",
-          "audio/aac",
-          "audio/ogg",
-          "audio/flac"
-        ] : [],
-        supportedVideoTypes: model.video ? [
-          "video/mp4",
-          "video/mpeg",
-          "video/mov",
-          "video/avi",
-          "video/webm",
-          "video/mkv"
-        ] : [],
-        supportsJsonMode: true,
-        // Gemini supports JSON mode
-        supportsSystemMessages: true
-      };
-    }
-  };
-}
-
-// src/providers/xai/index.ts
-var XAI_MODELS2 = {
-  // Grok 4.1 Fast (Latest - December 2025)
-  "grok-4-1-fast-reasoning": {
-    vision: false,
-    tools: true,
-    maxTokens: 2e6,
-    outputTokens: 16384
-  },
-  "grok-4-1-fast-non-reasoning": {
-    vision: false,
-    tools: true,
-    maxTokens: 2e6,
-    outputTokens: 16384
-  },
-  // Grok 4 Fast (September 2025)
-  "grok-4-fast-reasoning": {
-    vision: false,
-    tools: true,
-    maxTokens: 2e6,
-    outputTokens: 16384
-  },
-  "grok-4-fast-non-reasoning": {
-    vision: false,
-    tools: true,
-    maxTokens: 2e6,
-    outputTokens: 16384
-  },
-  // Grok 4 (July 2025)
-  "grok-4": {
-    vision: true,
-    tools: true,
-    maxTokens: 256e3,
-    outputTokens: 16384
-  },
-  "grok-4-0709": {
-    vision: true,
-    tools: true,
-    maxTokens: 256e3,
-    outputTokens: 16384
-  },
-  // Grok 3 (February 2025) - Stable
-  "grok-3-beta": {
-    vision: true,
-    tools: true,
-    maxTokens: 131072,
-    outputTokens: 8192
-  },
-  "grok-3-fast-beta": {
-    vision: false,
-    tools: true,
-    maxTokens: 131072,
-    outputTokens: 8192
-  },
-  "grok-3-mini-beta": {
-    vision: false,
-    tools: true,
-    maxTokens: 32768,
-    outputTokens: 8192
-  },
-  "grok-3-mini-fast-beta": {
-    vision: false,
-    tools: true,
-    maxTokens: 32768,
-    outputTokens: 8192
-  },
-  // Grok Code Fast (August 2025)
-  "grok-code-fast-1": {
-    vision: false,
-    tools: true,
-    maxTokens: 256e3,
-    outputTokens: 16384
-  },
-  // Grok 2 (Legacy - for backward compatibility)
-  "grok-2": {
-    vision: true,
-    tools: true,
-    maxTokens: 131072,
-    outputTokens: 4096
-  },
-  "grok-2-latest": {
-    vision: true,
-    tools: true,
-    maxTokens: 131072,
-    outputTokens: 4096
-  },
-  "grok-2-mini": {
-    vision: false,
-    tools: true,
-    maxTokens: 131072,
-    outputTokens: 4096
-  }
-};
-function createXAI(config = {}) {
-  const apiKey = config.apiKey ?? process.env.XAI_API_KEY ?? "";
-  return {
-    name: "xai",
-    supportedModels: Object.keys(XAI_MODELS2),
-    languageModel(modelId) {
-      return createXAIAdapter({
-        apiKey,
-        model: modelId,
-        baseUrl: config.baseUrl
-      });
-    },
-    getCapabilities(modelId) {
-      const model = XAI_MODELS2[modelId] ?? XAI_MODELS2["grok-3-fast-beta"];
-      return {
-        supportsVision: model.vision,
-        supportsTools: model.tools,
-        supportsThinking: false,
-        supportsStreaming: true,
-        supportsPDF: false,
-        supportsAudio: false,
-        supportsVideo: false,
-        maxTokens: model.maxTokens,
-        supportedImageTypes: model.vision ? ["image/png", "image/jpeg", "image/gif", "image/webp"] : [],
-        supportsJsonMode: false,
-        // xAI doesn't support JSON mode yet
-        supportsSystemMessages: true
-      };
-    }
-  };
-}
-
-// src/providers/azure/index.ts
-function detectCapabilitiesFromDeployment(deploymentName) {
-  const name = deploymentName.toLowerCase();
-  if (name.includes("gpt-4o") || name.includes("gpt4o")) {
-    return { vision: true, tools: true, maxTokens: 128e3 };
-  }
-  if ((name.includes("gpt-4") || name.includes("gpt4")) && (name.includes("turbo") || name.includes("vision"))) {
-    return { vision: true, tools: true, maxTokens: 128e3 };
-  }
-  if (name.includes("gpt-4") || name.includes("gpt4")) {
-    return { vision: false, tools: true, maxTokens: 8192 };
-  }
-  if (name.includes("gpt-35") || name.includes("gpt-3.5") || name.includes("gpt35")) {
-    return { vision: false, tools: true, maxTokens: 16385 };
-  }
-  if (name.includes("o1")) {
-    return { vision: true, tools: false, maxTokens: 128e3 };
-  }
-  return { vision: false, tools: true, maxTokens: 8192 };
-}
-function createAzure(config) {
-  const apiKey = config.apiKey ?? process.env.AZURE_OPENAI_API_KEY ?? "";
-  const resourceName = config.resourceName ?? process.env.AZURE_OPENAI_RESOURCE ?? "";
-  const defaultDeployment = config.deploymentName ?? process.env.AZURE_OPENAI_DEPLOYMENT ?? "";
-  const supportedModels = defaultDeployment ? [defaultDeployment] : [];
-  return {
-    name: "azure",
-    supportedModels,
-    languageModel(deploymentName) {
-      return createAzureAdapter({
-        apiKey,
-        resourceName,
-        deploymentName: deploymentName || defaultDeployment,
-        apiVersion: config.apiVersion,
-        baseUrl: config.baseUrl
-      });
-    },
-    getCapabilities(deploymentName) {
-      const detected = detectCapabilitiesFromDeployment(
-        deploymentName || defaultDeployment
-      );
-      return {
-        supportsVision: detected.vision,
-        supportsTools: detected.tools,
-        supportsThinking: false,
-        supportsStreaming: true,
-        supportsPDF: false,
-        supportsAudio: false,
-        supportsVideo: false,
-        maxTokens: detected.maxTokens,
-        supportedImageTypes: detected.vision ? ["image/png", "image/jpeg", "image/gif", "image/webp"] : [],
-        supportsJsonMode: true,
-        supportsSystemMessages: true
-      };
-    }
-  };
-}
-
 // src/providers/openai.ts
 function transformTools(tools) {
   return tools.map((tool2) => ({
@@ -5487,20 +2905,6 @@ function getFormatter(provider) {
   }
   return formatter;
 }
-function isProviderSupported(provider) {
-  return provider.toLowerCase() in formatters;
-}
-function getSupportedProviders() {
-  return Object.keys(formatters);
-}
-
-// src/providers/index.ts
-registerProvider("openai", (config) => createOpenAI(config));
-registerProvider("anthropic", (config) => createAnthropic(config));
-registerProvider("ollama", (config) => createOllama(config));
-registerProvider("google", (config) => createGoogle(config));
-registerProvider("xai", (config) => createXAI(config));
-registerProvider("azure", (config) => createAzure(config));
 
 // src/server/agent-loop.ts
 var DEFAULT_MAX_ITERATIONS = 20;
@@ -5742,58 +3146,24 @@ async function executeToolCalls(toolCalls, tools, executeServerTool, waitForClie
   return results;
 }
 
-exports.AnthropicAdapter = AnthropicAdapter;
-exports.AzureAdapter = AzureAdapter;
 exports.DEFAULT_CAPABILITIES = DEFAULT_CAPABILITIES;
 exports.DEFAULT_MAX_ITERATIONS = DEFAULT_MAX_ITERATIONS;
-exports.GoogleAdapter = GoogleAdapter;
-exports.OllamaAdapter = OllamaAdapter;
-exports.OpenAIAdapter = OpenAIAdapter;
 exports.Runtime = Runtime;
-exports.XAIAdapter = XAIAdapter;
-exports.anthropic = anthropic;
-exports.anthropicFormatter = anthropicFormatter;
-exports.createAnthropic = createAnthropic;
-exports.createAnthropicAdapter = createAnthropicAdapter;
-exports.createAzure = createAzure;
-exports.createAzureAdapter = createAzureAdapter;
 exports.createEventStream = createEventStream;
 exports.createExpressMiddleware = createExpressMiddleware;
-exports.createGoogle = createGoogle;
-exports.createGoogleAdapter = createGoogleAdapter;
 exports.createHonoApp = createHonoApp;
 exports.createNextHandler = createNextHandler;
 exports.createNodeHandler = createNodeHandler;
-exports.createOllama = createOllama;
-exports.createOllamaAdapter = createOllamaAdapter;
-exports.createOpenAI = createOpenAI;
-exports.createOpenAIAdapter = createOpenAIAdapter;
 exports.createRuntime = createRuntime;
 exports.createSSEHeaders = createSSEHeaders;
 exports.createSSEResponse = createSSEResponse;
-exports.createXAI = createXAI;
-exports.createXAIAdapter = createXAIAdapter;
 exports.formatSSEData = formatSSEData;
 exports.formatToolsForAnthropic = formatToolsForAnthropic;
 exports.formatToolsForGoogle = formatToolsForGoogle;
 exports.formatToolsForOpenAI = formatToolsForOpenAI;
-exports.geminiFormatter = geminiFormatter;
 exports.generateText = generateText;
-exports.getAvailableProviders = getAvailableProviders;
-exports.getFormatter = getFormatter;
-exports.getModelCapabilities = getModelCapabilities;
-exports.getProvider = getProvider;
-exports.getSupportedProviders = getSupportedProviders;
-exports.google = google;
-exports.hasProvider = hasProvider;
-exports.isProviderSupported = isProviderSupported;
-exports.listProviders = listProviders;
-exports.openai = openai;
-exports.openaiFormatter = openaiFormatter;
-exports.registerProvider = registerProvider;
 exports.runAgentLoop = runAgentLoop;
 exports.streamText = streamText;
 exports.tool = tool;
-exports.xai = xai;
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map