foliko 1.1.63 → 1.1.65

package/src/core/tool-executor.js

@@ -9,6 +9,7 @@
 
 const { EventEmitter } = require('../utils/event-emitter');
 const { logger } = require('../utils/logger');
+const { validateToolCalls } = require('../utils/message-validator');
 
 class ToolExecutor extends EventEmitter {
   /**
@@ -183,76 +184,7 @@ class ToolExecutor extends EventEmitter {
    * @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`);
-    }
+    return validateToolCalls(messages);
   }
 
   /**

package/src/executors/mcp-executor.js

@@ -307,7 +307,7 @@ class MCPExecutorPlugin extends Plugin {
 
         return {
           success: true,
-          result: {
+          data: {
             name: toolInfo.name,
             description: toolInfo.description,
             required,
@@ -405,7 +405,7 @@ class MCPExecutorPlugin extends Plugin {
             source: 'mcp',
           });
 
-          return { success: true, result: execResult };
+          return { success: true, data: execResult };
         } catch (err) {
           log.error(` Tool '${tool}' failed:`, err.message);
 
@@ -450,7 +450,7 @@ class MCPExecutorPlugin extends Plugin {
             });
           }
         }
-        return { success: true, servers };
+        return { success: true, data: servers };
       },
     });
 
@@ -481,8 +481,10 @@ class MCPExecutorPlugin extends Plugin {
 
           return {
             success: true,
-            message: 'MCP 配置已重载',
-            servers: Object.keys(config.mcpServers || {}),
+            data: 'MCP 配置已重载',
+            metadata: {
+              servers: Object.keys(config.mcpServers || {}),
+            },
           };
         } catch (err) {
           log.error(' Reload error:', err);
@@ -507,7 +509,7 @@ class MCPExecutorPlugin extends Plugin {
         if (enabled) {
           // 启用服务器
           if (clientInfo && clientInfo.enabled) {
-            return { success: true, message: `MCP 服务器 '${server}' 已经是开启状态` };
+            return { success: true, data: `MCP 服务器 '${server}' 已经是开启状态` };
           }
           // 如果服务器从未连接过，也检查配置中的 enabled 状态
           if (!clientInfo && serverConfig && serverConfig.enabled === false) {
@@ -527,7 +529,7 @@ class MCPExecutorPlugin extends Plugin {
               // 保存 enabled 状态到配置文件
               await this._saveMCPServerEnabled(server, true);
               this._refreshAllAgentsMCPPrompt(this._framework);
-              return { success: true, message: `MCP 服务器 '${server}' 已开启` };
+              return { success: true, data: `MCP 服务器 '${server}' 已开启` };
             } else {
               return { success: false, error: '服务器配置不存在，需要重载配置' };
             }
@@ -555,10 +557,10 @@ class MCPExecutorPlugin extends Plugin {
           // 保存 enabled 状态到配置文件
           await this._saveMCPServerEnabled(server, false);
           this._refreshAllAgentsMCPPrompt(this._framework);
-          return { success: true, message: `MCP 服务器 '${server}' 已关闭` };
+          return { success: true, data: `MCP 服务器 '${server}' 已关闭` };
         }
 
-        return { success: true, message: `MCP 服务器 '${server}' 状态未变化` };
+        return { success: true, data: `MCP 服务器 '${server}' 状态未变化` };
       },
     });
 
@@ -610,7 +612,7 @@ class MCPExecutorPlugin extends Plugin {
    */
   _refreshAgentMCPPrompt(agent) {
     // 检查是否已刷新过（通过检查系统提示词是否已包含 MCP 描述）
-    const existingPrompt = agent._originalPrompt || '';
+    const existingPrompt = (typeof agent.getOriginalPrompt === 'function' ? agent.getOriginalPrompt() : agent._originalPrompt) || '';
     if (existingPrompt.includes('【MCP Servers】')) {
       return;
     }

package/src/utils/chat-queue.js

@@ -1,6 +1,7 @@
 const { EventEmitter } = require('./event-emitter');
 const { cleanResponse } = require('./index');
 const { logger } = require('./logger');
+const { isNetworkError, calculateDelay, PRESETS } = require('./retry');
 const log = logger.child('ChatQueue');
 // ChatQueueManager.js
 class ChatQueueManager extends EventEmitter {
@@ -118,10 +119,9 @@ class ChatQueueManager extends EventEmitter {
         if (result.error) {
           lastError = result.error;
           if (attempt < this.retryAttempts && this.isRetryableError(lastError)) {
-            await this.sleep(this.retryDelay * Math.pow(2, attempt - 1));
+            await this.sleep(calculateDelay(attempt, { baseDelay: this.retryDelay }));
             continue;
           }
-          // 重试耗尽，直接抛出 result.error
           throw lastError;
         }
 
@@ -130,7 +130,7 @@ class ChatQueueManager extends EventEmitter {
         log.warn('[ChatQueue] executeWithRetry: ', attempt, 'error:', error.message);
         lastError = error;
         if (attempt < this.retryAttempts && this.isRetryableError(error)) {
-          await this.sleep(this.retryDelay * Math.pow(2, attempt - 1));
+          await this.sleep(calculateDelay(attempt, { baseDelay: this.retryDelay }));
           continue;
         }
         break;
@@ -138,9 +138,7 @@ class ChatQueueManager extends EventEmitter {
     }
 
     // 将最后的错误转换为友好消息
-    const errName = lastError?.name || '';
-    const isRetryError = errName === 'AI_RetryError' || errName === 'RetryError';
-    const friendlyMessage = isRetryError
+    const friendlyMessage = isNetworkError(lastError)
       ? 'AI 服务暂时不可用，请稍后重试'
       : (lastError?.message || String(lastError)).split('\n')[0];
 
@@ -175,9 +173,7 @@ class ChatQueueManager extends EventEmitter {
     } catch (err) {
       // SDK 直接抛出错误（没有通过 chunk 传递）
       // 转换为友好错误消息
-      const errName = err?.name || '';
-      const isRetryError = errName === 'AI_RetryError' || errName === 'RetryError';
-      const friendlyMessage = isRetryError
+      const friendlyMessage = isNetworkError(err)
         ? 'AI 服务暂时不可用，请稍后重试'
         : (err.message || err.toString()).split('\n')[0];
 
@@ -225,20 +221,13 @@ class ChatQueueManager extends EventEmitter {
   /**
    * 判断错误是否可重试
    */
+  /**
+   * 判断错误是否可重试（委托给统一入口）
+   * @param {Error} error
+   * @returns {boolean}
+   */
   isRetryableError(error) {
-    const message = error.message || String(error);
-    return (
-      message.includes('负载较高') ||
-      message.includes('timeout') ||
-      message.includes('network') ||
-      message.includes('429') ||
-      message.includes('500') ||
-      message.includes('502') ||
-      message.includes('503') ||
-      message.includes('rate limit') ||
-      error.name === 'AI_RetryError' ||
-      error.name === 'AI_APICallError'
-    );
+    return isNetworkError(error);
   }
 
   /**

package/src/utils/data-splitter.js

@@ -0,0 +1,345 @@
+/**
+ * DataSplitter — 大数据分拆引擎
+ *
+ * 职责：
+ * 1. 将大文本内容按 token 估算分块
+ * 2. 为每个分块创建子 Agent 并行处理
+ * 3. 汇总各子 Agent 的结果
+ *
+ * 使用场景：
+ * - 读取超过 200KB 的大文件
+ * - 抓取内容过多的网页
+ * - 任何超过上下文限制的工具结果
+ */
+
+const { logger } = require('./logger');
+
+// 默认分块大小 (字符数，约 50K tokens)
+const DEFAULT_CHUNK_SIZE = 60000;
+
+// 默认 token 字节换算（中英混合粗略估算：1 token ≈ 2 chars）
+const CHARS_PER_TOKEN = 2;
+
+// 安全阈值：超过此字符数触发自动分拆（默认 100K tokens = 200K chars）
+const DEFAULT_SAFE_THRESHOLD = 50000;
+
+class DataSplitter {
+  /**
+   * @param {Object} framework - Framework 实例
+   * @param {Object} [options]
+   * @param {number} [options.chunkSize=60000] - 每块字符数
+   * @param {number} [options.safeThreshold=50000] - 安全阈值字符数
+   * @param {number} [options.maxConcurrent=3] - 最大并行子Agent数
+   * @param {number} [options.maxRetries=2] - 子Agent最大重试次数
+   */
+  constructor(framework, options = {}) {
+    this.framework = framework;
+    this.chunkSize = options.chunkSize || DEFAULT_CHUNK_SIZE;
+    this.safeThreshold = options.safeThreshold || DEFAULT_SAFE_THRESHOLD;
+    this.maxConcurrent = options.maxConcurrent || 3;
+    this.maxRetries = options.maxRetries || 2;
+  }
+
+  /**
+   * 判断内容是否需要分拆
+   * @param {string} content - 大文本内容
+   * @returns {boolean}
+   */
+  needsSplit(content) {
+    if (!content || typeof content !== 'string') return false;
+    return content.length > this.safeThreshold;
+  }
+
+  /**
+   * 获取内容统计信息
+   * @param {string} content
+   * @returns {{ chars: number, estimatedTokens: number, chunks: number }}
+   */
+  getContentStats(content) {
+    const chars = content.length;
+    return {
+      chars,
+      estimatedTokens: Math.ceil(chars / CHARS_PER_TOKEN),
+      chunks: Math.ceil(chars / this.chunkSize),
+    };
+  }
+
+  /**
+   * 将大文本按分块大小拆分成多个片段
+   * 尝试在段落边界（\n\n）切分，保持语义完整性
+   * @param {string} content - 大文本内容
+   * @param {number} [chunkSize] - 每块最大字符数，默认使用实例配置
+   * @returns {Array<{ index: number, content: string, startOffset: number, endOffset: number }>}
+   */
+  splitContent(content, chunkSize) {
+    chunkSize = chunkSize || this.chunkSize;
+    if (!content) return [];
+
+    const chunks = [];
+    let start = 0;
+
+    while (start < content.length) {
+      // 计算当前块的理论结束位置
+      let end = Math.min(start + chunkSize, content.length);
+
+      // 如果不是最后一块，尝试在段落边界切分
+      if (end < content.length) {
+        // 从 end 向前查找段落边界（双重换行）
+        const searchStart = Math.max(start, end - Math.floor(chunkSize * 0.3));
+        const segmentToSearch = content.slice(searchStart, end);
+
+        // 优先找 \n\n（段落边界）
+        let boundary = segmentToSearch.lastIndexOf('\n\n');
+        if (boundary > 0) {
+          end = searchStart + boundary + 1; // 把 \n\n 留给下一块开头会空行，更好
+          // 实际上保留 \n\n 在末尾更好
+          end = searchStart + boundary + 2;
+        } else {
+          // 其次找 \n（行边界）
+          boundary = segmentToSearch.lastIndexOf('\n');
+          if (boundary > 0) {
+            end = searchStart + boundary + 1;
+          } else {
+            // 最后找空格
+            boundary = segmentToSearch.lastIndexOf(' ');
+            if (boundary > 0) {
+              end = searchStart + boundary + 1;
+            }
+            // 找不到合适边界就在 chunkSize 处硬切
+          }
+        }
+      }
+
+      const chunkContent = content.slice(start, end);
+      if (chunkContent.trim()) {
+        chunks.push({
+          index: chunks.length,
+          content: chunkContent,
+          startOffset: start,
+          endOffset: end,
+        });
+      }
+
+      start = end;
+    }
+
+    return chunks;
+  }
+
+  /**
+   * 为每个分块创建子 Agent 并分配处理任务
+   * 子 Agent 并行处理，结果自动汇总
+   *
+   * @param {Object} options
+   * @param {Array<{ index: number, content: string }>} options.chunks - 分块数据
+   * @param {string} options.taskDescription - 每个子 Agent 要执行的任务描述
+   * @param {string} [options.agentName] - 子 Agent 名称前缀
+   * @param {string} [options.agentRole] - 子 Agent 角色
+   * @param {number} [options.maxConcurrent] - 并行度
+   * @param {AbortSignal} [options.signal] - 取消信号
+   * @returns {Promise<{ success: boolean, results: Array, summary: string, errors: Array }>}
+   */
+  async dispatchToSubAgents(options) {
+    const {
+      chunks,
+      taskDescription,
+      agentName = 'data-processor',
+      agentRole = '数据处理专家',
+      maxConcurrent = this.maxConcurrent,
+      signal,
+    } = options;
+
+    if (!chunks || chunks.length === 0) {
+      return { success: true, results: [], summary: '', errors: [] };
+    }
+
+    const totalChunks = chunks.length;
+    const results = [];
+    const errors = [];
+
+    logger.info(
+      `[DataSplitter] 开始分拆处理: ${totalChunks} 块, 任务="${taskDescription.slice(0, 50)}..."`
+    );
+
+    // 并行执行（受 maxConcurrent 限制）
+    const queue = [...chunks];
+    const inFlight = new Set();
+
+    const processChunk = async (chunk) => {
+      const chunkIndex = chunk.index;
+
+      // 为当前块创建子 Agent
+      const subagent = this.framework.createSubAgent({
+        name: `${agentName}-chunk-${chunkIndex}`,
+        role: agentRole,
+        systemPrompt: `你是${agentRole}，负责处理大数据中的第 ${chunkIndex + 1}/${totalChunks} 块。`,
+        maxRetries: this.maxRetries,
+        disableTools: true, // 分拆处理只做文本分析，不需要额外工具
+      });
+
+      try {
+        const taskMsg = `## 任务
+${taskDescription}
+
+## 待处理内容（第 ${chunkIndex + 1}/${totalChunks} 块）
+\`\`\`
+${chunk.content}
+\`\`\`
+
+## 要求
+- 只处理这块内容
+- 返回简洁的结果
+- 如果这块内容没有有用信息，返回"无有效信息"`;
+
+        const result = await subagent.chat(taskMsg, { signal });
+        results.push({
+          chunkIndex,
+          success: result.success,
+          message: result.message || '',
+        });
+
+        logger.debug(
+          `[DataSplitter] 块 ${chunkIndex + 1}/${totalChunks} 处理完成: ` +
+            `${result.success ? '成功' : '失败'}`
+        );
+      } catch (err) {
+        errors.push({ chunkIndex, error: err.message });
+        results.push({ chunkIndex, success: false, error: err.message });
+        logger.warn(
+          `[DataSplitter] 块 ${chunkIndex + 1}/${totalChunks} 处理失败: ${err.message}`
+        );
+      } finally {
+        subagent.destroy();
+        inFlight.delete(chunk);
+      }
+    };
+
+    // 并发控制：最多 maxConcurrent 个同时运行
+    while (queue.length > 0 || inFlight.size > 0) {
+      // 填充 inFlight 到 maxConcurrent
+      while (queue.length > 0 && inFlight.size < maxConcurrent) {
+        const chunk = queue.shift();
+        inFlight.add(chunk);
+        processChunk(chunk); // 不 await，并发执行
+      }
+
+      // 等待任意一个完成
+      if (inFlight.size > 0) {
+        await Promise.race(
+          [...inFlight].map(
+            (chunk) =>
+              new Promise((resolve) => {
+                const check = () => {
+                  if (!inFlight.has(chunk)) resolve();
+                  else setTimeout(check, 50);
+                };
+                check();
+              })
+          )
+        );
+      }
+    }
+
+    // 按块索引排序结果
+    results.sort((a, b) => a.chunkIndex - b.chunkIndex);
+
+    // 生成汇总摘要
+    const summary = this._buildSummary(results, errors, taskDescription);
+
+    logger.info(
+      `[DataSplitter] 分拆处理完成: ` +
+        `${results.filter((r) => r.success).length}/${totalChunks} 块成功, ` +
+        `${errors.length} 个错误`
+    );
+
+    return {
+      success: errors.length === 0,
+      results,
+      summary,
+      errors,
+    };
+  }
+
+  /**
+   * 一步完成：检测 → 分拆 → 派发 → 汇总
+   * 如果内容不超过阈值，直接返回原文
+   *
+   * @param {string} content - 原始内容
+   * @param {string} taskDescription - 要执行的任务
+   * @param {Object} [options]
+   * @returns {Promise<string>} 汇总结果
+   */
+  async processLargeContent(content, taskDescription, options = {}) {
+    if (!this.needsSplit(content)) {
+      return content; // 不需要分拆
+    }
+
+    const stats = this.getContentStats(content);
+    const chunkSize = options.chunkSize || this.chunkSize;
+
+    logger.info(
+      `[DataSplitter] 自动分拆: ${stats.chars} 字符, ` +
+        `约 ${stats.estimatedTokens} tokens, ` +
+        `分 ${stats.chunks} 块处理`
+    );
+
+    const chunks = this.splitContent(content, chunkSize);
+    const result = await this.dispatchToSubAgents({
+      chunks,
+      taskDescription,
+      maxConcurrent: options.maxConcurrent || this.maxConcurrent,
+      signal: options.signal,
+    });
+
+    return result.summary;
+  }
+
+  /**
+   * 构建汇总
+   * @private
+   */
+  _buildSummary(results, errors, taskDescription) {
+    const successfulResults = results.filter((r) => r.success && r.message && r.message !== '无有效信息');
+    const lineCounts = results.map((r) => r.message ? r.message.split('\n').length : 0);
+
+    const totalLines = lineCounts.reduce((a, b) => a + b, 0);
+
+    const lines = [
+      `## 大数据处理汇总`,
+      ``,
+      `**任务**: ${taskDescription}`,
+      `**总块数**: ${results.length}`,
+      `**成功**: ${successfulResults.length} 块`,
+      `**失败**: ${errors.length} 块`,
+      ``,
+      `### 各块处理结果`,
+      ``,
+    ];
+
+    for (const r of results) {
+      const status = r.success ? '✅' : '❌';
+      const msg = r.message || r.error || '无结果';
+      // 每块只取关键信息，避免重复
+      const trimmed = msg.split('\n').slice(0, 3).join('\n');
+      lines.push(`**块 ${r.chunkIndex + 1}** ${status}`);
+      lines.push(`> ${trimmed}`);
+      lines.push('');
+    }
+
+    if (errors.length > 0) {
+      lines.push(`### 错误信息`);
+      lines.push('');
+      for (const e of errors) {
+        lines.push(`- 块 ${e.chunkIndex + 1}: ${e.error}`);
+      }
+      lines.push('');
+    }
+
+    lines.push(`---`);
+    lines.push(`*共 ${results.length} 块, ${successfulResults.length} 块成功, 汇总 ${totalLines} 行*`);
+
+    return lines.join('\n');
+  }
+}
+
+module.exports = { DataSplitter };

package/src/utils/download.js

@@ -6,6 +6,7 @@ const path = require('path');
 const crypto = require('crypto');
 const { fileTypeFromFile, fileTypeFromBuffer } = require('file-type');
 const { downloadAndDecryptMedia } = require('@chnak/weixin-bot');
+const { logger } = require('./logger');
 class FileDownloader {
   constructor(options = {}) {
     this.timeout = options.timeout || 30000;
@@ -318,7 +319,7 @@ class FileDownloader {
         });
       } catch (error) {
         lastError = error;
-        console.log(`下载失败，第 ${i + 1}/${retries} 次重试...`);
+        logger.warn(`[Download] 失败，第 ${i + 1}/${retries} 次重试...`);
         await this._sleep(1000 * (i + 1));
       }
     }
@@ -432,8 +433,8 @@ class FileDownloader {
 
           // 获取 Content-Type
           const contentType = response.headers['content-type'] || '';
-          console.log(`[Download] URL: ${url}`);
-          console.log(`[Download] Content-Type: ${contentType}`);
+          logger.debug(`[Download] URL: ${url}`);
+          logger.debug(`[Download] Content-Type: ${contentType}`);
 
           // 提取文件信息
           const { filename: autoFilename, extension } = this._extractFileInfo(
@@ -484,7 +485,7 @@ class FileDownloader {
           });
 
           req.on('error', (err) => {
-            console.log('下载请求错误:', err.message);
+            logger.error(`[Download] 请求错误: ${err.message}`);
             reject(err);
           });