@huicai/cli 2026.711.0 → 2026.711.24616

package/src/agent.js

@@ -1,518 +1 @@
-// 客户端 Agent 循环：以平台 /v1 为模型后端，模型决定调哪个工具，工具在本机执行，结果回灌，直至无工具调用。
-// 核心机制：循环与工具都在客户端，平台只做模型推理与计费。
-//
-// 两种运行形态（按 config.model 自动判定）：
-//  - 原始模型：本机工具循环（内置文件/命令工具 + todo_write + memory_write + extraTools[MCP/子智能体]）；
-//  - 伪模型 agent-/workflow-/datahuman-：平台编排直连（不传 tools，纯流式多轮）——即智能体/数字人/工作流
-//    分享页的对话能力，CLI/扩展/REPL/TUI 全部可用。
-//
-// 关键机制：
-//  - 连续的只读工具调用并行执行（结果仍按原顺序回灌）；
-//  - 工具输出截断保头尾注入上下文；工具参数 JSON 解析失败时把错误回灌模型（而非静默空参数）；
-//  - 中断时为未执行的 tool_calls 合成占位结果（协议配对完整）；
-//  - pullQueued：用户回合中排队的消息在工具轮间隙/回合末注入；
-//  - 思考过程（reasoning）流式上抛（events.onReasoning / REPL 灰字），config.showReasoning=false 关闭；
-//  - 上下文压缩为**非破坏式**：摘要存 compaction 状态（随会话持久化），原消息/页面显示不受影响，
-//    仅发给模型时经 buildModelMessages 组装视图；
-//  - 文本化工具调用防泄漏（与平台侧同款）：模型把工具调用写成纯文本标记时（DeepSeek 系退化）
-//    过滤不显示、不进会话，并注入纠正指令重试（一次要求改走 tool_calls 通道，二次禁工具强制作答）。
-
-import fs from 'node:fs';
-import path from 'node:path';
-import { streamChat } from './api.js';
-import { MarkupFilter, stripMarkup } from './markup-filter.js';
-import { TOOL_SPECS, READONLY_TOOLS, runTool } from './tools.js';
-import { toolLabel, indent, renderFileDiff } from './render.js';
-import { compactIfNeeded, buildModelMessages } from './compaction.js';
-import { makeTodoTool, formatTodos, TODO_TOOL_NAME } from './todo.js';
-import { makeMemoryTool } from './memory.js';
-import { loadHooks, runHooks } from './hooks.js';
-import * as ide from './ide.js';
-import { c } from './colors.js';
-
-const DEFAULT_MAX_ITERS = 120; // 中大型项目需更多工具轮（读多文件/多次检索/多处编辑）；仍可 config.maxTurns 或 --max-turns 覆盖
-const TOOL_CONCURRENCY = 8;     // 并行只读工具的并发上限：大仓库里模型一次触发大量 grep/glob 时限并发，降争用、提稳定与总吞吐
-const MAX_TOOL_RESULT_CHARS = 20_000;
-const CAP_HEAD = 16_000;
-const CAP_TAIL = 3_000;
-
-// 「文本化工具调用」被拦截后的纠正指令：与平台侧 ToolCallingOrchestrator 同款两级策略。
-// 第一次：要求改走规范 tool_calls 通道重试；第二次：禁用工具、强制直接作答（保证用户拿到干净答复）。
-const MARKUP_RETRY_PROMPT =
-  '你刚才的输出把工具调用写成了文本标记，工具并未被执行，该内容也不会展示给用户。'
-  + '请重新处理：若需调用工具，必须使用规范的函数调用（tool_calls）通道发起，'
-  + '绝不要以任何文本形式书写工具调用标记；若无需工具，请直接用中文输出面向用户的最终答复。';
-const MARKUP_FORCE_ANSWER_PROMPT =
-  '请停止调用任何工具。基于目前已获得的全部信息，直接用中文输出面向用户的完整最终答复，'
-  + '不要输出任何工具调用或协议标记。';
-// 预算收敛：临近工具轮数上限时注入，禁用工具并要求直接作答，保证中大型项目里到达上限也能给出干净的最终答复（而非被硬截断）。
-const BUDGET_FINAL_PROMPT =
-  '已接近本回合的工具调用轮数上限。请不要再调用任何工具，基于目前已获得的信息，直接用中文输出面向用户的完整最终答复。';
-// 自我纠错：短时间内多次工具失败时注入，打破「反复用同样会失败的调用」的死循环。
-const SELF_CORRECT_NOTE =
-  '你刚才连续多次工具调用失败。请停下来重新审视：是不是文件路径/内容/前提假设错了？'
-  + '先用 read_file / grep / list_files 核实现状，再换一种更可靠的方法，绝不要重复同样会失败的调用。';
-// 判断一条工具结果是否为「失败」（用于自我纠错计数）。
-function looksLikeToolFailure(result) {
-  const s = String(result);
-  return s.startsWith('工具执行失败') || s.startsWith('命令启动失败')
-    || s.includes('不是合法 JSON') || s.includes('未找到要替换的内容')
-    || s.includes('路径超出项目目录') || s.includes('是目录而非文件');
-}
-// 计划模式（/plan 开启）：每轮追加到系统提示词末尾，令模型只读调研并产出方案，写/执行由权限层拦截。
-const PLAN_MODE_NOTE =
-  '\n\n# 计划模式（当前开启）\n'
-  + '你现在处于计划模式：只能用只读工具（read_file/glob/grep/list_files/fetch_url）调研，'
-  + '不得做任何改动——write_file/edit_file/run_bash 等写或执行操作都会被拒绝，不要反复尝试。'
-  + '请先充分理解需求与现状，然后产出一份清晰、分步的实施方案：涉及哪些文件、每步改动要点、如何验证、风险点，'
-  + '用 todo_write 列出步骤，随后停下等待用户确认。用户关闭计划模式后你再执行。';
-// 沙箱模式（/sandbox 开启）：禁 shell 与联网。
-const SANDBOX_MODE_NOTE =
-  '\n\n# 沙箱模式（当前开启）\n禁止执行 shell 命令（run_bash）与联网（fetch_url），调用会被拒绝，不要反复尝试。只做本地文件读写与分析。';
-
-/** /goal 设定的目标：每轮追加到系统提示词末尾，令模型停止前自检是否达成。 */
-function goalNote(goal) {
-  return '\n\n# 当前目标（用户设定）\n' + String(goal).trim()
-    + '\n在本回合结束、停止作答前，检查该目标是否已达成：若未达成，应继续推进（补充调研/改动/验证），不要过早停止；达成后用一句话说明已达成。';
-}
-
-/** 从消息 content（字符串或多模态数组）提取纯文本，用于钩子上下文。 */
-function contentText(content) {
-  if (typeof content === 'string') return content;
-  if (Array.isArray(content)) return content.filter((p) => p?.type === 'text').map((p) => p.text || '').join('\n');
-  return '';
-}
-
-/** 有序的有限并发 map：并发不超过 limit，结果按输入下标回填（与 Promise.all 相同的顺序语义，但并发受限）。 */
-async function mapLimit(items, limit, fn) {
-  const results = new Array(items.length);
-  let next = 0;
-  const worker = async () => {
-    while (next < items.length) {
-      const i = next++;
-      results[i] = await fn(items[i], i);
-    }
-  };
-  await Promise.all(Array.from({ length: Math.max(1, Math.min(limit, items.length)) }, worker));
-  return results;
-}
-
-/** 伪模型（平台编排）判定：agent-/workflow-/datahuman- 前缀。 */
-export function isPlatformModel(model) {
-  return /^(agent|workflow|datahuman)-/.test(String(model || ''));
-}
-
-function shortLine(s, max = 200) {
-  const first = String(s).split('\n')[0];
-  return first.length > max ? first.slice(0, max) + '…' : first;
-}
-
-/** 工具输出超长时截断（保头尾），防止单条结果撑爆上下文。 */
-export function capToolResult(text) {
-  const s = String(text);
-  if (s.length <= MAX_TOOL_RESULT_CHARS) return s;
-  const omitted = s.length - CAP_HEAD - CAP_TAIL;
-  return s.slice(0, CAP_HEAD) + `\n…【工具输出过长，中间已省略 ${omitted} 字符】…\n` + s.slice(-CAP_TAIL);
-}
-
-/**
- * 跑一个用户回合：mutate messages（追加 assistant/tool 消息），流式打印正文与工具进展。
- *
- * @param {object} p
- * @param {{spec:object,run:Function,readOnly:boolean}[]} [p.extraTools] 动态外部工具（MCP / 子智能体）
- * @param {number} [p.depth] 子智能体递归深度（0=顶层；todo/memory 仅顶层提供）
- * @param {{write:(s:string)=>void}} [p.io] 输出通道（子智能体传静默通道）
- * @param {object} [p.events] 结构化事件：onDelta/onReasoning/onAssistantText/onToolStart/onToolResult/onFileDiff/onSkip/onInfo/onTodo/onMemory/onTurnEnd
- * @param {{list:any[]}} [p.todoState] 任务清单状态（调用方持有可跨轮保留）
- * @param {{upTo?:number, summary?:string}} [p.compaction] 压缩状态（随会话持久化；原消息不被修改）
- * @param {() => (string|null)} [p.pullQueued] 取一条用户排队消息（无则 null）
- * @param {number} [p.maxIters] 本回合最大工具轮数（默认 config.maxTurns 或 60）
- * @returns {Promise<{aborted?:boolean, error?:string, usage:{prompt:number,completion:number}, lastPromptTokens:number}>}
- */
-export async function runTurn({
-  config, messages, permissions, cwd, ask, signal,
-  extraTools = [], depth = 0, io, events, todoState, compaction, pullQueued, maxIters, fileJournal,
-}) {
-  const out = (io && io.write) || ((s) => process.stdout.write(s));
-  const ev = events || null; // 结构化事件（ink TUI / 扩展用）；为空则走 out() 字符串输出（普通 REPL）
-  const info = (t) => {
-    if (ev) ev.onInfo?.(t);
-    else out(c.gray('  · ' + t) + '\n');
-  };
-  let prompt = 0;
-  let completion = 0;
-  let lastPromptTokens = 0;
-  const iterMax = Number(maxIters || config.maxTurns) || DEFAULT_MAX_ITERS;
-  const platformMode = isPlatformModel(config.model);
-
-  // 按任务自动选模型：非伪模型 + 配置了 strong 模型 + 本回合看起来复杂（长提示/难点关键词/计划模式）→ 升配
-  let effectiveModel = config.model;
-  if (depth === 0 && config.autoModelStrong && !platformMode) {
-    const lastUser = [...messages].reverse().find((m) => m.role === 'user');
-    const t = contentText(lastUser?.content);
-    const hard = config.planMode || t.length > 400
-      || /重构|架构|设计|复杂|排查|调试|debug|优化|性能|并发|死锁|重写|迁移|安全审查|根因/i.test(t);
-    if (hard && config.autoModelStrong !== config.model) {
-      effectiveModel = config.autoModelStrong;
-      if (config.debug) info(`[automodel] 复杂回合升配 → ${effectiveModel}`);
-    }
-  }
-  const compState = compaction || {}; // 未传则本回合内独立生效（不持久化）
-
-  // 顶层注入 todo_write / memory_write（平台编排模式无本机工具，均不注入）
-  const dynamicTools = [...extraTools];
-  if (depth === 0 && !platformMode && !dynamicTools.some((t) => t.spec?.function?.name === TODO_TOOL_NAME)) {
-    const state = todoState || { list: [] };
-    dynamicTools.push(
-      makeTodoTool({
-        state,
-        emit: (list) => {
-          if (ev) {
-            if (ev.onTodo) ev.onTodo(list.map((t) => ({ ...t })));
-            else ev.onInfo?.('任务清单：\n' + formatTodos(list));
-          } else {
-            out(c.gray(indent(formatTodos(list), '  ')) + '\n');
-          }
-        },
-      }),
-    );
-  }
-  if (depth === 0 && !platformMode && config.memoryEnabled !== false
-    && !dynamicTools.some((t) => t.spec?.function?.name === 'memory_write')) {
-    dynamicTools.push(
-      makeMemoryTool({
-        cwd,
-        emit: (t) => {
-          if (ev) {
-            if (ev.onMemory) ev.onMemory(t);
-            else ev.onInfo?.('已记入长期记忆：' + shortLine(t, 80));
-          } else {
-            out(c.gray('  ✎ 已记入长期记忆：' + shortLine(t, 80)) + '\n');
-          }
-        },
-      }),
-    );
-  }
-
-  const extraByName = new Map();
-  for (const t of dynamicTools) extraByName.set(t.spec.function.name, t);
-  const specs = platformMode ? undefined : [...TOOL_SPECS, ...dynamicTools.map((t) => t.spec)];
-
-  let markupRetries = 0; // 「文本化工具调用」纠正次数（首次要求改走 tool_calls 通道，二次禁工具收敛）
-  let toolsDisabled = false;
-  let toolFailures = 0; // 工具失败计数（自我纠错：累计≥3 注入一次「换策略」提示）
-  let correction = null; // 待注入的纠正指令：仅随本轮请求发给模型，不进会话记录（与平台侧临时 convo 等价）
-
-  // 工具事件钩子：仅顶层原始模型加载（平台伪模型由服务端编排，无本机工具）
-  const hooks = (depth === 0 && !platformMode) ? loadHooks(cwd) : null;
-  const hooksActive = !!(hooks && hooks.all.length);
-
-  // SessionStart（会话首个用户回合触发一次）+ UserPromptSubmit 钩子：可阻断，或注入附加上下文
-  if (hooksActive) {
-    const parts = [];
-    if (messages.filter((m) => m.role === 'user').length <= 1) {
-      const ss = runHooks('SessionStart', { cwd }, hooks);
-      if (ss.injectContext) parts.push(ss.injectContext);
-      for (const o of ss.outputs) parts.push(o.stdout);
-    }
-    const lastUser = [...messages].reverse().find((m) => m.role === 'user');
-    const r = runHooks('UserPromptSubmit', { cwd, prompt: contentText(lastUser?.content) }, hooks);
-    if (r.block) {
-      info('提交被 UserPromptSubmit 钩子阻断：' + r.reason);
-      return { error: '提交被钩子阻断：' + r.reason, usage: { prompt, completion }, lastPromptTokens };
-    }
-    if (r.injectContext) parts.push(r.injectContext);
-    for (const o of r.outputs) parts.push(o.stdout);
-    if (parts.length) correction = '【钩子提供的附加上下文】\n' + parts.join('\n');
-  }
-
-  for (let iter = 0; iter < iterMax; iter++) {
-    // 预算收敛：最后一轮禁用工具并提示直接作答，保证中大型项目里到达上限也能给出干净的最终答复（而非被硬截断）
-    const lastIter = iter === iterMax - 1;
-    if (lastIter && !platformMode && !toolsDisabled && !correction) correction = BUDGET_FINAL_PROMPT;
-    // 非破坏式上下文压缩：仅更新 compState（摘要独立存储），messages/页面内容不动
-    const compacted = await compactIfNeeded(messages, config, { state: compState, lastPromptTokens });
-    if (compacted > 0) info(`已压缩上下文（${compacted} 条较早消息已摘要，页面与会话记录不受影响）`);
-
-    let streamedAny = false;
-    let streamedReason = false;
-    const mf = new MarkupFilter(); // 文本化工具标记防泄漏：每轮模型输出独立实例
-    const emitDelta = (t) => {
-      if (!t) return;
-      if (!streamedAny && streamedReason && !ev) out('\n'); // 思考→正文换行
-      streamedAny = true;
-      if (ev) ev.onDelta?.(t);
-      else out(t);
-    };
-    const modelMessages = buildModelMessages(messages, compState);
-    // 会话级临时指令（计划模式 / 目标）追加到系统提示词末尾（构造新数组，绝不改动原 messages/会话）
-    let requestMessages = modelMessages;
-    if (!platformMode && modelMessages.length && modelMessages[0]?.role === 'system') {
-      let extra = '';
-      if (config.planMode) extra += PLAN_MODE_NOTE;
-      if (config.sandbox) extra += SANDBOX_MODE_NOTE;
-      if (config.goal && String(config.goal).trim()) extra += goalNote(config.goal);
-      if (extra) {
-        requestMessages = [
-          { ...modelMessages[0], content: String(modelMessages[0].content || '') + extra },
-          ...modelMessages.slice(1),
-        ];
-      }
-    }
-    const reqStart = Date.now();
-    let res;
-    try {
-      res = await streamChat(
-        {
-          baseUrl: config.baseUrl,
-          apiKey: config.apiKey,
-          model: effectiveModel,
-          messages: correction ? [...requestMessages, { role: 'user', content: correction }] : requestMessages,
-          tools: (toolsDisabled || lastIter) ? undefined : specs,
-          reasoningEffort: config.reasoningEffort, // 推理强度透传（/effort；模型不支持则忽略）
-          // 对话落库审计：来源与会话号（由 config 透传；扩展侧为 vscode）
-          client: config.client,
-          sessionId: config.sessionId,
-        },
-        {
-          onContent: (t) => emitDelta(mf.feed(t)),
-          onReasoning: (t) => {
-            if (config.showReasoning === false) return;
-            if (ev) {
-              ev.onReasoning?.(t);
-            } else {
-              if (!streamedReason) out(c.gray('\n[思考] '));
-              out(c.gray(t));
-            }
-            streamedReason = true;
-          },
-          onRetry: (n, waitMs, reason) => info(`模型响应异常，${Math.round(waitMs / 1000)}s 后自动重试（第 ${n} 次）：${reason}`),
-        },
-        signal,
-      );
-    } catch (e) {
-      if (e.name === 'AbortError') {
-        if (ev) ev.onInfo?.('已中断');
-        else out(c.gray('\n[已中断]\n'));
-        return { aborted: true, usage: { prompt, completion }, lastPromptTokens };
-      }
-      if (ev) ev.onInfo?.('✗ 模型调用失败：' + e.message);
-      else out('\n' + c.red('✗ 模型调用失败：') + e.message + '\n');
-      return { error: e.message, usage: { prompt, completion }, lastPromptTokens };
-    }
-    emitDelta(mf.flush()); // 放行轮末仍持有的未确认内容（吞噬中则丢弃）
-
-    if (res.usage) {
-      prompt += res.usage.prompt_tokens || 0;
-      completion += res.usage.completion_tokens || 0;
-      lastPromptTokens = res.usage.prompt_tokens || lastPromptTokens;
-    }
-    if (config.debug) {
-      info(`[debug] 轮${iter + 1} · ${config.model} · in ${res.usage?.prompt_tokens || 0} / out ${res.usage?.completion_tokens || 0} tok`
-        + ` · ${Date.now() - reqStart}ms · ${(res.toolCalls || []).length} 工具调用`);
-    }
-
-    // 全量内容按同一状态机二次清洗（与流式放行结果一致）：协议标记绝不进入会话记录与后续上下文
-    const { text: cleanText, sawMarkup: sawInFull } = stripMarkup(res.content);
-    const markupRound = sawInFull || mf.sawMarkup;
-    correction = null; // 上一轮注入的纠正指令已被消费
-
-    const toolCalls = platformMode ? [] : res.toolCalls;
-    if (!toolCalls.length) {
-      // 「文本化工具调用」拦截后的纠正：本轮"正文"实为协议标记（已被过滤，未显示，工具也未执行）。
-      // 平台编排模式（伪模型）由服务端过滤与纠正，客户端不再重试。
-      if (markupRound && !cleanText.trim() && !platformMode) {
-        if (markupRetries < 2) {
-          markupRetries++;
-          if (markupRetries === 2) toolsDisabled = true;
-          correction = markupRetries === 1 ? MARKUP_RETRY_PROMPT : MARKUP_FORCE_ANSWER_PROMPT;
-          info(`已拦截模型的文本化工具调用标记（工具未被执行），纠正重试中（第 ${markupRetries} 次）`);
-          continue;
-        }
-        info('模型持续输出无效的工具调用标记，已全部拦截；本轮无有效答复（可换个说法重试或更换模型）');
-      }
-      if (streamedAny && !ev) out('\n');
-      // 记录最终答复进上下文，使后续用户回合能看到助手上一次回复（多轮对话记忆）
-      if (cleanText) messages.push({ role: 'assistant', content: cleanText });
-      if (ev) ev.onTurnEnd?.(cleanText);
-      // 用户在回合中排队了新消息 → 直接续跑，无需重新发起回合
-      const queued = pullQueued?.();
-      if (queued) {
-        messages.push({ role: 'user', content: queued });
-        continue;
-      }
-      // Stop 钩子：回合结束触发（不阻断，仅采集输出，如收尾自检/通知）
-      if (hooksActive) {
-        const st = runHooks('Stop', { cwd, result: cleanText }, hooks);
-        for (const o of st.outputs) info('钩子·Stop：' + shortLine(o.stdout, 160));
-      }
-      return { usage: { prompt, completion }, lastPromptTokens };
-    }
-
-    if (streamedAny && !ev) out('\n');
-    if (ev && cleanText) ev.onAssistantText?.(cleanText); // 工具轮前的正文先落定
-    messages.push({ role: 'assistant', content: cleanText, tool_calls: toolCalls });
-
-    // 预解析全部调用（名称/参数/只读性）；参数 JSON 解析失败记录错误（回灌模型重试，而非静默空参数）
-    const parsed = toolCalls.map((tc, idx) => {
-      const name = tc.function?.name || '';
-      let args = {};
-      let argsError = null;
-      const raw = tc.function?.arguments || '';
-      if (raw) {
-        try {
-          args = JSON.parse(raw);
-        } catch (e) {
-          argsError = `工具参数不是合法 JSON（${e.message}）：${String(raw).slice(0, 200)}…请修正参数后重新调用。`;
-        }
-      }
-      const extra = extraByName.get(name);
-      // IDE 集成下，write_file/edit_file 的批准发生在编辑器的内联 diff 审阅里，跳过 CLI 自身的 y/n（避免双重确认）
-      const deferToIde = ide.isActive() && (name === 'write_file' || name === 'edit_file');
-      const readOnly = extra ? !!extra.readOnly : READONLY_TOOLS.has(name);
-      return { tc, idx, name, args, argsError, extra, readOnly, deferToIde };
-    });
-
-    // 中断时为剩余未执行的 tool_calls 合成占位结果，保证 assistant.tool_calls 配对完整（协议要求）
-    const abortRest = (from) => {
-      for (let k = from; k < parsed.length; k++) {
-        messages.push({ role: 'tool', tool_call_id: parsed[k].tc.id || `call_${k}`, content: '（用户中断，该工具未执行）' });
-      }
-      if (ev) ev.onInfo?.('已中断');
-      else out(c.gray('\n[已中断]\n'));
-      return { aborted: true, usage: { prompt, completion }, lastPromptTokens };
-    };
-
-    const execOne = async (item) => {
-      if (item.argsError) return item.argsError;
-      let result;
-      try {
-        result = item.extra ? await item.extra.run(item.args) : await runTool(item.name, item.args, cwd, config);
-      } catch (e) {
-        result = `工具执行失败：${e.message}`;
-      }
-      return capToolResult(String(result));
-    };
-    const emitStart = (item) => {
-      if (ev) ev.onToolStart?.(item.name, item.args);
-      else out(c.cyan('  ⏺ ') + toolLabel(item.name, item.args) + '\n');
-    };
-    const emitResult = (item, result) => {
-      if (looksLikeToolFailure(result)) toolFailures++;
-      if (ev) ev.onToolResult?.(item.name, String(result));
-      else out(c.gray('     ' + shortLine(result)) + '\n');
-      messages.push({ role: 'tool', tool_call_id: item.tc.id, content: String(result) });
-    };
-    const emitSkip = (item, reason) => {
-      if (ev) ev.onSkip?.(item.name, item.args);
-      else out(c.gray(`  ⊘ ${toolLabel(item.name, item.args)} — 已跳过\n`));
-      messages.push({ role: 'tool', tool_call_id: item.tc.id, content: reason || '未授权，未执行。' });
-    };
-    // 写文件类工具（edit_file/write_file）成功后向 UI 展示「更改的行」（display-only，不进模型上下文）。
-    // 以「执行前后文件内容对比」判定：未改动/失败/被拒 → before==after → 空 diff，天然不显示。
-    const isFileWrite = (name) => name === 'edit_file' || name === 'write_file';
-    const readSafe = (abs) => { try { return fs.readFileSync(abs, 'utf8'); } catch { return ''; } };
-    const emitFileDiff = (item, before) => {
-      const abs = path.resolve(cwd, String(item.args.path));
-      const diff = renderFileDiff(before, readSafe(abs), { path: String(item.args.path) });
-      if (!diff) return;
-      if (ev) ev.onFileDiff?.(diff);
-      else out(diff + '\n');
-    };
-
-    let i = 0;
-    while (i < parsed.length) {
-      if (signal?.aborted) return abortRest(i);
-      const cur = parsed[i];
-
-      // 参数损坏：不请求授权、不执行，直接把解析错误回灌（模型可修正后重试）
-      if (cur.argsError) {
-        emitStart(cur);
-        emitResult(cur, cur.argsError);
-        i++;
-        continue;
-      }
-
-      if (cur.readOnly) {
-        // 连续只读段：并行执行（权限对只读即时放行），结果按原顺序回灌
-        let j = i;
-        while (j < parsed.length && parsed[j].readOnly && !parsed[j].argsError) j++;
-        const batch = parsed.slice(i, j);
-        // 只读段并行执行，但并发受限（大仓库里模型可能一次触发很多 grep/glob，无限并发会抢占磁盘/CPU 反而更慢）；结果仍按原顺序回灌
-        const settled = await mapLimit(batch, TOOL_CONCURRENCY, async (item) => {
-          const perm = await permissions.request(item.name, item.args, cwd, true);
-          if (!perm.allow) return { item, denied: perm.reason || '未授权，未执行。' };
-          emitStart(item);
-          return { item, result: await execOne(item) };
-        });
-        for (const s of settled) {
-          if (s.denied != null) emitSkip(s.item, s.denied);
-          else emitResult(s.item, s.result);
-        }
-        i = j;
-        if (signal?.aborted) return abortRest(i);
-        continue;
-      }
-
-      // 写/执行类：顺序执行，逐个审批
-      const perm = await permissions.request(cur.name, cur.args, cwd, cur.readOnly || cur.deferToIde);
-      if (signal?.aborted) return abortRest(i);
-      if (!perm.allow) {
-        emitSkip(cur, perm.reason);
-        i++;
-        continue;
-      }
-      // PreToolUse 钩子：可阻断该工具（非零退出码），阻断原因回灌模型
-      if (hooksActive) {
-        const pre = runHooks('PreToolUse', { cwd, toolName: cur.name, args: cur.args }, hooks);
-        for (const o of pre.outputs) info('钩子·PreToolUse：' + shortLine(o.stdout, 120));
-        if (pre.block) {
-          emitSkip(cur, 'PreToolUse 钩子阻断：' + pre.reason);
-          i++;
-          continue;
-        }
-        if (pre.modifiedArgs) {
-          cur.args = { ...cur.args, ...pre.modifiedArgs }; // 结构化钩子改写工具参数
-          info('钩子·PreToolUse 已修改工具参数');
-        }
-      }
-      emitStart(cur);
-      // 检查点文件日志：写入前记录原文与是否已存在（供 /rewind 回滚；过大文件仅标记不存原文）
-      const before = isFileWrite(cur.name) && cur.args?.path
-        ? readSafe(path.resolve(cwd, String(cur.args.path)))
-        : null;
-      if (fileJournal && before != null && cur.args?.path) {
-        const existed = fs.existsSync(path.resolve(cwd, String(cur.args.path)));
-        fileJournal.push(before.length > 2 * 1024 * 1024
-          ? { path: String(cur.args.path), tooLarge: true }
-          : { path: String(cur.args.path), before, existed });
-      }
-      let result = await execOne(cur);
-      // PostToolUse 钩子：不阻断，输出附加到工具结果（模型可见，如格式化/测试结果）
-      if (hooksActive) {
-        const post = runHooks('PostToolUse', { cwd, toolName: cur.name, args: cur.args, result: String(result) }, hooks);
-        if (post.outputs.length) {
-          for (const o of post.outputs) info('钩子·PostToolUse：' + shortLine(o.stdout, 120));
-          result = String(result) + '\n\n[PostToolUse 钩子输出]\n' + post.outputs.map((o) => o.stdout).join('\n');
-        }
-      }
-      emitResult(cur, result);
-      if (before != null) emitFileDiff(cur, before);
-      i++;
-    }
-
-    // 自我纠错：本回合累计工具失败达阈值，注入一次「换策略」提示（打破反复失败的死循环）
-    if (toolFailures >= 3 && !toolsDisabled && !correction) {
-      correction = SELF_CORRECT_NOTE;
-      toolFailures = 0;
-      info('检测到连续工具失败，已提示智能体换一种更可靠的方法');
-    }
-    // 工具轮之间注入用户排队消息（协议合法：tool 配对已完整），模型下一轮即可看到
-    const queued = pullQueued?.();
-    if (queued) messages.push({ role: 'user', content: queued });
-  }
-
-  if (ev) ev.onInfo?.('已达最大工具轮数，停止');
-  else out(c.yellow('\n[已达最大工具轮数，停止]\n'));
-  return { usage: { prompt, completion }, lastPromptTokens };
-}
+import t from"node:fs";import o from"node:path";import{streamChat as e}from"./api.js";import{MarkupFilter as n,stripMarkup as r}from"./markup-filter.js";import{TOOL_SPECS as s,READONLY_TOOLS as a,runTool as l}from"./tools.js";import{toolLabel as i,indent as c,renderFileDiff as u}from"./render.js";import{compactIfNeeded as m,buildModelMessages as g}from"./compaction.js";import{makeTodoTool as p,formatTodos as f,TODO_TOOL_NAME as d}from"./todo.js";import{makeMemoryTool as h}from"./memory.js";import{loadHooks as y,runHooks as w}from"./hooks.js";import*as S from"./ide.js";import{c as _}from"./colors.js";function T(t){const o=String(t);return o.startsWith("工具执行失败")||o.startsWith("命令启动失败")||o.includes("不是合法 JSON")||o.includes("未找到要替换的内容")||o.includes("路径超出项目目录")||o.includes("是目录而非文件")}function b(t){return"\n\n# 当前目标（用户设定）\n"+String(t).trim()+"\n在本回合结束、停止作答前，检查该目标是否已达成：若未达成，应继续推进（补充调研/改动/验证），不要过早停止；达成后用一句话说明已达成。"}function k(t){return"string"==typeof t?t:Array.isArray(t)?t.filter(t=>"text"===t?.type).map(t=>t.text||"").join("\n"):""}async function x(t,o,e){const n=new Array(t.length);let r=0;return await Promise.all(Array.from({length:Math.max(1,Math.min(o,t.length))},async()=>{for(;r<t.length;){const o=r++;n[o]=await e(t[o],o)}})),n}export function isPlatformModel(t){return/^(agent|workflow|datahuman)-/.test(String(t||""))}function P(t,o=200){const e=String(t).split("\n")[0];return e.length>o?e.slice(0,o)+"…":e}export function capToolResult(t){const o=String(t);if(o.length<=2e4)return o;const e=o.length-16e3-3e3;return o.slice(0,16e3)+`\n…【工具输出过长，中间已省略 ${e} 字符】…\n`+o.slice(-3e3)}export async function runTurn({config:$,messages:j,permissions:M,cwd:I,ask:E,signal:U,extraTools:v=[],depth:A=0,io:O,events:C,todoState:R,compaction:N,pullQueued:D,maxIters:J,fileJournal:q}){const F=O&&O.write||(t=>process.stdout.write(t)),K=C||null,W=t=>{K?K.onInfo?.(t):F(_.gray("  · "+t)+"\n")};let L=0,Q=0,z=0;const B=Number(J||$.maxTurns)||120,G=isPlatformModel($.model);let H=$.model;if(0===A&&$.autoModelStrong&&!G){const t=[...j].reverse().find(t=>"user"===t.role),o=k(t?.content);($.planMode||o.length>400||/重构|架构|设计|复杂|排查|调试|debug|优化|性能|并发|死锁|重写|迁移|安全审查|根因/i.test(o))&&$.autoModelStrong!==$.model&&(H=$.autoModelStrong,$.debug&&W(`[automodel] 复杂回合升配 → ${H}`))}const V=N||{},X=[...v];if(0===A&&!G&&!X.some(t=>t.spec?.function?.name===d)){const t=R||{list:[]};X.push(p({state:t,emit:t=>{K?K.onTodo?K.onTodo(t.map(t=>({...t}))):K.onInfo?.("任务清单：\n"+f(t)):F(_.gray(c(f(t),"  "))+"\n")}}))}0!==A||G||!1===$.memoryEnabled||X.some(t=>"memory_write"===t.spec?.function?.name)||X.push(h({cwd:I,emit:t=>{K?K.onMemory?K.onMemory(t):K.onInfo?.("已记入长期记忆："+P(t,80)):F(_.gray("  ✎ 已记入长期记忆："+P(t,80))+"\n")}}));const Y=new Map;for(const t of X)Y.set(t.spec.function.name,t);const Z=G?void 0:[...s,...X.map(t=>t.spec)];let tt=0,ot=!1,et=0,nt=null;const rt=0!==A||G?null:y(I),st=!(!rt||!rt.all.length);if(st){const t=[];if(j.filter(t=>"user"===t.role).length<=1){const o=w("SessionStart",{cwd:I},rt);o.injectContext&&t.push(o.injectContext);for(const e of o.outputs)t.push(e.stdout)}const o=[...j].reverse().find(t=>"user"===t.role),e=w("UserPromptSubmit",{cwd:I,prompt:k(o?.content)},rt);if(e.block)return W("提交被 UserPromptSubmit 钩子阻断："+e.reason),{error:"提交被钩子阻断："+e.reason,usage:{prompt:L,completion:Q},lastPromptTokens:z};e.injectContext&&t.push(e.injectContext);for(const o of e.outputs)t.push(o.stdout);t.length&&(nt="【钩子提供的附加上下文】\n"+t.join("\n"))}for(let s=0;s<B;s++){const c=s===B-1;!c||G||ot||nt||(nt="已接近本回合的工具调用轮数上限。请不要再调用任何工具，基于目前已获得的信息，直接用中文输出面向用户的完整最终答复。");const p=await m(j,$,{state:V,lastPromptTokens:z});p>0&&W(`已压缩上下文（${p} 条较早消息已摘要，页面与会话记录不受影响）`);let f=!1,d=!1;const h=new n,y=t=>{t&&(f||!d||K||F("\n"),f=!0,K?K.onDelta?.(t):F(t))},k=g(j,V);let E=k;if(!G&&k.length&&"system"===k[0]?.role){let t="";$.planMode&&(t+="\n\n# 计划模式（当前开启）\n你现在处于计划模式：只能用只读工具（read_file/glob/grep/list_files/fetch_url）调研，不得做任何改动——write_file/edit_file/run_bash 等写或执行操作都会被拒绝，不要反复尝试。请先充分理解需求与现状，然后产出一份清晰、分步的实施方案：涉及哪些文件、每步改动要点、如何验证、风险点，用 todo_write 列出步骤，随后停下等待用户确认。用户关闭计划模式后你再执行。"),$.sandbox&&(t+="\n\n# 沙箱模式（当前开启）\n禁止执行 shell 命令（run_bash）与联网（fetch_url），调用会被拒绝，不要反复尝试。只做本地文件读写与分析。"),$.goal&&String($.goal).trim()&&(t+=b($.goal)),t&&(E=[{...k[0],content:String(k[0].content||"")+t},...k.slice(1)])}const v=Date.now();let A;try{A=await e({baseUrl:$.baseUrl,apiKey:$.apiKey,model:H,messages:nt?[...E,{role:"user",content:nt}]:E,tools:ot||c?void 0:Z,reasoningEffort:$.reasoningEffort,client:$.client,sessionId:$.sessionId},{onContent:t=>y(h.feed(t)),onReasoning:t=>{!1!==$.showReasoning&&(K?K.onReasoning?.(t):(d||F(_.gray("\n[思考] ")),F(_.gray(t))),d=!0)},onRetry:(t,o,e)=>W(`模型响应异常，${Math.round(o/1e3)}s 后自动重试（第 ${t} 次）：${e}`)},U)}catch(t){return"AbortError"===t.name?(K?K.onInfo?.("已中断"):F(_.gray("\n[已中断]\n")),{aborted:!0,usage:{prompt:L,completion:Q},lastPromptTokens:z}):(K?K.onInfo?.("✗ 模型调用失败："+t.message):F("\n"+_.red("✗ 模型调用失败：")+t.message+"\n"),{error:t.message,usage:{prompt:L,completion:Q},lastPromptTokens:z})}y(h.flush()),A.usage&&(L+=A.usage.prompt_tokens||0,Q+=A.usage.completion_tokens||0,z=A.usage.prompt_tokens||z),$.debug&&W(`[debug] 轮${s+1} · ${$.model} · in ${A.usage?.prompt_tokens||0} / out ${A.usage?.completion_tokens||0} tok · ${Date.now()-v}ms · ${(A.toolCalls||[]).length} 工具调用`);const{text:O,sawMarkup:C}=r(A.content),R=C||h.sawMarkup;nt=null;const N=G?[]:A.toolCalls;if(!N.length){if(R&&!O.trim()&&!G){if(tt<2){tt++,2===tt&&(ot=!0),nt=1===tt?"你刚才的输出把工具调用写成了文本标记，工具并未被执行，该内容也不会展示给用户。请重新处理：若需调用工具，必须使用规范的函数调用（tool_calls）通道发起，绝不要以任何文本形式书写工具调用标记；若无需工具，请直接用中文输出面向用户的最终答复。":"请停止调用任何工具。基于目前已获得的全部信息，直接用中文输出面向用户的完整最终答复，不要输出任何工具调用或协议标记。",W(`已拦截模型的文本化工具调用标记（工具未被执行），纠正重试中（第 ${tt} 次）`);continue}W("模型持续输出无效的工具调用标记，已全部拦截；本轮无有效答复（可换个说法重试或更换模型）")}f&&!K&&F("\n"),O&&j.push({role:"assistant",content:O}),K&&K.onTurnEnd?.(O);const t=D?.();if(t){j.push({role:"user",content:t});continue}if(st){const t=w("Stop",{cwd:I,result:O},rt);for(const o of t.outputs)W("钩子·Stop："+P(o.stdout,160))}return{usage:{prompt:L,completion:Q},lastPromptTokens:z}}f&&!K&&F("\n"),K&&O&&K.onAssistantText?.(O),j.push({role:"assistant",content:O,tool_calls:N});const J=N.map((t,o)=>{const e=t.function?.name||"";let n={},r=null;const s=t.function?.arguments||"";if(s)try{n=JSON.parse(s)}catch(t){r=`工具参数不是合法 JSON（${t.message}）：${String(s).slice(0,200)}…请修正参数后重新调用。`}const l=Y.get(e),i=S.isActive()&&("write_file"===e||"edit_file"===e);return{tc:t,idx:o,name:e,args:n,argsError:r,extra:l,readOnly:l?!!l.readOnly:a.has(e),deferToIde:i}}),X=t=>{for(let o=t;o<J.length;o++)j.push({role:"tool",tool_call_id:J[o].tc.id||`call_${o}`,content:"（用户中断，该工具未执行）"});return K?K.onInfo?.("已中断"):F(_.gray("\n[已中断]\n")),{aborted:!0,usage:{prompt:L,completion:Q},lastPromptTokens:z}},at=async t=>{if(t.argsError)return t.argsError;let o;try{o=t.extra?await t.extra.run(t.args):await l(t.name,t.args,I,$)}catch(t){o=`工具执行失败：${t.message}`}return capToolResult(String(o))},lt=t=>{K?K.onToolStart?.(t.name,t.args):F(_.cyan("  ⏺ ")+i(t.name,t.args)+"\n")},it=(t,o)=>{T(o)&&et++,K?K.onToolResult?.(t.name,String(o)):F(_.gray("     "+P(o))+"\n"),j.push({role:"tool",tool_call_id:t.tc.id,content:String(o)})},ct=(t,o)=>{K?K.onSkip?.(t.name,t.args):F(_.gray(`  ⊘ ${i(t.name,t.args)} — 已跳过\n`)),j.push({role:"tool",tool_call_id:t.tc.id,content:o||"未授权，未执行。"})},ut=t=>"edit_file"===t||"write_file"===t,mt=o=>{try{return t.readFileSync(o,"utf8")}catch{return""}},gt=(t,e)=>{const n=o.resolve(I,String(t.args.path)),r=u(e,mt(n),{path:String(t.args.path)});r&&(K?K.onFileDiff?.(r):F(r+"\n"))};let pt=0;for(;pt<J.length;){if(U?.aborted)return X(pt);const e=J[pt];if(e.argsError){lt(e),it(e,e.argsError),pt++;continue}if(e.readOnly){let t=pt;for(;t<J.length&&J[t].readOnly&&!J[t].argsError;)t++;const o=J.slice(pt,t),e=await x(o,8,async t=>{const o=await M.request(t.name,t.args,I,!0);return o.allow?(lt(t),{item:t,result:await at(t)}):{item:t,denied:o.reason||"未授权，未执行。"}});for(const t of e)null!=t.denied?ct(t.item,t.denied):it(t.item,t.result);if(pt=t,U?.aborted)return X(pt);continue}const n=await M.request(e.name,e.args,I,e.readOnly||e.deferToIde);if(U?.aborted)return X(pt);if(!n.allow){ct(e,n.reason),pt++;continue}if(st){const t=w("PreToolUse",{cwd:I,toolName:e.name,args:e.args},rt);for(const o of t.outputs)W("钩子·PreToolUse："+P(o.stdout,120));if(t.block){ct(e,"PreToolUse 钩子阻断："+t.reason),pt++;continue}t.modifiedArgs&&(e.args={...e.args,...t.modifiedArgs},W("钩子·PreToolUse 已修改工具参数"))}lt(e);const r=ut(e.name)&&e.args?.path?mt(o.resolve(I,String(e.args.path))):null;if(q&&null!=r&&e.args?.path){const n=t.existsSync(o.resolve(I,String(e.args.path)));q.push(r.length>2097152?{path:String(e.args.path),tooLarge:!0}:{path:String(e.args.path),before:r,existed:n})}let s=await at(e);if(st){const t=w("PostToolUse",{cwd:I,toolName:e.name,args:e.args,result:String(s)},rt);if(t.outputs.length){for(const o of t.outputs)W("钩子·PostToolUse："+P(o.stdout,120));s=String(s)+"\n\n[PostToolUse 钩子输出]\n"+t.outputs.map(t=>t.stdout).join("\n")}}it(e,s),null!=r&&gt(e,r),pt++}et>=3&&!ot&&!nt&&(nt="你刚才连续多次工具调用失败。请停下来重新审视：是不是文件路径/内容/前提假设错了？先用 read_file / grep / list_files 核实现状，再换一种更可靠的方法，绝不要重复同样会失败的调用。",et=0,W("检测到连续工具失败，已提示智能体换一种更可靠的方法"));const ft=D?.();ft&&j.push({role:"user",content:ft})}return K?K.onInfo?.("已达最大工具轮数，停止"):F(_.yellow("\n[已达最大工具轮数，停止]\n")),{usage:{prompt:L,completion:Q},lastPromptTokens:z}}