@yourgpt/llm-sdk 0.1.0 → 1.0.0

package/dist/providers/anthropic/index.js

@@ -0,0 +1,939 @@
+'use strict';
+
+var core = require('@yourgpt/copilot-sdk/core');
+
+// 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: mapFinishReason(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: mapFinishReason(event.delta.stop_reason),
+                usage: {
+                  promptTokens: inputTokens,
+                  completionTokens: outputTokens,
+                  totalTokens: inputTokens + outputTokens
+                }
+              };
+            }
+            break;
+        }
+      }
+    }
+  };
+}
+function mapFinishReason(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/adapters/base.ts
+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 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 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
+  };
+}
+
+// src/adapters/anthropic.ts
+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);
+}
+
+// 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
+      };
+    }
+  };
+}
+var createAnthropicProvider = createAnthropic;
+
+exports.anthropic = anthropic;
+exports.createAnthropic = createAnthropic;
+exports.createAnthropicModel = anthropic;
+exports.createAnthropicProvider = createAnthropicProvider;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map