jinzd-ai-cli 0.4.180 → 0.4.182

package/dist/electron-server.js

@@ -36,7 +36,7 @@ import {
   VERSION,
   buildUserIdentityPrompt,
   runTestsTool
-} from "./chunk-YDI22R3P.js";
+} from "./chunk-RUUJHLEV.js";
 import {
   hasSemanticIndex,
   semanticSearch
@@ -1551,6 +1551,321 @@ Node.js does not automatically use system proxies. Try one of the following:
 
 // src/providers/openai-compatible.ts
 import OpenAI from "openai";
+
+// src/core/agent-loop.ts
+function partialTagTail(s, tag) {
+  const max = Math.min(s.length, tag.length - 1);
+  for (let len = max; len > 0; len--) {
+    if (s.endsWith(tag.slice(0, len))) return len;
+  }
+  return 0;
+}
+var ThinkTagFilter = class {
+  inThink = false;
+  buf = "";
+  push(raw) {
+    this.buf += raw;
+    let out = "";
+    while (this.buf.length > 0) {
+      if (!this.inThink) {
+        const open = this.buf.indexOf("<think>");
+        if (open === -1) {
+          const keep = partialTagTail(this.buf, "<think>");
+          out += this.buf.slice(0, this.buf.length - keep);
+          this.buf = this.buf.slice(this.buf.length - keep);
+          break;
+        }
+        out += this.buf.slice(0, open);
+        this.buf = this.buf.slice(open + "<think>".length);
+        this.inThink = true;
+      } else {
+        const close = this.buf.indexOf("</think>");
+        if (close === -1) {
+          const keep = partialTagTail(this.buf, "</think>");
+          this.buf = this.buf.slice(this.buf.length - keep);
+          break;
+        }
+        this.buf = this.buf.slice(close + "</think>".length);
+        this.inThink = false;
+      }
+    }
+    return out;
+  }
+  /** 流结束：若仍持留可能的半截 '<think>' 前缀且并未进入 think 块，它是真实文本。 */
+  flush() {
+    if (!this.inThink && this.buf) {
+      const tail = this.buf;
+      this.buf = "";
+      return tail;
+    }
+    this.buf = "";
+    return "";
+  }
+};
+function repairToolCallArguments(raw, onWarn) {
+  const argStr = raw || "{}";
+  try {
+    return JSON.parse(argStr);
+  } catch {
+    const truncated = argStr.trimEnd();
+    const lastComma = truncated.lastIndexOf(",");
+    const fixed = lastComma > 0 ? truncated.slice(0, lastComma) + "}" : truncated.slice(0, truncated.indexOf("{") + 1) + "}";
+    try {
+      const repaired = JSON.parse(fixed);
+      onWarn?.("Tool call JSON was truncated and auto-repaired. Some parameters may be missing.");
+      return repaired;
+    } catch {
+      onWarn?.("Tool call JSON could not be parsed, using empty arguments.");
+      return {};
+    }
+  }
+}
+async function consumeToolCallStream(stream, hooks = {}) {
+  const textParts = [];
+  const accumulators = /* @__PURE__ */ new Map();
+  let usage;
+  let rawContent;
+  let reasoningContent;
+  let finishReason;
+  let aborted = false;
+  const thinkFilter = new ThinkTagFilter();
+  const emitText = (raw) => {
+    const visible = thinkFilter.push(raw);
+    if (visible) {
+      textParts.push(visible);
+      hooks.onText?.(visible);
+    }
+  };
+  try {
+    for await (const event of stream) {
+      if (hooks.signal?.aborted) {
+        aborted = true;
+        break;
+      }
+      switch (event.type) {
+        case "text_delta":
+          emitText(event.delta);
+          break;
+        case "thinking_start":
+          hooks.onThinkingStart?.();
+          break;
+        case "thinking_delta":
+          hooks.onThinkingDelta?.(event.delta);
+          break;
+        case "thinking_end":
+          hooks.onThinkingEnd?.();
+          break;
+        case "tool_call_start":
+          accumulators.set(event.index, { id: event.id, name: event.name, arguments: "" });
+          hooks.onToolCallStart?.(event.index, event.id, event.name);
+          break;
+        case "tool_call_delta": {
+          const acc = accumulators.get(event.index);
+          if (acc) acc.arguments += event.argumentsDelta;
+          break;
+        }
+        case "tool_call_end":
+          break;
+        case "done":
+          if (event.usage) usage = event.usage;
+          if (event.rawContent) rawContent = event.rawContent;
+          if (event.reasoningContent) reasoningContent = event.reasoningContent;
+          if (event.finishReason) finishReason = event.finishReason;
+          break;
+      }
+    }
+  } catch (err) {
+    if (err instanceof Error && (err.name === "AbortError" || err.message.includes("aborted"))) {
+      aborted = true;
+    } else {
+      throw err;
+    }
+  }
+  const tail = thinkFilter.flush();
+  if (tail && !aborted) {
+    textParts.push(tail);
+    hooks.onText?.(tail);
+  }
+  const textContent = textParts.join("");
+  if (aborted) {
+    return { textContent, toolCalls: [], usage, rawContent, reasoningContent, finishReason, aborted };
+  }
+  const toolCalls = [];
+  for (const [, acc] of accumulators) {
+    toolCalls.push({
+      id: acc.id,
+      name: acc.name,
+      arguments: repairToolCallArguments(acc.arguments, hooks.onWarn)
+    });
+  }
+  if (toolCalls.length > 0) {
+    if (rawContent) {
+      toolCalls._rawContent = rawContent;
+    }
+    if (textContent) {
+      toolCalls._streamedText = textContent;
+    }
+  }
+  return { textContent, toolCalls, usage, rawContent, reasoningContent, finishReason, aborted };
+}
+var FREE_ROUND_TOOLS = /* @__PURE__ */ new Set(["write_todos"]);
+var MAX_CONSECUTIVE_FREE_ROUNDS = 3;
+var FreeRoundTracker = class {
+  consecutive = 0;
+  /** 返回 true 表示本轮不消耗有效轮次（调用方执行 round--）。 */
+  apply(toolNames) {
+    const allFree = toolNames.length > 0 && toolNames.every((n) => FREE_ROUND_TOOLS.has(n));
+    if (!allFree) {
+      this.consecutive = 0;
+      return false;
+    }
+    this.consecutive++;
+    return this.consecutive <= MAX_CONSECUTIVE_FREE_ROUNDS;
+  }
+};
+var BudgetWarner = class {
+  constructor(maxToolRounds) {
+    this.maxToolRounds = maxToolRounds;
+    this.noteAt = Math.max(10, Math.floor(maxToolRounds * 0.2));
+    const lowRaw = Math.max(5, Math.floor(maxToolRounds * 0.1));
+    const criticalRaw = Math.max(3, Math.floor(maxToolRounds * 0.05));
+    this.lowAt = Math.min(lowRaw, this.noteAt - 1);
+    this.criticalAt = Math.min(criticalRaw, this.lowAt - 1);
+  }
+  noteAt;
+  lowAt;
+  criticalAt;
+  warnedNote = false;
+  warnedLow = false;
+  warnedCritical = false;
+  check(roundsLeft) {
+    if (!this.warnedCritical && roundsLeft <= this.criticalAt) {
+      this.warnedCritical = true;
+      return {
+        level: "critical",
+        injectMessage: `\u{1F6A8} Critical budget: Only ${roundsLeft} rounds left! Wrap up NOW \u2014 complete the current operation and give a final summary. Do NOT start new tasks.`,
+        displayMessage: `\u{1F6A8} Critical: ${roundsLeft} rounds remaining`
+      };
+    }
+    if (!this.warnedLow && roundsLeft <= this.lowAt) {
+      this.warnedLow = true;
+      return {
+        level: "low",
+        injectMessage: `\u26A0\uFE0F Budget warning: Only ${roundsLeft} tool rounds remaining. Prioritize completing the most critical task. Use efficient approaches (batch edits, fewer reads). If you cannot finish everything, summarize what's done and what remains.`,
+        displayMessage: `\u26A0\uFE0F Low budget: ${roundsLeft} rounds remaining`
+      };
+    }
+    if (!this.warnedNote && roundsLeft <= this.noteAt) {
+      this.warnedNote = true;
+      return {
+        level: "note",
+        injectMessage: `\u{1F4CA} Budget note: ${roundsLeft} tool rounds remaining out of ${this.maxToolRounds}. Plan your remaining work efficiently \u2014 use batch operations (e.g., replaceAll) when possible.`
+      };
+    }
+    return null;
+  }
+};
+var EMPTY_RESPONSE_NUDGE = "Your previous response was empty \u2014 no text and no tool calls. This usually means the context window is nearly full. Please either: (1) continue the task by calling the next tool you need, or (2) give a concise final text summary of what has been accomplished so far and what remains. Do NOT repeat earlier long outputs.";
+function describeFinishReason(fr) {
+  if (fr === "length") return "output limit reached (finish_reason=length)";
+  if (fr === "content_filter") return "content blocked (finish_reason=content_filter)";
+  if (fr) return `empty response (finish_reason=${fr})`;
+  return "empty response";
+}
+function emptyResponseHint(fr) {
+  if (fr === "length") return "Output token limit hit \u2014 try /compact to reduce context, raise maxTokens, or /model to switch.";
+  if (fr === "content_filter") return "Content was blocked by the provider filter.";
+  return "Context window may be exhausted or max_tokens too low.";
+}
+var EmptyResponseGuard = class {
+  retries = 0;
+  onEmpty(canRetry, finishReason) {
+    if (this.retries === 0 && canRetry) {
+      this.retries++;
+      return {
+        action: "nudge",
+        injectMessage: EMPTY_RESPONSE_NUDGE,
+        displayMessage: `\u26A0 ${describeFinishReason(finishReason)} \u2014 nudging AI to continue...`
+      };
+    }
+    return {
+      action: "stop",
+      displayMessage: "\u26A0 AI returned empty responses twice in a row. Stopping agentic loop.",
+      hint: emptyResponseHint(finishReason)
+    };
+  }
+  /** 非空响应到达 → 重置计数（下次空响应仍可 nudge 一次）。 */
+  onNonEmpty() {
+    this.retries = 0;
+  }
+};
+var ContextPressureMonitor = class {
+  warned80 = false;
+  check(requestTokens, contextWindow) {
+    if (contextWindow <= 0) return { action: "ok", ratio: 0 };
+    const ratio = requestTokens / contextWindow;
+    if (ratio >= 0.95) return { action: "abort", ratio };
+    if (ratio >= 0.8 && !this.warned80) {
+      this.warned80 = true;
+      return {
+        action: "warn",
+        ratio,
+        injectMessage: `\u26A0\uFE0F Context pressure: ~${Math.round(ratio * 100)}% of the ${contextWindow.toLocaleString()}-token context window is used. Avoid reading more files or running broad scans. Finish the current critical step, then produce a final summary. Every unnecessary tool call now risks breaking the conversation.`
+      };
+    }
+    return { action: "ok", ratio };
+  }
+};
+function accumulateUsage(total, delta) {
+  if (!delta) return;
+  total.inputTokens += delta.inputTokens;
+  total.outputTokens += delta.outputTokens;
+  total.cacheCreationTokens += delta.cacheCreationTokens ?? 0;
+  total.cacheReadTokens += delta.cacheReadTokens ?? 0;
+}
+function buildRoundBudgetHint(opts) {
+  const pauseHint = opts.autoPauseInterval > 0 ? `
+- Every ${opts.autoPauseInterval} rounds the user will be asked whether to continue \u2014 use this as a natural checkpoint to report progress.` : "";
+  if (opts.planMode) {
+    return `
+
+[Tool Round Budget \u2014 Plan Mode]
+You have a maximum of ${opts.maxToolRounds} tool call rounds. You are in READ-ONLY Plan Mode:
+- Only use: read_file, list_dir, grep_files, glob_files, ask_user, write_todos
+- Do NOT attempt to call bash, write_file, edit_file \u2014 they are disabled
+- Do NOT write shell commands or code blocks as a substitute for tool calls
+- Do NOT read the same file more than once
+- Call write_todos ONCE to present your plan, then give a text summary
+- If the user asks you to execute anything, respond: "Please type /plan execute to switch to execute mode."${pauseHint}`;
+  }
+  return `
+
+[Tool Round Budget]
+You have a maximum of ${opts.maxToolRounds} tool call rounds for this task. Plan efficiently:
+- Prefer batch operations (e.g. global find-and-replace) over repetitive single edits.
+- Do NOT read the same file more than once \u2014 use the content from previous reads.
+- Prioritize the most critical tasks first in case rounds run out.
+- When remaining rounds are low, focus on completing the current task and summarizing.${pauseHint}`;
+}
+function buildRoundsExhaustedPrompt(maxToolRounds) {
+  return `You have used all ${maxToolRounds} tool call rounds. Do not call any more tools. Summarize in text:
+1. What work has been completed so far
+2. What tasks remain unfinished
+3. What the user can do next (e.g. send another request to continue)`;
+}
+function buildUserStopMessage(effectiveRound, maxToolRounds) {
+  return `The user has stopped the task at round ${effectiveRound}/${maxToolRounds}. Do not call any more tools. Summarize what has been completed and what remains.`;
+}
+function summarizeRecentTools(history, interval) {
+  const recent = history.slice(-interval);
+  const counts = /* @__PURE__ */ new Map();
+  for (const rh of recent) {
+    for (const t of rh.tools) counts.set(t, (counts.get(t) || 0) + 1);
+  }
+  return [...counts.entries()].sort((a, b) => b[1] - a[1]).map(([name, count]) => count > 1 ? `${name}\xD7${count}` : name).join(", ");
+}
+
+// src/providers/openai-compatible.ts
 function toUsage(u) {
   if (!u) return void 0;
   const cached = u.prompt_tokens_details?.cached_tokens ?? 0;
@@ -1773,28 +2088,11 @@ var OpenAICompatibleProvider = class extends BaseProvider {
       const reasoningContent = message.reasoning_content;
       if (message.tool_calls && message.tool_calls.length > 0) {
         const toolCalls = message.tool_calls.map((tc) => {
-          const rawArgs = tc.function.arguments || "{}";
-          let parsedArgs;
-          try {
-            parsedArgs = JSON.parse(rawArgs);
-          } catch {
-            const truncated = rawArgs.trimEnd();
-            const lastComma = truncated.lastIndexOf(",");
-            const fixed = lastComma > 0 ? truncated.slice(0, lastComma) + "}" : truncated.slice(0, truncated.indexOf("{") + 1) + "}";
-            try {
-              parsedArgs = JSON.parse(fixed);
-              process.stderr.write(
-                `[warn] Tool call JSON was truncated and auto-repaired. Some parameters may be missing.
-`
-              );
-            } catch {
-              process.stderr.write(
-                `[warn] Tool call JSON could not be parsed, using empty arguments.
-`
-              );
-              parsedArgs = {};
-            }
-          }
+          const parsedArgs = repairToolCallArguments(
+            tc.function.arguments || "{}",
+            (m) => process.stderr.write(`[warn] ${m}
+`)
+          );
           return {
             id: tc.id,
             name: tc.function.name,
@@ -11585,8 +11883,6 @@ async function persistDiscussion(state2, config, defaultProvider, defaultModel)
 }
 
 // src/web/session-handler.ts
-var FREE_ROUND_TOOLS = /* @__PURE__ */ new Set(["write_todos"]);
-var MAX_CONSECUTIVE_FREE_ROUNDS = 5;
 var SessionHandler = class _SessionHandler {
   ws;
   config;
@@ -12071,15 +12367,7 @@ var SessionHandler = class _SessionHandler {
     const autoPauseIntervalRaw = this.config.get("autoPauseInterval");
     const autoPauseInterval = typeof autoPauseIntervalRaw === "number" ? autoPauseIntervalRaw : 50;
     const { stable: toolStable, volatile: toolVolatile } = this.buildSystemPrompt();
-    const pauseHint = autoPauseInterval > 0 ? `
-- Every ${autoPauseInterval} rounds the user will be asked whether to continue \u2014 use this as a natural checkpoint to report progress.` : "";
-    const roundBudgetHint = `
-
-[Tool Round Budget]
-You have a maximum of ${maxToolRounds} tool call rounds for this task. Plan efficiently:
-- Prefer batch operations (e.g. global find-and-replace) over repetitive single edits.
-- Prioritize the most critical tasks first in case rounds run out.
-- When remaining rounds are low, focus on completing the current task and summarizing.${pauseHint}`;
+    const roundBudgetHint = buildRoundBudgetHint({ maxToolRounds, autoPauseInterval });
     const systemPrompt = toolStable + TOOL_CALL_REMINDER + roundBudgetHint + (mcpBudgetNote ? `
 
 ${mcpBudgetNote}` : "");
@@ -12087,18 +12375,11 @@ ${mcpBudgetNote}` : "");
     const modelParams = this.getModelParams();
     const roundUsage = { inputTokens: 0, outputTokens: 0, cacheCreationTokens: 0, cacheReadTokens: 0 };
     const supportsStreamingTools = typeof provider.chatWithToolsStream === "function";
-    let consecutiveFreeRounds = 0;
     const roundToolHistory = [];
-    const warnNoteAt = Math.max(10, Math.floor(maxToolRounds * 0.2));
-    const warnLowAt = Math.max(5, Math.floor(maxToolRounds * 0.1));
-    const warnCriticalAt = Math.max(3, Math.floor(maxToolRounds * 0.05));
-    const warnLowEff = Math.min(warnLowAt, warnNoteAt - 1);
-    const warnCriticalEff = Math.min(warnCriticalAt, warnLowEff - 1);
-    let warnedNote = false;
-    let warnedLow = false;
-    let warnedCritical = false;
-    let emptyResponseRetries = 0;
-    let warnedCtx80 = false;
+    const budgetWarner = new BudgetWarner(maxToolRounds);
+    const emptyGuard = new EmptyResponseGuard();
+    const ctxMonitor = new ContextPressureMonitor();
+    const freeRounds = new FreeRoundTracker();
     const ac = new AbortController();
     this.abortController = ac;
     try {
@@ -12106,27 +12387,12 @@ ${mcpBudgetNote}` : "");
         if (ac.signal.aborted) break;
         this.toolExecutor.setRoundInfo(round + 1, maxToolRounds);
         this.send({ type: "round_progress", current: round + 1, total: maxToolRounds });
-        const roundsLeft = maxToolRounds - round;
-        if (!warnedCritical && roundsLeft <= warnCriticalEff) {
-          warnedCritical = true;
-          extraMessages.push({
-            role: "user",
-            content: `\u{1F6A8} Critical budget: Only ${roundsLeft} rounds left! Wrap up NOW \u2014 complete the current operation and give a final summary. Do NOT start new tasks.`
-          });
-          this.send({ type: "info", message: `\u{1F6A8} Critical: ${roundsLeft} rounds remaining` });
-        } else if (!warnedLow && roundsLeft <= warnLowEff) {
-          warnedLow = true;
-          extraMessages.push({
-            role: "user",
-            content: `\u26A0\uFE0F Budget warning: Only ${roundsLeft} tool rounds remaining. Prioritize completing the most critical task. If you cannot finish everything, summarize what's done and what remains.`
-          });
-          this.send({ type: "info", message: `\u26A0\uFE0F Low budget: ${roundsLeft} rounds remaining` });
-        } else if (!warnedNote && roundsLeft <= warnNoteAt) {
-          warnedNote = true;
-          extraMessages.push({
-            role: "user",
-            content: `\u{1F4CA} Budget note: ${roundsLeft} tool rounds remaining out of ${maxToolRounds}. Plan your remaining work efficiently \u2014 use batch operations (e.g., replaceAll) when possible.`
-          });
+        const budgetWarning = budgetWarner.check(maxToolRounds - round);
+        if (budgetWarning) {
+          extraMessages.push({ role: "user", content: budgetWarning.injectMessage });
+          if (budgetWarning.displayMessage) {
+            this.send({ type: "info", message: budgetWarning.displayMessage });
+          }
         }
         if (this.userInterjection) {
           const msg = this.userInterjection;
@@ -12137,11 +12403,11 @@ ${mcpBudgetNote}` : "");
         const ctxWindow = this.getContextWindowSize();
         if (ctxWindow > 0) {
           const reqTokens = this.estimateRequestTokens(systemPrompt, extraMessages);
-          const reqRatio = reqTokens / ctxWindow;
-          if (reqRatio >= 0.95) {
+          const pressure = ctxMonitor.check(reqTokens, ctxWindow);
+          if (pressure.action === "abort") {
             this.send({
               type: "response_done",
-              content: `\u26A0 Context at ${Math.round(reqRatio * 100)}% of ${ctxWindow.toLocaleString()} tokens \u2014 aborting before API rejection.
+              content: `\u26A0 Context at ${Math.round(pressure.ratio * 100)}% of ${ctxWindow.toLocaleString()} tokens \u2014 aborting before API rejection.
 
 Too much tool output accumulated this turn. Your work so far is preserved.
 
@@ -12154,16 +12420,12 @@ Too much tool output accumulated this turn. Your work so far is preserved.
             this.addWebSessionUsage(roundUsage);
             session.addTokenUsage(roundUsage);
             return;
-          } else if (reqRatio >= 0.8 && !warnedCtx80) {
-            warnedCtx80 = true;
+          } else if (pressure.action === "warn") {
             this.send({
               type: "info",
-              message: `\u26A0 Context at ${Math.round(reqRatio * 100)}% \u2014 asking AI to wrap up`
-            });
-            extraMessages.push({
-              role: "user",
-              content: `\u26A0\uFE0F Context pressure: ~${Math.round(reqRatio * 100)}% of the ${ctxWindow.toLocaleString()}-token context window is used. Avoid reading more files or running broad scans. Finish the current critical step, then produce a final summary. Every unnecessary tool call now risks breaking the conversation.`
+              message: `\u26A0 Context at ${Math.round(pressure.ratio * 100)}% \u2014 asking AI to wrap up`
             });
+            extraMessages.push({ role: "user", content: pressure.injectMessage });
           }
         }
         const chatRequest = {
@@ -12211,37 +12473,29 @@ Details: ${errMsg.split("\n")[0]}
           throw providerErr;
         }
         if (ac.signal.aborted) break;
-        if (result.usage) {
-          roundUsage.inputTokens += result.usage.inputTokens;
-          roundUsage.outputTokens += result.usage.outputTokens;
-          roundUsage.cacheCreationTokens += result.usage.cacheCreationTokens ?? 0;
-          roundUsage.cacheReadTokens += result.usage.cacheReadTokens ?? 0;
-        }
+        accumulateUsage(roundUsage, result.usage);
         const hasToolCalls = !!(result.toolCalls && result.toolCalls.length > 0);
         const contentBlank = !result.content || result.content.trim() === "";
         if (!hasToolCalls && contentBlank) {
-          if (emptyResponseRetries === 0 && round < maxToolRounds - 1) {
-            emptyResponseRetries++;
-            this.send({
-              type: "info",
-              message: "\u26A0 AI returned an empty response. Nudging to continue..."
-            });
-            extraMessages.push({
-              role: "user",
-              content: "Your previous response was empty \u2014 no text and no tool calls. This usually means the context window is nearly full. Please either: (1) continue the task by calling the next tool you need, or (2) give a concise final text summary of what has been accomplished so far and what remains. Do NOT repeat earlier long outputs."
-            });
+          const decision = emptyGuard.onEmpty(round < maxToolRounds - 1, result.finishReason);
+          if (decision.action === "nudge") {
+            this.send({ type: "info", message: decision.displayMessage });
+            extraMessages.push({ role: "user", content: decision.injectMessage });
             continue;
           }
           this.send({
             type: "response_done",
-            content: "\u26A0 AI returned empty responses twice in a row. Stopping agentic loop.\n\nLikely causes: context window exhausted, max_tokens too low, or content filter.\nTry: /compact to reduce context, /clear to reset, or switch to a larger-context model.",
+            content: `${decision.displayMessage}
+
+${decision.hint}
+Try: /compact to reduce context, /clear to reset, or switch to a larger-context model.`,
             usage: roundUsage
           });
           this.addWebSessionUsage(roundUsage);
           session.addTokenUsage(roundUsage);
           return;
         }
-        emptyResponseRetries = 0;
+        emptyGuard.onNonEmpty();
         if (result.content && !result.toolCalls) {
           const hasWriteTools = toolDefs.some((t) => t.name === "write_file" || t.name === "edit_file");
           const alreadyWrote = hadPreviousWriteToolCalls(extraMessages);
@@ -12321,7 +12575,7 @@ ${systemPromptVolatile}` : systemPrompt;
               assistantContent: teeResult.content,
               reasoningContent: reasoningContent2
             });
-            consecutiveFreeRounds = 0;
+            freeRounds.apply(result.toolCalls.map((tc) => tc.name));
             continue;
           }
           const toolResults = await this.toolExecutor.executeAll(result.toolCalls);
@@ -12332,14 +12586,8 @@ ${systemPromptVolatile}` : systemPrompt;
             assistantContent: result.content,
             reasoningContent
           });
-          const allFree = result.toolCalls.every((tc) => FREE_ROUND_TOOLS.has(tc.name));
-          if (allFree) {
-            consecutiveFreeRounds++;
-            if (consecutiveFreeRounds <= MAX_CONSECUTIVE_FREE_ROUNDS) {
-              round--;
-            }
-          } else {
-            consecutiveFreeRounds = 0;
+          if (freeRounds.apply(result.toolCalls.map((tc) => tc.name))) {
+            round--;
           }
           if (this.userInterjection) {
             const msg = this.userInterjection;
@@ -12351,12 +12599,7 @@ ${systemPromptVolatile}` : systemPrompt;
         const effectiveRound = round + 1;
         const remaining = maxToolRounds - effectiveRound;
         if (autoPauseInterval > 0 && effectiveRound > 0 && effectiveRound % autoPauseInterval === 0 && remaining > 0 && !ac.signal.aborted) {
-          const recentHistory = roundToolHistory.slice(-autoPauseInterval);
-          const toolCounts = /* @__PURE__ */ new Map();
-          for (const rh of recentHistory) {
-            for (const t of rh.tools) toolCounts.set(t, (toolCounts.get(t) || 0) + 1);
-          }
-          const toolSummary = [...toolCounts.entries()].sort((a, b) => b[1] - a[1]).map(([name, count]) => count > 1 ? `${name}\xD7${count}` : name).join(", ");
+          const toolSummary = summarizeRecentTools(roundToolHistory, autoPauseInterval);
           const requestId = `pause_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
           const pauseResp = await new Promise((resolve7) => {
             this.pendingAutoPause.set(requestId, resolve7);
@@ -12371,10 +12614,7 @@ ${systemPromptVolatile}` : systemPrompt;
           if (ac.signal.aborted) break;
           if (pauseResp.action === "stop") {
             this.send({ type: "info", message: `\u23F8  Stopped by user at ${effectiveRound}/${maxToolRounds}` });
-            extraMessages.push({
-              role: "user",
-              content: `The user has stopped the task at round ${effectiveRound}/${maxToolRounds}. Do not call any more tools. Summarize what has been completed and what remains.`
-            });
+            extraMessages.push({ role: "user", content: buildUserStopMessage(effectiveRound, maxToolRounds) });
             break;
           } else if (pauseResp.action === "redirect" && pauseResp.message) {
             this.send({ type: "info", message: `\u26A1 Redirect: "${pauseResp.message}"` });
@@ -12385,13 +12625,7 @@ ${systemPromptVolatile}` : systemPrompt;
       try {
         const summaryExtra = [
           ...extraMessages,
-          {
-            role: "user",
-            content: `You have used all ${maxToolRounds} tool call rounds. Do not call any more tools. Summarize in text:
-1. What work has been completed so far
-2. What tasks remain unfinished
-3. What the user can do next`
-          }
+          { role: "user", content: buildRoundsExhaustedPrompt(maxToolRounds) }
         ];
         const summaryResult = await provider.chatWithTools(
           {
@@ -12578,69 +12812,33 @@ This fresh stream has NO tools. Produce ONLY the document body: start with a mar
     });
     return { content: fullContent, summary, isError };
   }
-  /** Consume streaming tool call events and forward to client */
+  /**
+   * Consume streaming tool call events and forward to client.
+   *
+   * v0.4.181: 委托给 core/agent-loop 的统一消费器（与 REPL 同一实现）。
+   * Web 端由此获得三个此前只在 REPL 修过的行为：内联 <think> 折叠
+   * （MiniMax 推理泄漏不再渲染进浏览器）、截断 JSON 自动修复、
+   * 工具调用按 event.index 键累积（稀疏 index 不错位）。
+   */
   async consumeToolStream(streamGen, ac) {
-    let textContent = "";
-    const toolCalls = [];
-    const toolArgBuffers = /* @__PURE__ */ new Map();
-    let usage;
-    let rawContent;
-    let reasoningContent;
-    for await (const event of streamGen) {
-      if (ac.signal.aborted) break;
-      switch (event.type) {
-        case "text_delta":
-          textContent += event.delta;
-          this.send({ type: "text_delta", delta: event.delta });
-          break;
-        case "thinking_start":
-          this.send({ type: "thinking_start" });
-          break;
-        case "thinking_delta":
-          this.send({ type: "thinking_delta", delta: event.delta });
-          break;
-        case "thinking_end":
-          this.send({ type: "thinking_end" });
-          break;
-        case "tool_call_start":
-          toolArgBuffers.set(event.index, "");
-          this.send({ type: "info", message: `\u2699 Streaming: ${event.name}...` });
-          toolCalls.push({ id: event.id, name: event.name, arguments: {} });
-          break;
-        case "tool_call_delta": {
-          const buf = (toolArgBuffers.get(event.index) ?? "") + event.argumentsDelta;
-          toolArgBuffers.set(event.index, buf);
-          break;
-        }
-        case "tool_call_end": {
-          const tc = toolCalls.find((_, i) => i === event.index);
-          const argStr = toolArgBuffers.get(event.index) ?? "{}";
-          if (tc) {
-            try {
-              tc.arguments = JSON.parse(argStr);
-            } catch {
-              tc.arguments = { _raw: argStr };
-            }
-          }
-          break;
-        }
-        case "done":
-          if (event.usage) usage = event.usage;
-          if (event.rawContent) rawContent = event.rawContent;
-          if (event.reasoningContent) reasoningContent = event.reasoningContent;
-          break;
-      }
-    }
-    if (toolCalls.length > 0) {
-      if (rawContent) {
-        toolCalls._rawContent = rawContent;
-      }
-      if (textContent) {
-        toolCalls._streamedText = textContent;
-      }
-      return { toolCalls, usage, reasoningContent };
+    const result = await consumeToolCallStream(streamGen, {
+      signal: ac.signal,
+      onText: (visible) => this.send({ type: "text_delta", delta: visible }),
+      onThinkingStart: () => this.send({ type: "thinking_start" }),
+      onThinkingDelta: (delta) => this.send({ type: "thinking_delta", delta }),
+      onThinkingEnd: () => this.send({ type: "thinking_end" }),
+      onToolCallStart: (_index, _id, name) => this.send({ type: "info", message: `\u2699 Streaming: ${name}...` }),
+      onWarn: (message) => this.send({ type: "info", message: `\u26A0 ${message}` })
+    });
+    if (result.toolCalls.length > 0) {
+      return { toolCalls: result.toolCalls, usage: result.usage, reasoningContent: result.reasoningContent };
     }
-    return { content: textContent, usage, reasoningContent };
+    return {
+      content: result.textContent,
+      usage: result.usage,
+      reasoningContent: result.reasoningContent,
+      finishReason: result.finishReason
+    };
   }
   // ── Commands ─────────────────────────────────────────────────────
   async handleCommand(name, args) {
@@ -13646,7 +13844,7 @@ ${undoResults.map((r) => `  \u2022 ${r}`).join("\n")}` });
       case "test": {
         this.send({ type: "info", message: "\u{1F9EA} Running tests..." });
         try {
-          const { executeTests } = await import("./run-tests-BUII3HBU.js");
+          const { executeTests } = await import("./run-tests-ZP5TPFTK.js");
           const argStr = args.join(" ").trim();
           let testArgs = {};
           if (argStr) {