@agentscope-ai/agentscope 0.0.2

package/dist/formatter/index.js

@@ -0,0 +1,647 @@
+"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/formatter/index.ts
+var formatter_exports = {};
+__export(formatter_exports, {
+  DashScopeChatFormatter: () => DashScopeChatFormatter,
+  DeepSeekChatFormatter: () => DeepSeekChatFormatter,
+  FormatterBase: () => FormatterBase,
+  OllamaChatFormatter: () => OllamaChatFormatter,
+  OpenAIChatFormatter: () => OpenAIChatFormatter
+});
+module.exports = __toCommonJS(formatter_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/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;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DashScopeChatFormatter,
+  DeepSeekChatFormatter,
+  FormatterBase,
+  OllamaChatFormatter,
+  OpenAIChatFormatter
+});
+//# sourceMappingURL=index.js.map