inspiration-agent 0.0.1

package/dist/model/base-llm.service.js

@@ -0,0 +1,320 @@
+const axios = require("axios");
+const logger = require("../utils/logger");
+
+/**
+ * 基础 LLM 服务类
+ * 提供通用的 LLM API 调用功能
+ */
+class BaseLLMService {
+  constructor(config) {
+    this.apiKey = config.apiKey;
+    this.apiUrl = config.apiUrl;
+    this.model = config.model;
+    this.providerName = config.providerName || "LLM";
+    this.onTokenUsage = null;
+    this.toolHandlers = {};
+  }
+
+  setTokenUsageCallback(callback) {
+    this.onTokenUsage = callback;
+  }
+
+  registerToolHandler(name, handler) {
+    this.toolHandlers[name] = handler;
+  }
+
+  getHeaders() {
+    return {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${this.apiKey}`,
+    };
+  }
+
+  buildPayload(messages, tools = null, toolChoice = null, stream = false) {
+    const payload = {
+      model: this.model,
+      messages: messages,
+      temperature: 0.7,
+      stream: stream,
+    };
+
+    if (tools) {
+      payload.tools = tools;
+    }
+
+    if (toolChoice) {
+      payload.tool_choice = toolChoice;
+    }
+
+    return payload;
+  }
+
+  logRequest(messages, tools, toolChoice) {
+    logger.debug(`\n========== ${this.providerName} API 请求 ==========`);
+    logger.debug(`URL: ${this.apiUrl}`);
+    logger.debug(`Model: ${this.model}`);
+    logger.debug(`Messages: ${JSON.stringify(messages, null, 2)}`);
+    logger.debug(`Tools: ${tools ? JSON.stringify(tools, null, 2) : "无"}`);
+    logger.debug(`Tool Choice: ${toolChoice || "无"}`);
+    logger.debug("====================================\n");
+  }
+
+  logResponse(content, toolCalls, usage) {
+    logger.debug(`\n========== ${this.providerName} API 响应 ==========`);
+    logger.debug("Content Length:", content.length);
+    logger.debug(`Content: ${content}`);
+    logger.debug("Tool Calls:", toolCalls.length > 0 ? toolCalls : "无");
+    logger.debug("Usage:", usage ? usage : "无");
+    logger.debug("====================================\n");
+  }
+
+  handleError(error) {
+    logger.error(`\n========== ${this.providerName} API 错误 ==========`);
+    logger.error(`Error: ${error.message}`);
+    if (error.response) {
+      logger.error(`Status: ${error.response.status}`);
+      logger.error(`Data: ${JSON.stringify(error.response.data, null, 2)}`);
+    }
+    logger.error("====================================\n");
+
+    if (error.response) {
+      throw new Error(
+        `${this.providerName} API Error: ${error.response.status} - ${JSON.stringify(error.response.data)}`
+      );
+    }
+    throw new Error(`${this.providerName} API Error: ${error.message}`);
+  }
+
+  async chat(messages, tools = null, toolChoice = null) {
+    try {
+      this.logRequest(messages, tools, toolChoice);
+
+      const payload = this.buildPayload(messages, tools, toolChoice, false);
+
+      const response = await axios.post(this.apiUrl, payload, {
+        headers: this.getHeaders(),
+      });
+
+      const message = response.data.choices[0].message;
+      const usage = response.data.usage;
+
+      this.logResponse(message.content || "", message.tool_calls || [], usage);
+
+      if (usage && this.onTokenUsage) {
+        this.onTokenUsage(usage.prompt_tokens || 0, usage.completion_tokens || 0);
+      }
+
+      return response.data;
+    } catch (error) {
+      this.handleError(error);
+    }
+  }
+
+  async chatStream(messages, onChunk, tools = null, toolChoice = null) {
+    try {
+      this.logRequest(messages, tools, toolChoice);
+
+      const payload = this.buildPayload(messages, tools, toolChoice, true);
+
+      const response = await axios.post(this.apiUrl, payload, {
+        headers: this.getHeaders(),
+        responseType: "stream",
+      });
+
+      return new Promise((resolve, reject) => {
+        let fullContent = "";
+        let buffer = "";
+        let toolCalls = [];
+        let usage = null;
+
+        response.data.on("data", (chunk) => {
+          buffer += chunk.toString();
+          const lines = buffer.split("\n");
+          buffer = lines.pop() || "";
+
+          for (const line of lines) {
+            if (line.startsWith("data: ")) {
+              const data = line.slice(6);
+              if (data === "[DONE]") {
+                break;
+              }
+              try {
+                const parsed = JSON.parse(data);
+                const delta = parsed.choices[0]?.delta;
+
+                if (parsed.usage) {
+                  usage = parsed.usage;
+                }
+
+                if (delta?.content) {
+                  fullContent += delta.content;
+                  onChunk(delta.content);
+                }
+
+                if (delta?.tool_calls) {
+                  for (const toolCall of delta.tool_calls) {
+                    if (toolCall.index !== undefined) {
+                      if (!toolCalls[toolCall.index]) {
+                        toolCalls[toolCall.index] = {
+                          id: toolCall.id,
+                          type: toolCall.type,
+                          function: {
+                            name: toolCall.function?.name || "",
+                            arguments: "",
+                          },
+                        };
+                      }
+                      if (toolCall.function?.name) {
+                        toolCalls[toolCall.index].function.name = toolCall.function.name;
+                      }
+                      if (toolCall.function?.arguments) {
+                        toolCalls[toolCall.index].function.arguments += toolCall.function.arguments;
+                      }
+                    }
+                  }
+                }
+              } catch (e) {
+                // 忽略解析错误
+              }
+            }
+          }
+        });
+
+        response.data.on("end", () => {
+          const result = { content: fullContent };
+          if (toolCalls.length > 0) {
+            result.tool_calls = toolCalls;
+          }
+          if (usage) {
+            result.usage = usage;
+            if (this.onTokenUsage) {
+              this.onTokenUsage(usage.prompt_tokens || 0, usage.completion_tokens || 0);
+            }
+          }
+
+          this.logResponse(fullContent, toolCalls, usage);
+          resolve(result);
+        });
+
+        response.data.on("error", (error) => {
+          reject(error);
+        });
+      });
+    } catch (error) {
+      this.handleError(error);
+    }
+  }
+
+  async executeToolCall(toolCall) {
+    const { name, arguments: args } = toolCall.function;
+
+    logger.debug(`\n========== executeToolCall ==========`);
+    logger.debug(`工具名称: ${name}`);
+    logger.debug(`工具参数: ${args}`);
+    logger.debug(`======================================\n`);
+
+    try {
+      const parsedArgs = JSON.parse(args);
+      logger.debug(`参数解析成功: ${JSON.stringify(parsedArgs, null, 2)}`);
+
+      if (this.toolHandlers[name]) {
+        logger.debug(`找到工具处理器，开始执行...`);
+        const result = await this.toolHandlers[name](parsedArgs);
+        logger.debug(`工具执行完成，结果: ${JSON.stringify(result, null, 2)}`);
+        return result;
+      }
+
+      throw new Error(`Unknown tool: ${name}`);
+    } catch (error) {
+      logger.error(`工具执行失败: ${error}`);
+      throw error;
+    }
+  }
+
+  async chatWithFunctionCalls(messages, tools, maxIterations = 100) {
+    let currentMessages = [...messages];
+    let iteration = 0;
+
+    while (iteration < maxIterations) {
+      iteration++;
+
+      const response = await this.chat(currentMessages, tools);
+      const message = response.choices[0].message;
+
+      if (!message.tool_calls) {
+        return message;
+      }
+
+      currentMessages.push(message);
+
+      for (const toolCall of message.tool_calls) {
+        const result = await this.executeToolCall(toolCall);
+        currentMessages.push({
+          tool_call_id: toolCall.id,
+          role: "tool",
+          content: JSON.stringify(result),
+        });
+      }
+    }
+
+    throw new Error("Max iterations reached without final response");
+  }
+
+  async chatWithFunctionCallsStream(messages, onChunk, tools, maxIterations = 100) {
+    let currentMessages = [...messages];
+    let iteration = 0;
+
+    logger.debug(`\n========== chatWithFunctionCallsStream 开始 ==========`);
+    logger.debug(`工具数量: ${tools?.length || 0}`);
+    logger.debug(`消息数量: ${messages?.length || 0}`);
+    logger.debug("==============================================\n");
+
+    while (iteration < maxIterations) {
+      iteration++;
+
+      logger.debug(`\n--- 迭代 ${iteration} ---`);
+
+      const response = await this.chatStream(
+        currentMessages,
+        (chunk) => {
+          onChunk(chunk);
+        },
+        tools
+      );
+
+      if (!response.tool_calls) {
+        logger.debug("\n未检测到 tool_calls，返回最终响应");
+        logger.debug("==============================================\n");
+        return response;
+      }
+
+      logger.debug(`\n检测到 tool_calls，数量: ${response.tool_calls.length}`);
+      currentMessages.push({
+        role: "assistant",
+        tool_calls: response.tool_calls,
+        content: response.content || "",
+      });
+
+      for (const toolCall of response.tool_calls) {
+        logger.debug(`\n========== 准备执行工具 ==========`);
+        logger.debug(`工具 ID: ${toolCall.id}`);
+        logger.debug(`工具类型: ${toolCall.type}`);
+        logger.debug(`工具名称: ${toolCall.function.name}`);
+        logger.debug(`工具参数: ${toolCall.function.arguments}`);
+        logger.debug(`======================================\n`);
+
+        const result = await this.executeToolCall(toolCall);
+        logger.debug(`\n工具 ${toolCall.function.name} 执行完成`);
+        currentMessages.push({
+          tool_call_id: toolCall.id,
+          role: "tool",
+          content: JSON.stringify(result),
+        });
+      }
+    }
+
+    throw new Error("Max iterations reached without final response");
+  }
+}
+
+module.exports = BaseLLMService;

package/dist/model/deepseek.service.js

@@ -0,0 +1,18 @@
+const BaseLLMService = require("./base-llm.service");
+
+/**
+ * DeepSeek API 服务类
+ * 继承基础 LLM 服务，提供 DeepSeek 特定配置
+ */
+class DeepSeekService extends BaseLLMService {
+  constructor() {
+    super({
+      apiKey: process.env.DEEPSEEK_API_KEY,
+      apiUrl: process.env.DEEPSEEK_API_URL,
+      model: process.env.DEEPSEEK_MODEL || "deepseek-chat",
+      providerName: "DeepSeek",
+    });
+  }
+}
+
+module.exports = DeepSeekService;

package/dist/model/kimi.service.js

@@ -0,0 +1,19 @@
+const BaseLLMService = require("./base-llm.service");
+
+/**
+ * Kimi (月之暗面) API 服务类
+ * 继承基础 LLM 服务，提供 Kimi 特定配置
+ * API 文档: https://platform.moonshot.cn/docs
+ */
+class KimiService extends BaseLLMService {
+  constructor() {
+    super({
+      apiKey: process.env.KIMI_API_KEY,
+      apiUrl: process.env.KIMI_API_URL || "https://api.moonshot.cn/v1/chat/completions",
+      model: process.env.KIMI_MODEL || "moonshot-v1-8k",
+      providerName: "Kimi",
+    });
+  }
+}
+
+module.exports = KimiService;

package/dist/model/minimax.service.js

@@ -0,0 +1,35 @@
+const BaseLLMService = require("./base-llm.service");
+
+/**
+ * MiniMax API 服务类
+ * 继承基础 LLM 服务，提供 MiniMax 特定配置
+ * API 文档: https://www.minimaxi.com/document/
+ */
+class MiniMaxService extends BaseLLMService {
+  constructor() {
+    super({
+      apiKey: process.env.MINIMAX_API_KEY,
+      apiUrl: process.env.MINIMAX_API_URL || "https://api.minimax.chat/v1/chat/completions",
+      model: process.env.MINIMAX_MODEL || "abab6.5s-chat",
+      providerName: "MiniMax",
+    });
+    this.groupId = process.env.MINIMAX_GROUP_ID;
+  }
+
+  getHeaders() {
+    return {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${this.apiKey}`,
+    };
+  }
+
+  buildPayload(messages, tools = null, toolChoice = null, stream = false) {
+    const payload = super.buildPayload(messages, tools, toolChoice, stream);
+    if (this.groupId) {
+      payload.group_id = this.groupId;
+    }
+    return payload;
+  }
+}
+
+module.exports = MiniMaxService;

package/dist/model/zhipu.service.js

@@ -0,0 +1,26 @@
+const BaseLLMService = require("./base-llm.service");
+
+/**
+ * 智谱 GLM (ZhipuAI) API 服务类
+ * 继承基础 LLM 服务，提供智谱 GLM 特定配置
+ * API 文档: https://open.bigmodel.cn/dev/api
+ */
+class ZhipuService extends BaseLLMService {
+  constructor() {
+    super({
+      apiKey: process.env.ZHIPU_API_KEY,
+      apiUrl: process.env.ZHIPU_API_URL || "https://open.bigmodel.cn/api/paas/v4/chat/completions",
+      model: process.env.ZHIPU_MODEL || "glm-4-flash",
+      providerName: "ZhipuGLM",
+    });
+  }
+
+  getHeaders() {
+    return {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${this.apiKey}`,
+    };
+  }
+}
+
+module.exports = ZhipuService;