autosnippet 2.18.0 → 2.19.0

package/lib/service/chat/ChatAgent.js

@@ -62,55 +62,6 @@ const DEFAULT_BUDGET = Object.freeze({
   idleRoundsToExit: IDLE_ROUNDS_TO_EXIT,
 });
 
-/**
- * 系统调用续跑提示 — 当 AI 输出纯文本计划而未执行工具调用时注入
- * 告诉 AI 不要只写文字描述,而要实际调用工具
- */
-const SYSTEM_CONTINUATION_PROMPT = `你的分析计划很好。但你需要 **实际执行工具调用** 来完成任务,而不是只写文字描述。
-
-请现在开始执行:
-1. 用 \`search_project_code\` 搜索项目代码获取真实示例
-2. 用 \`read_project_file\` 查看完整文件内容
-3. 对每个值得保留的信号,用 \`submit_knowledge\` 提交候选
-
-⚡ 推荐使用 batch_actions 一次提交多条候选:
-\`\`\`batch_actions
-[
-  {"tool": "submit_knowledge", "params": {"title": "[Bootstrap] xxx/子主题", "code": "# 标题 — 项目特写\\n\\n> 摘要...\\n\\n描述和代码交织...", "language": "objectivec", "category": "Service", "summary": "...", "tags": ["bootstrap"], "source": "bootstrap", "reasoning": {"whyStandard": "...", "sources": ["file1"], "confidence": 0.7}}},
-  {"tool": "submit_knowledge", "params": {"title": "...", "code": "...", ...}}
-]
-\`\`\`
-
-请立即开始执行,不要再输出分析文字。`;
-
-/**
- * 系统调用提交提示 — 当 AI 做了工具调用(search/read)、写了分析文本,但没调 submit_knowledge 时注入
- * 引导 AI 将已有分析转化为实际的 submit_knowledge 调用
- */
-const SYSTEM_SUBMIT_PROMPT = `你的分析很好，已经获取了足够的项目信息。但你还没有调用 \`submit_knowledge\` 提交任何候选。
-
-**你的分析不能只停留在文字描述层面** — 必须通过工具调用将分析结果持久化。
-
-请根据你刚才的分析,立即使用 batch_actions 提交候选:
-
-\`\`\`batch_actions
-[
-  {"tool": "submit_knowledge", "params": {
-    "title": "[Bootstrap] 维度/子主题",
-    "code": "# 标题 — 项目特写\\n\\n> 本项目使用 XX 模式, N 个文件采用此写法\\n\\n描述...\\n\\n\`\`\`objc\\n// 真实代码示例\\n\`\`\`\\n\\n要点说明...",
-    "language": "objectivec",
-    "category": "Tool",
-    "summary": "≤80字精准摘要,引用真实类名和数字",
-    "tags": ["bootstrap", "维度id"],
-    "source": "bootstrap",
-    "reasoning": {"whyStandard": "为什么值得保留", "sources": ["真实文件名"], "confidence": 0.7}
-  }},
-  {"tool": "submit_knowledge", "params": {...}}
-]
-\`\`\`
-
-将你上面分析出的每个有价值的发现都转化为一条 submit_knowledge 调用。code 字段写「项目特写」风格: 描述和代码交织,用项目真实类名和代码。`;
-
 export class ChatAgent {
   #toolRegistry;
   #aiProvider;
@@ -156,6 +107,9 @@ export class ChatAgent {
      */
     this.hasRealAI = !!aiProvider && aiProvider.name !== 'mock';
 
+    /** AI Provider 引用（只读）— 用于外部模块直接调用 structuredOutput / extractJSON */
+    this.aiProvider = aiProvider || null;
+
     // 初始化跨对话记忆 + 对话持久化
     try {
       const projectRoot = container?.singletons?._projectRoot || process.cwd();
@@ -243,27 +197,18 @@ export class ChatAgent {
     // 每次对话刷新项目概况（不是每轮 ReAct）
     this.#projectBriefingCache = await this.#buildProjectBriefing();
 
-    // ── 双模路由: 原生函数调用 vs 文本解析 ──
-    // 支持原生函数调用的 Provider (如 Gemini) 走结构化路径，
-    // 其他 Provider 走传统文本 ReAct 解析路径
+    // ── 统一原生函数调用路径（v5.0: 移除文本解析路径） ──
+    // 所有 Provider 均通过 chatWithTools() 进行结构化工具调用。
+    // 不支持原生函数调用的 Provider 在基类 chatWithTools() 中降级为 chat()，
+    // 返回 { text, functionCalls: null }，被 native 循环视为最终回答。
+    this.#logger.info(`[ChatAgent] ✨ using NATIVE tool calling mode (${this.#aiProvider.name})`);
     let result;
-    if (this.#aiProvider.supportsNativeToolCalling) {
-      this.#logger.info(`[ChatAgent] ✨ using NATIVE tool calling mode (${this.#aiProvider.name})`);
-      result = await this.#executeWithNativeTools(prompt, {
-        effectiveHistory, conversationId, source, execStartTime, budget, dimensionMeta,
-        // v3.0 新增
-        systemPromptOverride, allowedTools, disablePhaseRouter, temperatureOverride,
-        projectLanguage,
-        // v4.0: Agent Memory
-        workingMemory, episodicMemory, toolResultCache,
-      });
-    } else {
-      this.#logger.info(`[ChatAgent] 📝 using TEXT parsing mode (${this.#aiProvider.name})`);
-      result = await this.#executeWithTextParsing(prompt, {
-        effectiveHistory, conversationId, source, execStartTime,
-        dimensionMeta, projectLanguage,
-      });
-    }
+    result = await this.#executeWithNativeTools(prompt, {
+      effectiveHistory, conversationId, source, execStartTime, budget, dimensionMeta,
+      systemPromptOverride, allowedTools, disablePhaseRouter, temperatureOverride,
+      projectLanguage,
+      workingMemory, episodicMemory, toolResultCache,
+    });
 
     // 持久化 assistant 回复
     if (conversationId && this.#conversations) {
@@ -333,7 +278,11 @@ export class ChatAgent {
 
     // ── Layer 1: ContextWindow ──
     // messages[0] = prompt（不可压缩），历史消息在前面
-    const ctx = new ContextWindow(isSystem ? 24000 : 16000);
+    // token 预算按模型动态适配：大窗口模型(Gemini/Claude)给更多预算，小窗口(Ollama)限制预算
+    const tokenBudget = ContextWindow.resolveTokenBudget(
+      this.#aiProvider?.model, { isSystem },
+    );
+    const ctx = new ContextWindow(tokenBudget);
     for (const h of effectiveHistory) {
       if (h.role === 'assistant') {
         ctx.appendAssistantText(h.content);
@@ -568,7 +517,7 @@ export class ChatAgent {
         consecutiveAiErrors = 0;
 
         // ── ReasoningLayer Hook 2: afterAICall — 提取 Thought ──
-        reasoning.afterAICall(aiResult, 'native');
+        reasoning.afterAICall(aiResult);
       } catch (aiErr) {
         consecutiveAiErrors++;
         this.#logger.warn(`[ChatAgent] AI call failed (attempt ${consecutiveAiErrors}): ${aiErr.message}`);
@@ -1052,202 +1001,10 @@ ${submitSummary ? `已提交候选:\n${submitSummary}\n` : ''}
     return { reply: finalReply, toolCalls, hasContext: toolCalls.length > 0 };
   }
 
-  // ─── Text Parsing ReAct 循环 (legacy) ─────────────────
-
-  /**
-   * 文本解析 ReAct 循环 — 传统模式
-   * 适用于不支持原生函数调用的 Provider (DeepSeek, OpenAI 兼容等)
-   * AI 输出文本 → #parseActions() 正则解析 → 执行工具 → 循环
-   */
-  async #executeWithTextParsing(prompt, { effectiveHistory, conversationId, source, execStartTime, dimensionMeta, projectLanguage }) {
-    const toolSchemas = this.#toolRegistry.getToolSchemas();
-    const systemPrompt = this.#buildSystemPrompt(toolSchemas);
-
-    const messages = [
-      ...effectiveHistory,
-      { role: 'user', content: prompt },
-    ];
-
-    const toolCalls = [];
-    let iterations = 0;
-    let currentPrompt = prompt;
-    let consecutiveAiErrors = 0;
-    const maxIter = source === 'system' ? MAX_ITERATIONS_SYSTEM : MAX_ITERATIONS;
-
-    // ── ReasoningLayer (文本解析模式) ──
-    const reasoning = new ReasoningLayer({
-      enabled: true,
-      reflectionEnabled: false,   // 文本模式暂不启用反思（避免复杂度）
-    });
-
-    while (iterations < maxIter) {
-      iterations++;
-      const iterStartTime = Date.now();
-
-      // ── ReasoningLayer Hook 1: beforeAICall ──
-      reasoning.beforeAICall(iterations);
-
-      let response;
-      try {
-        this.#logger.info(`[ChatAgent] 🔄 text iteration ${iterations}/${maxIter} — calling AI (${messages.length} messages)`);
-        response = await this.#aiProvider.chat(currentPrompt, {
-          history: messages.slice(0, -1),
-          systemPrompt,
-        });
-        const aiDuration = Date.now() - iterStartTime;
-        const responsePreview = (response || '').substring(0, 120).replace(/\n/g, '↵');
-        this.#logger.info(`[ChatAgent] ✓ AI responded in ${aiDuration}ms (${(response || '').length} chars) — "${responsePreview}…"`);
-        consecutiveAiErrors = 0;
-
-        // ── ReasoningLayer Hook 2: afterAICall ──
-        reasoning.afterAICall(response, 'text');
-      } catch (aiErr) {
-        consecutiveAiErrors++;
-        this.#logger.warn(`[ChatAgent] AI call failed (attempt ${consecutiveAiErrors}): ${aiErr.message}`);
-
-        // 熔断器已打开 → 立即返回
-        if (aiErr.code === 'CIRCUIT_OPEN') {
-          reasoning.afterRound();
-          return {
-            reply: `抱歉，AI 服务暂时不可用（${aiErr.message}）。请稍后重试，或检查 API 配置。`,
-            toolCalls,
-            hasContext: toolCalls.length > 0,
-            reasoningTrace: reasoning.trace,
-            reasoningQuality: reasoning.getQualityMetrics(),
-          };
-        }
-
-        if (consecutiveAiErrors >= 2) {
-          reasoning.afterRound();
-          return {
-            reply: `抱歉，AI 服务暂时不可用（${aiErr.message}）。请稍后重试，或检查 API 配置。`,
-            toolCalls,
-            hasContext: toolCalls.length > 0,
-            reasoningTrace: reasoning.trace,
-            reasoningQuality: reasoning.getQualityMetrics(),
-          };
-        }
-        await new Promise(r => setTimeout(r, 2000));
-        continue;
-      }
-
-      const actions = this.#parseActions(response);
-
-      if (!actions) {
-        // ── 系统调用自动续跑 ──
-        const hasSubmits = toolCalls.some(tc => tc.tool === 'submit_knowledge' || tc.tool === 'submit_with_check');
-        if (source === 'system' && iterations < maxIter && !hasSubmits) {
-          if (this.#looksLikeIncompleteStep(response)) {
-            this.#logger.info(`[ChatAgent] 🔄 detected planning-only response at iteration ${iterations}, injecting continuation prompt`);
-            messages.push({ role: 'assistant', content: response });
-            currentPrompt = SYSTEM_CONTINUATION_PROMPT;
-            messages.push({ role: 'user', content: currentPrompt });
-            continue;
-          }
-          if (toolCalls.length > 0) {
-            this.#logger.info(`[ChatAgent] 🔄 detected analysis-without-submission at iteration ${iterations} (${toolCalls.length} tool calls, 0 submits), injecting submission prompt`);
-            messages.push({ role: 'assistant', content: response });
-            currentPrompt = SYSTEM_SUBMIT_PROMPT;
-            messages.push({ role: 'user', content: currentPrompt });
-            continue;
-          }
-        }
-
-        const reply = this.#cleanFinalAnswer(response);
-        const totalDuration = Date.now() - execStartTime;
-        reasoning.afterRound();
-        this.#logger.info(`[ChatAgent] ✅ text final answer — ${reply.length} chars, ${iterations} iterations, ${toolCalls.length} tool calls, ${totalDuration}ms total`);
-
-        return { reply, toolCalls, hasContext: toolCalls.length > 0, reasoningTrace: reasoning.trace, reasoningQuality: reasoning.getQualityMetrics() };
-      }
-
-      // 执行工具
-      const isBatch = actions.length > 1;
-      if (isBatch) {
-        this.#logger.info(`[ChatAgent] 📦 batch tool call: ${actions.length} actions [${actions.map(a => a.tool).join(', ')}]`, { iteration: iterations });
-      }
-
-      const batchResults = [];
-      for (const action of actions) {
-        this.#logger.info(`[ChatAgent] 🔧 tool call: ${action.tool}(${JSON.stringify(action.params).substring(0, 100)})`, {
-          iteration: iterations,
-          batch: isBatch,
-        });
-
-        let toolResult;
-        const toolStartTime = Date.now();
-        try {
-          toolResult = await this.#toolRegistry.execute(
-            action.tool,
-            action.params,
-            this.#getToolContext({ _sessionToolCalls: toolCalls, _dimensionMeta: dimensionMeta, _projectLanguage: projectLanguage }),
-          );
-          const toolDuration = Date.now() - toolStartTime;
-          const resultSize = typeof toolResult === 'string' ? toolResult.length : JSON.stringify(toolResult).length;
-          this.#logger.info(`[ChatAgent] 🔧 tool done: ${action.tool} → ${resultSize} chars in ${toolDuration}ms`);
-        } catch (toolErr) {
-          this.#logger.warn(`[ChatAgent] 🔧 tool FAILED: ${action.tool} — ${toolErr.message} (${Date.now() - toolStartTime}ms)`);
-          toolResult = `Error: tool "${action.tool}" failed — ${toolErr.message}. Try a different approach or provide your answer based on available information.`;
-        }
-
-        const summarized = this.#summarizeResult(toolResult);
-        toolCalls.push({
-          tool: action.tool,
-          params: action.params,
-          result: summarized,
-        });
-        batchResults.push({ tool: action.tool, result: toolResult });
-
-        // ── ReasoningLayer Hook 3: afterToolExec ──
-        reasoning.afterToolExec(action.tool, action.params, toolResult);
-      }
-
-      // ── ReasoningLayer Hook 4: afterRound ──
-      reasoning.afterRound({
-        totalCalls: actions.length,
-        submitCount: 0,
-      });
-
-      // 将工具结果注入为下一轮 prompt
-      let observation;
-      if (batchResults.length === 1) {
-        const r = batchResults[0];
-        const obsText = typeof r.result === 'string' ? r.result : JSON.stringify(r.result, null, 2);
-        observation = `Observation from tool "${r.tool}":\n${this.#truncate(obsText, 4000)}`;
-      } else {
-        observation = `Batch observation (${batchResults.length} tools):\n` +
-          batchResults.map((r, i) => {
-            const obsText = typeof r.result === 'string' ? r.result : JSON.stringify(r.result, null, 2);
-            return `[${i + 1}] ${r.tool}: ${this.#truncate(obsText, 2000)}`;
-          }).join('\n\n');
-      }
-
-      currentPrompt = `${observation}\n\nBased on the above observation, continue reasoning about the user's question: "${prompt}".\nIf you have enough information, provide your final answer directly (without Action block). Otherwise, call another tool.`;
-
-      messages.push({ role: 'assistant', content: response });
-      messages.push({ role: 'user', content: currentPrompt });
-
-      this.#condenseIfNeeded(messages);
-    }
-
-    // 达到最大迭代次数
-    const summaryPrompt = `You have used ${iterations} tool calls. Summarize what you found and answer the user's original question: "${prompt}"`;
-    let finalResponse;
-    try {
-      finalResponse = await this.#aiProvider.chat(summaryPrompt, {
-        history: messages,
-        systemPrompt: '直接回答用户问题，不要再调用工具。',
-      });
-    } catch (err) {
-      this.#logger.warn(`[ChatAgent] Final summary AI call failed: ${err.message}`);
-      finalResponse = `根据 ${toolCalls.length} 次工具调用的结果，以下是收集到的信息：\n\n` +
-        toolCalls.map(tc => `• ${tc.tool}: ${typeof tc.result === 'string' ? tc.result.substring(0, 200) : JSON.stringify(tc.result).substring(0, 200)}`).join('\n') +
-        '\n\n（注：AI 总结服务暂时不可用，上述为原始工具输出摘要）';
-    }
-
-    const finalReply = this.#cleanFinalAnswer(finalResponse);
-    return { reply: finalReply, toolCalls, hasContext: toolCalls.length > 0, reasoningTrace: reasoning.trace, reasoningQuality: reasoning.getQualityMetrics() };
-  }
+  // ─── Text Parsing 已移除 (v5.0) ────────────────────────
+  // 所有 Provider 统一走 chatWithTools() 原生函数调用路径。
+  // 不支持 native tool calling 的 Provider 在基类 chatWithTools()
+  // 中降级为 chat()，返回 { text, functionCalls: null }。
 
   /**
    * 程序化直接调用指定工具（跳过 ReAct 循环）
@@ -1580,8 +1337,9 @@ ${code.substring(0, 3000)}
 
 请用 JSON 数组格式返回建议: [{"violation": "...", "suggestion": "...", "fixExample": "..."}]`;
 
-        const raw = await this.#aiProvider.chat(prompt, { temperature: 0.3 });
-        suggestions = this.#aiProvider.extractJSON(raw, '[', ']') || [];
+        suggestions = await this.#aiProvider.chatWithStructuredOutput(prompt, {
+          openChar: '[', closeChar: ']', temperature: 0.3,
+        }) || [];
       } catch { /* AI suggestions optional */ }
     }
 
@@ -1623,100 +1381,7 @@ ${code.substring(0, 3000)}
     ]));
   }
 
-  // ─── ReAct 内部方法 ────────────────────────────────────
-
-  /**
-   * 构建系统提示词（含工具描述 + Skills 感知）
-   *
-   * 工具注入策略（Lazy Tool Schema — 类似 Cline .clinerules 按需加载）:
-   *   - 首屏只注入工具名 + 一行描述（compact list）
-   *   - 系统提示词中告知 LLM 可通过 get_tool_details 获取完整参数
-   *   - 少量核心工具（search_project_code, read_project_file, search_knowledge,
-   *     submit_with_check, analyze_code, bootstrap_knowledge, load_skill,
-   *     suggest_skills）直接展开完整 schema
-   *
-   * 效果: 44 个工具的 prompt 从 ~5000 tokens 降到 ~1500 tokens
-   */
-  #buildSystemPrompt(toolSchemas) {
-    // 核心工具 — 使用最频繁，直接展示完整 schema
-    const coreTools = new Set([
-      'search_project_code', 'read_project_file',
-      'search_knowledge', 'submit_knowledge', 'submit_with_check', 'analyze_code',
-      'bootstrap_knowledge', 'load_skill', 'suggest_skills',
-      'create_skill', 'knowledge_overview', 'get_tool_details',
-      'plan_task', 'review_my_output',
-    ]);
-
-    const compactDescriptions = [];
-    const detailedDescriptions = [];
-
-    for (const t of toolSchemas) {
-      if (coreTools.has(t.name)) {
-        const paramsDesc = Object.entries(t.parameters.properties || {})
-          .map(([k, v]) => `    - ${k} (${v.type}): ${v.description || ''}`)
-          .join('\n');
-        detailedDescriptions.push(`- **${t.name}**: ${t.description}\n  Parameters:\n${paramsDesc || '    (none)'}`);
-      } else {
-        compactDescriptions.push(`- ${t.name}: ${t.description}`);
-      }
-    }
-
-    const toolDescriptions = `### 核心工具（完整参数）\n\n${detailedDescriptions.join('\n\n')}\n\n### 其他工具（调用 get_tool_details 获取参数详情）\n\n${compactDescriptions.join('\n')}`;
-
-    // Skills 清单 — 让 LLM 知道有哪些领域知识可加载
-    const skillList = this.#listAvailableSkills();
-    const skillSection = skillList.length > 0
-      ? `\n## 可用 Skills\n通过 load_skill 工具按需加载领域知识文档，获取操作指南和最佳实践参考。\n\n| Skill | 说明 |\n|---|---|\n${skillList.map(s => `| ${s.name} | ${s.summary || '-'} |`).join('\n')}\n\n**场景 → Skill 推荐**：\n- 冷启动、初始化 → autosnippet-coldstart\n- 深度项目分析 → autosnippet-analysis\n- 候选生成 → autosnippet-candidates + autosnippet-create\n- 代码规范审计 → autosnippet-guard\n- Snippet 概念解释 → autosnippet-concepts\n- 生命周期管理 → autosnippet-lifecycle\n- Swift/ObjC/JS·TS 语言参考 → autosnippet-reference-{swift,objc,jsts}\n- 项目结构分析 → autosnippet-structure\n- 不确定该用哪个 → autosnippet-intent\n`
-      : '';
-
-    // SOUL — AI 人格注入（如果 SOUL.md 存在）
-    let soulSection = '';
-    try {
-      if (fs.existsSync(SOUL_PATH)) {
-        soulSection = '\n' + fs.readFileSync(SOUL_PATH, 'utf-8').trim() + '\n';
-      }
-    } catch { /* SOUL.md not available */ }
-
-    return `${soulSection}
-你是 AutoSnippet 项目的统一 AI 中心。项目内所有 AI 推理和分析都通过你执行。
-你拥有 ${toolSchemas.length} 个工具覆盖知识库管理全链路：搜索、提交、审核、质量评估、Guard 检查、知识图谱、冷启动等。
-${this.#projectBriefingCache}${this.#memory?.toPromptSection({ source: this.#currentSource === 'system' ? undefined : 'user' }) || ''}${this.#semanticMemory?.toPromptSection({ source: this.#currentSource === 'system' ? undefined : 'user' }) || ''}
-可用工具:
-
-${toolDescriptions}
-${skillSection}
-## 使用规则
-1. 当用户的问题需要查询数据时，使用工具获取信息后再回答。
-2. 调用工具时，使用以下格式（必须严格遵循）:
-
-\`\`\`action
-{"tool": "tool_name", "params": {"key": "value"}}
-\`\`\`
-
-3. 当需要连续调用多个**同类工具**（如批量提交候选）时，可使用批量格式:
-
-\`\`\`batch_actions
-[
-  {"tool": "submit_knowledge", "params": {"title": "...", "code": "..."}},
-  {"tool": "submit_knowledge", "params": {"title": "...", "code": "..."}}
-]
-\`\`\`
-
-4. 如果不需要工具就能回答，直接回答，不要输出 action 块。
-5. 回答时使用用户的语言（中文/英文）。
-6. 回答要简洁、有依据（引用工具返回的数据）。
-7. 当涉及以下领域问题时，**必须**先 load_skill 加载对应 Skill，再执行操作：
-   - 冷启动/初始化 → load_skill("autosnippet-coldstart")
-   - 深度分析/扫描 → load_skill("autosnippet-analysis")
-   - 候选创建/提交 → load_skill("autosnippet-candidates")
-   - 代码规范/Guard → load_skill("autosnippet-guard")
-   - 不确定做什么 → load_skill("autosnippet-intent")
-8. 你可以组合多个工具完成复杂任务（如：查重 → 提交 → 质量评分 → 知识图谱关联）。
-9. 当工具返回 _meta.confidence = "none" 时，告知用户无匹配并建议下一步，不要凭空编造。当 _meta.confidence = "low" 时，明确标注结果不确定性。
-10. 优先使用组合工具（analyze_code, knowledge_overview, submit_with_check）减少调用轮次。
-11. 当你发现用户在重复解释编码规范、操作约定或项目特有模式时，主动调用 suggest_skills 检查是否需要创建 Skill。如果有高优先级建议，向用户说明并在确认后调用 create_skill 创建。
-12. 当对话中出现值得长期记忆的信息（用户偏好、项目规范、关键决策、技术栈事实），在回复中嵌入记忆标签：\`[MEMORY:type] 内容 [/MEMORY]\`，type 可选 preference/decision/context。这些标签会被自动提取并持久化，不会显示给用户。`;
-  }
+  // ─── Native Tool Calling 内部方法 ──────────────────────
 
   /**
    * 构建原生函数调用模式的系统提示词
@@ -1785,245 +1450,6 @@ submit_knowledge 的 code 字段必须是「项目特写」— 将技术的基
 - 高效利用步数 (≤${budget.maxIterations} 轮)`;
   }
 
-  /**
-   * 从 LLM 响应中解析 Action 块（单条）
-   *
-   * 兼容多家 AI 服务商的工具调用格式：
-   *   1. ```action {"tool":"...", "params":{...}} ```          — 标准格式
-   *   2. ```tool_code tool_name(key="value") ```               — Gemini 常用
-   *   3. ```python / ```javascript 围栏内函数调用               — 各家偶发
-   *   4. Action: tool_name / Action Input: {...}                — ReAct (GPT/DeepSeek)
-   *   5. <tool_call>{"name":"...", "arguments":{...}}</tool_call>  — 训练遗留 XML
-   *   6. ```json {"name":"...", "arguments":{...}} ```          — GPT function_call 文本化
-   *   7. {"tool":"...", "params":{...}} 裸 JSON                — 通用降级
-   *   8. response 末尾裸函数调用 tool_name(key="value")         — 通用降级
-   */
-  #parseAction(response) {
-    if (!response) return null;
-
-    // ── 1. 标准 ```action {...} ``` ──
-    const blockMatch = response.match(/```action\s*\n?([\s\S]*?)```/);
-    if (blockMatch) {
-      const parsed = this.#tryParseToolJson(blockMatch[1].trim());
-      if (parsed) return parsed;
-    }
-
-    // ── 2. ```tool_code fn(k=v) ``` (Gemini 常用) ──
-    const toolCodeMatch = response.match(/```tool_code\s*\n?([\s\S]*?)```/);
-    if (toolCodeMatch) {
-      const parsed = this.#parseToolCodeBlock(toolCodeMatch[1].trim());
-      if (parsed) return parsed;
-    }
-
-    // ── 3. ```python / ```javascript / ```js 围栏内函数调用 ──
-    const langFenceMatch = response.match(/```(?:python|javascript|js|typescript|ts)\s*\n?([\s\S]*?)```/);
-    if (langFenceMatch) {
-      const inner = langFenceMatch[1].trim();
-      const parsed = this.#parseToolCodeBlock(inner);
-      if (parsed) return parsed;
-      // JS 对象字面量: tool_name({key: "value"})
-      const jsObjMatch = inner.match(/^(\w+)\(\s*(\{[\s\S]*\})\s*\)$/s);
-      if (jsObjMatch) {
-        const toolName = jsObjMatch[1];
-        if (this.#toolRegistry.has(toolName)) {
-          try {
-            let params;
-            try { params = JSON.parse(jsObjMatch[2]); } catch {
-              const normalized = jsObjMatch[2]
-                .replace(/,\s*([}\]])/g, '$1')
-                .replace(/'/g, '"')
-                .replace(/([{,]\s*)(\w+)\s*:/g, '$1"$2":');
-              params = JSON.parse(normalized);
-            }
-            return { tool: toolName, params };
-          } catch { /* parse failed */ }
-        }
-      }
-    }
-
-    // ── 4. ReAct: Action: tool_name\nAction Input: {...} (GPT/DeepSeek) ──
-    const reactMatch = response.match(/Action\s*:\s*(\w+)\s*\n+Action\s*Input\s*:\s*([\s\S]*?)(?:\n\s*(?:Thought|Observation|$))/i);
-    if (reactMatch) {
-      const toolName = reactMatch[1];
-      if (this.#toolRegistry.has(toolName)) {
-        try {
-          return { tool: toolName, params: JSON.parse(reactMatch[2].trim()) };
-        } catch {
-          const parsed = this.#parseToolCodeBlock(`${toolName}(${reactMatch[2].trim()})`);
-          if (parsed) return parsed;
-        }
-      }
-    }
-    // Action/Action Input 在末尾（无后续 Thought）
-    const reactEndMatch = response.match(/Action\s*:\s*(\w+)\s*\n+Action\s*Input\s*:\s*(\{[\s\S]*\})\s*$/i);
-    if (reactEndMatch) {
-      const toolName = reactEndMatch[1];
-      if (this.#toolRegistry.has(toolName)) {
-        try { return { tool: toolName, params: JSON.parse(reactEndMatch[2].trim()) }; } catch { /* ignore */ }
-      }
-    }
-
-    // ── 5. XML: <tool_call>...</tool_call> / <function_call>...</function_call> ──
-    const xmlMatch = response.match(/<tool_call>\s*([\s\S]*?)\s*<\/tool_call>/);
-    if (xmlMatch) {
-      const parsed = this.#tryParseToolJson(xmlMatch[1].trim());
-      if (parsed) return parsed;
-    }
-    const fcMatch = response.match(/<function_call>\s*([\s\S]*?)\s*<\/function_call>/);
-    if (fcMatch) {
-      const parsed = this.#tryParseToolJson(fcMatch[1].trim());
-      if (parsed) return parsed;
-    }
-
-    // ── 6. ```json {...} ``` 内的 function_call 格式 ──
-    const jsonFenceMatch = response.match(/```json\s*\n?([\s\S]*?)```/);
-    if (jsonFenceMatch) {
-      const parsed = this.#tryParseToolJson(jsonFenceMatch[1].trim());
-      if (parsed) return parsed;
-    }
-
-    // ── 7. 裸 JSON: {"tool":"..."} 或 {"name":"..."} ──
-    const jsonMatch = response.match(/\{\s*"(?:tool|name|function)"\s*:\s*"([^"]+)"[\s\S]*?\}/);
-    if (jsonMatch) {
-      const parsed = this.#tryParseToolJson(jsonMatch[0]);
-      if (parsed) return parsed;
-    }
-
-    // ── 8. 末尾裸函数调用: tool_name(key="value") ──
-    const trailingFnMatch = response.match(/\b(\w+)\(([^)]*)\)\s*$/);
-    if (trailingFnMatch) {
-      const parsed = this.#parseToolCodeBlock(`${trailingFnMatch[1]}(${trailingFnMatch[2]})`);
-      if (parsed) return parsed;
-    }
-
-    return null;
-  }
-
-  /**
-   * 尝试从 JSON 文本解析工具调用
-   * 兼容多种 key 命名:
-   *   - {"tool": "x", "params": {...}}         — 标准格式
-   *   - {"name": "x", "arguments": {...}}      — OpenAI function_call
-   *   - {"function": "x", "parameters": {...}} — 变体
-   *   - {"tool": "x", "input": {...}}          — Claude 变体
-   */
-  #tryParseToolJson(text) {
-    if (!text) return null;
-    try {
-      const obj = JSON.parse(text);
-      const toolName = obj.tool || obj.name || obj.function;
-      if (!toolName || !this.#toolRegistry.has(toolName)) return null;
-      const params = obj.params || obj.arguments || obj.parameters || obj.input || {};
-      return { tool: toolName, params };
-    } catch { return null; }
-  }
-
-  /**
-   * 解析 tool_code 函数调用格式
-   * 支持三种参数格式:
-   *   1. key=value:  search_project_code(query="xxx", language="objc")
-   *   2. JSON 对象:  read_project_file({"file_path": "Code/X.m"})
-   *   3. 单字符串:   read_project_file("Code/X.m")
-   */
-  #parseToolCodeBlock(text) {
-    if (!text) return null;
-    const fnMatch = text.match(/^(\w+)\((.*)\)$/s);
-    if (!fnMatch) return null;
-
-    const toolName = fnMatch[1];
-    if (!this.#toolRegistry.has(toolName)) return null;
-
-    const argsStr = fnMatch[2].trim();
-    if (!argsStr) return { tool: toolName, params: {} };
-
-    // 尝试 1: key=value 格式 (Python 风格)
-    const params = {};
-    const argRegex = /(\w+)\s*=\s*(?:"([^"]*)"|'([^']*)'|([^,\s]+))/g;
-    let m;
-    while ((m = argRegex.exec(argsStr)) !== null) {
-      params[m[1]] = m[2] ?? m[3] ?? m[4];
-    }
-    if (Object.keys(params).length > 0) return { tool: toolName, params };
-
-    // 尝试 2: JSON 对象参数 — read_project_file({"file_path": "..."})
-    if (argsStr.startsWith('{')) {
-      try {
-        const jsonParams = JSON.parse(argsStr);
-        if (typeof jsonParams === 'object' && jsonParams !== null) {
-          return { tool: toolName, params: jsonParams };
-        }
-      } catch { /* not valid JSON, fall through */ }
-    }
-
-    // 尝试 3: 单字符串参数 — read_project_file("Code/X.m") → 映射到首个 required 参数
-    const strMatch = argsStr.match(/^["'](.+?)["']$/);
-    if (strMatch) {
-      const toolDef = this.#toolRegistry.getToolSchemas().find(t => t.name === toolName);
-      const firstRequired = toolDef?.parameters?.required?.[0];
-      if (firstRequired) {
-        return { tool: toolName, params: { [firstRequired]: strMatch[1] } };
-      }
-    }
-
-    return { tool: toolName, params };
-  }
-
-  /**
-   * 从 LLM 响应中解析 Action 块（支持批量）
-   *
-   * 优先匹配:
-   *   ```batch_actions [...]```
-   * 降级匹配:
-   *   - 多个 <tool_call> XML 标签
-   *   - 多个 ReAct Action 块
-   *   - 单条 #parseAction()
-   *
-   * @returns {Array<{tool:string, params:object}>|null}
-   */
-  #parseActions(response) {
-    if (!response) return null;
-
-    // 1. 优先尝试 ```batch_actions``` 块
-    const batchMatch = response.match(/```batch_actions\s*\n?([\s\S]*?)```/);
-    if (batchMatch) {
-      try {
-        const arr = JSON.parse(batchMatch[1].trim());
-        if (Array.isArray(arr) && arr.length > 0) {
-          const valid = arr.filter(a => a.tool && this.#toolRegistry.has(a.tool));
-          if (valid.length > 0) {
-            return valid.map(a => ({ tool: a.tool, params: a.params || {} }));
-          }
-        }
-      } catch { /* batch parse failed, fall through */ }
-    }
-
-    // 2. 多个 <tool_call> XML 块 (DeepSeek/Qwen)
-    const xmlMatches = [...response.matchAll(/<tool_call>\s*([\s\S]*?)\s*<\/tool_call>/g)];
-    if (xmlMatches.length > 1) {
-      const results = xmlMatches
-        .map(m => this.#tryParseToolJson(m[1].trim()))
-        .filter(Boolean);
-      if (results.length > 0) return results;
-    }
-
-    // 3. 多个 ReAct Action 块
-    const reactMatches = [...response.matchAll(/Action\s*:\s*(\w+)\s*\n+Action\s*Input\s*:\s*(\{[\s\S]*?\})/gi)];
-    if (reactMatches.length > 1) {
-      const results = reactMatches
-        .map(m => {
-          const toolName = m[1];
-          if (!this.#toolRegistry.has(toolName)) return null;
-          try { return { tool: toolName, params: JSON.parse(m[2].trim()) }; } catch { return null; }
-        })
-        .filter(Boolean);
-      if (results.length > 0) return results;
-    }
-
-    // 4. 降级到单 action
-    const single = this.#parseAction(response);
-    return single ? [single] : null;
-  }
-
   /**
    * 清理最终回答（去除 Thought/preamble + MEMORY 标签）
    */
@@ -2036,42 +1462,6 @@ submit_knowledge 的 code 字段必须是「项目特写」— 将技术的基
       .trim();
   }
 
-  /**
-   * 检测 AI 回复是否为「未完成的中间步骤」— 输出分析/计划文本但未实际调用工具
-   *
-   * Gemini 常见行为: 收到 production prompt 后先输出一段纯文本的
-   * "执行计划" 或 "信号审视" 而不包含任何 action/tool_code block,
-   * 导致 #parseActions() 返回 null,被误判为 final answer。
-   *
-   * 检测策略: 回复包含计划/分析关键词 + 不包含 dimensionDigest JSON
-   */
-  #looksLikeIncompleteStep(response) {
-    if (!response || response.length < 100) return false;
-
-    // 如果已包含 dimensionDigest → 是真正的最终回答
-    if (response.includes('"dimensionDigest"') || response.includes('dimensionDigest')) return false;
-
-    // 计划/分析性关键词 (中文 Gemini 常用)
-    const planningPatterns = [
-      /制定执行计划/,
-      /信号质量预判/,
-      /执行计划/,
-      /我将按照/,
-      /开始分析/,
-      /我将分析/,
-      /接下来我将/,
-      /我来分析/,
-      /首先[，,]?\s*我/,
-      /\*\*0\.\s*制定/,
-      /\*\*Signal\s+\d+/,                     // 信号列表分析
-      /质量[：:]\s*(高|中|低)/,                // 信号质量评估
-      /保留[。；]|丢弃[。；]|跳过[。；]/,       // 信号去留判断
-    ];
-
-    const matchCount = planningPatterns.filter(p => p.test(response)).length;
-    return matchCount >= 2; // 至少匹配 2 个模式才认为是计划性回复
-  }
-
   /**
    * 获取工具执行上下文
    * @param {object} [extras] — 额外注入到上下文的字段（如 _sessionToolCalls）
@@ -2305,54 +1695,6 @@ submit_knowledge 的 code 字段必须是「项目特写」— 将技术的基
     }
   }
 
-  /**
-   * Context Window 自动压缩（受 Cline AutoCondense 启发）
-   *
-   * 在 ReAct 循环中实时检测消息总 token 数。
-   * 当超过 TOKEN_BUDGET 时，保留:
-   *   - 首条消息（可能是 system / 用户首问）
-   *   - 最后 4 条消息（当前推理上下文）
-   * 中间消息压缩为一条摘要。
-   *
-   * 策略: 非阻塞、纯规则（不调 AI），避免 ReAct 循环内引入额外 AI 调用。
-   */
-  #condenseIfNeeded(messages, tokenBudget = 10000) {
-    const estimateTokens = (text) => Math.ceil((text || '').length / 3.5);
-
-    let totalTokens = 0;
-    for (const m of messages) totalTokens += estimateTokens(m.content);
-
-    if (totalTokens <= tokenBudget || messages.length <= 6) return;
-
-    // 保留首条 + 最后 4 条，压缩中间
-    const keepTail = 4;
-    const first = messages[0];
-    const tail = messages.slice(-keepTail);
-    const middle = messages.slice(1, -keepTail);
-
-    if (middle.length === 0) return;
-
-    // 生成摘要
-    const toolCallSummary = middle
-      .filter(m => m.role === 'user' && m.content.startsWith('Observation from tool'))
-      .map(m => {
-        const toolMatch = m.content.match(/Observation from tool "([^"]+)"/);
-        return toolMatch ? toolMatch[1] : null;
-      })
-      .filter(Boolean);
-
-    const condensed = {
-      role: 'system',
-      content: `[上下文压缩] 省略了 ${middle.length} 条中间消息（含工具调用: ${toolCallSummary.join(', ') || '无'}）。请基于最近的 observation 继续推理。`,
-    };
-
-    // 原地修改数组
-    messages.length = 0;
-    messages.push(first, condensed, ...tail);
-
-    this.#logger.debug(`[ChatAgent] condensed ${middle.length} messages (${totalTokens} → ~${estimateTokens(first.content) + estimateTokens(condensed.content) + tail.reduce((s, m) => s + estimateTokens(m.content), 0)} tokens)`);
-  }
-
   /**
    * 截断长文本
    */