foliko 1.1.13 → 1.1.14

package/src/core/token-counter.js

@@ -0,0 +1,190 @@
+/**
+ * TokenCounter - Token 计算工具
+ *
+ * 职责：
+ * 1. 计算文本的 token 数量
+ * 2. 计算消息数组的 token 总数
+ * 3. 计算工具定义的 token 总数
+ */
+
+/**
+ * 简单的中英文混合 tokenizer
+ * 粗略估计：中文每个字符 2 字节，英文每个单词约 1.5 字节
+ * @param {string} text - 文本
+ * @param {number} bytesPerToken - 每 token 字节数，默认 4
+ * @returns {number} token 数量
+ */
+function encode(text, bytesPerToken = 4) {
+  if (!text) return 0;
+  const bytes = Buffer.byteLength(String(text), 'utf8');
+  return Math.ceil(bytes / bytesPerToken);
+}
+
+/**
+ * 计算 JSON 字符串的 token 数量
+ * @param {string} text - JSON 字符串
+ * @returns {number} token 数量
+ */
+function encodeForJSON(text) {
+  if (!text) return 0;
+  // JSON 字符串需要额外计算引号和转义
+  const encoded = encode(text);
+  return encoded + Math.ceil(Buffer.byteLength(JSON.stringify(text), 'utf8') / 100);
+}
+
+class TokenCounter {
+  /**
+   * @param {Object} config - 配置
+   * @param {Object} config.toolSchema - 工具 schema（用于工具 token 计算）
+   */
+  constructor(config = {}) {
+    this.toolSchema = config.toolSchema || null;
+  }
+
+  /**
+   * 计算文本 token
+   * @param {string} text - 文本
+   * @param {number} bytesPerToken - 每 token 字节数
+   * @returns {number} token 数量
+   */
+  countText(text, bytesPerToken = 4) {
+    return encode(text, bytesPerToken);
+  }
+
+  /**
+   * 计算消息数组的 token 总数
+   * @param {Array} messages - 消息数组
+   * @returns {number} token 总数
+   */
+  countMessages(messages) {
+    if (!Array.isArray(messages)) return 0;
+    return messages.reduce((sum, msg) => sum + this.countMessage(msg), 0);
+  }
+
+  /**
+   * 计算单条消息的 token
+   * @param {Object} msg - 消息
+   * @returns {number} token 数量
+   */
+  countMessage(msg) {
+    if (!msg) return 0;
+
+    let total = 0;
+
+    // 角色和格式开销
+    total += 4;
+
+    if (typeof msg.content === 'string') {
+      total += this.countText(msg.content);
+    } else if (Array.isArray(msg.content)) {
+      for (const block of msg.content) {
+        total += this.countContentBlock(block);
+      }
+    }
+
+    // tool_calls 开销
+    if (msg.tool_calls && Array.isArray(msg.tool_calls)) {
+      total += 15; // overhead per tool_calls block
+      for (const tc of msg.tool_calls) {
+        if (tc.function) {
+          total += this.countText(tc.function.name) + this.countText(tc.function.arguments);
+        }
+      }
+    }
+
+    // tool_call_id 开销
+    if (msg.tool_call_id) {
+      total += 15;
+    }
+
+    return total;
+  }
+
+  /**
+   * 计算 content block 的 token
+   * @param {Object} block - content block
+   * @returns {number} token 数量
+   */
+  countContentBlock(block) {
+    if (!block) return 0;
+
+    switch (block.type) {
+      case 'text':
+        return this.countText(block.text);
+      case 'tool-call':
+      case 'tool-use':
+        if (block.input) {
+          return this.countText(JSON.stringify(block.input));
+        }
+        return 0;
+      case 'tool-result':
+      case 'tool_result':
+        if (block.content) {
+          const content =
+            typeof block.content === 'string' ? block.content : JSON.stringify(block.content);
+          return this.countText(content);
+        }
+        return 0;
+      case 'image':
+        // 图片按 token 估算
+        return 85;
+      default:
+        return this.countText(JSON.stringify(block));
+    }
+  }
+
+  /**
+   * 计算工具定义的 token 总数
+   * @param {Array} tools - 工具数组
+   * @returns {number} token 总数
+   */
+  countTools(tools) {
+    if (!tools || !Array.isArray(tools)) return 0;
+
+    let total = 0;
+    for (const tool of tools) {
+      // 工具名和描述
+      total += 20; // overhead
+
+      if (tool.description) {
+        total += this.countText(tool.description);
+      }
+
+      // 参数
+      if (tool.inputSchema) {
+        const schema =
+          tool.inputSchema.jsonSchema || tool.inputSchema.inputSchema || tool.inputSchema;
+        if (schema.properties) {
+          for (const [name, prop] of Object.entries(schema.properties)) {
+            total += this.countText(name) + 10;
+            if (prop.description) {
+              total += this.countText(prop.description);
+            }
+          }
+        }
+      }
+    }
+
+    return total;
+  }
+
+  /**
+   * 估算完整请求的 token（消息 + 工具 + 系统提示）
+   * @param {Object} params - 请求参数
+   * @returns {Object} - { messagesTokens, toolsTokens, systemPromptTokens, total }
+   */
+  estimateRequest({ messages, tools, systemPrompt }) {
+    const messagesTokens = this.countMessages(messages);
+    const toolsTokens = this.countTools(tools);
+    const systemPromptTokens = systemPrompt ? this.countText(systemPrompt) : 0;
+
+    return {
+      messagesTokens,
+      toolsTokens,
+      systemPromptTokens,
+      total: messagesTokens + toolsTokens + systemPromptTokens,
+    };
+  }
+}
+
+module.exports = { TokenCounter, encode, encodeForJSON };

package/src/core/tool-executor.js

@@ -0,0 +1,270 @@
+/**
+ * ToolExecutor - 工具执行器
+ *
+ * 职责：
+ * 1. 工具发现和注册
+ * 2. 工具执行
+ * 3. 工具调用验证
+ */
+
+const { EventEmitter } = require('../utils/event-emitter');
+const { logger } = require('../utils/logger');
+
+class ToolExecutor extends EventEmitter {
+  /**
+   * @param {Object} config - 配置
+   */
+  constructor(config = {}) {
+    super();
+
+    this.config = config;
+    this.agent = config.agent;
+    this.framework = config.framework;
+
+    // 工具注册表: name -> toolDef
+    this._tools = new Map();
+
+    // 工具调用统计
+    this._toolStats = {
+      totalCalls: 0,
+      failedCalls: 0,
+      lastCall: null,
+    };
+  }
+
+  /**
+   * 注册工具
+   * @param {Object} tool - 工具定义
+   */
+  registerTool(tool) {
+    if (!tool || !tool.name) {
+      logger.warn('ToolExecutor', 'Ignoring tool with no name');
+      return;
+    }
+    this._tools.set(tool.name, tool);
+    logger.debug('ToolExecutor', `Registered tool: ${tool.name}`);
+  }
+
+  /**
+   * 批量注册工具
+   * @param {Array} tools - 工具数组
+   */
+  registerTools(tools) {
+    if (!Array.isArray(tools)) return;
+    for (const tool of tools) {
+      this.registerTool(tool);
+    }
+  }
+
+  /**
+   * 注销工具
+   * @param {string} name - 工具名
+   */
+  unregisterTool(name) {
+    this._tools.delete(name);
+  }
+
+  /**
+   * 获取工具
+   * @param {string} name - 工具名
+   * @returns {Object|null}
+   */
+  getTool(name) {
+    return this._tools.get(name) || null;
+  }
+
+  /**
+   * 获取所有工具
+   * @returns {Array}
+   */
+  getAllTools() {
+    return Array.from(this._tools.values());
+  }
+
+  /**
+   * 检查工具是否存在
+   * @param {string} name - 工具名
+   * @returns {boolean}
+   */
+  hasTool(name) {
+    return this._tools.has(name);
+  }
+
+  /**
+   * 执行工具
+   * @param {string} name - 工具名
+   * @param {Object} args - 参数
+   * @param {Object} options - 选项
+   * @returns {Promise}
+   */
+  async executeTool(name, args = {}, options = {}) {
+    const tool = this._tools.get(name);
+    if (!tool) {
+      const error = `Tool '${name}' not found`;
+      logger.warn('ToolExecutor', error);
+      throw new Error(error);
+    }
+
+    this._toolStats.totalCalls++;
+    this._toolStats.lastCall = {
+      name,
+      args,
+      timestamp: Date.now(),
+    };
+
+    this.emit('tool:call', { name, args, source: options.source });
+
+    try {
+      // 统一 execute 签名为 (args, framework)
+      const result = await tool.execute(args, this.framework);
+
+      this.emit('tool:result', { name, args, result, source: options.source });
+
+      return result;
+    } catch (err) {
+      this._toolStats.failedCalls++;
+      logger.error('ToolExecutor', `Tool '${name}' failed:`, err.message);
+
+      this.emit('tool:error', {
+        name,
+        args,
+        error: err.message,
+        source: options.source,
+      });
+
+      throw err;
+    }
+  }
+
+  /**
+   * 批量执行工具
+   * @param {Array} tools - 工具调用数组 [{name, args}, ...]
+   * @param {Object} options - 选项
+   * @returns {Promise<Array>}
+   */
+  async executeTools(tools, options = {}) {
+    if (!Array.isArray(tools)) {
+      throw new Error('tools must be an array');
+    }
+
+    const results = [];
+    for (const toolCall of tools) {
+      try {
+        const result = await this.executeTool(toolCall.name, toolCall.args || {}, options);
+        results.push({ success: true, name: toolCall.name, result });
+      } catch (err) {
+        results.push({ success: false, name: toolCall.name, error: err.message });
+      }
+    }
+    return results;
+  }
+
+  /**
+   * 获取工具的 AI 格式（用于发送给 AI）
+   * @returns {Object} AI SDK 格式的工具对象
+   */
+  getToolsForAI() {
+    const tools = {};
+    for (const [name, tool] of this._tools) {
+      if (!tool.description) continue;
+
+      tools[name] = {
+        description: tool.description,
+        inputSchema: tool.inputSchema,
+        execute: tool.execute ? tool.execute.bind(tool) : undefined,
+      };
+    }
+    return tools;
+  }
+
+  /**
+   * 验证工具调用的参数
+   * @param {Array} messages - 消息数组
+   * @returns {Array} 验证后的消息
+   */
+  validateToolCalls(messages) {
+    let fixedCount = 0;
+    // 收集被跳过的 toolCallId，用于清理对应的 tool-result
+    const invalidatedToolCallIds = new Set();
+
+    for (const msg of messages) {
+      // 清理 assistant 消息中的不完整 tool-call
+      if (msg.role === 'assistant' && Array.isArray(msg.content)) {
+        for (const item of msg.content) {
+          // 兼容 tool-call 和 tool-use 两种类型
+          if (item.type !== 'tool-call' && item.type !== 'tool-use') {
+            continue;
+          }
+
+          const input = item.input;
+          if (typeof input !== 'string') {
+            continue;
+          }
+
+          // 检查 input 是否是有效的 JSON（不是不完整的）
+          const trimmed = input.trim();
+          if (trimmed === '{' || trimmed === '' || !trimmed.startsWith('{')) {
+            // 不完整的 JSON，移除这个 tool-call
+            // 记录 toolCallId，以便后续清理对应的 tool-result
+            if (item.toolCallId) {
+              invalidatedToolCallIds.add(item.toolCallId);
+            }
+            logger.warn(
+              `_validateToolCalls: invalid tool-call input="${input}", toolCallId=${item.toolCallId}, converting to text`
+            );
+            item.type = 'text';
+            item.text = `（工具调用 ${item.toolName} 参数不完整，已跳过）`;
+            delete item.toolCallId;
+            delete item.toolName;
+            delete item.input;
+            fixedCount++;
+          }
+        }
+      }
+    }
+
+    // 如果有无效的 tool-call，清理对应的 tool-result
+    if (invalidatedToolCallIds.size > 0) {
+      logger.warn(
+        `_validateToolCalls: removing ${invalidatedToolCallIds.size} tool-results with invalidated toolCallIds`
+      );
+      for (const msg of messages) {
+        if (msg.role === 'tool' && Array.isArray(msg.content)) {
+          // 过滤掉引用了无效 toolCallId 的 tool-result
+          const oldLen = msg.content.length;
+          msg.content = msg.content.filter((item) => {
+            if (item.type !== 'tool-result' && item.type !== 'tool_result') {
+              return true;
+            }
+            // 如果 tool-result 引用的 toolCallId 已被标记为无效，则移除
+            if (item.toolCallId && invalidatedToolCallIds.has(item.toolCallId)) {
+              logger.warn(
+                `_validateToolCalls: removing orphaned tool-result with toolCallId=${item.toolCallId}`
+              );
+              fixedCount++;
+              return false;
+            }
+            return true;
+          });
+        }
+      }
+    }
+
+    if (fixedCount > 0) {
+      logger.info(`_validateToolCalls: Fixed ${fixedCount} incomplete tool calls/results`);
+    }
+  }
+
+  /**
+   * 获取工具统计
+   * @returns {Object}
+   */
+  getStats() {
+    return {
+      ...this._toolStats,
+      toolCount: this._tools.size,
+    };
+  }
+}
+
+module.exports = { ToolExecutor };

package/src/executors/mcp-executor.js

@@ -37,6 +37,10 @@ class MCPClientWrapper {
   async connect() {
     if (this.connected) return;
 
+    const controller = new AbortController();
+    const timeoutMs = this.timeout || 30000;
+    const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+
     try {
       // 动态导入 @ai-sdk/mcp
       let createMCPClient;
@@ -63,7 +67,10 @@ class MCPClientWrapper {
           args: shellResolve ? [shellResolve, ...this.args] : this.args,
           env: { ...process.env, ...this.env },
         });
-        this.client = await createMCPClient({ transport });
+        this.client = await createMCPClient({
+          transport,
+          signal: controller.signal,
+        });
       } catch (transportErr) {
         log.error(` Transport error:`, transportErr.message);
         throw transportErr;
@@ -85,8 +92,14 @@ class MCPClientWrapper {
       this.connected = true;
       log.info(` Connected to ${this.serverName} with ${this.tools.length} tools`);
     } catch (err) {
+      if (controller.signal.aborted) {
+        log.error(` Connection timeout (${timeoutMs}ms) for ${this.serverName}`);
+        throw new Error(`连接超时 (${timeoutMs}ms): ${this.serverName}`);
+      }
       log.error(` Failed to connect to ${this.serverName}:`, err.message);
       // 不抛出错误，让框架继续运行
+    } finally {
+      clearTimeout(timeoutId);
     }
   }