foliko 2.0.11 → 2.0.13

package/src/agent/chat.js

@@ -15,9 +15,11 @@ const {
   tool: aiTool,
   ToolLoopAgent,
   isLoopFinished,
+  InvalidToolInputError,
 } = require('ai');
 const { z } = require('zod');
 const { autoSplitToolResult } = require('../../plugins/executors/data-splitter');
+const { normalizeToolOutputs, validateAll } = require('../utils/message-validator');
 const { cleanResponse } = require('../utils');
 const { ChatQueueManager } = require('../common/queue');
 const { TokenCounter } = require('../llm/tokens');
@@ -232,12 +234,70 @@ class AgentChatHandler extends EventEmitter {
 
   /**
    * 验证工具调用
-   * @private
+   * @deprecated Use validateAll() instead
    */
   _validateToolCalls(messages) {
     return this._toolExecutor.validateToolCalls(messages);
   }
 
+  /**
+   * 规范化 tool-result output 字段。
+   * 委托给 message-validator 版本（避免重复逻辑）。
+   * @private
+   */
+  _normalizeToolOutputs(messages) {
+    return normalizeToolOutputs(messages);
+  }
+
+  /**
+   * 最终兜底：暴力清理所有 orphaned tool 消息。
+   * @deprecated 由 validateAll 替代
+   */
+  _stripOrphanedToolMessages(messages) {
+    const validIds = new Set();
+    for (const msg of messages) {
+      if (msg.role !== 'assistant') continue;
+      if (Array.isArray(msg.content)) {
+        for (const item of msg.content) {
+          if ((item.type === 'tool-call' || item.type === 'tool-use') && item.toolCallId) validIds.add(item.toolCallId);
+        }
+      }
+      if (Array.isArray(msg.tool_calls)) {
+        for (const tc of msg.tool_calls) { if (tc.id) validIds.add(tc.id); }
+      }
+    }
+
+    let removed = 0;
+    for (let i = messages.length - 1; i >= 0; i--) {
+      const msg = messages[i];
+      if (msg.role !== 'tool') continue;
+
+      let isOrphaned = false;
+      if (Array.isArray(msg.content)) {
+        msg.content = msg.content.filter(item => {
+          if (item && (item.type === 'tool-result' || item.type === 'tool_result') && item.toolCallId && !validIds.has(item.toolCallId)) {
+            return false;
+          }
+          return true;
+        });
+        if (msg.content.length === 0) isOrphaned = true;
+      } else if (msg.tool_call_id && !validIds.has(msg.tool_call_id)) {
+        isOrphaned = true;
+      } else if (!msg.tool_call_id && validIds.size === 0) {
+        isOrphaned = true;
+      }
+
+      if (isOrphaned) {
+        messages.splice(i, 1);
+        removed++;
+      }
+    }
+
+    if (removed > 0) {
+      logger.debug(`[_stripOrphanedToolMessages] removed ${removed} orphaned tool message(s)`);
+    }
+  }
+
   // ==================== AI 调用 ====================
 
   setAIClient(client) {
@@ -268,6 +328,152 @@ class AgentChatHandler extends EventEmitter {
    * 创建 ToolLoopAgent
    * @private
    */
+  /**
+   * 为历史消息中的 tool-call ID 加上前缀，避免与新生成的 ID 冲突。
+   * 历史消息的 tool-call ID 可能与当前请求新生成的 ID 重复，
+   * 导致 AI API 返回 "tool result's tool id not found" 错误。
+   */
+  /**
+   * 单次遍历完成：
+   * 1. 修复历史错误转换的 text tool-call（"参数不完整，已跳过"）
+   * 2. 给所有历史 tool-call ID 加上前缀（避免与新 ID 冲突）
+   * 3. 重映射对应的 tool-result ID
+   * @param {Array} messages - 消息数组（会被修改）
+   * @param {Map} [idMap] - 可选，外部传入的 ID 映射（用于跨调用共享）
+   */
+  _repairAndPrefixHistoricalIds(messages, idMap = new Map()) {
+    const HISTORICAL_PREFIX = 'h_';
+
+    for (const msg of messages) {
+      if (msg.role === 'assistant') {
+        if (Array.isArray(msg.content)) {
+          for (let i = 0; i < msg.content.length; i++) {
+            const item = msg.content[i];
+            if (!item) continue;
+
+            // 1. 修复被错误转成 text 的 tool-call
+            if (item.type === 'text') {
+              const text = item.text;
+              if (typeof text === 'string') {
+                const match = text.match(/^（工具调用 (.+?) 参数不完整，已跳过）$/);
+                if (match) {
+                  const newId = `${HISTORICAL_PREFIX}restored_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+                  idMap.set(`restored_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`, newId);
+                  msg.content[i] = {
+                    type: 'tool-call',
+                    toolName: match[1],
+                    toolCallId: newId,
+                    input: '{}',
+                  };
+                  continue;
+                }
+              }
+            }
+
+            // 2. 重映射有历史 ID 的 tool-call
+            if ((item.type === 'tool-call' || item.type === 'tool-use') && item.toolCallId) {
+              if (!item.toolCallId.startsWith(HISTORICAL_PREFIX)) {
+                const newId = HISTORICAL_PREFIX + item.toolCallId;
+                idMap.set(item.toolCallId, newId);
+                item.toolCallId = newId;
+              }
+            }
+          }
+        }
+        // tool_calls 数组格式
+        if (Array.isArray(msg.tool_calls)) {
+          for (const tc of msg.tool_calls) {
+            if (tc.id && !tc.id.startsWith(HISTORICAL_PREFIX)) {
+              const newId = HISTORICAL_PREFIX + tc.id;
+              idMap.set(tc.id, newId);
+              tc.id = newId;
+            }
+          }
+        }
+      } else if (msg.role === 'tool') {
+        // 3. 重映射 tool-result 的 ID
+        if (Array.isArray(msg.content)) {
+          for (const item of msg.content) {
+            if ((item.type === 'tool-result' || item.type === 'tool_result') && item.toolCallId && !item.toolCallId.startsWith(HISTORICAL_PREFIX)) {
+              const newId = idMap.get(item.toolCallId);
+              if (newId) item.toolCallId = newId;
+            }
+          }
+        }
+        if (msg.tool_call_id && !msg.tool_call_id.startsWith(HISTORICAL_PREFIX)) {
+          const newId = idMap.get(msg.tool_call_id);
+          if (newId) msg.tool_call_id = newId;
+        }
+      }
+    }
+
+    return idMap;
+  }
+
+  /**
+   * 修复消息数组中 AI SDK 标记为 invalid 的 tool-call
+   * @param {Array} messages - 消息数组（会被修改）
+   * @returns {number} 修复数量
+   */
+  _repairInvalidToolCallsInMessages(messages) {
+    let count = 0;
+    for (const msg of messages) {
+      if (msg.role !== 'assistant' || !Array.isArray(msg.content)) continue;
+      for (const item of msg.content) {
+        if ((item.type === 'tool-call' || item.type === 'tool-use') && item.invalid) {
+          const input = item.input;
+          if (typeof input !== 'string') continue;
+          const trimmed = input.trim();
+          // 空输入 → {}
+          if (trimmed === '') {
+            item.input = '{}';
+            delete item.invalid;
+            count++;
+            continue;
+          }
+          // 尝试补全花括号
+          let fixed = null;
+          if (!trimmed.startsWith('{')) {
+            fixed = '{' + trimmed + '}';
+          } else if (!trimmed.endsWith('}')) {
+            fixed = trimmed + '}';
+          }
+          if (fixed) {
+            try { JSON.parse(fixed); item.input = fixed; delete item.invalid; count++; } catch {}
+          }
+        }
+      }
+    }
+    return count;
+  }
+
+  /**
+   * AI SDK repairToolCall: 修复无效的 tool-call 输入
+   * 当模型返回的 JSON 参数无法解析时，尝试修复
+   */
+  _repairToolCall({ toolCall, tools, error }) {
+    // 只处理 InvalidToolInputError（JSON 解析失败）
+    if (!InvalidToolInputError.isInstance(error)) return null;
+    const input = toolCall.input;
+    if (typeof input !== 'string') return null;
+    const trimmed = input.trim();
+    // 空输入 → 修复为 {}
+    if (trimmed === '') {
+      return { ...toolCall, input: '{}' };
+    }
+    // 尝试补全花括号
+    let fixed = null;
+    if (!trimmed.startsWith('{')) {
+      fixed = '{' + trimmed + '}';
+    } else if (!trimmed.endsWith('}')) {
+      fixed = trimmed + '}';
+    }
+    if (fixed) {
+      try { JSON.parse(fixed); return { ...toolCall, input: fixed }; } catch {}
+    }
+    return null;
+  }
+
   _createToolLoopAgent(model, tools) {
     return new ToolLoopAgent({
       model,
@@ -275,6 +481,7 @@ class AgentChatHandler extends EventEmitter {
       tools,
       stopWhen: isLoopFinished(),
       prepareStep: this._createPrepareStep(),
+      experimental_repairToolCall: this._repairToolCall.bind(this),
     });
   }
 
@@ -474,7 +681,6 @@ class AgentChatHandler extends EventEmitter {
       if (!this._aiClient) {
         throw new Error('AI 客户端未配置');
       }
-      this._validateToolCalls(messages);
       const systemPrompt = framework.prompts.build();
       //await fs.promises.writeFile(`.${sessionId}_systemPrompt.md`, systemPrompt); // 调试用：保存系统提示词
       const tools = this._getAITools(aiTool);
@@ -484,6 +690,7 @@ class AgentChatHandler extends EventEmitter {
         tools,
         stopWhen: isLoopFinished(),
         prepareStep: this._createPrepareStep(),
+        experimental_repairToolCall: this._repairToolCall.bind(this),
       });
 
       // AI SDK 错误回调：仅记录日志，不在这里处理（统一由 catch/yield 处理）
@@ -557,7 +764,8 @@ class AgentChatHandler extends EventEmitter {
       }
       // 写入端 sanitize：AI SDK v6 响应里允许 error-text/error-json（工具失败标记），
       // 但 ModelMessage 输入 schema 不接受；持久化前必须规范化
-      this._normalizeToolOutputs(finishMessages);
+      normalizeToolOutputs(finishMessages);
+
       messages.push(...finishMessages);
 
       // 获取或估算 token 用量
@@ -668,7 +876,6 @@ class AgentChatHandler extends EventEmitter {
       if (!this._aiClient) {
         throw new Error('AI 客户端未配置');
       }
-      this._validateToolCalls(messages);
       const systemPrompt = framework.prompts.build();
       const tools = this._getAITools(aiTool);
 
@@ -684,6 +891,7 @@ class AgentChatHandler extends EventEmitter {
         tools,
         stopWhen: isLoopFinished(),
         prepareStep: this._createPrepareStep(),
+        experimental_repairToolCall: this._repairToolCall.bind(this),
       });
 
       const result = await framework.runInSession(sessionId, {}, async () => {
@@ -787,65 +995,29 @@ class AgentChatHandler extends EventEmitter {
       logger.debug(`[_prepareSession] AFTER compress: messages=${messages.length}`);
     }
 
-    // 验证工具调用
-    const validated = this._validateMessagesPairing(messages);
+    // 单次遍历完成：修复 invalid tool-call + 修复错误 text + 重映射历史 ID
+    this._repairInvalidToolCallsInMessages(messages);
+    this._repairAndPrefixHistoricalIds(messages);
+
+    // 单次遍历完成所有验证 + 规范化（validateAll 内部处理 error-text/error-json）
+    const validated = validateAll(messages);
     if (validated.length !== messages.length) {
-      // 删除了消息，缓存失效
       this._invalidateMessageTokensCache(messageStore);
       messages.length = 0;
       messages.push(...validated);
     }
     messages.push(userMessage);
-    this._validateToolCalls(messages);
-
-    // 读取端 sanitize：修复历史 chat log 中可能存在的 error-text/error-json
-    this._normalizeToolOutputs(messages);
-
-    // 最终兜底：暴力清理所有 orphaned tool 消息，确保 AI SDK 不报错
-    this._stripOrphanedToolMessages(messages);
 
     return { messageStore, messages };
   }
 
   /**
    * 规范化 tool-result 的 output 字段。
-   * AI SDK v6 响应中允许 'error-text' / 'error-json'（表示工具执行失败），
-   * 但 ModelMessage 输入 schema（AI SDK 发送 prompt 时使用）不接受这两类。
-   * 必须在写入磁盘和读取发送前都做转换。
+   * 委托给 message-validator 版本（避免重复逻辑）。
    * @private
    */
   _normalizeToolOutputs(messages) {
-    const VALID_OUTPUT_TYPES = new Set(['text', 'json', 'execution-denied', 'content']);
-    let fixed = 0;
-    for (const msg of messages) {
-      if (msg.role !== 'tool' || !Array.isArray(msg.content)) continue;
-      for (const part of msg.content) {
-        if (!part || part.type !== 'tool-result') continue;
-        const out = part.output;
-        if (out === undefined || out === null || typeof out !== 'object') {
-          const v = out === undefined ? 'undefined' : (typeof out === 'string' ? out : JSON.stringify(out));
-          part.output = { type: 'text', value: String(v) };
-          fixed++;
-          continue;
-        }
-        if (VALID_OUTPUT_TYPES.has(out.type)) continue;
-        if (out.type === 'error-text' || out.type === 'error_text') {
-          part.output = { type: 'text', value: typeof out.value === 'string' ? out.value : String(out.value ?? '') };
-          fixed++;
-          continue;
-        }
-        if (out.type === 'error-json' || out.type === 'error_json') {
-          part.output = { type: 'json', value: out.value ?? null };
-          fixed++;
-          continue;
-        }
-        // 未知 type 降级为 text
-        try { part.output = { type: 'text', value: JSON.stringify(out) }; }
-        catch { part.output = { type: 'text', value: String(out) }; }
-        fixed++;
-      }
-    }
-    return fixed;
+    return normalizeToolOutputs(messages);
   }
 
   /**
@@ -1090,19 +1262,20 @@ class AgentChatHandler extends EventEmitter {
           inputMessages.push(...trimmed);
         }
 
-        // 验证 tool-call 和 tool-result 配对
-        const validated = this._validateMessagesPairing(inputMessages);
+        // 单次遍历完成：修复 invalid tool-call + 修复错误 text + 重映射历史 ID
+        const repairedCount = this._repairInvalidToolCallsInMessages(inputMessages);
+        this._repairAndPrefixHistoricalIds(inputMessages);
+
+        // 单次遍历完成所有验证 + 规范化
+        const validated = validateAll(inputMessages);
         if (validated.length !== inputMessages.length) {
           logger.debug(
-            `[PrepareStep] After pairing validation: ${inputMessages.length} -> ${validated.length}`
+            `[PrepareStep] After validation: ${inputMessages.length} -> ${validated.length}`
           );
           inputMessages.length = 0;
           inputMessages.push(...validated);
         }
 
-        // 验证 tool-call 格式
-        this._validateToolCalls(inputMessages);
-
         return { messages: inputMessages };
       } catch (err) {
         logger.error('prepareStep error:', err.message, err.stack);

package/src/utils/message-validator.js

@@ -114,17 +114,21 @@ function validateToolCalls(messages, options = {}) {
       if (typeof input !== 'string') continue;
 
       const trimmed = input.trim();
-      if (trimmed === '{' || trimmed === '' || !trimmed.startsWith('{')) {
-        if (item.toolCallId) {
-          invalidatedToolCallIds.add(item.toolCallId);
-        }
+      // 只有真正无法解析为 JSON 的才标记为 invalid
+      let invalid = false;
+      if (trimmed.startsWith('{') && trimmed.endsWith('}')) {
+        try { JSON.parse(trimmed); } catch { invalid = true; }
+      } else if (trimmed !== '') {
+        invalid = true;
+      }
+
+      if (invalid) {
+        if (item.toolCallId) invalidatedToolCallIds.add(item.toolCallId);
         if (shouldLog) {
           logger.warn(
-            `[validateToolCalls] invalid input for "${item.toolName}", toolCallId=${item.toolCallId ||
-              '?'}, converting to text`
+            `[validateToolCalls] invalid input for "${item.toolName}", toolCallId=${item.toolCallId || '?'}, converting to text`
           );
         }
-        // 把无效的 tool-call 转换成 text 文本
         item.type = 'text';
         item.text = `（工具调用 ${item.toolName} 参数不完整，已跳过）`;
         delete item.toolCallId;
@@ -155,24 +159,143 @@ function validateToolCalls(messages, options = {}) {
     }
   }
 
-  if (shouldLog && fixedCount > 0) {
-    // logger.info(`[validateToolCalls] Fixed ${fixedCount} incomplete tool calls/results`);
-  }
+  if (shouldLog && fixedCount > 0) {}
 
   return fixedCount;
 }
 
 /**
- * 一次遍历完成配对验证 + tool-call 格式验证
- * 相比分别调用减少消息数组迭代次数
+ * 单次遍历完成所有验证和规范化：
+ * 1. 修复 tool-call 格式（不完整 JSON → text）
+ * 2. 收集有效 toolCallId（content[] 和 tool_calls[]）
+ * 3. 规范化 error-text/error-json → text/json
+ * 4. 移除 orphaned tool-result（没有对应 tool-call 的）
+ * 5. 移除整个 orphaned tool 消息（content 被清空的）
+ *
+ * 比分别调用减少 3-4 次消息数组遍历
  * @param {Array} messages - 消息数组（会被修改）
  * @returns {Array} 过滤后的消息数组
  */
 function validateAll(messages) {
-  // 1. 先修复 tool-call 格式（避免无效 ID 干扰后续配对验证）
-  validateToolCalls(messages);
-  // 2. 再移除 orphaned tool-result
-  return validateMessagesPairing(messages);
+  const VALID_OUTPUT_TYPES = new Set(['text', 'json', 'execution-denied', 'content']);
+  const validToolCallIds = new Set();
+  const invalidatedIds = new Set();
+
+  // 第一遍：收集有效 ID + 修复格式 + 规范化 error 类型
+  for (const msg of messages) {
+    if (msg.role === 'assistant') {
+      const content = msg.content;
+      if (Array.isArray(content)) {
+        for (const item of content) {
+          if (item && (item.type === 'tool-call' || item.type === 'tool-use')) {
+            const input = item.input;
+            // 检查 input 是否为不完整的 JSON：空字符串、或只有 { 或 }
+            // 有效 input 应能被 JSON.parse（即使是 {}）
+            let invalid = false;
+            if (typeof input === 'string') {
+              const trimmed = input.trim();
+              // 有效 input：能解析为 JSON 的字符串（包括 '{}'）
+              if (trimmed.startsWith('{') && trimmed.endsWith('}')) {
+                try { JSON.parse(trimmed); } catch { invalid = true; }
+              } else if (trimmed !== '') {
+                // 非空且不是 {} 开头：无效
+                invalid = true;
+              }
+              // 空字符串 '' 单独放过（无参数工具是合法的）
+            } else if (input === undefined || input === null) {
+              // input 为 null/undefined 时：只有当工具 schema 要求必填时才应该报错
+              // 但我们无法在此判断工具是否必填，统一放行让后续验证处理
+              // invalid = true;
+            }
+            if (invalid) {
+              logger.debug(`[validateAll] INVALID detected: toolName=${item.toolName}, input=${JSON.stringify(input)}, typeof=${typeof input}`);
+              // 无效输入 → 转 text，标记为 invalid
+              item.type = 'text';
+              item.text = `（工具调用 ${item.toolName} 参数不完整，已跳过）`;
+              if (item.toolCallId) invalidatedIds.add(item.toolCallId);
+              delete item.toolCallId;
+              delete item.toolName;
+              delete item.input;
+            } else if (item.toolCallId) {
+              validToolCallIds.add(item.toolCallId);
+            }
+          } else if (item && item.type === 'tool-result') {
+            // 规范化 tool-result output
+            const out = item.output;
+            if (out === undefined || out === null || typeof out !== 'object') {
+              item.output = { type: 'text', value: String(out ?? 'undefined') };
+            } else if (!VALID_OUTPUT_TYPES.has(out.type)) {
+              if (out.type === 'error-text' || out.type === 'error_text') {
+                item.output = { type: 'text', value: typeof out.value === 'string' ? out.value : String(out.value ?? '') };
+              } else if (out.type === 'error-json' || out.type === 'error_json') {
+                item.output = { type: 'json', value: out.value ?? null };
+              } else {
+                try { item.output = { type: 'text', value: JSON.stringify(out) }; }
+                catch { item.output = { type: 'text', value: String(out) }; }
+              }
+            }
+          }
+        }
+      }
+      // tool_calls[] 格式（OpenAI 兼容）
+      if (Array.isArray(msg.tool_calls)) {
+        for (const tc of msg.tool_calls) {
+          if (tc.id && !invalidatedIds.has(tc.id)) validToolCallIds.add(tc.id);
+        }
+      }
+    } else if (msg.role === 'tool') {
+      // 规范化 tool 消息 output
+      if (Array.isArray(msg.content)) {
+        for (const item of msg.content) {
+          if (item && item.type === 'tool-result') {
+            const out = item.output;
+            if (out === undefined || out === null || typeof out !== 'object') {
+              item.output = { type: 'text', value: String(out ?? 'undefined') };
+            } else if (!VALID_OUTPUT_TYPES.has(out.type)) {
+              if (out.type === 'error-text' || out.type === 'error_text') {
+                item.output = { type: 'text', value: typeof out.value === 'string' ? out.value : String(out.value ?? '') };
+              } else if (out.type === 'error-json' || out.type === 'error_json') {
+                item.output = { type: 'json', value: out.value ?? null };
+              } else {
+                try { item.output = { type: 'text', value: JSON.stringify(out) }; }
+                catch { item.output = { type: 'text', value: String(out) }; }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+
+  // 第二遍：过滤 orphaned tool-result + orphaned tool messages
+  const toolMessageIndicesToRemove = new Set();
+  for (let i = 0; i < messages.length; i++) {
+    const msg = messages[i];
+    if (msg.role !== 'tool') continue;
+
+    let hasValidResult = false;
+    if (Array.isArray(msg.content)) {
+      const originalLen = msg.content.length;
+      msg.content = msg.content.filter((item) => {
+        if (!item || (item.type !== 'tool-result' && item.type !== 'tool_result')) return true;
+        const id = item.toolCallId;
+        if (!id || (!validToolCallIds.has(id) && !invalidatedIds.has(id))) return false;
+        hasValidResult = true;
+        return true;
+      });
+      if (msg.content.length === 0 && originalLen > 0) {
+        toolMessageIndicesToRemove.add(i);
+      }
+    } else if (msg.tool_call_id && !validToolCallIds.has(msg.tool_call_id)) {
+      toolMessageIndicesToRemove.add(i);
+    }
+  }
+
+  if (toolMessageIndicesToRemove.size > 0) {
+    messages = messages.filter((_, i) => !toolMessageIndicesToRemove.has(i));
+  }
+
+  return messages;
 }
 
 // AI SDK v6 ToolResultOutput 允许的类型（用于 ModelMessage[] 输入 schema）