foliko 2.0.21 → 2.0.23

package/src/agent/chat.js

@@ -11,15 +11,10 @@
 const { EventEmitter } = require('../common/events');
 const { logger } = require('../common/logger');
 const fs = require('fs');
-const {
-  tool: aiTool,
-  ToolLoopAgent,
-  isLoopFinished,
-  InvalidToolInputError,
-} = require('ai');
+const { ToolLoop } = require('./tool-loop');
 const { z } = require('zod');
 const { autoSplitToolResult } = require('../../plugins/executors/data-splitter');
-const { normalizeToolOutputs, validateAll } = require('../utils/message-validator');
+const { normalizeToolOutputs, validateAll, sanitizeForLLM } = require('../utils/message-validator');
 const { cleanResponse } = require('../utils');
 const { ChatQueueManager } = require('../common/queue');
 const { TokenCounter } = require('../llm/tokens');
@@ -60,7 +55,10 @@ class AgentChatHandler extends EventEmitter {
 
     // DeepSeek thinking mode: 支持通过 config.thinkingMode 控制开关
     // config.thinkingMode = true 可启用，默认为禁用
-    const enableThinking = config.thinkingMode === true && isThinkingModel(this.model);
+    // ★ 紧急关闭：设环境变量 FOLIKO_DISABLE_THINKING=1 强制关闭（绕过所有检测）
+    const forceDisabled = process.env.FOLIKO_DISABLE_THINKING === '1' ||
+      process.env.FOLIKO_DISABLE_THINKING === 'true';
+    const enableThinking = !forceDisabled && config.thinkingMode === true && isThinkingModel(this.model);
     this._thinkingMode = enableThinking;
 
     if (enableThinking) {
@@ -192,15 +190,10 @@ class AgentChatHandler extends EventEmitter {
 
   // ==================== 工具管理（委托给 ToolExecutor） ====================
 
-  /** AI tools 格式缓存 (避免每次 chat 重建) */
-  _aiToolsCache = null;
-  _aiToolsCacheKey = ''; // 工具列表的哈希摘要
-
   registerTool(tool) {
     this._toolExecutor.registerTool(tool);
     // 工具列表变了，清除缓存
     this._toolsTokensCacheVersion = 0;
-    this._aiToolsCache = null; // 清除 AI tools 缓存
     return this;
   }
 
@@ -298,6 +291,40 @@ class AgentChatHandler extends EventEmitter {
     }
   }
 
+  /**
+   * ★ DeepSeek thinking mode：把 reasoning 文本注入 assistant message
+   * 关键：必须作为 `{type: 'reasoning', text: '...'}` part 放入 content 数组，
+   *       AI SDK 的 openai-compatible provider 才能识别并在下次 API 调用时
+   *       序列化为 `reasoning_content` 字段。
+   * 错误做法：直接 `msg.reasoning_content = '...'` → AI SDK 不认识这个字段，丢弃 → 报错
+   *
+   * @private
+   */
+  _injectReasoningContent(msg, reasoningText) {
+    if (!msg || !reasoningText) return;
+    if (typeof msg.content === 'string') {
+      // 旧格式：content 是字符串。转为数组，reasoning part 放前面
+      msg.content = [
+        { type: 'reasoning', text: reasoningText },
+        { type: 'text', text: msg.content },
+      ];
+      return;
+    }
+    if (Array.isArray(msg.content)) {
+      // 查找已有 reasoning part（合并而非重复）
+      const existing = msg.content.find(c => c && c.type === 'reasoning');
+      if (existing) {
+        existing.text = reasoningText;
+      } else {
+        // reasoning 放最前（按时间顺序）
+        msg.content.unshift({ type: 'reasoning', text: reasoningText });
+      }
+      return;
+    }
+    // content 不存在或不是 string/array：新建
+    msg.content = [{ type: 'reasoning', text: reasoningText }];
+  }
+
   // ==================== AI 调用 ====================
 
   setAIClient(client) {
@@ -448,20 +475,13 @@ class AgentChatHandler extends EventEmitter {
   }
 
   /**
-   * AI SDK repairToolCall: 修复无效的 tool-call 输入
-   * 当模型返回的 JSON 参数无法解析时，尝试修复
+   * 修复无效的 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: '{}' };
-    }
-    // 尝试补全花括号
+    if (trimmed === '') return { ...toolCall, input: '{}' };
     let fixed = null;
     if (!trimmed.startsWith('{')) {
       fixed = '{' + trimmed + '}';
@@ -474,15 +494,39 @@ class AgentChatHandler extends EventEmitter {
     return null;
   }
 
-  _createToolLoopAgent(model, tools) {
-    return new ToolLoopAgent({
-      model,
-      instructions: this._systemPrompt,
-      tools,
-      stopWhen: isLoopFinished(),
-      prepareStep: this._createPrepareStep(),
-      experimental_repairToolCall: this._repairToolCall.bind(this),
-    });
+  /**
+   * 获取工具 Map（OpenAI tool 格式，供 ToolLoop 使用）
+   * @returns {{ name => { name, description, execute, parameters } }}
+   */
+  _getToolMap() {
+    const map = {};
+    const allTools = this.agent.framework.getTools();
+    for (const toolDef of allTools) {
+      map[toolDef.name] = {
+        name: toolDef.name,
+        description: toolDef.description || '',
+        parameters: toolDef.inputSchema || toolDef.parameters || null,
+        execute: async (args) => {
+          const cleanedArgs = this._cleanToolArgs(args, toolDef.inputSchema);
+          this.emit('tool-call', { name: toolDef.name, args: cleanedArgs });
+          try {
+            const result = await toolDef.execute(cleanedArgs, this.agent.framework);
+            // 自动检测大工具结果，透明分拆
+            let finalResult = result;
+            try {
+              const splitCheck = await autoSplitToolResult(toolDef.name, result, this.agent.framework);
+              if (splitCheck.wasSplit && splitCheck.result) finalResult = splitCheck.result;
+            } catch { /* 分拆失败不中断 */ }
+            this.emit('tool-result', { name: toolDef.name, args: cleanedArgs, result: finalResult });
+            return finalResult;
+          } catch (err) {
+            this.emit('tool-error', { name: toolDef.name, args: cleanedArgs, error: err.message });
+            return { success: false, error: err.message };
+          }
+        },
+      };
+    }
+    return map;
   }
 
   /**
@@ -690,128 +734,65 @@ class AgentChatHandler extends EventEmitter {
       }
       const systemPrompt = framework.prompts.build();
       //await fs.promises.writeFile(`.${sessionId}_systemPrompt.md`, systemPrompt); // 调试用：保存系统提示词
-      const tools = this._getAITools(aiTool);
-      const agent = new ToolLoopAgent({
-        model: this._aiClient,
-        instructions: systemPrompt,
+      const tools = this._getToolMap();
+      const toolLoop = new ToolLoop({
         tools,
-        stopWhen: isLoopFinished(),
+        maxSteps: this._maxSteps || 20,
         prepareStep: this._createPrepareStep(),
-        experimental_repairToolCall: this._repairToolCall.bind(this),
+        repairToolCall: this._repairToolCall.bind(this),
+        abortSignal: framework.getAbortSignal?.(),
+        thinkingMode: this._thinkingMode,
       });
 
-      // AI SDK 错误回调：仅记录日志，不在这里处理（统一由 catch/yield 处理）
-      const handleSDKError = ({ error }) => {
-        //logger.debug(`[AgentChat] SDK onError: ${error?.message}`);
-      };
-
       // DeepSeek thinking mode: 收集 reasoning_content
       const isThinking = this._thinkingMode;
       let reasoningContent = '';
 
-      const result = await framework.runInSession(sessionId, {}, async () => {
-        return agent.stream({
-          messages,
-          ...this.providerOptions,
-          onError: handleSDKError,
-          abortSignal: framework.getAbortSignal?.(),
-        });
+      const stream = toolLoop.stream({
+        messages,
+        systemPrompt,
+        model: this.model,
+        client: this._aiClient,
+        ...this.providerOptions,
       });
-
-      const stream = result.fullStream;
+      // 遍历流式响应
       let fullText = '';
-      const iterator = stream[Symbol.asyncIterator] ? stream : stream.fullStream;
-      // 追踪发送的 tool-call ID，过滤 API 返回的不匹配 tool-result
-      const sentToolCallIds = new Set();
+      let usageRecv = {};
 
-      for await (const part of iterator || stream) {
+      for await (const part of stream) {
         if (part.type === 'text-delta') {
-          const text = part.text || part.textDelta || '';
-          fullText += text;
-          yield { type: 'text', text };
-        } else if (part.type === 'reasoning') {
+          fullText += part.text;
+          yield { type: 'text', text: part.text };
+        } else if (part.type === 'thinking') {
           reasoningContent += part.text || '';
           yield { type: 'thinking', text: part.text };
         } else if (part.type === 'tool-call') {
-          const toolCallId = part.toolCallId;
-          if (toolCallId) sentToolCallIds.add(toolCallId);
           yield { type: 'tool-call', toolName: part.toolName, input: part.input };
         } else if (part.type === 'tool-result') {
-          // 过滤 toolCallId 不匹配的 tool-result（API bug）
-          const resultToolCallId = part.toolCallId;
-          if (resultToolCallId && !sentToolCallIds.has(resultToolCallId)) {
-            logger.debug(`[stream]过滤不匹配的 tool-result: ${resultToolCallId}`);
-            continue;
-          }
-          yield { type: 'tool-result', toolName: part.toolName, result: part.output };
+          yield { type: 'tool-result', toolName: part.toolName, result: part.result };
         } else if (part.type === 'error') {
-          // 统一错误消息
-          const errMsg = part.error?.message || 'AI 服务错误';
+          const errMsg = part.error || 'AI 服务错误';
           yield { type: 'error', error: errMsg.split('\n')[0] };
+        } else if (part.type === 'usage') {
+          usageRecv = { inputTokens: part.inputTokens || 0, outputTokens: part.outputTokens || 0 };
+          yield { type: 'usage', inputTokens: usageRecv.inputTokens, outputTokens: usageRecv.outputTokens };
         }
       }
-
-      // DeepSeek thinking mode: 标记 reasoning_content 已处理
-      // 在 finishMessages 中标记，避免重复添加
-      const finishMessages = (await result.response).messages;
-      if (isThinking && reasoningContent) {
-        // DeepSeek 要求：当有 tool_calls 时，必须将 reasoning_content 添加到消息中
-        // AI SDK 的 finishMessage 不会包含 reasoning_content，需要手动添加
-        for (const msg of finishMessages) {
-          if (msg.role === 'assistant') {
-            // 检查是否有 tool_calls
-            const hasToolCalls = msg.tool_calls?.length > 0 ||
-              (Array.isArray(msg.content) && msg.content.some(c => c.type === 'tool-call' || c.type === 'tool-use'));
-            if (hasToolCalls) {
-              // DeepSeek API 要求：带 tool_calls 时必须传递 reasoning_content
-              msg.reasoning_content = reasoningContent;
-            }
-          }
-        }
-      }
-      // 写入端 sanitize：AI SDK v6 响应里允许 error-text/error-json（工具失败标记），
-      // 但 ModelMessage 输入 schema 不接受；持久化前必须规范化
-      normalizeToolOutputs(finishMessages);
-
-      messages.push(...finishMessages);
-
-      // 获取或估算 token 用量
-      const usage = await result.totalUsage;
-      let inputTokens = 0, outputTokens = 0;
-
-      if (usage && (usage.promptTokens > 0 || usage.completionTokens > 0 || usage.prompt_tokens > 0 || usage.completion_tokens > 0)) {
-        // totalUsage 有真实数据（DeepSeek 等 API）
-        inputTokens = usage.promptTokens || usage.prompt_tokens || 0;
-        outputTokens = usage.completionTokens || usage.completion_tokens || 0;
-        this._updateMessageStoreUsage(messageStore, usage);
-      } else {
-        // totalUsage 不可用或为空（MiniMax 等 API 返回 {promptTokens:0,completionTokens:0}）
-        // 用 TokenCounter 从实际消息内容估算
-        inputTokens = this._tokenCounter.countMessages(messages);
-        outputTokens = this._tokenCounter.countText(fullText);
-      }
-
-      // 确保 messageStore.usage 始终有数据
-      const usageData = { promptTokens: inputTokens, completionTokens: outputTokens };
-      messageStore.usage = usageData;
+      // 持久化用量
+      messageStore.usage = usageRecv;
 
       // 同时通过 framework 事件广播（绕开 queue 事件链路）
       if (this.agent && this.agent.framework) {
         this.agent.framework.emit('agent:usage', {
           sessionId,
-          usage: usageData,
+          usage: usageRecv,
         });
       }
 
       // yield usage 数据，让 UI 层能直接获取
-      yield {
-        type: 'usage',
-        sessionId,
-        inputTokens,
-        outputTokens,
-      };
+      // （usage 已在 stream 循环中 yield，无需重复）
 
-      const userMsg = messages[messages.length - finishMessages.length - 1];
+      const userMsg = messages.length > 0 ? messages[messages.length - 1] : null;
       this.emit('message', { content: fullText, sessionId: sessionId, userMessage: userMsg });
 
       // ★ 修复：成功路径才持久化。AI 失败时若 finally 也 save，
@@ -907,7 +888,6 @@ class AgentChatHandler extends EventEmitter {
    */
   async _processMessage(sessionId, message, options) {
     const framework = this.agent.framework;
-    // ★ 提到外层作用域，catch 中要回滚 userMessage 时需要访问
     let messageStore = null;
     let messages = null;
     let userMessage = null;
@@ -922,7 +902,7 @@ class AgentChatHandler extends EventEmitter {
         throw new Error('AI 客户端未配置');
       }
       const systemPrompt = framework.prompts.build();
-      const tools = this._getAITools(aiTool);
+      const tools = this._getToolMap();
 
       // DeepSeek thinking mode: 处理参数
       const apiOptions = { ...this.providerOptions };
@@ -930,46 +910,37 @@ class AgentChatHandler extends EventEmitter {
         delete apiOptions.temperature;
       }
 
-      const agent = new ToolLoopAgent({
-        model: this._aiClient,
-        instructions: systemPrompt,
+      const toolLoop = new ToolLoop({
         tools,
-        stopWhen: isLoopFinished(),
+        maxSteps: this._maxSteps || 20,
         prepareStep: this._createPrepareStep(),
-        experimental_repairToolCall: this._repairToolCall.bind(this),
+        repairToolCall: this._repairToolCall.bind(this),
+        abortSignal: framework.getAbortSignal?.(),
+        thinkingMode: this._thinkingMode,
       });
 
-      const result = await framework.runInSession(sessionId, {}, async () => {
-        return agent.generate({ messages, ...apiOptions, abortSignal: framework.getAbortSignal?.() });
+      const result = await toolLoop.generate({
+        messages,
+        systemPrompt,
+        model: this.model,
+        client: this._aiClient,
+        ...apiOptions,
       });
+      // result = { text, response: { messages }, steps, usage, reasoningText }
 
       if (result.usage && (result.usage.promptTokens > 0 || result.usage.completionTokens > 0)) {
         this._updateMessageStoreUsage(messageStore, result.usage);
       } else {
-        // fallback: 用 TokenCounter 估算
         const inputTokens = this._tokenCounter.countMessages(messages);
         const outputTokens = this._tokenCounter.countText(result.text || '');
         messageStore.usage = { promptTokens: inputTokens, completionTokens: outputTokens };
       }
 
-      // DeepSeek thinking mode: 处理 reasoning_content
-      const isThinking = this._thinkingMode;
-      if (isThinking && result.reasoningText) {
-        // 有 reasoning_text 需要添加到消息中（当有 tool_calls 时）
-        const finishMessages = result.response.messages;
-        for (const msg of finishMessages) {
-          if (msg.role === 'assistant') {
-            const hasToolCalls = msg.tool_calls?.length > 0 ||
-              (Array.isArray(msg.content) && msg.content.some(c => c.type === 'tool-call' || c.type === 'tool-use'));
-            if (hasToolCalls) {
-              msg.reasoning_content = result.reasoningText;
-            }
-          }
-        }
-      }
-
-      messages.push(...result.response.messages);
-      const userMsg = messages[messages.length - result.response.messages.length - 1];
+      // ToolLoop 已经直接在 messages 末尾添加了新消息，不需要再 push
+      // 计算 original 的 user message
+      const userMsg = result.text
+        ? messages.slice(-1)[0]
+        : messages[messages.length - 1];
       this.emit('message', { content: result.text, sessionId: sessionId, userMessage: userMsg });
 
       // ★ 修复：AI 调用成功后才持久化（之前 finally 总是 save，
@@ -1083,6 +1054,15 @@ class AgentChatHandler extends EventEmitter {
       logger.warn(`[_prepareSession] 去重 ${deduped} 个重复 tool-call ID`);
     }
 
+    // ★ 防御性 sanitize：确保所有 message 符合 AI SDK ModelMessage[] schema
+    // 修复/丢弃：content 类型错误、part 缺 type、tool-result.output 异常等
+    const sanitized = sanitizeForLLM(messages);
+    if (sanitized.fixed > 0 || sanitized.dropped > 0) {
+      logger.warn(`[_prepareSession] sanitize: fixed=${sanitized.fixed}, dropped=${sanitized.dropped}`);
+      messages.length = 0;
+      messages.push(...sanitized.messages);
+    }
+
     // 单次遍历完成所有验证 + 规范化（validateAll 内部处理 error-text/error-json）
     const validated = validateAll(messages);
     if (validated.length !== messages.length) {
@@ -1334,78 +1314,6 @@ class AgentChatHandler extends EventEmitter {
     return createHash('sha256').update(toolDescriptors).digest('hex').slice(0, 32);
   }
 
-  /**
-   * 获取 AI 工具格式（带缓存）
-   * 使用 AI SDK 的 tool() 格式
-   * @private
-   */
-  _getAITools(toolFn) {
-    const currentKey = this._computeToolsCacheKey();
-    if (this._aiToolsCache && this._aiToolsCacheKey === currentKey) {
-      return this._aiToolsCache;
-    }
-
-    const tools = {};
-    const allTools = this.agent.framework.getTools();
-    for (const toolDef of allTools) {
-      const toolName = toolDef.name;
-
-      // 使用 AI SDK 的 tool() 格式
-      const toolConfig = {
-        name: toolName,
-        description: toolDef.description || '',
-        execute: async (args) => {
-          // 清理参数并验证类型
-          const cleanedArgs = this._cleanToolArgs(args, toolDef.inputSchema);
-
-          // 执行工具
-          this.emit('tool-call', { name: toolName, args: cleanedArgs });
-          // logger.info(`[Tool] Call: ${toolName}`);
-          try {
-            const result = await toolDef.execute(cleanedArgs, this.agent.framework);
-
-            // 自动检测大工具结果，透明分拆
-            // 仅在数据分拆插件已加载时生效
-            let finalResult = result;
-            try {
-              const splitCheck = await autoSplitToolResult(toolName, result, this.agent.framework);
-              if (splitCheck.wasSplit && splitCheck.result) {
-                finalResult = splitCheck.result;
-                // logger.info(
-                //   `[AutoSplit] 工具 "${toolName}" 结果过大，已自动分拆处理`
-                // );
-              }
-            } catch (splitErr) {
-              // 分拆失败不阻断主流程，继续使用原始结果
-              logger.warn(`[AutoSplit] 自动分拆跳过: ${splitErr.message}`);
-            }
-
-            this.emit('tool-result', { name: toolName, args: cleanedArgs, result: finalResult });
-            return finalResult;
-          } catch (err) {
-            this.emit('tool-error', { name: toolName, args: cleanedArgs, error: err.message });
-            // 返回错误信息字符串，而不是抛出异常
-            return { success: false, error: err.message }
-          }
-        },
-      };
-
-      // 支持 inputSchema 或 parameters
-      if (toolDef.inputSchema) {
-        toolConfig.inputSchema = toolDef.inputSchema;
-      } else if (toolDef.parameters) {
-        toolConfig.parameters = toolDef.parameters;
-      }
-
-      // AI SDK 6.x 使用对象形式，键为工具名
-      tools[toolName] = toolFn(toolConfig);
-    }
-
-    this._aiToolsCache = tools;
-    this._aiToolsCacheKey = currentKey;
-    return tools;
-  }
-
   /**
    * 清理工具参数并根据 inputSchema 验证类型
    * @private
@@ -1423,6 +1331,14 @@ class AgentChatHandler extends EventEmitter {
       if (value === undefined || typeof value === 'function' || typeof value === 'symbol') {
         continue;
       }
+      // ★ 自动修复：LLM 有时把 JSON 对象参数序列化为字符串传进来
+      //   如 ext_call 的 args: "{id: ...}" → 自动 parse 为 {id: ...}
+      if (typeof value === 'string' && (value.startsWith('{') || value.startsWith('['))) {
+        try {
+          cleaned[key] = JSON.parse(value);
+          continue;
+        } catch { /* 不是 JSON，当普通字符串处理 */ }
+      }
       cleaned[key] = value;
     }
 
@@ -1460,10 +1376,23 @@ class AgentChatHandler extends EventEmitter {
           inputMessages.push(...trimmed);
         }
 
+        // ★ _buildApiMessages 现在会自动补 placeholder reasoning_content
+        //   (对于 thinking mode 下无 reasoning 的旧消息，补 '...')
+        //   所以不再需要 _stripStaleToolCalls 提前清理
+
         // 单次遍历完成：修复 invalid tool-call + 修复错误 text + 重映射历史 ID
         const repairedCount = this._repairInvalidToolCallsInMessages(inputMessages);
         this._repairAndPrefixHistoricalIds(inputMessages);
 
+        // ★ 防御性 sanitize：确保所有 message 符合 AI SDK ModelMessage[] schema
+        // 每次 LLM step 前都跑一次（messages 数组里可能有 AI SDK 上一步加进来的）
+        const sanitized = sanitizeForLLM(inputMessages);
+        if (sanitized.fixed > 0 || sanitized.dropped > 0) {
+          logger.warn(`[PrepareStep] sanitize: fixed=${sanitized.fixed}, dropped=${sanitized.dropped}`);
+          inputMessages.length = 0;
+          inputMessages.push(...sanitized.messages);
+        }
+
         // 单次遍历完成所有验证 + 规范化
         const validated = validateAll(inputMessages);
         if (validated.length !== inputMessages.length) {
@@ -1482,6 +1411,62 @@ class AgentChatHandler extends EventEmitter {
     };
   }
 
+  /**
+   * ★ 清理"过时"的 tool_call：移除缺 reasoning 的 assistant 消息中的 tool_calls
+   * 场景：旧 session（修复前保存）里的 assistant 消息只有 tool_call 没有 reasoning part
+   *       截断/压缩后这些消息被发给 DeepSeek，DeepSeek 报 "reasoning_content must be passed back"
+   * 处理：移除 tool_calls（tool result 会变 orphan，validateAll 清理掉）
+   *       保留消息的 text/reasoning 内容（如果有），LLM 仍能看到"我之前说了什么"
+   *
+   * @private
+   */
+  _stripStaleToolCalls(messages) {
+    if (!Array.isArray(messages)) return 0;
+    const isThinking = this._thinkingMode;
+    if (!isThinking) return 0;  // 非 thinking 模式不需要处理
+    let stripped = 0;
+    for (const msg of messages) {
+      if (msg.role !== 'assistant') continue;
+
+      // ★ 检查两种格式：
+      //   1. content array 里含 tool-call part（AI SDK 标准）
+      //   2. 顶层 tool_calls 字段（OpenAI 兼容格式，AI SDK 旧版本/未规范化）
+      const contentParts = Array.isArray(msg.content) ? msg.content : [];
+      const hasToolCallPart = contentParts.some(c => c && (c.type === 'tool-call' || c.type === 'tool-use'));
+      const hasTopLevelToolCalls = Array.isArray(msg.tool_calls) && msg.tool_calls.length > 0;
+      if (!hasToolCallPart && !hasTopLevelToolCalls) continue;
+
+      // ★ 找 reasoning：两种格式都可能
+      const hasReasoningPart = contentParts.some(c => c && c.type === 'reasoning' && c.text);
+      // 顶层 reasoning_content（旧 fix 留下的字段，已被 AI SDK 不识别）
+      const hasTopLevelReasoning = typeof msg.reasoning_content === 'string' && msg.reasoning_content.length > 0;
+      if (hasReasoningPart || hasTopLevelReasoning) continue;
+
+      // 缺 reasoning：清理
+      if (hasToolCallPart) {
+        msg.content = contentParts.filter(c => {
+          if (c && (c.type === 'tool-call' || c.type === 'tool-use')) {
+            stripped++;
+            return false;
+          }
+          return true;
+        });
+      }
+      if (hasTopLevelToolCalls) {
+        stripped += msg.tool_calls.length;
+        delete msg.tool_calls;
+      }
+      // 清理孤立的 reasoning_content（如果之前 fix 留下的）
+      if (hasTopLevelReasoning) {
+        delete msg.reasoning_content;
+      }
+    }
+    if (stripped > 0) {
+      logger.warn(`[_stripStaleToolCalls] removed ${stripped} stale tool-call(s) (no reasoning_content, would fail DeepSeek)`);
+    }
+    return stripped;
+  }
+
   /**
    * 压缩上下文（用于 prepareStep）
    * @private