@ddlqhd/agent-sdk 0.1.0

package/dist/chunk-NDSL7NPN.js

@@ -0,0 +1,807 @@
+#!/usr/bin/env node
+import { BaseModelAdapter, toolsToModelSchema } from './chunk-WH3APNQ5.js';
+
+// src/models/openai.ts
+var OPENAI_CAPABILITIES = {
+  "gpt-4o": { contextLength: 128e3, maxOutputTokens: 16384 },
+  "gpt-4o-mini": { contextLength: 128e3, maxOutputTokens: 16384 },
+  "gpt-4-turbo": { contextLength: 128e3, maxOutputTokens: 4096 },
+  "gpt-4": { contextLength: 8192, maxOutputTokens: 4096 },
+  "gpt-3.5-turbo": { contextLength: 16385, maxOutputTokens: 4096 }
+};
+var OpenAIAdapter = class extends BaseModelAdapter {
+  name;
+  apiKey;
+  baseUrl;
+  model;
+  organization;
+  constructor(config = {}) {
+    super();
+    this.apiKey = config.apiKey || process.env.OPENAI_API_KEY || "";
+    this.baseUrl = config.baseUrl || process.env.OPENAI_BASE_URL || "https://api.openai.com/v1";
+    this.model = config.model || "gpt-4o";
+    this.organization = config.organization || process.env.OPENAI_ORG_ID;
+    if (!this.apiKey) {
+      throw new Error("OpenAI API key is required. Set OPENAI_API_KEY environment variable or pass apiKey in config.");
+    }
+    this.name = `openai/${this.model}`;
+    this.capabilities = config.capabilities ?? OPENAI_CAPABILITIES[this.model] ?? { contextLength: 128e3, maxOutputTokens: 4096 };
+  }
+  async *stream(params) {
+    const body = this.buildRequestBody(params, true);
+    const response = await this.fetch("/chat/completions", body, params.signal);
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`OpenAI API error: ${response.status} - ${error}`);
+    }
+    const reader = response.body?.getReader();
+    if (!reader) {
+      throw new Error("No response body");
+    }
+    const decoder = new TextDecoder();
+    let buffer = "";
+    let currentToolCall = null;
+    try {
+      while (true) {
+        if (params.signal?.aborted) {
+          reader.cancel();
+          break;
+        }
+        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) {
+          const trimmed = line.trim();
+          if (!trimmed || trimmed === "data: [DONE]") continue;
+          if (!trimmed.startsWith("data: ")) continue;
+          try {
+            const data = JSON.parse(trimmed.slice(6));
+            const choice = data.choices?.[0];
+            if (!choice) continue;
+            const raw = params.includeRawStreamEvents ? { providerRaw: data } : {};
+            if (choice.delta?.content) {
+              yield { type: "text", content: choice.delta.content, ...raw };
+            }
+            if (choice.delta?.tool_calls) {
+              for (const toolCall of choice.delta.tool_calls) {
+                if (toolCall.index !== void 0) {
+                  if (toolCall.id && toolCall.function?.name) {
+                    if (currentToolCall) {
+                      yield {
+                        type: "tool_call",
+                        toolCall: {
+                          id: currentToolCall.id,
+                          name: currentToolCall.name,
+                          arguments: this.safeParseJSON(currentToolCall.arguments)
+                        },
+                        ...raw
+                      };
+                    }
+                    currentToolCall = {
+                      id: toolCall.id,
+                      name: toolCall.function.name,
+                      arguments: toolCall.function.arguments || ""
+                    };
+                    yield {
+                      type: "tool_call_start",
+                      content: toolCall.function.name,
+                      toolCallId: toolCall.id,
+                      ...raw
+                    };
+                  } else if (toolCall.function?.arguments && currentToolCall) {
+                    currentToolCall.arguments += toolCall.function.arguments;
+                    yield {
+                      type: "tool_call_delta",
+                      content: toolCall.function.arguments,
+                      toolCallId: currentToolCall.id,
+                      ...raw
+                    };
+                  }
+                }
+              }
+            }
+            if (choice.finish_reason === "tool_calls" && currentToolCall) {
+              yield {
+                type: "tool_call",
+                toolCall: {
+                  id: currentToolCall.id,
+                  name: currentToolCall.name,
+                  arguments: this.safeParseJSON(currentToolCall.arguments)
+                },
+                ...raw
+              };
+              currentToolCall = null;
+            }
+            if (data.usage) {
+              yield {
+                type: "metadata",
+                usagePhase: "output",
+                metadata: {
+                  usage: {
+                    promptTokens: data.usage.prompt_tokens,
+                    completionTokens: data.usage.completion_tokens,
+                    totalTokens: data.usage.total_tokens
+                  }
+                },
+                ...raw
+              };
+            }
+          } catch {
+          }
+        }
+      }
+      if (currentToolCall) {
+        yield {
+          type: "tool_call",
+          toolCall: {
+            id: currentToolCall.id,
+            name: currentToolCall.name,
+            arguments: this.safeParseJSON(currentToolCall.arguments)
+          },
+          ...params.includeRawStreamEvents ? { providerRaw: { trailing: true } } : {}
+        };
+      }
+      yield { type: "done" };
+    } finally {
+      reader.releaseLock();
+    }
+  }
+  async complete(params) {
+    const body = this.buildRequestBody(params, false);
+    const response = await this.fetch("/chat/completions", body);
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`OpenAI API error: ${response.status} - ${error}`);
+    }
+    const data = await response.json();
+    const choice = data.choices?.[0];
+    if (!choice) {
+      throw new Error("No completion choice returned");
+    }
+    const result = {
+      content: choice.message?.content || ""
+    };
+    if (choice.message?.tool_calls) {
+      result.toolCalls = choice.message.tool_calls.map((tc) => ({
+        id: tc.id,
+        name: tc.function.name,
+        arguments: this.safeParseJSON(tc.function.arguments)
+      }));
+    }
+    if (data.usage) {
+      result.usage = {
+        promptTokens: data.usage.prompt_tokens,
+        completionTokens: data.usage.completion_tokens,
+        totalTokens: data.usage.total_tokens
+      };
+    }
+    return result;
+  }
+  buildRequestBody(params, stream) {
+    const messages = this.transformMessages(params.messages);
+    const body = {
+      model: this.model,
+      messages,
+      stream,
+      ...stream && { stream_options: { include_usage: true } },
+      ...params.temperature !== void 0 && { temperature: params.temperature },
+      ...params.maxTokens !== void 0 && { max_tokens: params.maxTokens },
+      ...params.stopSequences && { stop: params.stopSequences }
+    };
+    if (params.tools && params.tools.length > 0) {
+      body.tools = toolsToModelSchema(params.tools).map((tool) => ({
+        type: "function",
+        function: tool
+      }));
+    }
+    return body;
+  }
+  async fetch(path, body, signal) {
+    const headers = {
+      "Content-Type": "application/json",
+      "Authorization": `Bearer ${this.apiKey}`
+    };
+    if (this.organization) {
+      headers["OpenAI-Organization"] = this.organization;
+    }
+    return globalThis.fetch(`${this.baseUrl}${path}`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(body),
+      signal
+    });
+  }
+  safeParseJSON(str) {
+    try {
+      return JSON.parse(str);
+    } catch {
+      return str;
+    }
+  }
+};
+function createOpenAI(config) {
+  return new OpenAIAdapter(config);
+}
+
+// src/models/anthropic.ts
+var ANTHROPIC_CAPABILITIES = {
+  "claude-sonnet-4-20250514": { contextLength: 2e5, maxOutputTokens: 16384 },
+  "claude-haiku": { contextLength: 2e5, maxOutputTokens: 8192 },
+  "claude-3-5-sonnet-20241022": { contextLength: 2e5, maxOutputTokens: 8192 },
+  "claude-3-haiku-20240307": { contextLength: 2e5, maxOutputTokens: 4096 }
+};
+var AnthropicAdapter = class extends BaseModelAdapter {
+  name;
+  apiKey;
+  baseUrl;
+  model;
+  version;
+  constructor(config = {}) {
+    super();
+    this.apiKey = config.apiKey || process.env.ANTHROPIC_API_KEY || "";
+    this.baseUrl = config.baseUrl || process.env.ANTHROPIC_BASE_URL || "https://api.anthropic.com";
+    this.model = config.model || "claude-sonnet-4-20250514";
+    this.version = config.version || "2023-06-01";
+    if (!this.apiKey) {
+      throw new Error("Anthropic API key is required. Set ANTHROPIC_API_KEY environment variable or pass apiKey in config.");
+    }
+    this.name = `anthropic/${this.model}`;
+    this.capabilities = config.capabilities ?? ANTHROPIC_CAPABILITIES[this.model] ?? { contextLength: 2e5, maxOutputTokens: 4096 };
+  }
+  async *stream(params) {
+    const body = this.buildRequestBody(params, true);
+    const response = await this.fetch("/v1/messages", body, params.signal);
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`Anthropic API error: ${response.status} - ${error}`);
+    }
+    const reader = response.body?.getReader();
+    if (!reader) {
+      throw new Error("No response body");
+    }
+    const decoder = new TextDecoder();
+    let buffer = "";
+    let currentToolCall = null;
+    let currentThinkingBlock = null;
+    try {
+      while (true) {
+        if (params.signal?.aborted) {
+          reader.cancel();
+          break;
+        }
+        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) {
+          const trimmed = line.trim();
+          if (!trimmed || !trimmed.startsWith("data:")) continue;
+          let jsonStart = 5;
+          if (trimmed.length > 5 && trimmed[5] === " ") {
+            jsonStart = 6;
+          }
+          const jsonStr = trimmed.slice(jsonStart);
+          try {
+            const data = JSON.parse(jsonStr);
+            const raw = params.includeRawStreamEvents ? { providerRaw: data } : {};
+            switch (data.type) {
+              case "content_block_start":
+                if (data.content_block?.type === "tool_use") {
+                  currentToolCall = {
+                    id: data.content_block.id,
+                    name: data.content_block.name,
+                    input: ""
+                  };
+                  yield {
+                    type: "tool_call_start",
+                    toolCall: {
+                      id: data.content_block.id,
+                      name: data.content_block.name,
+                      arguments: {}
+                    },
+                    ...raw
+                  };
+                } else if (data.content_block?.type === "thinking") {
+                  currentThinkingBlock = {
+                    signature: data.content_block.signature
+                  };
+                  yield {
+                    type: "thinking",
+                    content: data.content_block.thinking,
+                    signature: currentThinkingBlock.signature,
+                    ...raw
+                  };
+                }
+                break;
+              case "content_block_delta":
+                if (data.delta?.type === "text_delta") {
+                  yield { type: "text", content: data.delta.text, ...raw };
+                } else if (data.delta?.type === "thinking_delta") {
+                  yield {
+                    type: "thinking",
+                    content: data.delta.thinking,
+                    signature: currentThinkingBlock?.signature,
+                    ...raw
+                  };
+                } else if (data.delta?.type === "input_json_delta" && currentToolCall) {
+                  currentToolCall.input += data.delta.partial_json;
+                  yield {
+                    type: "tool_call_delta",
+                    content: data.delta.partial_json,
+                    toolCallId: currentToolCall.id,
+                    ...raw
+                  };
+                }
+                break;
+              case "content_block_stop":
+                if (currentToolCall) {
+                  yield {
+                    type: "tool_call",
+                    toolCall: {
+                      id: currentToolCall.id,
+                      name: currentToolCall.name,
+                      arguments: this.safeParseJSON(currentToolCall.input)
+                    },
+                    ...raw
+                  };
+                  currentToolCall = null;
+                }
+                if (currentThinkingBlock) {
+                  currentThinkingBlock = null;
+                }
+                break;
+              case "message_start":
+                if (data.message?.usage) {
+                  const usage = data.message.usage;
+                  const actualInputTokens = usage.input_tokens + (usage.cache_read_input_tokens || 0);
+                  yield {
+                    type: "metadata",
+                    usagePhase: "input",
+                    metadata: {
+                      usage: {
+                        promptTokens: actualInputTokens,
+                        completionTokens: 0,
+                        totalTokens: actualInputTokens,
+                        // 传递缓存信息
+                        cacheReadTokens: usage.cache_read_input_tokens || 0,
+                        cacheWriteTokens: usage.cache_creation_input_tokens || 0
+                      }
+                    },
+                    ...raw
+                  };
+                }
+                break;
+              case "message_delta":
+                if (data.usage) {
+                  yield {
+                    type: "metadata",
+                    usagePhase: "output",
+                    metadata: {
+                      usage: {
+                        promptTokens: 0,
+                        completionTokens: data.usage.output_tokens,
+                        totalTokens: data.usage.output_tokens
+                      }
+                    },
+                    ...raw
+                  };
+                }
+                break;
+            }
+          } catch {
+          }
+        }
+      }
+      yield { type: "done" };
+    } finally {
+      reader.releaseLock();
+    }
+  }
+  async complete(params) {
+    const body = this.buildRequestBody(params, false);
+    const response = await this.fetch("/v1/messages", body);
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`Anthropic API error: ${response.status} - ${error}`);
+    }
+    const data = await response.json();
+    const result = {
+      content: ""
+    };
+    const toolCalls = [];
+    for (const block of data.content || []) {
+      if (block.type === "text") {
+        result.content += block.text;
+      } else if (block.type === "tool_use") {
+        toolCalls.push({
+          id: block.id,
+          name: block.name,
+          arguments: block.input
+        });
+      }
+    }
+    if (toolCalls.length > 0) {
+      result.toolCalls = toolCalls;
+    }
+    if (data.usage) {
+      const usage = data.usage;
+      const actualInputTokens = usage.input_tokens + (usage.cache_read_input_tokens || 0);
+      result.usage = {
+        promptTokens: actualInputTokens,
+        completionTokens: usage.output_tokens,
+        totalTokens: actualInputTokens + usage.output_tokens
+      };
+    }
+    return result;
+  }
+  buildRequestBody(params, stream) {
+    const { system, messages } = this.extractSystemMessage(params.messages);
+    const transformedMessages = this.transformAnthropicMessages(messages);
+    const body = {
+      model: this.model,
+      max_tokens: params.maxTokens || 4096,
+      messages: transformedMessages,
+      stream,
+      ...system && { system },
+      ...params.temperature !== void 0 && { temperature: params.temperature }
+    };
+    if (params.tools && params.tools.length > 0) {
+      body.tools = toolsToModelSchema(params.tools).map((tool) => ({
+        name: tool.name,
+        description: tool.description,
+        input_schema: tool.parameters
+      }));
+    }
+    return body;
+  }
+  extractSystemMessage(messages) {
+    const systemMessages = messages.filter((m) => m.role === "system");
+    const otherMessages = messages.filter((m) => m.role !== "system");
+    const combinedSystem = systemMessages.length > 0 ? systemMessages.map((m) => m.content).join("\n\n") : void 0;
+    return {
+      system: combinedSystem,
+      messages: otherMessages
+    };
+  }
+  transformAnthropicMessages(messages) {
+    return messages.map((msg) => {
+      const transformed = {
+        role: msg.role === "assistant" ? "assistant" : "user",
+        content: []
+      };
+      if (typeof msg.content === "string") {
+        transformed.content = [{ type: "text", text: msg.content }];
+      } else if (Array.isArray(msg.content)) {
+        const contentParts = [];
+        for (const part of msg.content) {
+          if (part.type === "thinking") {
+            contentParts.push(part);
+          } else if (part.type === "text") {
+            contentParts.push({ type: "text", text: part.text });
+          } else {
+            contentParts.push(part);
+          }
+        }
+        transformed.content = contentParts;
+        if (contentParts.length === 0) {
+          transformed.content = "";
+        }
+      }
+      if (msg.toolCalls && msg.role === "assistant") {
+        for (const tc of msg.toolCalls) {
+          transformed.content.push({
+            type: "tool_use",
+            id: tc.id,
+            name: tc.name,
+            input: tc.arguments
+          });
+        }
+      }
+      if (msg.role === "tool" && msg.toolCallId) {
+        transformed.role = "user";
+        transformed.content = [{
+          type: "tool_result",
+          tool_use_id: msg.toolCallId,
+          content: msg.content
+        }];
+      }
+      return transformed;
+    });
+  }
+  async fetch(path, body, signal) {
+    return globalThis.fetch(`${this.baseUrl}${path}`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "x-api-key": this.apiKey,
+        "anthropic-version": this.version
+      },
+      body: JSON.stringify(body),
+      signal
+    });
+  }
+  safeParseJSON(str) {
+    try {
+      return JSON.parse(str);
+    } catch {
+      return str;
+    }
+  }
+};
+function createAnthropic(config) {
+  return new AnthropicAdapter(config);
+}
+
+// src/models/ollama.ts
+var OLLAMA_CAPABILITIES = {
+  "qwen3.5:0.8b": { contextLength: 32768, maxOutputTokens: 4096 },
+  "minimax-m2.7:cloud": { contextLength: 128e3, maxOutputTokens: 16384 },
+  "nemotron-3-super:cloud": { contextLength: 128e3, maxOutputTokens: 16384 },
+  "glm-5:cloud": { contextLength: 128e3, maxOutputTokens: 16384 }
+};
+function ollamaStreamChunksFromChatData(data, parseToolArguments, nextToolCallId) {
+  const chunks = [];
+  const msg = data.message;
+  if (!msg) return chunks;
+  const thinking = msg.thinking;
+  if (typeof thinking === "string" && thinking.length > 0) {
+    chunks.push({ type: "thinking", content: thinking });
+  }
+  const content = msg.content;
+  if (typeof content === "string" && content.length > 0) {
+    chunks.push({ type: "text", content });
+  }
+  const toolCalls = msg.tool_calls;
+  if (toolCalls && Array.isArray(toolCalls)) {
+    for (const tc of toolCalls) {
+      const t = tc;
+      const fn = t.function;
+      chunks.push({
+        type: "tool_call",
+        toolCall: {
+          id: nextToolCallId(),
+          name: (typeof fn?.name === "string" ? fn.name : "") || "",
+          arguments: parseToolArguments(fn?.arguments)
+        }
+      });
+    }
+  }
+  return chunks;
+}
+function ollamaMessageContentToApiString(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  const texts = [];
+  for (const part of content) {
+    if (part.type === "text") {
+      texts.push(part.text);
+    }
+  }
+  return texts.join("\n\n");
+}
+function uniqueOllamaToolCallId(batchMs, index) {
+  return `ollama_${batchMs}_${index}_${Math.random().toString(36).slice(2, 11)}`;
+}
+var OllamaAdapter = class extends BaseModelAdapter {
+  name;
+  baseUrl;
+  model;
+  think;
+  constructor(config = {}) {
+    super();
+    this.baseUrl = config.baseUrl || process.env.OLLAMA_BASE_URL || "http://localhost:11434";
+    this.model = config.model || "qwen3.5:0.8b";
+    this.think = config.think;
+    this.name = `ollama/${this.model}`;
+    this.capabilities = config.capabilities ?? OLLAMA_CAPABILITIES[this.model] ?? { contextLength: 4096, maxOutputTokens: 2048 };
+  }
+  async *stream(params) {
+    const body = this.buildRequestBody(params, true);
+    const response = await this.fetch("/api/chat", body, params.signal);
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`Ollama API error: ${response.status} - ${error}`);
+    }
+    const reader = response.body?.getReader();
+    if (!reader) {
+      throw new Error("No response body");
+    }
+    const decoder = new TextDecoder();
+    let buffer = "";
+    const nextToolCallId = () => `ollama_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`;
+    try {
+      while (true) {
+        if (params.signal?.aborted) {
+          reader.cancel();
+          break;
+        }
+        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) {
+          const trimmed = line.trim();
+          if (!trimmed) continue;
+          try {
+            const data = JSON.parse(trimmed);
+            const raw = params.includeRawStreamEvents ? { providerRaw: data } : {};
+            const messageChunks = ollamaStreamChunksFromChatData(
+              data,
+              (args) => this.parseToolArguments(args),
+              nextToolCallId
+            );
+            for (const chunk of messageChunks) {
+              yield { ...chunk, ...raw };
+            }
+            if (data.done) {
+              if (data.prompt_eval_count || data.eval_count) {
+                yield {
+                  type: "metadata",
+                  usagePhase: "output",
+                  metadata: {
+                    usage: {
+                      promptTokens: data.prompt_eval_count || 0,
+                      completionTokens: data.eval_count || 0,
+                      totalTokens: (data.prompt_eval_count || 0) + (data.eval_count || 0)
+                    }
+                  },
+                  ...raw
+                };
+              }
+              yield { type: "done", ...raw };
+            }
+          } catch {
+          }
+        }
+      }
+    } finally {
+      reader.releaseLock();
+    }
+  }
+  async complete(params) {
+    const body = this.buildRequestBody(params, false);
+    const response = await this.fetch("/api/chat", body);
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`Ollama API error: ${response.status} - ${error}`);
+    }
+    const data = await response.json();
+    const result = {
+      content: data.message?.content || ""
+    };
+    const thinking = data.message?.thinking;
+    if (typeof thinking === "string" && thinking.length > 0) {
+      result.thinking = thinking;
+    }
+    if (data.message?.tool_calls) {
+      const batchMs = Date.now();
+      result.toolCalls = data.message.tool_calls.map((tc, index) => ({
+        id: uniqueOllamaToolCallId(batchMs, index),
+        name: tc.function?.name || "",
+        arguments: this.parseToolArguments(tc.function?.arguments)
+      }));
+    }
+    if (data.prompt_eval_count || data.eval_count) {
+      result.usage = {
+        promptTokens: data.prompt_eval_count || 0,
+        completionTokens: data.eval_count || 0,
+        totalTokens: (data.prompt_eval_count || 0) + (data.eval_count || 0)
+      };
+    }
+    return result;
+  }
+  parseToolArguments(args) {
+    if (args == null) return {};
+    if (typeof args === "object" && !Array.isArray(args)) return args;
+    if (typeof args === "string") {
+      try {
+        const parsed = JSON.parse(args);
+        return typeof parsed === "object" && parsed !== null ? parsed : { value: parsed };
+      } catch {
+        return {};
+      }
+    }
+    return {};
+  }
+  /**
+   * Ollama 要求 tool_calls.function.arguments 为对象，而非 JSON 字符串。
+   * 工具结果消息使用 tool_name（见 https://docs.ollama.com/capabilities/tool-calling ），非 OpenAI 的 tool_call_id。
+   */
+  transformMessages(messages) {
+    const toolCallIdToName = /* @__PURE__ */ new Map();
+    for (const msg of messages) {
+      if (msg.role === "assistant" && msg.toolCalls) {
+        for (const tc of msg.toolCalls) {
+          toolCallIdToName.set(tc.id, tc.name);
+        }
+      }
+    }
+    return messages.map((msg) => {
+      if (msg.role === "tool" && msg.toolCallId) {
+        const toolName = toolCallIdToName.get(msg.toolCallId) ?? msg.name;
+        return {
+          role: "tool",
+          content: ollamaMessageContentToApiString(msg.content),
+          ...toolName && { tool_name: toolName }
+        };
+      }
+      return {
+        role: msg.role,
+        content: ollamaMessageContentToApiString(msg.content),
+        ...msg.toolCalls && { tool_calls: msg.toolCalls.map((tc) => ({
+          id: tc.id,
+          type: "function",
+          function: {
+            name: tc.name,
+            arguments: this.parseToolArguments(tc.arguments)
+          }
+        })) }
+      };
+    });
+  }
+  buildRequestBody(params, stream) {
+    const body = {
+      model: this.model,
+      messages: this.transformMessages(params.messages),
+      stream,
+      ...params.temperature !== void 0 && { options: { temperature: params.temperature } }
+    };
+    if (this.think !== void 0) {
+      body.think = this.think;
+    }
+    if (params.tools && params.tools.length > 0) {
+      body.tools = toolsToModelSchema(params.tools).map((tool) => ({
+        type: "function",
+        function: tool
+      }));
+    }
+    return body;
+  }
+  async fetch(path, body, signal) {
+    return globalThis.fetch(`${this.baseUrl}${path}`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(body),
+      signal
+    });
+  }
+};
+function createOllama(config) {
+  return new OllamaAdapter(config);
+}
+
+// src/models/index.ts
+function createModel(config) {
+  switch (config.provider) {
+    case "openai":
+      return new OpenAIAdapter({
+        apiKey: config.apiKey,
+        baseUrl: config.baseUrl,
+        model: config.model
+      });
+    case "anthropic":
+      return new AnthropicAdapter({
+        apiKey: config.apiKey,
+        baseUrl: config.baseUrl,
+        model: config.model
+      });
+    case "ollama":
+      return new OllamaAdapter({
+        baseUrl: config.baseUrl,
+        model: config.model,
+        think: config.think
+      });
+    default:
+      throw new Error(`Unknown model provider: ${config.provider}`);
+  }
+}
+
+export { AnthropicAdapter, OllamaAdapter, OpenAIAdapter, createAnthropic, createModel, createOllama, createOpenAI, ollamaMessageContentToApiString, ollamaStreamChunksFromChatData };
+//# sourceMappingURL=chunk-NDSL7NPN.js.map
+//# sourceMappingURL=chunk-NDSL7NPN.js.map