@agentscope-ai/agentscope 0.0.2

package/dist/model/index.js

@@ -0,0 +1,1880 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/model/index.ts
+var model_exports = {};
+__export(model_exports, {
+  ChatModelBase: () => ChatModelBase,
+  DashScopeChatModel: () => DashScopeChatModel,
+  DeepSeekChatModel: () => DeepSeekChatModel,
+  OllamaChatModel: () => OllamaChatModel,
+  OpenAIChatModel: () => OpenAIChatModel
+});
+module.exports = __toCommonJS(model_exports);
+
+// src/message/message.ts
+function createMsg({
+  name,
+  content,
+  role,
+  metadata = {},
+  id = crypto.randomUUID(),
+  timestamp = (/* @__PURE__ */ new Date()).toISOString(),
+  usage
+}) {
+  return { id, name, role, content, metadata, timestamp, usage };
+}
+function getTextContent(msg, separator = "\n") {
+  const textBlocks = msg.content.filter((block) => block.type === "text");
+  if (textBlocks.length === 0) {
+    return null;
+  }
+  return textBlocks.map((block) => block.text).join(separator);
+}
+function getContentBlocks(msg, blockType) {
+  if (!blockType) return msg.content;
+  return msg.content.filter((block) => block.type === blockType);
+}
+
+// src/model/base.ts
+var ChatModelBase = class {
+  modelName;
+  stream;
+  maxRetries;
+  fallbackModelName;
+  formatter;
+  /**
+   * Initializes a new instance of the ChatModelBase class.
+   *
+   * @param options - The chat model options, including model name, streaming option, max retries, fallback
+   *  model name, and formatter.
+   *
+   * @param options.modelName
+   * @param options.stream
+   * @param options.maxRetries
+   * @param options.fallbackModelName
+   * @param options.formatter
+   */
+  constructor({
+    modelName,
+    stream,
+    maxRetries,
+    fallbackModelName,
+    formatter
+  }) {
+    this.modelName = modelName;
+    this.stream = stream ?? true;
+    this.maxRetries = maxRetries ?? 0;
+    this.fallbackModelName = fallbackModelName;
+    this.formatter = formatter;
+  }
+  /**
+   * Calls the chat model with the given messages.
+   * This is the main method to interact with the model.
+   *
+   * @param options - The chat model call options.
+   * @returns A promise that resolves to the model's response.
+   */
+  async call(options) {
+    let formattedMessages;
+    if (this.formatter) {
+      formattedMessages = await this.formatter.format({ msgs: options.messages });
+    } else {
+      formattedMessages = options.messages;
+    }
+    const requestOptions = {
+      ...options,
+      messages: formattedMessages
+    };
+    let lastError;
+    for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
+      try {
+        return await this._callAPI(this.modelName, requestOptions);
+      } catch (error) {
+        lastError = error;
+        if (attempt === this.maxRetries) {
+          throw error;
+        } else {
+          console.log(
+            `Attempt ${attempt + 1} failed for model ${this.modelName}. Retrying...`
+          );
+        }
+      }
+    }
+    if (this.fallbackModelName) {
+      console.log(
+        `Using fallback model ${this.fallbackModelName} after ${this.maxRetries} failed attempts.`
+      );
+      return await this._callAPI(this.fallbackModelName, requestOptions);
+    }
+    throw lastError;
+  }
+  /**
+   * A heuristic method to count the number of the tokens
+   * Note the multimodal content is ignored in the token counting
+   * @param options
+   * @param options.messages
+   * @param options.tools
+   * @returns The estimated number of tokens in the input messages and tools.
+   */
+  async countTokens(options) {
+    let accText = "";
+    for (const msg of options.messages) {
+      accText += getTextContent(msg) || "";
+    }
+    if (options.tools) {
+      accText += JSON.stringify(options.tools);
+    }
+    const chineseMatches = accText.match(/[\u4e00-\u9fff\u3400-\u4dbf\u{20000}-\u{2a6df}]/gu)?.length ?? 0;
+    const englishMatches = accText.match(/[a-zA-Z]+/g)?.length ?? 0;
+    return chineseMatches * 2 + englishMatches * 1.5;
+  }
+  /**
+   * A default implementation of the structured call method. For those supporting structured output, the model should
+   * override this method.
+   * @param options
+   * @returns The structured response from the model, which should conform to the provided Zod schema.
+   */
+  async callStructured(options) {
+    const toolSchema = {
+      type: "function",
+      function: {
+        name: "GenerateStructuredResponse",
+        description: "Generate required structured response by this toll.",
+        parameters: options.schema.toJSONSchema({
+          target: "openapi-3.0"
+        })
+      }
+    };
+    const res = await this.call({
+      messages: options.messages,
+      tools: [toolSchema],
+      toolChoice: "GenerateStructuredResponse"
+    });
+    let completedResponse;
+    if (this.stream) {
+      while (true) {
+        const { value, done } = await res.next();
+        if (done) {
+          completedResponse = value;
+          break;
+        }
+      }
+    } else {
+      completedResponse = res;
+    }
+    for (const block of completedResponse.content) {
+      if (block.type === "tool_call" && block.name === "GenerateStructuredResponse") {
+        const structuredContent = JSON.parse(block.input);
+        return {
+          ...completedResponse,
+          content: structuredContent,
+          type: "structured"
+        };
+      }
+    }
+    throw new Error(`Failed to generate the structured response`);
+  }
+};
+
+// src/_utils/common.ts
+var import_jsonrepair = require("jsonrepair");
+async function* _parseStreamedResponse(response) {
+  const reader = response.body?.getReader();
+  if (!reader) {
+    throw new Error("Failed to get reader from response body for streaming.");
+  }
+  const decoder = new TextDecoder();
+  let buffer = "";
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() || "";
+      for (const line of lines) {
+        const trimmedLine = line.trim();
+        if (!trimmedLine || trimmedLine.startsWith(":")) {
+          continue;
+        }
+        if (trimmedLine.startsWith("data:")) {
+          const jsonStr = trimmedLine.slice(5).trim();
+          if (jsonStr === "[DONE]") {
+            break;
+          }
+          try {
+            const json = JSON.parse(jsonStr);
+            yield json;
+          } catch (e) {
+            console.error("Failed to parse JSON:", e);
+            throw new Error(`Failed to parse JSON from stream: ${jsonStr}`);
+          }
+        }
+      }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+
+// src/formatter/base.ts
+var FormatterBase = class {
+  /**
+   * Convert the tool output to string format for the LLM APIs that only accept text input. If
+   * `promoteMultimodalToolResult` is true, the multimodal content will be promoted to be a user message with
+   * "<system-info></system-info>" tags. Otherwise, the multimodal content will be saved to a storage and a URL link
+   * will be provided in the text output.
+   *
+   * @param output - The tool output, which can be a string or an array of content blocks.
+   * @param promoteMultimodalToolResult - Whether to promote the multimodal content to the prompt messages.
+   * @returns An object containing the text output and an optional promoted message.
+   */
+  convertToolOutputToString(output, promoteMultimodalToolResult) {
+    if (typeof output === "string") return { text: output, promotedMsg: null };
+    let textualOutput = [];
+    const promotedData = [];
+    for (const block of output) {
+      switch (block.type) {
+        case "text":
+          textualOutput.push(block.text);
+          break;
+        default:
+          const type = block.source.mediaType.split("/")[0];
+          if (type !== "image" && type !== "audio" && type !== "video") {
+            console.log(
+              `Unsupported media type '${block.source.mediaType}' in tool output. Only image, audio and video are supported.`
+            );
+            break;
+          }
+          if (block.source.type === "url") {
+            textualOutput.push(
+              `<system-info>One returned ${type} can be found at: ${block.source.url}</system-info>`
+            );
+          } else {
+            const shouldPromote = promoteMultimodalToolResult === true || typeof promoteMultimodalToolResult === "object" && promoteMultimodalToolResult[type];
+            if (shouldPromote) {
+              const dataID = Math.random().toString(36).substring(2, 10);
+              textualOutput.push(
+                `<system-info>One returned ${type} is embedded with ID '${dataID}' and will be attached within '<system-info></system-info>' tags later.</system-info>`
+              );
+              promotedData.push({ id: dataID, block });
+            } else {
+              textualOutput.push(`The returned ${block.type} is stored locally.`);
+            }
+          }
+      }
+    }
+    const promotedBlocks = [];
+    promotedData.forEach(({ id, block }) => {
+      const type = block.source.mediaType.split("/")[0];
+      promotedBlocks.push({
+        id: crypto.randomUUID(),
+        type: "text",
+        text: `<${type}_data id='${id}'>`
+      });
+      promotedBlocks.push(block);
+      promotedBlocks.push({
+        id: crypto.randomUUID(),
+        type: "text",
+        text: `</${type}_data>
+`
+      });
+    });
+    if (promotedBlocks.length > 0) {
+      const prefix = "<system-info>The multimodal contents returned from the tool call are as follows:\n";
+      if (promotedBlocks[0].type === "text") {
+        promotedBlocks[0].text = `${prefix}${promotedBlocks[0].text}`;
+      } else {
+        promotedBlocks.unshift({
+          id: crypto.randomUUID(),
+          type: "text",
+          text: `${prefix}`
+        });
+      }
+      const lastBlock = promotedBlocks[promotedBlocks.length - 1];
+      if (lastBlock.type === "text") {
+        promotedBlocks[promotedBlocks.length - 1] = {
+          id: crypto.randomUUID(),
+          type: "text",
+          text: `${lastBlock.text}</system-info>`
+        };
+      } else {
+        promotedBlocks.push({
+          id: crypto.randomUUID(),
+          type: "text",
+          text: `</system-info>`
+        });
+      }
+    }
+    return {
+      text: textualOutput.join("\n"),
+      promotedMsg: createMsg({ name: "user", content: promotedBlocks, role: "user" })
+    };
+  }
+};
+
+// src/formatter/dashscope-chat-formatter.ts
+var DashScopeChatFormatter = class extends FormatterBase {
+  promoteMultimodalToolResult;
+  /**
+   * Initialize a DashScopeChatFormatter instance.
+   *
+   * @param promoteMultimodalToolResult - Since DashScope API doesn't support multimodal tool outputs, this option
+   *  indicates whether to promote the multimodal tool results to the prompt messages, so that LLMs can see them.
+   *  Note you should ensure your model supports the corresponding modalities.
+   * @param promoteMultimodalToolResult.promoteMultimodalToolResult
+   */
+  constructor({ promoteMultimodalToolResult = false } = {}) {
+    super();
+    this.promoteMultimodalToolResult = promoteMultimodalToolResult;
+  }
+  /**
+   * Format the input message objects into the required format by DashScope API.
+   *
+   * @param msgs - An array of Msg instances to be formatted.
+   * @param msgs.msgs
+   * @returns A promise that resolves to an array of formatted message objects.
+   */
+  async format({ msgs }) {
+    const formattedMsgs = [];
+    let index = 0;
+    while (index < msgs.length) {
+      const msg = msgs[index];
+      const formattedMsg = {
+        role: msg.role,
+        content: []
+      };
+      const cachedMsgs = [];
+      for (const block of getContentBlocks(msg)) {
+        switch (block.type) {
+          case "text":
+            formattedMsg.content.push(this._formatTextBlock(block));
+            break;
+          case "thinking":
+            break;
+          case "tool_call":
+            if (!formattedMsg.tool_calls) {
+              formattedMsg.tool_calls = [];
+            }
+            formattedMsg.tool_calls.push({
+              id: block.id,
+              type: "function",
+              function: {
+                name: block.name,
+                arguments: block.input
+              }
+            });
+            break;
+          case "tool_result":
+            const formattedToolResult = this.convertToolOutputToString(
+              block.output,
+              this.promoteMultimodalToolResult
+            );
+            cachedMsgs.push({
+              role: "tool",
+              tool_call_id: block.id,
+              name: block.name,
+              content: formattedToolResult.text
+            });
+            if (formattedToolResult.promotedMsg) {
+              msgs.splice(index + 1, 0, formattedToolResult.promotedMsg);
+            }
+            break;
+          case "data":
+            formattedMsg.content.push(...this._formatMultimodalBlock(block));
+            break;
+        }
+      }
+      if (formattedMsg.content.length > 0 || formattedMsg.tool_calls) {
+        formattedMsgs.push(formattedMsg);
+      }
+      if (cachedMsgs.length > 0) {
+        formattedMsgs.push(...cachedMsgs);
+      }
+      index++;
+    }
+    return formattedMsgs;
+  }
+  /**
+   * Format a text content block into the required format.
+   *
+   * @param block - The text content block to format.
+   * @returns An object representing the formatted text content.
+   */
+  _formatTextBlock(block) {
+    return { text: block.text };
+  }
+  /**
+   * Format a multimodal data block into the required format.
+   * In DashScope API, the local file paths should be prefixed with "file://". URLs are kept unchanged.
+   *
+   * @param block - The multimodal content block to format.
+   * @returns An object representing the formatted multimodal content.
+   */
+  _formatMultimodalBlock(block) {
+    const type = block.source.mediaType.split("/")[0];
+    if (!["image", "audio", "video"].includes(type)) {
+      console.log(
+        `Skip unsupported media type ${block.source.mediaType} in DashScopeChatFormatter. Only image, audio and video are supported.`
+      );
+      return [];
+    }
+    if (block.source.type === "url") {
+      return [{ [type]: block.source.url }];
+    }
+    return [
+      {
+        [type]: `data:${block.source.mediaType};base64,${block.source.data}`
+      }
+    ];
+  }
+};
+
+// src/formatter/deepseek-chat-formatter.ts
+var DeepSeekChatFormatter = class extends FormatterBase {
+  promoteMultimodalToolResult;
+  /**
+   * Initializes a new instance of the DeepSeekChatFormatter class.
+   * @param root0
+   * @param root0.promoteMultimodalToolResult
+   */
+  constructor({ promoteMultimodalToolResult = false } = {}) {
+    super();
+    this.promoteMultimodalToolResult = promoteMultimodalToolResult;
+  }
+  /**
+   * Format the input messages into the structure expected by DeepSeek Chat Completions API.
+   * @param root0
+   * @param root0.msgs
+   * @returns An array of formatted message objects ready to be sent to the DeepSeek API.
+   */
+  async format({ msgs }) {
+    const formattedMsgs = [];
+    let index = 0;
+    while (index < msgs.length) {
+      const msg = msgs[index];
+      const formattedMsg = {
+        role: msg.role,
+        name: msg.name,
+        content: null
+      };
+      const content = [];
+      const cachedMsgs = [];
+      for (const block of getContentBlocks(msg)) {
+        switch (block.type) {
+          case "text":
+            content.push({
+              type: "text",
+              text: block.text
+            });
+            break;
+          case "thinking":
+            break;
+          case "tool_call":
+            if (!formattedMsg.tool_calls) {
+              formattedMsg.tool_calls = [];
+            }
+            formattedMsg.tool_calls.push({
+              id: block.id,
+              type: "function",
+              function: {
+                name: block.name,
+                arguments: block.input
+              }
+            });
+            break;
+          case "tool_result":
+            const formattedToolResult = this.convertToolOutputToString(
+              block.output,
+              this.promoteMultimodalToolResult
+            );
+            cachedMsgs.push({
+              role: "tool",
+              tool_call_id: block.id,
+              name: block.name,
+              content: formattedToolResult.text
+            });
+            if (formattedToolResult.promotedMsg?.content.length) {
+              msgs.splice(index + 1, 0, formattedToolResult.promotedMsg);
+            }
+            break;
+          case "data":
+            console.warn(
+              `DeepSeek models don't support multimodal data for now (2026-03), skip the data block in message content.`
+            );
+            break;
+        }
+      }
+      if (content.length > 0) {
+        formattedMsg.content = content;
+      }
+      if (formattedMsg.content || formattedMsg.tool_calls) {
+        formattedMsgs.push(formattedMsg);
+      }
+      if (cachedMsgs.length > 0) {
+        formattedMsgs.push(...cachedMsgs);
+      }
+      index++;
+    }
+    return formattedMsgs;
+  }
+};
+
+// src/formatter/ollama-chat-formatter.ts
+var OllamaChatFormatter = class extends FormatterBase {
+  // eslint-disable-next-line jsdoc/require-returns
+  /**
+   * Format messages for Ollama API
+   * @param root0
+   * @param root0.msgs
+   */
+  async format({ msgs }) {
+    const formattedMsgs = [];
+    for (const msg of msgs) {
+      const formattedMsg = {
+        role: msg.role,
+        content: ""
+      };
+      const textContent = getTextContent(msg);
+      if (textContent) {
+        formattedMsg.content = textContent;
+      }
+      const toolCalls = getContentBlocks(msg, "tool_call");
+      if (toolCalls.length > 0) {
+        formattedMsg.tool_calls = toolCalls.map((toolCall) => ({
+          function: {
+            name: toolCall.name,
+            arguments: JSON.parse(toolCall.input)
+          }
+        }));
+      }
+      const toolResults = getContentBlocks(msg, "tool_result");
+      for (const toolResult of toolResults) {
+        const resultText = this.convertToolOutputToString(toolResult.output, false);
+        formattedMsgs.push({
+          role: "tool",
+          content: resultText.text
+        });
+      }
+      if (formattedMsg.content || formattedMsg.tool_calls) {
+        formattedMsgs.push(formattedMsg);
+      }
+    }
+    return formattedMsgs;
+  }
+};
+
+// src/formatter/openai-chat-formatter.ts
+var import_fs = require("fs");
+var import_promises = require("fs/promises");
+var import_path = require("path");
+var import_url = require("url");
+var OpenAIChatFormatter = class extends FormatterBase {
+  promoteMultimodalToolResult;
+  /**
+   * Initializes a new instance of the OpenAIChatFormatter class.
+   * @param root0
+   * @param root0.promoteMultimodalToolResult
+   */
+  constructor({ promoteMultimodalToolResult = false } = {}) {
+    super();
+    this.promoteMultimodalToolResult = promoteMultimodalToolResult;
+  }
+  /**
+   * Format the input messages into OpenAI Chat Completions message format.
+   * @param root0
+   * @param root0.msgs
+   * @returns An array of formatted messages compatible with OpenAI Chat Completions API.
+   */
+  async format({ msgs }) {
+    const formattedMsgs = [];
+    let index = 0;
+    while (index < msgs.length) {
+      const msg = msgs[index];
+      const formattedMsg = {
+        role: msg.role,
+        name: msg.name,
+        content: null
+      };
+      const content = [];
+      const cachedMsgs = [];
+      for (const block of getContentBlocks(msg)) {
+        switch (block.type) {
+          case "text":
+            content.push(this._formatTextBlock(block));
+            break;
+          case "thinking":
+            break;
+          case "tool_call":
+            if (!formattedMsg.tool_calls) {
+              formattedMsg.tool_calls = [];
+            }
+            formattedMsg.tool_calls.push({
+              id: block.id,
+              type: "function",
+              function: {
+                name: block.name,
+                arguments: block.input
+              }
+            });
+            break;
+          case "tool_result":
+            const formattedToolResult = this.convertToolOutputToString(
+              block.output,
+              this.promoteMultimodalToolResult
+            );
+            cachedMsgs.push({
+              role: "tool",
+              tool_call_id: block.id,
+              name: block.name,
+              content: formattedToolResult.text
+            });
+            if (formattedToolResult.promotedMsg?.content.length) {
+              msgs.splice(index + 1, 0, formattedToolResult.promotedMsg);
+            }
+            break;
+          case "data":
+            content.push(
+              ...await this._formatMultimodalBlock({ block, role: msg.role })
+            );
+            break;
+        }
+      }
+      if (content.length > 0) {
+        formattedMsg.content = content;
+      }
+      if (formattedMsg.content || formattedMsg.tool_calls) {
+        formattedMsgs.push(formattedMsg);
+      }
+      if (cachedMsgs.length > 0) {
+        formattedMsgs.push(...cachedMsgs);
+      }
+      index++;
+    }
+    return formattedMsgs;
+  }
+  /**
+   * Format a text block into OpenAI Chat Completions message content format.
+   * @param block
+   * @returns An object representing the formatted text block.
+   */
+  _formatTextBlock(block) {
+    return {
+      type: "text",
+      text: block.text
+    };
+  }
+  /**
+   * Format a multimodal data block into OpenAI Chat Completions message content format.
+   * @param root0
+   * @param root0.block
+   * @param root0.role
+   * @returns The formatted content blocks
+   */
+  async _formatMultimodalBlock({
+    block,
+    role
+  }) {
+    const type = block.source.mediaType.split("/")[0];
+    if (type === "image") {
+      return [
+        {
+          type: "image_url",
+          image_url: {
+            url: await this._toOpenAIImageURL(block)
+          }
+        }
+      ];
+    }
+    if (type === "audio") {
+      if (role === "assistant") {
+        return [];
+      }
+      return [
+        {
+          type: "input_audio",
+          input_audio: await this._toOpenAIAudioData(block)
+        }
+      ];
+    }
+    console.log(
+      `Skip unsupported media type ${block.source.mediaType} in OpenAIChatFormatter. Only image and audio are supported.`
+    );
+    return [];
+  }
+  /**
+   * Convert the data block to an OpenAI compatible image URL.
+   * @param block
+   * @returns A promise that resolves to a string representing the image URL in a format compatible with OpenAI Chat Completions API.
+   */
+  async _toOpenAIImageURL(block) {
+    if (block.source.type === "base64") {
+      return `data:${block.source.mediaType};base64,${block.source.data}`;
+    }
+    const sourceUrl = block.source.url;
+    if (sourceUrl.startsWith("http://") || sourceUrl.startsWith("https://")) {
+      return sourceUrl;
+    }
+    if (sourceUrl.startsWith("data:")) {
+      return sourceUrl;
+    }
+    const localPath = this._toLocalPath(sourceUrl);
+    if (!localPath || !(0, import_fs.existsSync)(localPath)) {
+      throw new Error(`Image path not found: ${sourceUrl}`);
+    }
+    const ext = (0, import_path.extname)(localPath).toLowerCase();
+    const supportedImageExtensions = [".png", ".jpg", ".jpeg", ".gif", ".webp"];
+    if (!supportedImageExtensions.includes(ext)) {
+      throw new TypeError(
+        `Unsupported image extension: ${ext}. Supported: ${supportedImageExtensions.join(", ")}`
+      );
+    }
+    const file = await (0, import_promises.readFile)(localPath);
+    const mime = block.source.mediaType || `image/${ext.slice(1)}`;
+    return `data:${mime};base64,${file.toString("base64")}`;
+  }
+  /**
+   * Converts a data block to OpenAI compatible audio data format.
+   *
+   * @param block - The data block containing audio information.
+   * @returns A promise that resolves to an object with audio data and format.
+   */
+  async _toOpenAIAudioData(block) {
+    const supportedMediaTypes = /* @__PURE__ */ new Map([
+      ["audio/wav", "wav"],
+      ["audio/mp3", "mp3"],
+      ["audio/mpeg", "mp3"]
+    ]);
+    if (block.source.type === "base64") {
+      const format2 = supportedMediaTypes.get(block.source.mediaType);
+      if (!format2) {
+        throw new TypeError(
+          `Unsupported audio media type: ${block.source.mediaType}, only audio/wav and audio/mp3 are supported.`
+        );
+      }
+      return { data: block.source.data, format: format2 };
+    }
+    const sourceUrl = block.source.url;
+    const localPath = this._toLocalPath(sourceUrl);
+    let data;
+    if (localPath && (0, import_fs.existsSync)(localPath)) {
+      const file = await (0, import_promises.readFile)(localPath);
+      data = file.toString("base64");
+    } else if (sourceUrl.startsWith("http://") || sourceUrl.startsWith("https://")) {
+      const response = await fetch(sourceUrl);
+      if (!response.ok) {
+        throw new Error(
+          `Failed to fetch audio from URL: ${sourceUrl} (${response.status})`
+        );
+      }
+      const arr = await response.arrayBuffer();
+      data = Buffer.from(arr).toString("base64");
+    } else {
+      throw new Error(
+        `Unsupported audio source: ${sourceUrl}, it should be a local file path, file URL, or an HTTP URL.`
+      );
+    }
+    const ext = (0, import_path.extname)(localPath || sourceUrl).toLowerCase();
+    const extToFormat = /* @__PURE__ */ new Map([
+      [".wav", "wav"],
+      [".mp3", "mp3"]
+    ]);
+    const format = extToFormat.get(ext);
+    if (!format) {
+      throw new TypeError(`Unsupported audio extension: ${ext}, wav and mp3 are supported.`);
+    }
+    return { data, format };
+  }
+  /**
+   * Converts a URL or path to a local file path.
+   *
+   * @param urlOrPath - The URL or path to convert.
+   * @returns The local file path, or null if not a local path.
+   */
+  _toLocalPath(urlOrPath) {
+    if (urlOrPath.startsWith("file://")) {
+      return (0, import_url.fileURLToPath)(urlOrPath);
+    }
+    if (!urlOrPath.includes("://")) {
+      return urlOrPath;
+    }
+    return null;
+  }
+};
+
+// src/model/dashscope-model.ts
+var DashScopeChatModel = class extends ChatModelBase {
+  apiURL;
+  apiKey;
+  presetGenParams;
+  presetHeaders;
+  thinkingConfig;
+  /**
+   * Initializes a new instance of the DashScopeChatModel class.
+   *
+   * @param options - The DashScope chat model options.
+   * @param options.modelName - The name of the model to use.
+   * @param options.apiKey - The API key for authentication.
+   * @param options.stream - Whether to use streaming responses. Default is true.
+   * @param options.thinkingConfig - The thinking configuration for DashScope models, including whether to enable thinking and the thinking budget.
+   * @param options.maxRetries - The maximum number of retries for failed requests. Default is 3.
+   * @param options.fallbackModelName - The fallback model name to use if the primary model fails.
+   * @param options.presetGenParams - Preset generation parameters to include in each request.
+   * @param options.presetHeaders - Preset headers that will be included in each request.
+   * @param options.multimodal - Whether the model is multimodal or not, this will decide the default API endpoint. If not provided, it will be inferred from the model name.
+   * @param options.formatter - An optional custom formatter. If not provided, a default DashScopeChatFormatter will be used.
+   */
+  constructor({
+    modelName,
+    apiKey,
+    stream = true,
+    thinkingConfig,
+    maxRetries = 0,
+    fallbackModelName,
+    presetGenParams,
+    presetHeaders,
+    multimodal,
+    formatter
+  }) {
+    const defaultFormatter = formatter || new DashScopeChatFormatter();
+    super({
+      modelName,
+      stream,
+      maxRetries,
+      fallbackModelName,
+      formatter: defaultFormatter
+    });
+    this.apiKey = apiKey;
+    this.thinkingConfig = thinkingConfig;
+    this.presetGenParams = presetGenParams;
+    this.presetHeaders = presetHeaders;
+    if (multimodal === void 0) {
+      multimodal = modelName.includes("vl") || modelName.includes("qwen3.5-plus") || modelName.includes("qvq");
+    }
+    this.apiURL = multimodal ? "https://dashscope.aliyuncs.com/api/v1/services/aigc/multimodal-generation/generation" : "https://dashscope.aliyuncs.com/api/v1/services/aigc/text-generation/generation";
+  }
+  /**
+   * Calls the DashScope API with the given parameters.
+   *
+   * @param modelName - The name of the model to use.
+   * @param options - The chat model options.
+   * @returns A promise that resolves to either a ChatResponse or an AsyncGenerator of ChatResponses.
+   */
+  async _callAPI(modelName, options) {
+    const data = {
+      model: modelName,
+      input: {
+        messages: options.messages
+      },
+      parameters: {
+        result_format: "message",
+        tools: this._formatToolSchemas(options.tools),
+        toolChoice: this._formatToolChoice(options.toolChoice),
+        enable_thinking: this.thinkingConfig?.enableThinking ?? false,
+        ...this.thinkingConfig?.thinkingBudget !== void 0 && {
+          thinking_budget: this.thinkingConfig.thinkingBudget
+        },
+        ...this.presetGenParams ?? {},
+        incremental_output: true
+      }
+    };
+    const headers = {
+      Authorization: `Bearer ${this.apiKey}`,
+      "Content-Type": "application/json",
+      ...this.presetHeaders
+    };
+    if (this.stream) {
+      headers["X-DashScope-SSE"] = "enable";
+    }
+    const startTime = Date.now();
+    const response = await fetch(this.apiURL, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(data)
+    });
+    if (!response.ok) {
+      throw new Error(
+        `DashScope API request failed with status ${response.status}: ${await response.text()}`
+      );
+    }
+    if (this.stream) {
+      return this._parseDashScopeStreamedResponse(response, startTime);
+    }
+    const blocks = [];
+    const res = await response.json();
+    const choice = res.output.choices[0];
+    if (choice.message.reasoning_content) {
+      blocks.push({
+        type: "thinking",
+        thinking: choice.message.reasoning_content,
+        id: crypto.randomUUID()
+      });
+    }
+    if (choice.message.content) {
+      blocks.push({ type: "text", text: choice.message.content, id: crypto.randomUUID() });
+    }
+    if (choice.message.tool_calls && Array.isArray(choice.message.tool_calls)) {
+      choice.message.tool_calls.forEach((toolCall) => {
+        if ("id" in toolCall && "function" in toolCall && typeof toolCall.function === "object" && toolCall.function && "name" in toolCall.function && "arguments" in toolCall.function) {
+          const inputString = String(toolCall.function.arguments);
+          blocks.push({
+            type: "tool_call",
+            id: String(toolCall.id),
+            name: String(toolCall.function.name),
+            input: inputString
+          });
+        }
+      });
+    }
+    const usage = res.usage ? {
+      type: "chat_usage",
+      inputTokens: res.usage.input_tokens || 0,
+      outputTokens: res.usage.output_tokens || 0,
+      time: (Date.now() - startTime) / 1e3
+    } : void 0;
+    return {
+      type: "chat",
+      id: crypto.randomUUID(),
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      content: blocks,
+      usage
+    };
+  }
+  /**
+   * The method to format the tool choice parameter.
+   *
+   * @param toolChoice - The tool choice option.
+   * @returns The formatted tool choice.
+   */
+  _formatToolChoice(toolChoice) {
+    if (toolChoice) {
+      if (toolChoice === "auto") return "auto";
+      if (toolChoice === "none") return "none";
+      return {
+        type: "function",
+        function: {
+          name: toolChoice
+        }
+      };
+    }
+    return "auto";
+  }
+  /**
+   * Parses a streamed response from DashScope API specifically for chat responses.
+   * An async generator that yields delta ChatResponse objects as they are received.
+   *
+   * @param response - The fetch response object.
+   * @param startTime - The start time of the request for usage calculation.
+   * @returns An async generator yielding delta ChatResponse objects, and returns the complete ChatResponse.
+   */
+  async *_parseDashScopeStreamedResponse(response, startTime) {
+    const asyncGenerator = _parseStreamedResponse(response);
+    let accText = "";
+    let accThinking = "";
+    const accToolInputs = /* @__PURE__ */ new Map();
+    const toolCallMeta = /* @__PURE__ */ new Map();
+    let lastUsage = void 0;
+    for await (const jsonObj of asyncGenerator) {
+      if (jsonObj.output && jsonObj.output.choices) {
+        const choice = jsonObj.output.choices[0];
+        let deltaText = "";
+        let deltaThinking = "";
+        const deltaToolCalls = /* @__PURE__ */ new Map();
+        const content = choice.message?.content;
+        if (content) {
+          if (typeof content === "string") {
+            deltaText = content;
+          } else if (Array.isArray(content)) {
+            for (const block of content) {
+              if (block.text) {
+                deltaText += block.text;
+              }
+            }
+          }
+          accText += deltaText;
+        }
+        if (choice.message?.reasoning_content) {
+          deltaThinking = choice.message.reasoning_content;
+          accThinking += deltaThinking;
+        }
+        if (choice.message?.tool_calls) {
+          choice.message.tool_calls.forEach((toolCall) => {
+            const index = toolCall.index.toString();
+            if (!toolCallMeta.has(index)) {
+              toolCallMeta.set(index, { id: "", name: "" });
+            }
+            if (!accToolInputs.has(index)) {
+              accToolInputs.set(index, "");
+            }
+            if (toolCall.id) {
+              toolCallMeta.get(index).id = toolCall.id;
+            }
+            if (toolCall.function?.name) {
+              toolCallMeta.get(index).name = toolCall.function.name;
+            }
+            if (toolCall.function?.arguments) {
+              const deltaArgs = toolCall.function.arguments;
+              accToolInputs.set(index, accToolInputs.get(index) + deltaArgs);
+              const meta = toolCallMeta.get(index);
+              deltaToolCalls.set(index, {
+                type: "tool_call",
+                id: meta.id,
+                name: meta.name,
+                input: deltaArgs
+              });
+            }
+          });
+        }
+        const deltaBlocks = this._dataToBlocks(deltaText, deltaThinking, deltaToolCalls);
+        lastUsage = jsonObj.usage ? {
+          type: "chat_usage",
+          inputTokens: jsonObj.usage.input_tokens || 0,
+          outputTokens: jsonObj.usage.output_tokens || 0,
+          time: (Date.now() - startTime) / 1e3
+        } : void 0;
+        yield {
+          type: "chat",
+          id: crypto.randomUUID(),
+          createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+          content: deltaBlocks,
+          usage: lastUsage
+        };
+      }
+    }
+    const finalToolCalls = /* @__PURE__ */ new Map();
+    toolCallMeta.forEach((meta, index) => {
+      finalToolCalls.set(index, {
+        type: "tool_call",
+        id: meta.id,
+        name: meta.name,
+        input: accToolInputs.get(index) || "{}"
+      });
+    });
+    const blocks = this._dataToBlocks(accText, accThinking, finalToolCalls);
+    return {
+      type: "chat",
+      id: crypto.randomUUID(),
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      content: blocks,
+      usage: lastUsage
+    };
+  }
+  /**
+   * Convert data into blocks
+   *
+   * @param text - The text response from the llm API
+   * @param thinking - The thinking response
+   * @param toolCalls - The tool calls
+   * @returns An array of blocks
+   */
+  _dataToBlocks(text, thinking, toolCalls) {
+    const blocks = [];
+    if (thinking) {
+      blocks.push({ type: "thinking", thinking, id: crypto.randomUUID() });
+    }
+    if (text) {
+      blocks.push({ type: "text", text, id: crypto.randomUUID() });
+    }
+    if (toolCalls.size > 0) {
+      toolCalls.forEach((value) => {
+        blocks.push(value);
+      });
+    }
+    return blocks;
+  }
+  /**
+   * Format the tool schemas to the expected API format.
+   * @param tools
+   * @returns The formatted tool schemas.
+   */
+  _formatToolSchemas(tools) {
+    return tools || [];
+  }
+};
+
+// src/model/deepseek-model.ts
+var DeepSeekChatModel = class extends ChatModelBase {
+  apiURL;
+  apiKey;
+  presetGenParams;
+  presetHeaders;
+  thinkingConfig;
+  /**
+   * Initializes a new instance of the DeepSeekChatModel class.
+   *
+   * @param options - The DeepSeek chat model options.
+   * @param options.modelName - The name of the model to use.
+   * @param options.apiKey - The API key for authentication.
+   * @param options.stream - Whether to use streaming responses. Default is true.
+   * @param options.thinkingConfig - Thinking configuration.
+   * @param options.maxRetries - The maximum number of retries for failed requests. Default is 0.
+   * @param options.fallbackModelName - The fallback model name to use if the primary model fails.
+   * @param options.presetGenParams - Preset generation parameters to include in each request.
+   * @param options.presetHeaders - Preset headers that will be included in each request.
+   * @param options.formatter
+   */
+  constructor({
+    modelName,
+    apiKey,
+    stream = true,
+    thinkingConfig,
+    maxRetries = 0,
+    fallbackModelName,
+    presetGenParams,
+    presetHeaders,
+    formatter
+  }) {
+    const defaultFormatter = formatter || new DeepSeekChatFormatter();
+    super({
+      modelName,
+      stream,
+      maxRetries,
+      fallbackModelName,
+      formatter: defaultFormatter
+    });
+    this.apiKey = apiKey;
+    this.thinkingConfig = thinkingConfig || { enableThinking: false };
+    this.presetGenParams = presetGenParams;
+    this.presetHeaders = presetHeaders;
+    this.apiURL = "https://api.deepseek.com/chat/completions";
+  }
+  /**
+   * Calls the DeepSeek API with the given parameters.
+   *
+   * @param modelName - The name of the model to use.
+   * @param options - The chat model options.
+   * @returns A promise that resolves to either a ChatResponse or an AsyncGenerator of ChatResponses.
+   */
+  async _callAPI(modelName, options) {
+    const data = {
+      model: modelName,
+      messages: options.messages,
+      tools: this._formatToolSchemas(options.tools),
+      tool_choice: this._formatToolChoice(options.toolChoice),
+      thinking: this.thinkingConfig.enableThinking ? { type: "enabled" } : { type: "disabled" },
+      stream: this.stream,
+      ...this.presetGenParams ?? {}
+    };
+    const headers = {
+      Authorization: `Bearer ${this.apiKey}`,
+      "Content-Type": "application/json",
+      ...this.presetHeaders
+    };
+    const startTime = Date.now();
+    const response = await fetch(this.apiURL, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(data)
+    });
+    if (!response.ok) {
+      throw new Error(
+        `DeepSeek API request failed with status ${response.status}: ${await response.text()}`
+      );
+    }
+    if (this.stream) {
+      return this._parseDeepSeekStreamedResponse(response, startTime);
+    }
+    const blocks = [];
+    const res = await response.json();
+    const choice = res.choices[0];
+    if (choice.message.reasoning_content) {
+      blocks.push({
+        id: crypto.randomUUID(),
+        type: "thinking",
+        thinking: choice.message.reasoning_content
+      });
+    }
+    if (choice.message.content) {
+      blocks.push({ id: crypto.randomUUID(), type: "text", text: choice.message.content });
+    }
+    if (choice.message.tool_calls && Array.isArray(choice.message.tool_calls)) {
+      choice.message.tool_calls.forEach((toolCall) => {
+        if ("id" in toolCall && "function" in toolCall && typeof toolCall.function === "object" && toolCall.function && "name" in toolCall.function && "arguments" in toolCall.function) {
+          const inputString = String(toolCall.function.arguments);
+          blocks.push({
+            type: "tool_call",
+            id: String(toolCall.id),
+            name: String(toolCall.function.name),
+            input: inputString
+          });
+        }
+      });
+    }
+    const usage = res.usage ? {
+      type: "chat_usage",
+      inputTokens: res.usage.prompt_tokens || 0,
+      outputTokens: res.usage.completion_tokens || 0,
+      time: (Date.now() - startTime) / 1e3
+    } : void 0;
+    return {
+      type: "chat",
+      id: crypto.randomUUID(),
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      content: blocks,
+      usage
+    };
+  }
+  /**
+   * The method to format the tool choice parameter.
+   *
+   * @param toolChoice - The tool choice option.
+   * @returns The formatted tool choice.
+   */
+  _formatToolChoice(toolChoice) {
+    if (toolChoice) {
+      if (toolChoice === "auto") return "auto";
+      if (toolChoice === "none") return "none";
+      if (this.thinkingConfig?.enableThinking) {
+        console.log(
+          `The deepseek reasoning model does not support tool choice options '${toolChoice}'. 'auto' will be used instead.`
+        );
+        return "auto";
+      }
+      if (toolChoice === "required") return "required";
+      return {
+        type: "function",
+        function: {
+          name: toolChoice
+        }
+      };
+    }
+    return "auto";
+  }
+  /**
+   * Parses a streamed response from DeepSeek API specifically for chat responses.
+   * An async generator that yields delta ChatResponse objects as they are received.
+   *
+   * @param response - The fetch response object.
+   * @param startTime - The start time of the request for usage calculation.
+   * @returns An async generator yielding delta ChatResponse objects, and returns the complete ChatResponse.
+   */
+  async *_parseDeepSeekStreamedResponse(response, startTime) {
+    const asyncGenerator = _parseStreamedResponse(response);
+    let accText = "";
+    let accThinking = "";
+    const accToolInputs = /* @__PURE__ */ new Map();
+    const toolCallMeta = /* @__PURE__ */ new Map();
+    let lastUsage = void 0;
+    for await (const jsonObj of asyncGenerator) {
+      if (jsonObj.choices && jsonObj.choices.length > 0) {
+        const choice = jsonObj.choices[0];
+        let deltaText = "";
+        let deltaThinking = "";
+        const deltaToolCalls = /* @__PURE__ */ new Map();
+        if (choice.delta?.content) {
+          deltaText = choice.delta.content;
+          accText += deltaText;
+        }
+        if (choice.delta?.reasoning_content) {
+          deltaThinking = choice.delta.reasoning_content;
+          accThinking += deltaThinking;
+        }
+        if (choice.delta?.tool_calls) {
+          choice.delta.tool_calls.forEach((toolCall) => {
+            const index = toolCall.index.toString();
+            if (!toolCallMeta.has(index)) {
+              toolCallMeta.set(index, { id: "", name: "" });
+            }
+            if (!accToolInputs.has(index)) {
+              accToolInputs.set(index, "");
+            }
+            if (toolCall.id) {
+              toolCallMeta.get(index).id = toolCall.id;
+            }
+            if (toolCall.function?.name) {
+              toolCallMeta.get(index).name = toolCall.function.name;
+            }
+            if (toolCall.function?.arguments) {
+              const deltaArgs = toolCall.function.arguments;
+              accToolInputs.set(index, accToolInputs.get(index) + deltaArgs);
+              const meta = toolCallMeta.get(index);
+              deltaToolCalls.set(index, {
+                type: "tool_call",
+                id: meta.id,
+                name: meta.name,
+                input: deltaArgs
+              });
+            }
+          });
+        }
+        const deltaBlocks = this._accDataToBlocks(deltaText, deltaThinking, deltaToolCalls);
+        lastUsage = jsonObj.usage ? {
+          type: "chat_usage",
+          inputTokens: jsonObj.usage.prompt_tokens || 0,
+          outputTokens: jsonObj.usage.completion_tokens || 0,
+          time: (Date.now() - startTime) / 1e3
+        } : void 0;
+        yield {
+          type: "chat",
+          id: crypto.randomUUID(),
+          createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+          content: deltaBlocks,
+          usage: lastUsage
+        };
+      }
+    }
+    const finalToolCalls = /* @__PURE__ */ new Map();
+    toolCallMeta.forEach((meta, index) => {
+      finalToolCalls.set(index, {
+        type: "tool_call",
+        id: meta.id,
+        name: meta.name,
+        input: accToolInputs.get(index) || "{}"
+      });
+    });
+    const blocks = this._accDataToBlocks(accText, accThinking, finalToolCalls);
+    return {
+      type: "chat",
+      id: crypto.randomUUID(),
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      content: blocks,
+      usage: lastUsage
+    };
+  }
+  /**
+   * Convert data into blocks
+   *
+   * @param text - The text response from the llm API
+   * @param thinking - The thinking response
+   * @param toolCalls - The tool calls
+   * @returns An array of blocks
+   */
+  _accDataToBlocks(text, thinking, toolCalls) {
+    const blocks = [];
+    if (thinking) {
+      blocks.push({ id: crypto.randomUUID(), type: "thinking", thinking });
+    }
+    if (text) {
+      blocks.push({ id: crypto.randomUUID(), type: "text", text });
+    }
+    if (toolCalls.size > 0) {
+      toolCalls.forEach((value) => {
+        blocks.push(value);
+      });
+    }
+    return blocks;
+  }
+  /**
+   * Format the tool schemas to the expected API format for DeepSeek API.
+   * @param tools
+   * @returns The formatted tool schemas.
+   */
+  _formatToolSchemas(tools) {
+    return tools || [];
+  }
+};
+
+// src/model/ollama-model.ts
+var import_ollama = require("ollama");
+var OllamaChatModel = class extends ChatModelBase {
+  client;
+  options;
+  keepAlive;
+  thinkingConfig;
+  generateKwargs;
+  /**
+   * Initializes a new instance of the OllamaChatModel class.
+   * @param root0
+   * @param root0.modelName
+   * @param root0.stream
+   * @param root0.options
+   * @param root0.keepAlive
+   * @param root0.thinkingConfig
+   * @param root0.host
+   * @param root0.maxRetries
+   * @param root0.fallbackModelName
+   * @param root0.clientKwargs
+   * @param root0.generateKwargs
+   * @param root0.formatter
+   */
+  constructor({
+    modelName,
+    stream = true,
+    options,
+    keepAlive = "5m",
+    thinkingConfig,
+    host,
+    maxRetries = 0,
+    fallbackModelName,
+    clientKwargs,
+    generateKwargs,
+    formatter
+  }) {
+    const defaultFormatter = formatter || new OllamaChatFormatter();
+    super({
+      modelName,
+      stream,
+      maxRetries,
+      fallbackModelName,
+      formatter: defaultFormatter
+    });
+    this.options = options;
+    this.keepAlive = keepAlive;
+    this.thinkingConfig = thinkingConfig || {
+      enableThinking: false
+    };
+    this.generateKwargs = generateKwargs || {};
+    this.client = new import_ollama.Ollama({
+      host,
+      ...clientKwargs
+    });
+  }
+  /**
+   * Calls the Ollama API with the given parameters.
+   * @param modelName
+   * @param options
+   * @returns A promise that resolves to either a ChatResponse or an AsyncGenerator of ChatResponses.
+   */
+  async _callAPI(modelName, options) {
+    const kwargs = {
+      model: modelName,
+      messages: options.messages,
+      stream: this.stream,
+      options: this.options,
+      keep_alive: this.keepAlive,
+      ...this.generateKwargs
+    };
+    if (this.thinkingConfig.enableThinking) {
+      kwargs.think = this.thinkingConfig.thinkingLevel || true;
+    } else {
+      kwargs.think = false;
+    }
+    if (options.tools) {
+      kwargs.tools = this._formatToolSchemas(options.tools);
+    }
+    if (options.toolChoice) {
+      console.warn("Ollama does not support tool_choice yet, ignored.");
+    }
+    const startTime = Date.now();
+    if (this.stream) {
+      const response2 = await this.client.chat({
+        ...kwargs,
+        stream: true
+      });
+      return this._parseOllamaStreamResponse(response2, startTime);
+    }
+    const response = await this.client.chat({
+      ...kwargs,
+      stream: false
+    });
+    return this._parseOllamaResponse(response, startTime);
+  }
+  /**
+   * Parse Ollama streaming response.
+   * @param stream
+   * @param startTime
+   * @returns An async generator that yields delta ChatResponse objects and returns the complete ChatResponse.
+   */
+  async *_parseOllamaStreamResponse(stream, startTime) {
+    let accText = "";
+    let accThinking = "";
+    const toolCalls = /* @__PURE__ */ new Map();
+    let lastUsage = null;
+    for await (const chunk of stream) {
+      const msg = chunk.message;
+      let deltaText = "";
+      let deltaThinking = "";
+      const deltaToolCalls = /* @__PURE__ */ new Map();
+      if (msg.thinking) {
+        deltaThinking = msg.thinking;
+        accThinking += msg.thinking;
+      }
+      if (msg.content) {
+        deltaText = msg.content;
+        accText += msg.content;
+      }
+      if (msg.tool_calls && Array.isArray(msg.tool_calls)) {
+        for (let idx = 0; idx < msg.tool_calls.length; idx++) {
+          const toolCall = msg.tool_calls[idx];
+          const func = toolCall.function;
+          const toolId = `${idx}_${func.name}`;
+          const toolCallBlock = {
+            type: "tool_call",
+            id: toolId,
+            name: func.name,
+            input: JSON.stringify(func.arguments)
+          };
+          toolCalls.set(toolId, toolCallBlock);
+          deltaToolCalls.set(toolId, toolCallBlock);
+        }
+      }
+      const currentTime = (Date.now() - startTime) / 1e3;
+      lastUsage = {
+        type: "chat_usage",
+        inputTokens: chunk.prompt_eval_count || 0,
+        outputTokens: chunk.eval_count || 0,
+        time: currentTime
+      };
+      const deltaBlocks = this._buildContentBlocks(deltaText, deltaThinking, deltaToolCalls);
+      yield {
+        type: "chat",
+        id: crypto.randomUUID(),
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        content: deltaBlocks,
+        usage: lastUsage
+      };
+    }
+    const blocks = this._buildContentBlocks(accText, accThinking, toolCalls);
+    return {
+      type: "chat",
+      id: crypto.randomUUID(),
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      content: blocks,
+      usage: lastUsage
+    };
+  }
+  /**
+   * Parse Ollama non-streaming response.
+   * @param response
+   * @param startTime
+   * @returns A ChatResponse object containing the content blocks and usage.
+   */
+  _parseOllamaResponse(response, startTime) {
+    const blocks = [];
+    if (response.message.thinking) {
+      blocks.push({
+        id: crypto.randomUUID(),
+        type: "thinking",
+        thinking: response.message.thinking
+      });
+    }
+    if (response.message.content) {
+      blocks.push({
+        id: crypto.randomUUID(),
+        type: "text",
+        text: response.message.content
+      });
+    }
+    if (response.message.tool_calls && Array.isArray(response.message.tool_calls)) {
+      for (let idx = 0; idx < response.message.tool_calls.length; idx++) {
+        const toolCall = response.message.tool_calls[idx];
+        blocks.push({
+          type: "tool_call",
+          id: `${idx}_${toolCall.function.name}`,
+          name: toolCall.function.name,
+          input: JSON.stringify(toolCall.function.arguments)
+        });
+      }
+    }
+    const usage = response.prompt_eval_count !== void 0 && response.eval_count !== void 0 ? {
+      type: "chat_usage",
+      inputTokens: response.prompt_eval_count || 0,
+      outputTokens: response.eval_count || 0,
+      time: (Date.now() - startTime) / 1e3
+    } : void 0;
+    return {
+      type: "chat",
+      id: crypto.randomUUID(),
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      content: blocks,
+      usage
+    };
+  }
+  /**
+   * Build content blocks from accumulated data.
+   * @param text
+   * @param thinking
+   * @param toolCalls
+   * @returns An array of content blocks.
+   */
+  _buildContentBlocks(text, thinking, toolCalls) {
+    const blocks = [];
+    if (thinking) {
+      blocks.push({ id: crypto.randomUUID(), type: "thinking", thinking });
+    }
+    if (text) {
+      blocks.push({ id: crypto.randomUUID(), type: "text", text });
+    }
+    toolCalls.forEach((toolCall) => {
+      blocks.push(toolCall);
+    });
+    return blocks;
+  }
+  /**
+   * Format tool choice parameter (not supported by Ollama).
+   * @param _toolChoice
+   * @returns undefined as Ollama does not support tool choice.
+   */
+  _formatToolChoice(_toolChoice) {
+    return void 0;
+  }
+  /**
+   * Format tool schemas for Ollama API (no special formatting needed).
+   * @param tools
+   * @returns The same array of tool schemas, or an empty array if undefined.
+   */
+  _formatToolSchemas(tools) {
+    return tools || [];
+  }
+};
+
+// src/model/openai-model.ts
+var import_openai = require("openai");
+var OpenAIChatModel = class extends ChatModelBase {
+  client;
+  presetGenParams;
+  /**
+   * Initializes a new instance of the OpenAIChatModel class.
+   * @param options
+   * @param options.modelName
+   * @param options.apiKey
+   * @param options.stream
+   * @param options.maxRetries
+   * @param options.fallbackModelName
+   * @param options.presetGenParams
+   * @param options.baseURL
+   * @param options.formatter
+   */
+  constructor({
+    modelName,
+    apiKey,
+    stream = true,
+    maxRetries = 3,
+    fallbackModelName,
+    presetGenParams,
+    baseURL,
+    formatter
+  }) {
+    const defaultFormatter = formatter || new OpenAIChatFormatter();
+    super({
+      modelName,
+      stream,
+      maxRetries,
+      fallbackModelName,
+      formatter: defaultFormatter
+    });
+    this.client = new import_openai.OpenAI({
+      apiKey,
+      baseURL
+    });
+    this.presetGenParams = presetGenParams;
+  }
+  /**
+   * Calls the OpenAI API with the given parameters.
+   *
+   * @param modelName - The name of the model to use.
+   * @param options - The chat model options.
+   * @returns A promise that resolves to either a ChatResponse or an AsyncGenerator of ChatResponses.
+   */
+  async _callAPI(modelName, options) {
+    const startTime = Date.now();
+    if (this.stream) {
+      const stream = await this.client.chat.completions.create({
+        model: modelName,
+        messages: options.messages,
+        tools: this._formatToolSchemas(options.tools),
+        tool_choice: this._formatToolChoice(options.toolChoice),
+        stream: true,
+        ...this.presetGenParams ?? {}
+      });
+      return this._parseOpenAIStreamedResponse(stream, startTime);
+    }
+    const response = await this.client.chat.completions.create({
+      model: modelName,
+      messages: options.messages,
+      tools: options.tools,
+      tool_choice: this._formatToolChoice(options.toolChoice),
+      stream: false,
+      ...this.presetGenParams ?? {}
+    });
+    const choice = response.choices[0];
+    const blocks = [];
+    if (choice.message.content) {
+      blocks.push({ id: crypto.randomUUID(), type: "text", text: choice.message.content });
+    }
+    if (choice.message.tool_calls && Array.isArray(choice.message.tool_calls)) {
+      choice.message.tool_calls.forEach((toolCall) => {
+        if (toolCall.type === "function") {
+          blocks.push({
+            type: "tool_call",
+            id: toolCall.id,
+            name: toolCall.function.name,
+            input: toolCall.function.arguments
+          });
+        }
+      });
+    }
+    const usage = response.usage ? {
+      type: "chat_usage",
+      inputTokens: response.usage.prompt_tokens,
+      outputTokens: response.usage.completion_tokens,
+      time: (Date.now() - startTime) / 1e3
+    } : void 0;
+    return {
+      type: "chat",
+      id: response.id,
+      createdAt: new Date(response.created * 1e3).toISOString(),
+      content: blocks,
+      usage
+    };
+  }
+  /**
+   * Formats the tool choice for the API request.
+   *
+   * TODO: supports grouped tool choices.
+   *
+   * @param toolChoice - The tool choice option.
+   * @returns The formatted tool choice.
+   */
+  _formatToolChoice(toolChoice) {
+    if (toolChoice) {
+      if (toolChoice === "none" || toolChoice === "auto" || toolChoice === "required") {
+        return toolChoice;
+      }
+      return {
+        type: "function",
+        function: {
+          name: toolChoice
+        }
+      };
+    }
+    return "auto";
+  }
+  /**
+   * Parses a streamed response from OpenAI API.
+   * An async generator that yields delta ChatResponse objects as they are received.
+   *
+   * @param stream - The OpenAI stream object.
+   * @param startTime - The start time of the request for usage calculation.
+   * @returns An async generator yielding delta ChatResponse objects, and returns the complete ChatResponse.
+   */
+  async *_parseOpenAIStreamedResponse(stream, startTime) {
+    let accText = "";
+    const accToolInputs = /* @__PURE__ */ new Map();
+    const toolCallMeta = /* @__PURE__ */ new Map();
+    let lastUsage = null;
+    let responseId = "";
+    let createdTimestamp = 0;
+    for await (const chunk of stream) {
+      if (!responseId && chunk.id) {
+        responseId = chunk.id;
+      }
+      if (!createdTimestamp && chunk.created) {
+        createdTimestamp = chunk.created;
+      }
+      if (chunk.choices && chunk.choices.length > 0) {
+        const choice = chunk.choices[0];
+        let deltaText = "";
+        const deltaToolCalls = /* @__PURE__ */ new Map();
+        if (choice.delta?.content) {
+          deltaText = choice.delta.content;
+          accText += deltaText;
+        }
+        if (choice.delta?.tool_calls) {
+          choice.delta.tool_calls.forEach((toolCall) => {
+            const index = toolCall.index.toString();
+            if (!toolCallMeta.has(index)) {
+              toolCallMeta.set(index, { id: "", name: "" });
+            }
+            if (!accToolInputs.has(index)) {
+              accToolInputs.set(index, "");
+            }
+            if (toolCall.id) {
+              toolCallMeta.get(index).id = toolCall.id;
+            }
+            if (toolCall.function?.name) {
+              toolCallMeta.get(index).name = toolCall.function.name;
+            }
+            if (toolCall.function?.arguments) {
+              const deltaArgs = toolCall.function.arguments;
+              accToolInputs.set(index, accToolInputs.get(index) + deltaArgs);
+              const meta = toolCallMeta.get(index);
+              deltaToolCalls.set(index, {
+                type: "tool_call",
+                id: meta.id,
+                name: meta.name,
+                input: deltaArgs
+              });
+            }
+          });
+        }
+        const deltaBlocks = this._accDataToBlocks(deltaText, deltaToolCalls);
+        yield {
+          type: "chat",
+          id: responseId || crypto.randomUUID(),
+          createdAt: createdTimestamp ? new Date(createdTimestamp * 1e3).toISOString() : (/* @__PURE__ */ new Date()).toISOString(),
+          content: deltaBlocks,
+          usage: lastUsage
+        };
+      }
+      if (chunk.usage) {
+        lastUsage = {
+          type: "chat_usage",
+          inputTokens: chunk.usage.prompt_tokens || 0,
+          outputTokens: chunk.usage.completion_tokens || 0,
+          time: (Date.now() - startTime) / 1e3
+        };
+      }
+    }
+    const finalToolCalls = /* @__PURE__ */ new Map();
+    toolCallMeta.forEach((meta, index) => {
+      finalToolCalls.set(index, {
+        type: "tool_call",
+        id: meta.id,
+        name: meta.name,
+        input: accToolInputs.get(index) || "{}"
+      });
+    });
+    const blocks = this._accDataToBlocks(accText, finalToolCalls);
+    return {
+      type: "chat",
+      id: responseId || crypto.randomUUID(),
+      createdAt: createdTimestamp ? new Date(createdTimestamp * 1e3).toISOString() : (/* @__PURE__ */ new Date()).toISOString(),
+      content: blocks,
+      usage: lastUsage
+    };
+  }
+  /**
+   * Convert data into blocks
+   *
+   * @param text - The text response from the llm API
+   * @param toolCalls - The tool calls
+   * @returns An array of blocks
+   */
+  _accDataToBlocks(text, toolCalls) {
+    const blocks = [];
+    if (text) {
+      blocks.push({ id: crypto.randomUUID(), type: "text", text });
+    }
+    if (toolCalls.size > 0) {
+      toolCalls.forEach((value) => {
+        blocks.push(value);
+      });
+    }
+    return blocks;
+  }
+  /**
+   * Format the tool schemas to the expected API format.
+   * @param tools
+   * @returns The formatted tool schemas.
+   */
+  _formatToolSchemas(tools) {
+    return tools || [];
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ChatModelBase,
+  DashScopeChatModel,
+  DeepSeekChatModel,
+  OllamaChatModel,
+  OpenAIChatModel
+});
+//# sourceMappingURL=index.js.map