foliko 1.1.2 → 1.1.4

package/src/core/agent-chat.js

@@ -31,7 +31,7 @@ const MODEL_CONTEXT_LIMITS = {
   'deepseek-chat': 28000,
   'deepseek-coder': 28000,
   // MiniMax
-  'MiniMax-M2.7': 130800,
+  'MiniMax-M2.7': 90000,
   // OpenAI
   'gpt-4': 100000,
   'gpt-4o': 100000,
@@ -45,11 +45,9 @@ const MODEL_CONTEXT_LIMITS = {
 
 /**
  * 纯 JavaScript token 计数器
- * 基于字符数估算，兼容中英文
- * 估算规则：
- * - 英文：约 4 字符 = 1 token
- * - 中文：约 2 字符 = 1 token
- * - 混合文本取加权平均
+ * 参考 Claude Code 的实现，使用 bytes/token 比率估算
+ * - 普通文本：4 bytes ≈ 1 token
+ * - JSON 等密集文本：2 bytes ≈ 1 token
  */
 class SimpleTokenizer {
   constructor() {
@@ -59,9 +57,10 @@ class SimpleTokenizer {
   /**
    * 估算文本的 token 数
    * @param {string} text
+   * @param {number} [bytesPerToken=4] - bytes per token 比率
    * @returns {number}
    */
-  encode(text) {
+  encode(text, bytesPerToken = 4) {
     if (!text || typeof text !== 'string') {
       return 0;
     }
@@ -76,16 +75,16 @@ class SimpleTokenizer {
       return 0;
     }
 
-    // 分离中英文分别计数
-    const chineseChars = (cleanText.match(/[\u4e00-\u9fff\u3400-\u4dbf]/g) || []).length;
-    const englishChars = cleanText.length - chineseChars;
-
-    // 中英文分开估算后相加
-    // 中文约 2 字符/token，英文约 4 字符/token
-    const chineseTokens = chineseChars / 2;
-    const englishTokens = englishChars / 4;
+    return Math.ceil(cleanText.length / bytesPerToken);
+  }
 
-    return Math.ceil(chineseTokens + englishTokens);
+  /**
+   * 估算 JSON 文本的 token 数（更密集）
+   * @param {string} text
+   * @returns {number}
+   */
+  encodeForJSON(text) {
+    return this.encode(text, 2);
   }
 }
 
@@ -93,7 +92,7 @@ class SimpleTokenizer {
 const _globalTokenizer = new SimpleTokenizer();
 
 // 压缩超时时间（毫秒）
-const COMPRESSION_TIMEOUT = 120000; // 2分钟
+const COMPRESSION_TIMEOUT = 30000;
 
 class AgentChatHandler extends EventEmitter {
   /**
@@ -166,7 +165,13 @@ class AgentChatHandler extends EventEmitter {
   _getSessionMessageStore(sessionId) {
     if (!sessionId) {
       // 无 session 的单次请求，使用临时存储
-      return { messages: [], historyLoaded: false, compressionState: {}, save: () => {} };
+      return {
+        messages: [],
+        historyLoaded: false,
+        compressionState: {},
+        lastUsage: null, // API 返回的真实 usage
+        save: () => {},
+      };
     }
 
     if (!this._sessionMessageStores.has(sessionId)) {
@@ -181,6 +186,7 @@ class AgentChatHandler extends EventEmitter {
           lastTokenCount: 0,
           count: 0,
         },
+        lastUsage: null, // API 返回的真实 usage
         save: () => {
           // 简洁的保存方法
           if (this.agent?.framework) {
@@ -305,22 +311,24 @@ class AgentChatHandler extends EventEmitter {
   /**
    * 计算文本的 token 数
    * @param {string} text
+   * @param {number} [bytesPerToken=4] - bytes per token 比率
    * @returns {number}
    * @private
    */
-  _countTokens(text) {
+  _countTokens(text, bytesPerToken = 4) {
     if (!text || typeof text !== 'string') return 0;
     // SimpleTokenizer.encode 已经处理了清理逻辑
     try {
-      return this._encoder.encode(text);
+      return this._encoder.encode(text, bytesPerToken);
     } catch (err) {
       // 估算失败时使用字符计数
-      return Math.ceil(text.length / 4);
+      return Math.ceil(text.length / bytesPerToken);
     }
   }
 
   /**
    * 计算消息列表的总 token 数
+   * 参考 Claude Code 的分块计数逻辑
    * @param {Array} messages
    * @returns {number}
    * @private
@@ -329,68 +337,184 @@ class AgentChatHandler extends EventEmitter {
     let total = 0;
     for (const msg of messages) {
       if (!msg) continue;
-      total += 4; // role 标记
-      if (typeof msg.content === 'string') {
-        total += this._countTokens(msg.content);
-      } else if (Array.isArray(msg.content)) {
-        for (const part of msg.content) {
-          if (!part || typeof part !== 'object') continue;
+      total += this._countMessageTokens(msg);
+    }
+    return total;
+  }
 
-          // 处理普通文本
-          if (part.text) {
-            total += this._countTokens(String(part.text));
-          }
+  /**
+   * 计算单条消息的 token 数
+   * @param {Object} msg - 消息对象
+   * @returns {number}
+   * @private
+   */
+  _countMessageTokens(msg) {
+    let total = 0;
+    total += 4; // role 标记
 
-          // 处理 tool-result 的 output 字段
-          if (part.type === 'tool-result' && part.output) {
-            if (typeof part.output === 'string') {
-              total += this._countTokens(part.output);
-            } else if (part.output && typeof part.output === 'object') {
-              // 处理 { type: 'text', value: '...' } 或 { type: 'text', html: '...' } 等
-              if (part.output.value) {
-                total += this._countTokens(String(part.output.value));
-              }
-              if (part.output.html) {
-                total += this._countTokens(part.output.html);
-              }
-              // 其他字段也序列化计算
-              try {
-                const others = {};
-                for (const [k, v] of Object.entries(part.output)) {
-                  if (k !== 'value' && k !== 'html') others[k] = v;
-                }
-                if (Object.keys(others).length > 0) {
-                  total += this._countTokens(JSON.stringify(others));
-                }
-              } catch (e) {
-                // 忽略
-              }
-            }
-          }
+    if (typeof msg.content === 'string') {
+      total += this._countTokens(msg.content);
+    } else if (Array.isArray(msg.content)) {
+      for (const part of msg.content) {
+        total += this._countContentBlockTokens(part);
+      }
+    } else if (msg.content && typeof msg.content === 'object') {
+      // 处理工具结果等对象类型
+      try {
+        const str = JSON.stringify(msg.content);
+        total += this._countTokens(str, 2); // JSON 用更密集的比率
+      } catch (e) {
+        // 无法序列化的内容，忽略
+      }
+    }
+    total += 4; // 结尾标记
+    return total;
+  }
 
-          // 处理 tool-use 的 input 字段
-          if (part.type === 'tool_use' && part.input) {
-            try {
-              total += this._countTokens(JSON.stringify(part.input));
-            } catch (e) {
-              // 忽略
+  /**
+   * 计算单个内容块的 token 数
+   * 参考 Claude Code 的实现
+   * @param {Object} block - 内容块
+   * @returns {number}
+   * @private
+   */
+  _countContentBlockTokens(block) {
+    if (!block || typeof block !== 'object') {
+      return 0;
+    }
+
+    const tokenizer = this._encoder;
+
+    // 文本块
+    if (block.type === 'text') {
+      return tokenizer.encode(block.text || '');
+    }
+
+    // 工具调用块 - 工具名 + 输入参数（JSON 更密集）
+    if (block.type === 'tool-use' || block.type === 'tool_call') {
+      let count = 0;
+      if (block.name || block.toolName) {
+        count += tokenizer.encode(String(block.name || block.toolName || ''));
+      }
+      if (block.input) {
+        try {
+          count += tokenizer.encode(JSON.stringify(block.input), 2);
+        } catch (e) {}
+      }
+      return count;
+    }
+
+    // 工具结果块
+    if (block.type === 'tool-result' || block.type === 'tool_result') {
+      let count = 0;
+      if (block.content) {
+        if (typeof block.content === 'string') {
+          count += tokenizer.encode(block.content);
+        } else if (Array.isArray(block.content)) {
+          for (const c of block.content) {
+            if (c && c.type === 'text') {
+              count += tokenizer.encode(c.text || '');
             }
           }
         }
-      } else if (msg.content && typeof msg.content === 'object') {
-        // 处理工具结果等对象类型
-        try {
-          const str = JSON.stringify(msg.content);
-          total += this._countTokens(str);
-        } catch (e) {
-          // 无法序列化的内容，忽略
+      }
+      if (block.toolUseId || block.tool_call_id) {
+        count += 10; // 工具结果标识
+      }
+      return count;
+    }
+
+    // 输入块 (tool_input)
+    if (block.type === 'input') {
+      try {
+        return tokenizer.encode(JSON.stringify(block), 2);
+      } catch (e) {
+        return 0;
+      }
+    }
+
+    // 其他类型，尝试 JSON 序列化
+    try {
+      return tokenizer.encode(JSON.stringify(block), 2);
+    } catch (e) {
+      return 0;
+    }
+  }
+
+  /**
+   * 估算消息列表的 token 数（不带消息结构的简单估算）
+   * 用于快速检查
+   * @param {Array} messages
+   * @returns {number}
+   * @private
+   */
+  _roughEstimateMessagesTokens(messages) {
+    let total = 0;
+    for (const msg of messages) {
+      if (!msg) continue;
+      if (typeof msg.content === 'string') {
+        total += this._countTokens(msg.content);
+      } else if (Array.isArray(msg.content)) {
+        for (const part of msg.content) {
+          if (part && part.text) {
+            total += this._countTokens(String(part.text));
+          }
         }
       }
     }
-    total += 4; // 结尾标记
     return total;
   }
 
+  /**
+   * 基于 API usage 和新消息估算计算当前上下文 token 数
+   * 参考 Claude Code 的 tokenCountWithEstimation 实现
+   * @param {Array} messages - 消息数组
+   * @param {Object} lastUsage - 上一次 API 返回的 usage
+   * @param {number} baseMessageCount - 基准消息数量（usage 对应时）
+   * @returns {number} 估算的总 token 数
+   * @private
+   */
+  _tokenCountWithEstimation(messages, lastUsage, baseMessageCount = 0) {
+    // 如果有真实的 usage 数据，使用它作为基准
+    if (lastUsage && typeof lastUsage === 'object') {
+      const inputTokens = lastUsage.inputTokens || 0;
+      const outputTokens = lastUsage.outputTokens || 0;
+      const cacheReadTokens = lastUsage.inputTokenDetails?.cacheReadTokens || 0;
+      const cacheWriteTokens = lastUsage.inputTokenDetails?.cacheWriteTokens || 0;
+
+      // 计算已有消息的真实 token 数
+      const baseTokens = inputTokens + cacheReadTokens + outputTokens;
+
+      // 估算新增消息的 token 数
+      if (messages.length > baseMessageCount) {
+        const newMessages = messages.slice(baseMessageCount);
+        const newMessagesTokens = this._countMessagesTokens(newMessages);
+        return baseTokens + newMessagesTokens;
+      }
+
+      return baseTokens;
+    }
+
+    // 没有 usage 数据，使用纯估算
+    return this._countMessagesTokens(messages);
+  }
+
+  /**
+   * 更新 messageStore 的 lastUsage
+   * @param {Object} messageStore
+   * @param {Object} usage - API 返回的 usage
+   * @private
+   */
+  _updateMessageStoreUsage(messageStore, usage) {
+    if (messageStore && usage) {
+      messageStore.lastUsage = {
+        inputTokens: usage.inputTokens,
+        outputTokens: usage.outputTokens,
+        inputTokenDetails: usage.inputTokenDetails || {},
+      };
+    }
+  }
+
   /**
    * 计算工具定义的 token 数（估算）
    * @returns {number}
@@ -577,13 +701,11 @@ class AgentChatHandler extends EventEmitter {
     }
 
     // 过滤时保留：有 result 的 tool call，以及没有 result 的 tool call（但要附带其 result）
-    const indicesToKeep = new Set();
+    // 第一遍：先确定哪些 assistant 消息要保留
+    const assistantIndicesToKeep = new Set();
     for (let i = 0; i < recentMessages.length; i++) {
       const msg = recentMessages[i];
-      if (msg.role === 'tool') {
-        // 保留所有 tool result（它们是必要的）
-        indicesToKeep.add(i);
-      } else if (msg.role === 'assistant') {
+      if (msg.role === 'assistant') {
         // 检查这个 assistant 消息是否有 tool call
         let hasToolCall = false;
         if (msg.content) {
@@ -596,21 +718,53 @@ class AgentChatHandler extends EventEmitter {
           }
         }
         if (hasToolCall) {
-          indicesToKeep.add(i);
+          assistantIndicesToKeep.add(i);
         } else if (i >= recentMessages.length - 3) {
           // 保留最近几条 assistant 消息（它们可能包含重要上下文）
-          indicesToKeep.add(i);
+          assistantIndicesToKeep.add(i);
         }
-      } else {
-        // user, system 等角色默认保留
-        indicesToKeep.add(i);
       }
     }
 
     // 如果有孤儿的 tool call（没有 result），保留该 assistant 消息
     for (const [toolCallId, assistantIdx] of assistantToolCalls) {
       if (!toolResults.has(toolCallId)) {
-        indicesToKeep.add(assistantIdx);
+        assistantIndicesToKeep.add(assistantIdx);
+      }
+    }
+
+    // 第二遍：基于 assistant 的保留情况，确定哪些 tool result 要保留
+    const indicesToKeep = new Set();
+    for (let i = 0; i < recentMessages.length; i++) {
+      const msg = recentMessages[i];
+      if (msg.role === 'tool') {
+        // 检查这个 tool result 是否对应一个被保留的 assistant tool_call
+        // 如果对应的 assistant 消息被删除了，这个 tool result 也应该被删除（否则会报 orphaned error）
+        let hasPairedAssistant = false;
+        const content = Array.isArray(msg.content) ? msg.content : [msg.content];
+        for (const item of content) {
+          if (item && item.type === 'tool-result' && item.toolCallId) {
+            // 检查这个 toolCallId 对应的 assistant 消息是否被保留
+            const assistantIdx = assistantToolCalls.get(item.toolCallId);
+            if (assistantIdx !== undefined && assistantIndicesToKeep.has(assistantIdx)) {
+              hasPairedAssistant = true;
+              break;
+            }
+          }
+        }
+        // 只有有配对的 assistant 消息被保留时，才保留这个 tool result
+        if (hasPairedAssistant) {
+          indicesToKeep.add(i);
+        } else {
+          logger.debug(`Dropping orphaned tool result at index ${i}`);
+        }
+      } else if (msg.role === 'assistant') {
+        if (assistantIndicesToKeep.has(i)) {
+          indicesToKeep.add(i);
+        }
+      } else {
+        // user, system 等角色默认保留
+        indicesToKeep.add(i);
       }
     }
 
@@ -618,9 +772,6 @@ class AgentChatHandler extends EventEmitter {
     const sortedIndices = Array.from(indicesToKeep).sort((a, b) => a - b);
     const filteredRecentMessages = sortedIndices.map((i) => recentMessages[i]);
 
-    // 清理孤立 tool results（tool call 已被总结，但 result 还在）
-    this._cleanOrphanedToolResults(filteredRecentMessages);
-
     // 直接修改传入的 messages 数组
     messages.length = 0;
     messages.push(...systemMessages, summary, ...filteredRecentMessages);
@@ -741,9 +892,6 @@ class AgentChatHandler extends EventEmitter {
     const sortedIndices = Array.from(indicesToKeep).sort((a, b) => a - b);
     const filteredRecentMessages = sortedIndices.map((i) => recentMessages[i]);
 
-    // 清理孤立 tool results（tool call 已被总结，但 result 还在）
-    this._cleanOrphanedToolResults(filteredRecentMessages);
-
     // 直接修改传入的 messages 数组
     messages.length = 0;
     messages.push(...systemMessages, summary, ...filteredRecentMessages);
@@ -766,38 +914,6 @@ class AgentChatHandler extends EventEmitter {
     }
   }
 
-  /**
-   * 清理孤立的 tool results（对应的 tool call 已被压缩删除）
-   * @param {Array} messages - 消息数组
-   * @private
-   */
-  _cleanOrphanedToolResults(messages) {
-    // 构建当前消息中存在的 toolCallId 集合
-    const validToolCallIds = new Set();
-    for (const msg of messages) {
-      if (msg.role === 'assistant' && msg.content) {
-        const content = Array.isArray(msg.content) ? msg.content : [msg.content];
-        for (const item of content) {
-          if (item.type === 'tool-call' && item.toolCallId) {
-            validToolCallIds.add(item.toolCallId);
-          }
-        }
-      }
-    }
-
-    // 过滤掉孤立 tool results
-    for (const msg of messages) {
-      if (msg.role === 'tool' && Array.isArray(msg.content)) {
-        msg.content = msg.content.filter((item) => {
-          if (item && item.type === 'tool-result' && item.toolCallId) {
-            return validToolCallIds.has(item.toolCallId);
-          }
-          return true;
-        });
-      }
-    }
-  }
-
   /**
    * 使用 AI 对消息进行总结
    * @param {Array} messages - 要总结的消息
@@ -1074,7 +1190,7 @@ ${truncatedContent}${truncatedNote}
       const toolsTokens = this._countToolsTokens();
       const systemPromptTokens = this._countTokens(this._systemPrompt);
       const totalTokens = messagesTokens + toolsTokens + systemPromptTokens;
-      const limit = this._maxContextTokens * 0.7; // 降低到 70%，更早压缩
+      const limit = this._maxContextTokens * 0.5; // 降低到 50%，更早压缩，防止 context window 超限
 
       if (totalTokens > limit) {
         logger.info(
@@ -1082,11 +1198,48 @@ ${truncatedContent}${truncatedNote}
         );
         // 使用带超时控制的压缩（传入 messages 引用）
         await this._compressContext(sessionId, messages, messageStore);
+        // 压缩后验证消息配对（防止 orphaned tool result）
+        const validatedMessages = this._validateMessagesPairing(messages);
+        if (validatedMessages.length !== messages.length) {
+          messages.length = 0;
+          messages.push(...validatedMessages);
+        }
       }
 
       const maxSteps = options.maxSteps || this._maxSteps;
       const tools = this._getAITools(tool);
 
+      // 验证消息配对（防止 API 调用时报 orphaned tool result 错误）
+      const validatedMessages = this._validateMessagesPairing(messages);
+      if (validatedMessages.length !== messages.length) {
+        messages.length = 0;
+        messages.push(...validatedMessages);
+      }
+
+      // 最终检查：在 API 调用前再次验证 token 数
+      const finalMessagesTokens = this._countMessagesTokens(messages);
+      const finalToolsTokens = this._countToolsTokens();
+      const finalSystemPromptTokens = this._countTokens(this._systemPrompt);
+      const finalTotalTokens = finalMessagesTokens + finalToolsTokens + finalSystemPromptTokens;
+      const finalLimit = this._maxContextTokens * 0.5;
+
+      logger.info(
+        `[API Call Check] messages=${messages.length}, tokens=(${finalMessagesTokens}+${finalToolsTokens}+${finalSystemPromptTokens}=${finalTotalTokens}) vs limit=${finalLimit}`
+      );
+
+      // 如果仍然超过限制，强制压缩
+      if (finalTotalTokens > finalLimit) {
+        logger.warn(`[API Call Check] Still over limit after validation, forcing compression`);
+        await this._compressContext(sessionId, messages, messageStore);
+        const compressedMessages = this._validateMessagesPairing(messages);
+        messages.length = 0;
+        messages.push(...compressedMessages);
+        const afterTokens = this._countMessagesTokens(messages);
+        logger.info(
+          `[After Forced Compression] messages=${messages.length}, tokens=${afterTokens}`
+        );
+      }
+
       // 准备传给 agent 的消息
       const prepareStepChainStream = async ({ stepNumber, messages }) => {
         try {
@@ -1096,18 +1249,12 @@ ${truncatedContent}${truncatedNote}
             return messages;
           }
 
-          // 2. 检查并移除不完整的 tool-call 和对应的 tool result
-          const validated = this._validateToolCallsForPrepare(messages);
-          if (validated !== messages) {
-            return validated;
-          }
-
-          // 3. 消息数量超过阈值才修剪
+          // 2. 消息数量超过阈值才修剪
           if (messages.length <= 50) {
             return messages;
           }
 
-          // 4. 保留配对完整的消息
+          // 3. 保留配对完整的消息
           const pruned = this._prepareMessagesForAI(messages);
           return pruned;
         } catch (err) {
@@ -1125,7 +1272,6 @@ ${truncatedContent}${truncatedNote}
         model: this._aiClient,
         instructions: this._systemPrompt,
         tools: tools,
-        stopWhen: stepCountIs(30),
         prepareStep: prepareStepChainStream,
       });
 
@@ -1134,6 +1280,14 @@ ${truncatedContent}${truncatedNote}
         return agent.generate({ messages, ...this.providerOptions });
       });
 
+      // 捕获 API 返回的 usage 用于更准确的 token 估算
+      if (result.usage) {
+        this._updateMessageStoreUsage(messageStore, result.usage);
+        logger.debug(
+          `API usage: input=${result.usage.inputTokens}, output=${result.usage.outputTokens}`
+        );
+      }
+
       messages.push(...result.response.messages);
 
       // 触发 agent:message 事件，让 memory 插件可以自动提取记忆
@@ -1142,7 +1296,7 @@ ${truncatedContent}${truncatedNote}
 
       // 生成后检查：如果消息太长，下次需要压缩
       const afterTokens = this._countMessagesTokens(messages);
-      if (afterTokens > this._maxContextTokens * 0.8) {
+      if (afterTokens > this._maxContextTokens * 0.5) {
         logger.info(`After generation: ${afterTokens} tokens, will compress on next turn`);
       }
 
@@ -1152,6 +1306,8 @@ ${truncatedContent}${truncatedNote}
         stepCount: result.stepCount || 1,
       };
     } finally {
+      // 校验并修复消息中的不完整工具调用
+      this._validateToolCalls(messages);
       // 确保保存聊天历史到 session（无论成功还是失败）
       messageStore.save();
     }
@@ -1176,7 +1332,7 @@ ${truncatedContent}${truncatedNote}
       this._systemPrompt = this.agent._buildSystemPrompt();
       // 动态导入 AI SDK
       const { tool, ToolLoopAgent } = await this._importAI();
-
+      //await fs.writeFile('system.md',this._systemPrompt)
       const userMessage =
         typeof message === 'string' ? { role: 'user', content: message } : message;
       messages.push(userMessage);
@@ -1186,7 +1342,7 @@ ${truncatedContent}${truncatedNote}
       const toolsTokens = this._countToolsTokens();
       const systemPromptTokens = this._countTokens(this._systemPrompt);
       const totalTokens = messagesTokens + toolsTokens + systemPromptTokens;
-      const limit = this._maxContextTokens * 0.7; // 降低到 70%
+      const limit = this._maxContextTokens * 0.5; // 降低到 50%，更早压缩，防止 context window 超限
       // 对于流式调用，如果上下文太大，先压缩再开始
       if (totalTokens > limit) {
         logger.info(
@@ -1194,6 +1350,12 @@ ${truncatedContent}${truncatedNote}
         );
         // 流式调用时等待压缩完成（使用带超时控制的压缩）
         await this._compressContext(sessionId, messages, messageStore);
+        // 压缩后验证消息配对（防止 orphaned tool result）
+        const validatedMessages = this._validateMessagesPairing(messages);
+        if (validatedMessages.length !== messages.length) {
+          messages.length = 0;
+          messages.push(...validatedMessages);
+        }
       }
 
       const maxSteps = options.maxSteps || this._maxSteps;
@@ -1202,6 +1364,37 @@ ${truncatedContent}${truncatedNote}
         throw new Error('AI client not configured.');
       }
 
+      // 验证消息配对（防止 API 调用时报 orphaned tool result 错误）
+      const validatedMessages = this._validateMessagesPairing(messages);
+      if (validatedMessages.length !== messages.length) {
+        messages.length = 0;
+        messages.push(...validatedMessages);
+      }
+
+      // 最终检查：在 API 调用前再次验证 token 数
+      const finalMessagesTokens = this._countMessagesTokens(messages);
+      const finalToolsTokens = this._countToolsTokens();
+      const finalSystemPromptTokens = this._countTokens(this._systemPrompt);
+      const finalTotalTokens = finalMessagesTokens + finalToolsTokens + finalSystemPromptTokens;
+      const finalLimit = this._maxContextTokens * 0.5;
+
+      logger.info(
+        `[API Call Check (stream)] messages=${messages.length}, tokens=(${finalMessagesTokens}+${finalToolsTokens}+${finalSystemPromptTokens}=${finalTotalTokens}) vs limit=${finalLimit}`
+      );
+
+      // 如果仍然超过限制，强制压缩
+      if (finalTotalTokens > finalLimit) {
+        logger.warn(`[API Call Check (stream)] Still over limit, forcing compression`);
+        await this._compressContext(sessionId, messages, messageStore);
+        const compressedMessages = this._validateMessagesPairing(messages);
+        messages.length = 0;
+        messages.push(...compressedMessages);
+        const afterTokens = this._countMessagesTokens(messages);
+        logger.info(
+          `[After Forced Compression (stream)] messages=${messages.length}, tokens=${afterTokens}`
+        );
+      }
+
       // 准备传给 agent 的消息
       const prepareStepChainStream = async ({ stepNumber, messages }) => {
         try {
@@ -1211,18 +1404,12 @@ ${truncatedContent}${truncatedNote}
             return messages;
           }
 
-          // 2. 检查并移除不完整的 tool-call 和对应的 tool result
-          const validated = this._validateToolCallsForPrepare(messages);
-          if (validated !== messages) {
-            return validated;
-          }
-
-          // 3. 消息数量超过阈值才修剪
+          // 2. 消息数量超过阈值才修剪
           if (messages.length <= 50) {
             return messages;
           }
 
-          // 4. 保留配对完整的消息
+          // 3. 保留配对完整的消息
           const pruned = this._prepareMessagesForAI(messages);
           return pruned;
         } catch (err) {
@@ -1235,7 +1422,6 @@ ${truncatedContent}${truncatedNote}
         model: this._aiClient,
         instructions: this._systemPrompt,
         tools: tools,
-        stopWhen: stepCountIs(30),
         prepareStep: prepareStepChainStream,
       });
 
@@ -1271,6 +1457,18 @@ ${truncatedContent}${truncatedNote}
 
       const finishMessages = (await result.response).messages;
       messages.push(...finishMessages);
+      // 捕获 API 返回的 usage 用于更准确的 token 估算
+      const usage = await result.totalUsage;
+      if (usage) {
+        try {
+          this._updateMessageStoreUsage(messageStore, usage);
+          logger.debug(
+            `API usage (stream): input=${usage.inputTokens}, output=${usage.outputTokens}`
+          );
+        } catch (e) {
+          logger.debug('Failed to capture stream usage:', e.message);
+        }
+      }
 
       // 触发 agent:message 事件，让 memory 插件可以自动提取记忆
       const userMsg = messages[messages.length - finishMessages.length - 1];
@@ -1279,6 +1477,8 @@ ${truncatedContent}${truncatedNote}
       this.emit('error', { error: err.message });
       yield { type: 'error', error: err.message };
     } finally {
+      // 校验并修复消息中的不完整工具调用
+      this._validateToolCalls(messages);
       // 确保保存聊天历史到 session（无论成功还是失败）
       messageStore.save();
     }
@@ -1437,171 +1637,141 @@ ${truncatedContent}${truncatedNote}
   }
 
   /**
-   * 校验并修复消息中的工具调用参数
-   * 移除不完整的 JSON（如只有 "{" ）的工具调用
+   * 验证并修复消息中的 tool call/result 配对
+   * 删除没有对应 assistant tool_call 的 tool result（会导致 API 报错）
    * @param {Array} messages - 消息列表
    * @private
    */
-  _validateToolCalls(messages) {
-    let fixedCount = 0;
-
+  _validateMessagesPairing(messages) {
+    // 收集所有 assistant 的 tool-call IDs
+    const assistantToolCallIds = new Set();
     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') {
-          continue;
-        }
-
-        const input = item.input;
-        if (typeof input !== 'string') {
-          continue;
+      if (msg.role === 'assistant' && Array.isArray(msg.content)) {
+        for (const item of msg.content) {
+          if (item.type === 'tool-call' && item.toolCallId) {
+            assistantToolCallIds.add(item.toolCallId);
+          }
         }
+      }
+    }
 
-        // 检查 input 是否是有效的 JSON（不是不完整的）
-        const trimmed = input.trim();
-        if (trimmed === '{' || trimmed === '' || !trimmed.startsWith('{')) {
-          // 不完整的 JSON，移除这个 tool-call
-          item.type = 'text';
-          item.text = `（工具调用 ${item.toolName} 参数不完整，已跳过）`;
-          delete item.toolCallId;
-          delete item.toolName;
-          delete item.input;
-          fixedCount++;
-        } else {
-          // 检查 JSON 是否能完整解析
-          try {
-            JSON.parse(trimmed);
-          } catch (e) {
-            // JSON 解析失败，说明是不完整的 JSON
-            item.type = 'text';
-            item.text = `（工具调用 ${item.toolName} 参数不完整（${e.message}），已跳过）`;
-            delete item.toolCallId;
-            delete item.toolName;
-            delete item.input;
-            fixedCount++;
+    // 检查并删除没有配对的 tool result
+    let removedCount = 0;
+    for (const msg of messages) {
+      if (msg.role === 'tool' && Array.isArray(msg.content)) {
+        const originalLength = msg.content.length;
+        msg.content = msg.content.filter((item) => {
+          if (item && item.type === 'tool-result' && item.toolCallId) {
+            if (!assistantToolCallIds.has(item.toolCallId)) {
+              removedCount++;
+              return false; // 删除没有配对的 tool result
+            }
           }
+          return true;
+        });
+
+        // 如果所有 content 都被删除了，标记整个消息待删除
+        if (msg.content.length === 0 && originalLength > 0) {
+          msg._orphaned = true;
         }
       }
     }
 
-    if (fixedCount > 0) {
-      logger.info(`Fixed ${fixedCount} incomplete tool calls`);
+    // 移除被标记为 orphaned 的 tool 消息
+    const originalLength = messages.length;
+    const filtered = messages.filter((msg) => !(msg.role === 'tool' && msg._orphaned));
+
+    if (removedCount > 0 || filtered.length !== originalLength) {
+      logger.debug(
+        `Removed ${removedCount} orphaned tool-results, ${originalLength - filtered.length} orphaned tool messages`
+      );
     }
+
+    return filtered;
   }
 
   /**
-   * 在 prepareStep 中检查并移除不完整的 tool-call 和对应的 tool result
-   * 返回修改后的消息数组（如果没修改则返回原数组）
+   * 校验并修复消息中的工具调用参数
+   * 移除不完整的 JSON（如只有 "{" ）的工具调用
+   * 同时清理 tool result 中的错误信息
    * @param {Array} messages - 消息列表
-   * @returns {Array} 修改后的消息数组或原数组
    * @private
    */
-  _validateToolCallsForPrepare(messages) {
-    // 收集不完整的 toolCallId
-    const invalidToolCallIds = new Set();
+  _validateToolCalls(messages) {
+    let fixedCount = 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.toolCallId) {
-          continue;
-        }
-
-        const input = item.input;
-        if (typeof input !== 'string') {
-          continue;
-        }
-
-        // 检查 input 是否是有效的 JSON
-        const trimmed = input.trim();
-        let isInvalid = false;
+      // 清理 assistant 消息中的不完整 tool-call
+      if (msg.role === 'assistant' && Array.isArray(msg.content)) {
+        for (const item of msg.content) {
+          if (item.type !== 'tool-call') {
+            continue;
+          }
 
-        if (trimmed === '{' || trimmed === '' || !trimmed.startsWith('{')) {
-          isInvalid = true;
-        } else {
-          try {
-            JSON.parse(trimmed);
-          } catch (e) {
-            isInvalid = true;
+          const input = item.input;
+          if (typeof input !== 'string') {
+            continue;
           }
-        }
 
-        if (isInvalid) {
-          invalidToolCallIds.add(item.toolCallId);
-          logger.warn(`Found incomplete tool call: ${item.toolName} (${item.toolCallId})`);
+          // 检查 input 是否是有效的 JSON（不是不完整的）
+          const trimmed = input.trim();
+          if (trimmed === '{' || trimmed === '' || !trimmed.startsWith('{')) {
+            // 不完整的 JSON，移除这个 tool-call
+            item.type = 'text';
+            item.text = `（工具调用 ${item.toolName} 参数不完整，已跳过）`;
+            delete item.toolCallId;
+            delete item.toolName;
+            delete item.input;
+            fixedCount++;
+          }
         }
       }
-    }
 
-    // 如果没有不完整的 tool-call，返回原数组
-    if (invalidToolCallIds.size === 0) {
-      return messages;
-    }
+      // 清理 tool result 中的无效 JSON 错误信息
+      if (msg.role === 'tool' && Array.isArray(msg.content)) {
+        for (const item of msg.content) {
+          if (item.type !== 'tool-result') {
+            continue;
+          }
 
-    // 构建新的消息数组，移除不完整的 tool-call 和对应的 tool result
-    const result = [];
+          const output = item.output;
+          let errorText = null;
 
-    for (const msg of messages) {
-      if (msg.role === 'tool') {
-        // 检查 tool result 是否对应不完整的 tool-call
-        if (Array.isArray(msg.content)) {
-          const newContent = [];
-          for (const item of msg.content) {
-            if (
-              item.type === 'tool-result' &&
-              item.toolCallId &&
-              invalidToolCallIds.has(item.toolCallId)
-            ) {
-              // 跳过这个 tool result
-              continue;
+          // 处理字符串类型 output
+          if (typeof output === 'string') {
+            errorText = output;
+          } else if (typeof output === 'object' && output !== null) {
+            // 处理 { type: 'error-text', value: '...' } 结构
+            if (output.value && typeof output.value === 'string') {
+              errorText = output.value;
             }
-            newContent.push(item);
           }
-          // 如果所有 content 都被移除了，跳过这条消息
-          if (newContent.length === 0) {
+
+          if (!errorText) {
             continue;
           }
-          // 浅拷贝消息对象
-          result.push({ ...msg, content: newContent });
-        } else {
-          result.push(msg);
-        }
-      } else if (msg.role === 'assistant') {
-        // 检查并移除 assistant 消息中的不完整 tool-call
-        if (Array.isArray(msg.content)) {
-          const newContent = [];
-          for (const item of msg.content) {
-            if (
-              item.type === 'tool-call' &&
-              item.toolCallId &&
-              invalidToolCallIds.has(item.toolCallId)
-            ) {
-              // 跳过不完整的 tool-call
-              continue;
+
+          // 检查是否包含 "JSON parsing failed" 或类似的不完整 JSON 错误
+          if (errorText.includes('JSON parsing failed') || errorText.includes('Invalid input')) {
+            const toolName = item.toolName || 'unknown';
+            // 替换为更简洁的错误信息
+            if (typeof output === 'string') {
+              item.output = `（工具 ${toolName} 参数不完整，已跳过）`;
+            } else {
+              item.output = {
+                type: 'error-text',
+                value: `（工具 ${toolName} 参数不完整，已跳过）`,
+              };
             }
-            newContent.push(item);
-          }
-          // 如果所有 content 都被移除了，跳过这条消息
-          if (newContent.length === 0) {
-            continue;
+            fixedCount++;
           }
-          result.push({ ...msg, content: newContent });
-        } else {
-          result.push(msg);
         }
-      } else {
-        result.push(msg);
       }
     }
 
-    logger.info(`Removed ${invalidToolCallIds.size} incomplete tool calls and their results`);
-    return result;
+    if (fixedCount > 0) {
+      logger.info(`Fixed ${fixedCount} incomplete tool calls/results`);
+    }
   }
 
   /**