@astack-tech/integrations 0.1.1-beta.6 → 0.2.0-beta.10

package/dist/index.cjs

@@ -37,310 +37,295 @@ module.exports = __toCommonJS(src_exports);
 // src/model-provider/index.ts
 var model_provider_exports = {};
 __export(model_provider_exports, {
-  Deepseek: () => deepseek_default
+  Deepseek: () => deepseek_default,
+  OpenAICompatible: () => openai_compatible_default
 });
 
-// src/model-provider/deepseek/index.ts
+// src/model-provider/openai-compatible/index.ts
 var import_core = require("@astack-tech/core");
 var import_openai = __toESM(require("openai"), 1);
-var Deepseek = class extends import_core.Component {
+var DEFAULT_BASE_URL = "https://api.openai.com/v1";
+var DEFAULT_NAME = "The model API";
+var DEFAULT_TEMPERATURE = 0.7;
+var FALLBACK_TEXT = "API call failed";
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function toApiTool(tool) {
+  const raw = isRecord(tool) ? tool : {};
+  const definition = raw["function"];
+  if (raw["type"] === "function" && isRecord(definition)) {
+    const { name: name2, description: description2, parameters: parameters2, strict } = definition;
+    return {
+      type: "function",
+      function: {
+        name: typeof name2 === "string" ? name2 : "",
+        ...typeof description2 === "string" ? { description: description2 } : {},
+        ...isRecord(parameters2) ? { parameters: parameters2 } : {},
+        ...typeof strict === "boolean" ? { strict } : {}
+      }
+    };
+  }
+  const { name, description, parameters } = raw;
+  return {
+    type: "function",
+    function: {
+      name: typeof name === "string" ? name : "",
+      description: typeof description === "string" ? description : "",
+      parameters: isRecord(parameters) ? parameters : {}
+    }
+  };
+}
+function parseArguments(raw) {
+  if (raw.trim().length === 0) {
+    return {};
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    return isRecord(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function mapUsage(usage) {
+  return {
+    completion_tokens: usage.completion_tokens ?? 0,
+    prompt_tokens: usage.prompt_tokens ?? 0,
+    total_tokens: usage.total_tokens ?? 0,
+    ...usage.prompt_cache_hit_tokens === void 0 ? {} : { prompt_cache_hit_tokens: usage.prompt_cache_hit_tokens },
+    ...usage.prompt_cache_miss_tokens === void 0 ? {} : { prompt_cache_miss_tokens: usage.prompt_cache_miss_tokens }
+  };
+}
+var OpenAICompatible = class extends import_core.Component {
+  client;
+  model;
+  temperature;
+  maxTokens;
+  topP;
+  systemPrompt;
+  tools;
+  verbose;
+  name;
   constructor(config) {
     super({});
     this.client = new import_openai.default({
       apiKey: config.apiKey,
-      baseURL: config.baseURL || "https://api.deepseek.com/v1",
+      baseURL: config.baseURL ?? DEFAULT_BASE_URL,
       dangerouslyAllowBrowser: config.dangerouslyAllowBrowser ?? false
     });
-    this.model = config.model || "deepseek-chat";
-    this.temperature = config.temperature ?? 0.7;
+    this.model = config.model;
+    this.name = config.name ?? DEFAULT_NAME;
+    this.temperature = config.temperature ?? DEFAULT_TEMPERATURE;
     this.maxTokens = config.maxTokens;
     this.topP = config.topP;
     this.systemPrompt = config.systemPrompt;
-    if (config.rawTools && config.rawTools.length > 0) {
-      this.tools = config.rawTools.map((tool) => ({
-        type: "function",
-        function: {
-          name: tool.name,
-          description: tool.description,
-          parameters: tool.parameters || {}
-        }
-      }));
-    } else {
-      this.tools = config.tools;
-    }
+    this.verbose = config.verbose ?? false;
+    this.tools = config.rawTools !== void 0 && config.rawTools.length > 0 ? config.rawTools.map(toApiTool) : config.tools;
     import_core.Component.Port.I("prompt").attach(this);
     import_core.Component.Port.I("messages").attach(this);
     import_core.Component.Port.O("completion").attach(this);
     import_core.Component.Port.O("message").attach(this);
   }
   /**
-   * 生成文本完成
-   * @param prompt 提示文本
-   * @returns 生成的文本
+   * Generates a completion for a single prompt.
+   *
+   * @returns The text answer, or the JSON-encoded assistant message when it contains tool calls.
    */
   async generateCompletion(prompt) {
-    const messages = [];
-    if (this.systemPrompt) {
-      messages.push({
-        role: "system",
-        content: this.systemPrompt
-      });
-    }
-    messages.push({
-      role: "user",
-      content: prompt
+    const response = await this.client.chat.completions.create({
+      ...this.baseRequest(),
+      messages: [...this.systemMessages(), { role: "user", content: prompt }],
+      ...this.toolsParam(this.tools)
     });
-    const requestParams = {
-      model: this.model,
-      messages,
-      temperature: this.temperature,
-      max_tokens: this.maxTokens,
-      top_p: this.topP
-    };
-    if (this.tools && this.tools.length > 0) {
-      requestParams.tools = this.tools;
-    }
-    const response = await this.client.chat.completions.create(requestParams);
-    if (response.choices[0].message.tool_calls && response.choices[0].message.tool_calls.length > 0) {
-      return JSON.stringify(response.choices[0].message);
+    const message = this.firstMessage(response);
+    if (message.tool_calls !== void 0 && message.tool_calls.length > 0) {
+      return JSON.stringify(message);
     }
-    return response.choices[0].message.content || "";
+    return message.content ?? "";
   }
   /**
-   * 流式处理对话消息
-   * @param messages 对话消息数组
-   * @param options 可选的调用选项，包含临时工具列表
-   * @returns 生成的流式响应消息异步生成器
+   * Sends a conversation and returns the assistant reply.
    */
-  async *streamChatCompletion(messages, options) {
-    const formattedMessages = [];
-    if (this.systemPrompt) {
-      formattedMessages.push({
-        role: "system",
-        content: this.systemPrompt
-      });
+  async chatCompletion(messages, options) {
+    const response = await this.client.chat.completions.create({
+      ...this.baseRequest(),
+      messages: this.formatMessages(messages),
+      ...this.toolsParam(options?.temporaryTools ?? this.tools)
+    });
+    const message = this.firstMessage(response);
+    const result = { role: "assistant", content: message.content ?? "" };
+    if (response.usage !== void 0) {
+      result.usage = mapUsage(response.usage);
     }
-    formattedMessages.push(
-      ...messages.map((msg) => {
-        const formattedMsg = {
-          role: msg.role,
-          content: msg.content
-        };
-        if (msg.role === "tool" && msg.tool_call_id) {
-          formattedMsg.tool_call_id = msg.tool_call_id;
-        }
-        return formattedMsg;
-      })
-    );
-    const requestParams = {
-      model: this.model,
-      messages: formattedMessages,
-      temperature: this.temperature,
-      max_tokens: this.maxTokens,
-      top_p: this.topP,
-      stream: true
-      // 开启流式模式
-    };
-    const toolsToUse = options?.temporaryTools || this.tools;
-    if (toolsToUse && toolsToUse.length > 0) {
-      const formattedTools = toolsToUse.map((tool) => {
-        const typedTool = tool;
-        if (typedTool.type === "function") {
-          return tool;
+    if (message.tool_calls !== void 0 && message.tool_calls.length > 0) {
+      result.tool_calls = message.tool_calls.map((toolCall) => {
+        if (toolCall.type !== "function") {
+          throw new Error(`Unsupported tool call type: ${toolCall.type}`);
         }
+        const rawArguments = toolCall.function.arguments;
         return {
+          id: toolCall.id,
           type: "function",
           function: {
-            name: typedTool.name,
-            description: typedTool.description,
-            parameters: typedTool.parameters || {}
-          }
+            name: toolCall.function.name,
+            arguments: rawArguments.length > 0 ? rawArguments : "{}"
+          },
+          tool_name: toolCall.function.name,
+          arguments: parseArguments(rawArguments)
         };
       });
-      requestParams.tools = formattedTools;
     }
-    const stream = await this.client.chat.completions.create(requestParams);
+    return result;
+  }
+  /**
+   * Streams the assistant reply. Each chunk holds a text delta, tool-call deltas, or usage.
+   */
+  async *streamChatCompletion(messages, options) {
+    const stream = await this.client.chat.completions.create({
+      ...this.baseRequest(),
+      messages: this.formatMessages(messages),
+      ...this.toolsParam(options?.temporaryTools ?? this.tools),
+      stream: true
+    });
     for await (const chunk of stream) {
       const delta = chunk.choices[0]?.delta;
-      if (delta?.content) {
-        yield {
-          role: "assistant",
-          content: delta.content
-        };
+      const text = delta?.content ?? "";
+      if (text !== "") {
+        yield { role: "assistant", content: text };
       }
       if (delta?.tool_calls) {
         yield {
           role: "assistant",
           content: "",
-          // eslint-disable-next-line @typescript-eslint/no-explicit-any
-          tool_calls: delta.tool_calls.map((toolCall) => ({
-            id: toolCall.id || "",
-            function: {
-              name: toolCall.function?.name || "",
-              arguments: toolCall.function?.arguments || ""
-            },
-            type: "function",
-            tool_name: toolCall.function?.name || "",
-            arguments: toolCall.function?.arguments || ""
-          }))
+          tool_calls: delta.tool_calls.map((toolCall) => {
+            const name = toolCall.function?.name ?? "";
+            const args = toolCall.function?.arguments ?? "";
+            return {
+              id: toolCall.id ?? "",
+              type: "function",
+              function: { name, arguments: args },
+              tool_name: name,
+              arguments: args
+            };
+          })
         };
       }
       if (chunk.usage) {
-        yield {
-          role: "assistant",
-          content: "",
-          usage: {
-            completion_tokens: chunk.usage.completion_tokens || 0,
-            prompt_tokens: chunk.usage.prompt_tokens || 0,
-            prompt_cache_hit_tokens: chunk.usage.prompt_cache_hit_tokens,
-            prompt_cache_miss_tokens: chunk.usage.prompt_cache_miss_tokens,
-            total_tokens: chunk.usage.total_tokens || 0
-          }
-        };
+        yield { role: "assistant", content: "", usage: mapUsage(chunk.usage) };
       }
     }
   }
   /**
-   * 处理对话消息
-   * @param messages 对话消息数组
-   * @param options 可选的调用选项，包含临时工具列表
-   * @returns 生成的响应消息
+   * Runs the model outside a pipeline.
+   *
+   * @param input - A prompt string or a list of messages.
    */
-  async chatCompletion(messages, options) {
-    const formattedMessages = [];
-    if (this.systemPrompt) {
-      formattedMessages.push({
-        role: "system",
-        content: this.systemPrompt
-      });
-    }
-    formattedMessages.push(
-      ...messages.map((msg) => {
-        const formattedMsg = {
-          role: msg.role,
-          content: msg.content
-        };
-        if (msg.role === "tool" && msg.tool_call_id) {
-          formattedMsg.tool_call_id = msg.tool_call_id;
+  run(input) {
+    return typeof input === "string" ? this.generateCompletion(input) : this.chatCompletion(input);
+  }
+  /**
+   * Connects the `prompt` and `messages` input ports to the model.
+   * API errors produce a fallback value so the pipeline keeps flowing.
+   */
+  _transform($i, $o) {
+    $i("prompt").receive((prompt) => {
+      this.generateCompletion(prompt).then(
+        (completion) => {
+          $o("completion").send(completion);
+        },
+        (error) => {
+          this.logError(error);
+          $o("completion").send(FALLBACK_TEXT);
         }
-        return formattedMsg;
-      })
-    );
-    const requestParams = {
+      );
+    });
+    $i("messages").receive((messages) => {
+      this.chatCompletion(messages).then(
+        (message) => {
+          $o("message").send(message);
+        },
+        (error) => {
+          this.logError(error);
+          $o("message").send({ role: "assistant", content: FALLBACK_TEXT });
+        }
+      );
+    });
+  }
+  baseRequest() {
+    return {
       model: this.model,
-      messages: formattedMessages,
       temperature: this.temperature,
-      max_tokens: this.maxTokens,
-      top_p: this.topP
+      ...this.maxTokens === void 0 ? {} : { max_tokens: this.maxTokens },
+      ...this.topP === void 0 ? {} : { top_p: this.topP }
     };
-    const toolsToUse = options?.temporaryTools || this.tools;
-    if (toolsToUse && toolsToUse.length > 0) {
-      const formattedTools = toolsToUse.map((tool) => {
-        const typedTool = tool;
-        if (typedTool.type === "function") {
-          return tool;
-        }
-        return {
-          type: "function",
-          function: {
-            name: typedTool.name,
-            description: typedTool.description,
-            parameters: typedTool.parameters || {}
-          }
-        };
-      });
-      requestParams.tools = formattedTools;
-    }
-    const response = await this.client.chat.completions.create(requestParams);
-    const responseMessage = response.choices[0].message;
-    const result = {
-      role: "assistant",
-      content: responseMessage.content || ""
-    };
-    if (response.usage) {
-      const usage = response.usage;
-      result.usage = {
-        completion_tokens: usage.completion_tokens || 0,
-        prompt_tokens: usage.prompt_tokens || 0,
-        prompt_cache_hit_tokens: usage.prompt_cache_hit_tokens,
-        prompt_cache_miss_tokens: usage.prompt_cache_miss_tokens,
-        total_tokens: usage.total_tokens || 0
-      };
-    }
-    if (responseMessage.tool_calls && responseMessage.tool_calls.length > 0) {
-      result.tool_calls = responseMessage.tool_calls.map((toolCall) => {
-        if (toolCall.type !== "function" || !("function" in toolCall)) {
-          throw new Error(`Unsupported tool call type: ${toolCall.type}`);
-        }
-        let args;
-        const rawArgs = toolCall.function.arguments;
-        if (typeof rawArgs === "string") {
-          const raw = rawArgs;
-          try {
-            args = raw && raw.trim().length > 0 ? JSON.parse(raw) : {};
-          } catch {
-            args = {};
-          }
-        } else if (rawArgs && typeof rawArgs === "object") {
-          args = rawArgs;
-        } else {
-          args = {};
-        }
-        return {
-          id: toolCall.id,
-          // 满足 Agent 组件期望的格式
-          function: {
-            name: toolCall.function.name,
-            arguments: toolCall.function.arguments || "{}"
-          },
-          type: "function",
-          // 满足内部 ToolCall 接口
-          tool_name: toolCall.function.name,
-          arguments: args
-        };
-      });
-    }
-    return result;
+  }
+  toolsParam(tools) {
+    return tools !== void 0 && tools.length > 0 ? { tools: tools.map(toApiTool) } : {};
+  }
+  systemMessages() {
+    return this.systemPrompt === void 0 || this.systemPrompt === "" ? [] : [{ role: "system", content: this.systemPrompt }];
   }
   /**
-   * 在独立模式下运行组件
-   * @param input 输入参数，可以是提示文本或对话消息数组
-   * @returns 生成的文本或响应消息
+   * Converts input messages to API messages. Assistant `tool_calls` are not forwarded:
+   * agents send tool results back as user messages, and the API rejects assistant tool
+   * calls that are not followed by tool messages.
    */
-  async run(input) {
-    if (typeof input === "string") {
-      return this.generateCompletion(input);
-    } else {
-      return this.chatCompletion(input);
-    }
+  formatMessages(messages) {
+    return [...this.systemMessages(), ...messages.map((message) => this.toApiMessage(message))];
   }
   /**
-   * 在流水线中运行组件
-   * @param $i 输入端口
-   * @param $o 输出端口
+   * Converts one input message to its API shape.
+   *
+   * @throws Error when the role is not one of `MessageRole`, or a `tool` message has no
+   * `tool_call_id`. The API would reject both.
    */
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  _transform($i, $o) {
-    $i("prompt").receive(async (prompt) => {
-      try {
-        const completion = await this.generateCompletion(prompt);
-        $o("completion").send(completion);
-      } catch (error) {
-        console.error("Deepseek API \u8C03\u7528\u9519\u8BEF:", error);
-        $o("completion").send("API \u8C03\u7528\u9519\u8BEF");
-      }
-    });
-    $i("messages").receive(async (messages) => {
-      try {
-        const responseMessage = await this.chatCompletion(messages);
-        $o("message").send(responseMessage);
-      } catch (error) {
-        console.error("Deepseek API \u8C03\u7528\u9519\u8BEF:", error);
-        $o("message").send({
-          role: "assistant",
-          content: "API \u8C03\u7528\u9519\u8BEF"
-        });
-      }
+  toApiMessage(message) {
+    const content = message.content ?? "";
+    switch (message.role) {
+      case "system":
+        return { role: "system", content };
+      case "user":
+        return { role: "user", content };
+      case "assistant":
+        return message.content === void 0 ? { role: "assistant" } : { role: "assistant", content: message.content };
+      case "tool":
+        if (message.tool_call_id === void 0 || message.tool_call_id === "") {
+          throw new Error(
+            `${this.name}: a tool message needs the tool_call_id of the call it answers.`
+          );
+        }
+        return { role: "tool", content, tool_call_id: message.tool_call_id };
+      default:
+        throw new Error(
+          `${this.name}: unsupported message role '${message.role}'. Use system, user, assistant or tool.`
+        );
+    }
+  }
+  firstMessage(response) {
+    const choice = response.choices[0];
+    if (choice === void 0) {
+      throw new Error(`${this.name} returned no choices.`);
+    }
+    return choice.message;
+  }
+  logError(error) {
+    if (this.verbose) {
+      console.error(`[${this.name}] API call failed:`, error);
+    }
+  }
+};
+var openai_compatible_default = OpenAICompatible;
+
+// src/model-provider/deepseek/index.ts
+var DEFAULT_BASE_URL2 = "https://api.deepseek.com/v1";
+var DEFAULT_MODEL = "deepseek-chat";
+var Deepseek = class extends openai_compatible_default {
+  constructor(config) {
+    super({
+      ...config,
+      model: config.model ?? DEFAULT_MODEL,
+      baseURL: config.baseURL ?? DEFAULT_BASE_URL2,
+      name: "DeepSeek"
     });
   }
 };