jinzd-ai-cli 0.4.191 → 0.4.193

package/dist/chunk-JOR572WG.js

@@ -0,0 +1,1058 @@
+#!/usr/bin/env node
+
+// src/tools/types.ts
+function isFileWriteTool(name) {
+  return name === "write_file" || name === "edit_file" || name === "notebook_edit";
+}
+function getDangerLevel(toolName, args) {
+  if (toolName.startsWith("mcp__")) return "safe";
+  if (toolName === "bash") {
+    const cmd = String(args["command"] ?? "");
+    if (/\brm\s+[^\n]*(?:-\w*[rRfF]\w*|--recursive|--force)\b/.test(cmd)) return "destructive";
+    if (/\brm\s+\S/.test(cmd)) return "destructive";
+    if (/\brmdir\b|\bformat\b|\bmkfs\b|\bdd\s+if=|\bshred\b|\bfdisk\b|\bparted\b/.test(cmd)) return "destructive";
+    if (/\bshutdown\b|\breboot\b|\bhalt\b|\bpoweroff\b/.test(cmd)) return "destructive";
+    if (/\bkill\s+-9\b|\bkillall\b/.test(cmd)) return "destructive";
+    if (/\bRemove-Item\b|\bri\s+\S/i.test(cmd)) return "destructive";
+    if (/\brd\s+\/s\b|\brmdir\s+\/s\b/i.test(cmd)) return "destructive";
+    if (/\bdel\s+\S/.test(cmd)) return "destructive";
+    if (/\bShutdown(-Computer)?\b|\bRestart-Computer\b/i.test(cmd)) return "destructive";
+    if (/(?:^|[\s|;&])>>?\s*\S/.test(cmd)) return "write";
+    if (/\btee\b|\bcp\b|\bmv\b|\bln\s+-s/.test(cmd)) return "write";
+    if (/\bchmod\b|\bchown\b/.test(cmd)) return "write";
+    if (/\bSet-Content\b|\bOut-File\b|\bAdd-Content\b|\bCopy-Item\b|\bMove-Item\b|\bSet-ItemProperty\b|\bNew-ItemProperty\b/i.test(cmd)) return "write";
+    if (/\b(python3?|node|deno|bun|perl|ruby|php|bash|sh|zsh|pwsh|powershell)(\.exe)?\b[^\n]*?\s-(?:Command|EncodedCommand|c|e|p|r)\b/i.test(cmd)) return "write";
+    if (/\bcmd(\.exe)?\s+\/[ck]\b/i.test(cmd)) return "write";
+    return "safe";
+  }
+  if (toolName === "write_file") return "write";
+  if (toolName === "edit_file") return "write";
+  if (toolName === "save_last_response") return "write";
+  if (toolName === "run_interactive") {
+    const exe = String(args["executable"] ?? "").toLowerCase();
+    if (/\b(rm|rmdir|del|format|mkfs|Remove-Item)\b/i.test(exe)) return "destructive";
+    if (/\b(bash|sh|zsh|cmd|powershell|pwsh|python|node|ruby|perl)\b/i.test(exe)) return "write";
+    return "write";
+  }
+  if (toolName === "task_create" || toolName === "task_stop") return "write";
+  if (toolName === "task_list") return "safe";
+  if (toolName === "git_commit") return "write";
+  if (toolName === "git_status" || toolName === "git_diff" || toolName === "git_log") return "safe";
+  if (toolName === "notebook_edit") return "write";
+  if (toolName === "read_file" || toolName === "list_dir" || toolName === "grep_files" || toolName === "glob_files" || toolName === "web_fetch" || toolName === "save_memory" || toolName === "ask_user" || toolName === "write_todos" || toolName === "google_search" || toolName === "spawn_agent" || toolName === "run_tests") return "safe";
+  return "write";
+}
+function schemaToJsonSchema(schema) {
+  const result = {
+    type: schema.type,
+    description: schema.description
+  };
+  if (schema.enum) result["enum"] = schema.enum;
+  if (schema.items) result["items"] = schemaToJsonSchema(schema.items);
+  if (schema.properties) {
+    result["properties"] = Object.fromEntries(
+      Object.entries(schema.properties).map(([k, v]) => [k, schemaToJsonSchema(v)])
+    );
+  }
+  return result;
+}
+
+// src/tools/hallucination.ts
+var HALLUCINATION_PATTERNS = [
+  /文件路径[：:]\s*`?[^\s`]+\.\w{1,5}/,
+  // 文件路径: `path/to/file.ext`（要求文件扩展名）
+  /已生成[：:!！]/,
+  // 已生成完成！
+  /已保存到?\s*[`'"]/,
+  // 已保存到 `path`（要求后跟路径引号）
+  /已写入[：:!！]/,
+  // 已写入！
+  /已创建[：:!！]/,
+  // 已创建！
+  /File\s+(?:written|saved|created)\s+(?:to|as|at)/i,
+  // File written to / saved as（要求介词）
+  /生成完成[！!]/,
+  // 生成完成！
+  /✅\s*(?:文件|已[生保写创]|第)\S*\.\w{1,5}/,
+  // ✅ 文件已保存 path.ext（要求文件扩展名）
+  /文件已[成功]?创建/,
+  // 文件已成功创建 / 文件已创建
+  /教案已[成功]?[生创保写]/,
+  // 教案已成功生成 / 教案已保存
+  /已成功[保写创生]入?[：:!！\s`'"]/,
+  // 已成功保存 / 已成功写入 / 已成功创建
+  /保存[到至]了?\s*[`'"]/,
+  // 保存到了 `path` / 保存至 'path'
+  /内容如下[：:]/,
+  // 内容如下：（后跟大段文件内容）
+  /以下是.*(?:教案|文件|内容)[：:]/
+  // 以下是xx教案内容：（Kimi 常见模式）
+];
+function detectsHallucinatedFileOp(content) {
+  return HALLUCINATION_PATTERNS.some((pattern) => pattern.test(content));
+}
+function hadPreviousWriteToolCalls(extraMessages) {
+  const msgs = extraMessages;
+  return msgs.some((msg) => {
+    if (msg.role === "assistant" && Array.isArray(msg.tool_calls)) {
+      return msg.tool_calls.some((tc) => {
+        const fn = tc.function;
+        const name = fn?.name ?? "";
+        return name === "write_file" || name === "edit_file";
+      });
+    }
+    if (msg.role === "assistant" && Array.isArray(msg.content)) {
+      return msg.content.some((block) => {
+        if (block.type !== "tool_use") return false;
+        const name = block.name ?? "";
+        return name === "write_file" || name === "edit_file";
+      });
+    }
+    if (msg.role === "model" && Array.isArray(msg.parts)) {
+      return msg.parts.some((part) => {
+        const fc = part.functionCall;
+        const name = fc?.name ?? "";
+        return name === "write_file" || name === "edit_file";
+      });
+    }
+    return false;
+  });
+}
+var TOOL_CALL_REMINDER = `
+
+[\u26A0\uFE0F Mandatory Tool Call Policy]
+When you need to create, write, or modify files, you MUST use the function calling API to invoke write_file or edit_file.
+NEVER claim "file saved", "file created", "written to", etc. in your response text without actually calling the tool.
+Describing file content in text without calling the tool = the file does not exist = task failure.
+If multiple files need to be generated, you MUST call write_file separately for each file \u2014 do not skip any.
+Do NOT output fake "completion summaries" unless you have actually completed all file writes via tool_calls.
+
+CRITICAL \u2014 Batch file generation rules:
+1. You MUST call write_file once per file. There are NO shortcuts.
+2. After writing file N, immediately proceed to call write_file for file N+1. Do NOT stop to summarize.
+3. If you find yourself typing file content into your response text instead of into a write_file call, STOP and use the tool.
+4. Only produce a text summary AFTER all write_file calls have been made and returned success.
+5. The system compares every "file saved" claim against actual tool calls. Phantom claims trigger an automatic retry \u2014 do not waste rounds.`;
+function buildWriteRoundReminder(writtenCount) {
+  return `
+
+[Write Progress Reminder]
+You have successfully called write_file ${writtenCount} time(s) so far in this turn. If there are more files to write, call write_file NOW for the next file. Do NOT produce a text summary until ALL files have been written via tool calls.`;
+}
+var HALLUCINATION_CORRECTION_MESSAGE = "You did NOT actually call the write_file tool \u2014 the file was NOT created! Please immediately use the write_file tool via the function calling API to perform the actual file write. Do NOT describe file content in text \u2014 you MUST invoke write_file through the tool_calls mechanism.";
+function extractClaimedFilePaths(content) {
+  const paths = /* @__PURE__ */ new Set();
+  const add = (p) => {
+    const trimmed = p.trim().replace(/[，,。、；;:：]+$/, "");
+    if (trimmed && /\.\w{1,6}$/.test(trimmed)) paths.add(trimmed);
+  };
+  let m;
+  const actionLineRe = /(?:已[生保写创]|saved|written|created|完成.*(?:写入|保存|创建|生成)|输出|file\s+(?:saved|written|created))/i;
+  const backtickRe = /`([^`\n]+?\.\w{1,6})`/g;
+  while ((m = backtickRe.exec(content)) !== null) {
+    let pos = m.index;
+    let linesBack = 0;
+    while (linesBack < 9 && pos > 0) {
+      pos--;
+      if (content[pos] === "\n") linesBack++;
+    }
+    const windowStart = pos === 0 ? 0 : pos + 1;
+    const lineEndIdx = content.indexOf("\n", m.index + m[0].length);
+    const window = content.slice(windowStart, lineEndIdx === -1 ? void 0 : lineEndIdx);
+    if (actionLineRe.test(window)) add(m[1]);
+  }
+  const zhRe = /(?:已保存(?:到)?|已写入(?:到)?|已创建|已生成|文件路径[：:]|保存为|写入到)\s*[`'”””]?([^\s`'”””，,。\n]+?\.\w{1,6})/g;
+  while ((m = zhRe.exec(content)) !== null) add(m[1]);
+  const enRe = /(?:saved|written|created)\s+(?:to|as|at)\s+[`'”]?([^\s`'”\n,]+?\.\w{1,6})/gi;
+  while ((m = enRe.exec(content)) !== null) add(m[1]);
+  const checkRe = /✅[^\n`]*?[`'”]?([^\s`'”\n,，。]+?\.\w{1,6})/g;
+  while ((m = checkRe.exec(content)) !== null) {
+    let pos = m.index;
+    let linesBack = 0;
+    while (linesBack < 9 && pos > 0) {
+      pos--;
+      if (content[pos] === "\n") linesBack++;
+    }
+    const windowStart = pos === 0 ? 0 : pos + 1;
+    const lineEndIdx = content.indexOf("\n", m.index + m[0].length);
+    const window = content.slice(windowStart, lineEndIdx === -1 ? void 0 : lineEndIdx);
+    if (actionLineRe.test(window)) add(m[1]);
+  }
+  return Array.from(paths);
+}
+function extractWrittenFilePaths(extraMessages) {
+  const paths = /* @__PURE__ */ new Set();
+  const msgs = extraMessages;
+  const addFromArgs = (raw) => {
+    if (typeof raw === "string") {
+      try {
+        const parsed = JSON.parse(raw);
+        if (typeof parsed.path === "string") paths.add(parsed.path);
+      } catch {
+      }
+    } else if (raw && typeof raw === "object") {
+      const p = raw.path;
+      if (typeof p === "string") paths.add(p);
+    }
+  };
+  for (const msg of msgs) {
+    if (msg.role === "assistant" && Array.isArray(msg.tool_calls)) {
+      for (const tc of msg.tool_calls) {
+        const fn = tc.function;
+        const name = fn?.name ?? "";
+        if (name === "write_file" || name === "edit_file") {
+          addFromArgs(fn?.arguments);
+        }
+      }
+    }
+    if (msg.role === "assistant" && Array.isArray(msg.content)) {
+      for (const block of msg.content) {
+        if (block.type !== "tool_use") continue;
+        const name = block.name ?? "";
+        if (name === "write_file" || name === "edit_file") {
+          addFromArgs(block.input);
+        }
+      }
+    }
+    if (msg.role === "model" && Array.isArray(msg.parts)) {
+      for (const part of msg.parts) {
+        const fc = part.functionCall;
+        if (!fc) continue;
+        const name = fc.name ?? "";
+        if (name === "write_file" || name === "edit_file") {
+          addFromArgs(fc.args);
+        }
+      }
+    }
+  }
+  return Array.from(paths);
+}
+function extractBashCommands(extraMessages) {
+  const cmds = [];
+  const msgs = extraMessages;
+  const addCmd = (raw) => {
+    if (typeof raw === "string") {
+      try {
+        const parsed = JSON.parse(raw);
+        if (typeof parsed.command === "string") cmds.push(parsed.command);
+      } catch {
+      }
+    } else if (raw && typeof raw === "object") {
+      const c = raw.command;
+      if (typeof c === "string") cmds.push(c);
+    }
+  };
+  for (const msg of msgs) {
+    if (msg.role === "assistant" && Array.isArray(msg.tool_calls)) {
+      for (const tc of msg.tool_calls) {
+        const fn = tc.function;
+        if (fn?.name === "bash") addCmd(fn?.arguments);
+      }
+    }
+    if (msg.role === "assistant" && Array.isArray(msg.content)) {
+      for (const block of msg.content) {
+        if (block.type === "tool_use" && block.name === "bash") addCmd(block.input);
+      }
+    }
+    if (msg.role === "model" && Array.isArray(msg.parts)) {
+      for (const part of msg.parts) {
+        const fc = part.functionCall;
+        if (fc && fc.name === "bash") addCmd(fc.args);
+      }
+    }
+  }
+  return cmds;
+}
+function findPhantomClaims(content, extraMessages) {
+  const claimed = extractClaimedFilePaths(content);
+  if (claimed.length === 0) return [];
+  const normalize = (p) => p.replace(/\\/g, "/").toLowerCase().replace(/^\.\//, "");
+  const basename = (p) => {
+    const parts = normalize(p).split("/");
+    return parts[parts.length - 1] ?? "";
+  };
+  const written = extractWrittenFilePaths(extraMessages).map(normalize);
+  const writtenBases = new Set(written.map(basename));
+  const writtenFull = new Set(written);
+  const bashText = extractBashCommands(extraMessages).map((c) => c.replace(/\\/g, "/").toLowerCase()).join("\n");
+  return claimed.filter((raw) => {
+    const norm = normalize(raw);
+    if (writtenFull.has(norm)) return false;
+    for (const w of writtenFull) {
+      if (w.endsWith("/" + norm) || norm.endsWith("/" + w)) return false;
+    }
+    if (writtenBases.has(basename(norm))) return false;
+    const base = basename(norm);
+    if (base && bashText.includes(base)) return false;
+    return true;
+  });
+}
+function buildPhantomCorrectionMessage(phantoms) {
+  const list = phantoms.map((p) => `  - ${p}`).join("\n");
+  return "You claimed to have written the following file(s), but no matching write_file tool call was actually made in this turn:\n" + list + '\n\nEach of these files does NOT exist on disk. You MUST now invoke write_file (via the function calling API) for every missing file listed above. Do NOT output another "completion summary" until the tool calls have actually been made.';
+}
+var DSML_PIPE_CLASS = "[|\\uFF5C\\u2502\\u2503\\u01C0]";
+var PSEUDO_TOOL_CALL_PATTERNS = [
+  // <tool_call name="..."> ... </tool_call>  (DeepSeek V4 thinking, GLM)
+  /<tool_call\s+name\s*=\s*["'][\w._-]+["']/,
+  // <function_calls> ... </function_calls>  (Anthropic-style as text)
+  /<\/?function_calls\s*>/,
+  // <invoke name="..." />  (Anthropic XML tool-call, which is real for
+  // Claude API but is text/garbage for any other provider's plain stream)
+  /<invoke\s+name\s*=\s*["'][\w._-]+["']/,
+  // <tool_use> ... <tool_use_id>  (Claude flavor leaked into text)
+  /<tool_use(?:_id)?\b/,
+  // ```tool_call\n...\n``` markdown fences (Kimi/Zhipu fallback)
+  /```\s*tool_call\b/i,
+  // Bare JSON tool-call block: lines starting with `{"name":"...","arguments":`
+  /^\s*\{\s*"name"\s*:\s*"[\w._-]+"\s*,\s*"arguments"\s*:/m,
+  // v0.4.112: <think> ... </think> reasoning blocks. The REPL renderer
+  // suppresses these from terminal output, but tee mode writes the raw
+  // delta to disk → reasoning leaks into the saved file. We saw a 600-line
+  // 审计报告.md whose first 57 lines were the model's planning monologue.
+  /<think\b[^>]*>/i,
+  // v0.4.112: leading ```markdown / ```md fence wrapping the entire document.
+  // DeepSeek V4 Pro Thinking sometimes "politely" wraps its document output
+  // in a markdown fence. The fence ends up literally in the saved file.
+  /^\s*```\s*(?:markdown|md|gfm)\b/im,
+  // v0.4.173: DeepSeek V4 DSML pseudo-tool-call markup leaked as text. DeepSeek
+  // emits a fake tool call using its native special-token markup
+  //   <｜｜DSML｜｜tool_calls> <｜｜DSML｜｜invoke name="write"> <｜｜DSML｜｜parameter …>
+  // where the "pipe" is U+FF5C FULLWIDTH VERTICAL LINE (the same token family as
+  // <｜User｜>/<｜Assistant｜>). We saw an exam paper saved via save_last_response
+  // whose tee stream was preamble + this DSML wrapper + the real document body.
+  // The earlier <invoke …> pattern uses ASCII < > and does NOT match these.
+  new RegExp(`<\\/?\\s*${DSML_PIPE_CLASS}+\\s*DSML\\s*${DSML_PIPE_CLASS}+`, "i")
+];
+function detectPseudoToolCalls(content) {
+  if (!content || content.length === 0) return null;
+  for (const re of PSEUDO_TOOL_CALL_PATTERNS) {
+    if (re.test(content)) return re.source;
+  }
+  return null;
+}
+function stripPseudoToolCalls(content) {
+  if (!content) return content;
+  let out = content;
+  const dsmlBody = extractDsmlContent(out);
+  if (dsmlBody !== null) {
+    out = dsmlBody;
+  } else {
+    out = stripDsmlTags(out);
+  }
+  out = out.replace(/<tool_call\b[^>]*>[\s\S]*?<\/tool_call>/gi, "");
+  out = out.replace(/<tool_call\b[^>]*\/>/gi, "");
+  out = out.replace(/<function_calls\b[^>]*>[\s\S]*?<\/function_calls>/gi, "");
+  out = out.replace(/<invoke\b[^>]*>[\s\S]*?<\/invoke>/gi, "");
+  out = out.replace(/<invoke\b[^>]*\/>/gi, "");
+  out = out.replace(/<tool_use(?:_id)?\b[^>]*>[\s\S]*?<\/tool_use(?:_id)?>/gi, "");
+  out = out.replace(/```\s*tool_call\b[\s\S]*?```/gi, "");
+  out = out.replace(/<think\b[^>]*>[\s\S]*?<\/think>/gi, "");
+  out = out.replace(/<think\b[^>]*>[\s\S]*?(?=^#{1,3}\s+\S|\n\s*\n)/im, "");
+  out = out.replace(/^\s*\{\s*"name"\s*:\s*"[\w._-]+"\s*,\s*"arguments"\s*:[\s\S]*?\}\s*$/gm, "");
+  out = unwrapDocumentFence(out);
+  out = peelMetaNarration(out);
+  out = out.replace(/\n{3,}/g, "\n\n").trim();
+  return out;
+}
+function extractDsmlContent(content) {
+  if (!content) return null;
+  const P = DSML_PIPE_CLASS;
+  const re = new RegExp(
+    `<\\s*${P}+\\s*DSML\\s*${P}+\\s*parameter\\b[^>]*\\bname\\s*=\\s*["']content["'][^>]*>([\\s\\S]*?)<\\s*/\\s*${P}+\\s*DSML\\s*${P}+\\s*parameter\\s*>`,
+    "i"
+  );
+  const m = content.match(re);
+  if (m && typeof m[1] === "string") {
+    const body = m[1].trim();
+    return body.length > 0 ? body : null;
+  }
+  return null;
+}
+function stripDsmlTags(content) {
+  const P = DSML_PIPE_CLASS;
+  let out = content;
+  out = out.replace(
+    new RegExp(
+      `<\\s*${P}+\\s*DSML\\s*${P}+\\s*tool_calls\\b[\\s\\S]*?<\\s*/\\s*${P}+\\s*DSML\\s*${P}+\\s*tool_calls\\s*>`,
+      "gi"
+    ),
+    ""
+  );
+  out = out.replace(new RegExp(`<\\s*/?\\s*${P}+\\s*DSML\\s*${P}+[^>]*>`, "gi"), "");
+  return out;
+}
+function unwrapDocumentFence(content) {
+  const trimmed = content.trim();
+  const open = trimmed.match(/^```\s*(markdown|md|gfm)?\s*\n/i);
+  if (!open) return content;
+  const afterOpen = trimmed.slice(open[0].length);
+  const closeMatch = afterOpen.match(/\n```\s*$/);
+  if (!closeMatch) return content;
+  const inner = afterOpen.slice(0, afterOpen.length - closeMatch[0].length);
+  if (inner.length < 200) return content;
+  return inner;
+}
+function peelMetaNarration(content) {
+  let out = content;
+  const firstHeadingMatch = out.match(/^#{1,3}\s+\S.*$/m);
+  if (firstHeadingMatch && firstHeadingMatch.index !== void 0) {
+    const before = out.slice(0, firstHeadingMatch.index);
+    const hasIntroMarker = /(?:以下(?:即为|是|就是)|这是|Here\s+is|Below\s+is|完整的?(?:审计报告|内容|文档)|审计报告(?:如下|的完整内容))/i.test(before);
+    if (before.length > 0 && before.length < 800 && hasIntroMarker) {
+      out = out.slice(firstHeadingMatch.index);
+    }
+    if (out.startsWith("---\n")) {
+      const headingAfterRule = out.slice(4).match(/^#{1,3}\s+\S/m);
+      if (headingAfterRule && headingAfterRule.index !== void 0 && headingAfterRule.index < 100) {
+        out = out.slice(4 + headingAfterRule.index);
+      }
+    }
+  }
+  const codaMatch = out.match(/\n[^\n]*?(?:以上(?:即为|就是|内容|为完整的?)|Above\s+is\s+the|本报告已经|该报告(?:已经|包含)|报告(?:已|至此)结束)[^\n]*$/i);
+  if (codaMatch && codaMatch.index !== void 0 && codaMatch.index > out.length / 2) {
+    out = out.slice(0, codaMatch.index);
+  }
+  return out.trim();
+}
+var META_NARRATION_HARD_MARKERS = [
+  /\[⚠️\s*CONTENT GENERATION MODE\]/,
+  /CONTENT_ONLY_STREAM_REMINDER\b/,
+  /<system-reminder>/i
+];
+var META_NARRATION_HEURISTICS = [
+  /\bthe user (?:is asking me|wants me|is requesting|expects me)\b/i,
+  /\blet me (?:re-?read|re-?consider|reconsider|think about|carefully (?:re-?read|consider))\b/i,
+  /\bI'?m (?:in (?:a )?content-only|in CONTENT-ONLY|currently in)\b/i,
+  /\bI think (?:there might be|I should|I cannot|the (?:user|best)|maybe)\b/i,
+  /\bWait,?\s+let me\b/i,
+  /\bActually,?\s+I\b/i,
+  /\bI need to be honest with the user\b/i,
+  /\bI(?:'m| am) in a special mode\b/i,
+  /\bGiven that I cannot\b/i
+];
+function detectMetaNarration(content) {
+  if (!content) return null;
+  const head = content.slice(0, 2e3);
+  for (const re of META_NARRATION_HARD_MARKERS) {
+    if (re.test(head)) return re.source;
+  }
+  if (/^#{1,3}\s+\S/m.test(head)) return null;
+  let hits = 0;
+  let firstMatch = "";
+  for (const re of META_NARRATION_HEURISTICS) {
+    if (re.test(head)) {
+      hits++;
+      if (!firstMatch) firstMatch = re.source;
+      if (hits >= 2) return `meta-narration:${firstMatch}`;
+    }
+  }
+  return null;
+}
+function looksLikeDocumentBody(content) {
+  if (!content || content.length < 200) return false;
+  if (/^#{1,6}\s+\S/m.test(content)) return true;
+  const paragraphs = content.split(/\n\s*\n/).filter((p) => p.trim().length > 30);
+  if (paragraphs.length >= 3) return true;
+  return false;
+}
+function stripToolCallReminder(systemPrompt) {
+  if (!systemPrompt) return systemPrompt;
+  const idx = systemPrompt.indexOf("[\u26A0\uFE0F Mandatory Tool Call Policy]");
+  if (idx === -1) return systemPrompt;
+  return systemPrompt.slice(0, idx).trimEnd();
+}
+var TEE_FINAL_USER_NUDGE = `\u26A0\uFE0F STOP using tools NOW. The save_last_response tee stream is open and capturing every token of THIS response. Output ONLY the requested document body, in markdown. The very first character of your response must be the document's top-level heading (e.g. "# \u5BA1\u8BA1\u62A5\u544A" / "# Audit Report"). Do NOT print <tool_call>, </tool_call>, <function_calls>, <invoke>, <tool_use>, <think>, or any other tool-call markup. Do NOT narrate that you will produce the document \u2014 just produce it. Do NOT pretend to call tools \u2014 there are none in this stream.`;
+var CONTENT_ONLY_STREAM_REMINDER = `
+
+[\u26A0\uFE0F CONTENT GENERATION MODE]
+You are now in a CONTENT-ONLY streaming pass. The file at the configured path will receive every token of THIS response.
+- Do NOT emit <tool_call>, </tool_call>, <function_calls>, <invoke>, <tool_use>, or any tool-call XML/JSON markup.
+- Do NOT print "I will now call ...", "let me read ...", "<think>" reasoning blocks (the surrounding REPL handles those separately \u2014 they should not enter the saved file).
+- Do NOT pretend to call tools. There are NO tools available in this stream \u2014 only your text output is captured.
+- Produce ONLY the requested document body. Markdown is fine. Code blocks are fine. Tool-call markup is NOT.
+- If you accidentally start a <tool_call>, STOP and produce the document body instead.
+
+The file is closed and named when this stream ends. If your output contains pseudo-tool-call markup, the save will be REJECTED and you will be asked to retry.`;
+function isCleanDocumentBody(content) {
+  if (!content) return false;
+  if (detectMetaNarration(content)) return false;
+  if (detectPseudoToolCalls(content)) return false;
+  return looksLikeDocumentBody(content);
+}
+function teeFileStats(content) {
+  return { lines: content.split("\n").length, bytes: Buffer.byteLength(content, "utf-8") };
+}
+function evaluateTeeContent(rawContent, saveToFile, priorContent) {
+  const fallback = (matched) => {
+    if (priorContent && priorContent !== rawContent && isCleanDocumentBody(priorContent)) {
+      const body = priorContent.trim();
+      const { lines: lines2, bytes: bytes2 } = teeFileStats(body);
+      return {
+        kind: "fallback",
+        content: body,
+        matched,
+        summary: `File saved (fallback to last shown response): ${saveToFile} (${lines2} lines, ${bytes2} bytes). The fresh content-only stream produced no usable document body (matched: ${matched}); saved the response you previously displayed instead. Verify it is the intended document.`
+      };
+    }
+    return null;
+  };
+  const metaMatch = detectMetaNarration(rawContent);
+  if (metaMatch) {
+    return fallback(metaMatch) ?? {
+      kind: "reject",
+      reason: "meta-narration",
+      matched: metaMatch,
+      summary: `[save_last_response REJECTED] Your output was internal reasoning / meta-narration (e.g. "Let me re-read\u2026", "the user is asking me to\u2026") instead of the requested document body (matched: ${metaMatch}). ${saveToFile} was NOT saved.
+
+This fresh stream has NO tools. Produce ONLY the document body: start with a markdown heading like "# \u5BA1\u8BA1\u62A5\u544A" / "# Audit Report" and write the full content. Do NOT narrate that you will produce the document \u2014 produce it.`
+    };
+  }
+  const pseudoMatch = detectPseudoToolCalls(rawContent);
+  if (pseudoMatch) {
+    const cleaned = stripPseudoToolCalls(rawContent);
+    if (looksLikeDocumentBody(cleaned)) {
+      const { lines: lines2, bytes: bytes2 } = teeFileStats(cleaned);
+      return {
+        kind: "salvaged",
+        content: cleaned,
+        matched: pseudoMatch,
+        summary: `File saved (with cleanup): ${saveToFile} (${lines2} lines, ${bytes2} bytes; pseudo-tool-call markup matching ${pseudoMatch} was stripped before save)`
+      };
+    }
+    return fallback(pseudoMatch) ?? {
+      kind: "reject",
+      reason: "pseudo-tool-call",
+      matched: pseudoMatch,
+      summary: `[save_last_response REJECTED] Your output was tool-call markup with no usable document body (matched: ${pseudoMatch}). ${saveToFile} was NOT saved.
+
+This fresh stream has NO tools \u2014 output is captured verbatim. STOP emitting <tool_call>, <function_calls>, <invoke>, <think>, or JSON tool blocks. Produce the document body NOW: start with a markdown heading like "# \u5BA1\u8BA1\u62A5\u544A" and write the full report.`
+    };
+  }
+  const { lines, bytes } = teeFileStats(rawContent);
+  return {
+    kind: "ok",
+    content: rawContent,
+    summary: `File saved: ${saveToFile} (${lines} lines, ${bytes} bytes)`
+  };
+}
+function teeStreamErrorSummary(saveToFile, errMsg) {
+  return `[save_last_response failed] streaming was interrupted: ${errMsg}. ${saveToFile} (partial) was deleted. Retry \u2014 and consider producing a more compact output (split very large reports across multiple save_last_response calls if the previous attempt timed out).`;
+}
+
+// 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.`;
+}
+async function runAgentLoop(host) {
+  const { maxToolRounds, autoPauseInterval, usage } = host;
+  const extraMessages = [];
+  const budgetWarner = new BudgetWarner(maxToolRounds);
+  const emptyGuard = new EmptyResponseGuard();
+  const ctxMonitor = new ContextPressureMonitor();
+  const freeRounds = new FreeRoundTracker();
+  const roundToolHistory = [];
+  const hasWriteTools = host.toolDefs.some((t) => t.name === "write_file" || t.name === "edit_file");
+  for (let round = 0; round < maxToolRounds; round++) {
+    if (host.signal?.aborted) return { reason: "aborted", usage };
+    host.onRoundStart?.(round, maxToolRounds);
+    if (await host.beforeRound?.(round, extraMessages) === "stop") {
+      return { reason: "stopped", usage };
+    }
+    const warning = budgetWarner.check(maxToolRounds - round);
+    if (warning) {
+      extraMessages.push({ role: "user", content: warning.injectMessage });
+      host.onBudgetWarning?.(warning);
+    }
+    const interjection = host.pollInterjection?.();
+    if (interjection) extraMessages.push({ role: "user", content: interjection });
+    const ctxWindow = host.getContextWindow();
+    if (ctxWindow > 0) {
+      const pressure = ctxMonitor.check(host.estimateRequestTokens(extraMessages), ctxWindow);
+      if (pressure.action === "abort") {
+        host.onContextPressure?.(pressure, ctxWindow, round);
+        return { reason: "context-overflow", usage };
+      } else if (pressure.action === "warn") {
+        host.onContextPressure?.(pressure, ctxWindow, round);
+        extraMessages.push({ role: "user", content: pressure.injectMessage });
+      }
+    }
+    const outcome = await host.callModel(round, extraMessages);
+    if (host.signal?.aborted) return { reason: "aborted", usage };
+    accumulateUsage(usage, outcome.usage);
+    if (outcome.stopLoop) return { reason: "host-stop", usage };
+    const toolCalls = outcome.toolCalls ?? [];
+    if (toolCalls.length === 0) {
+      const content = outcome.content ?? "";
+      const alreadyRendered = !!outcome.alreadyRendered;
+      const alreadyWrote = hadPreviousWriteToolCalls(extraMessages);
+      const coarseHallucination = !host.planMode && hasWriteTools && !alreadyWrote && !!content && detectsHallucinatedFileOp(content);
+      const phantomPaths = (coarseHallucination || alreadyWrote) && !host.planMode && hasWriteTools && content ? findPhantomClaims(content, extraMessages) : [];
+      const bashRanThisTurn = extractBashCommands(extraMessages).length > 0;
+      const coarseShouldFire = coarseHallucination && !bashRanThisTurn;
+      if ((phantomPaths.length > 0 || coarseShouldFire) && round < maxToolRounds - 1) {
+        host.onHallucinationRetry?.({ phantomPaths, round, alreadyRendered });
+        const correctionMsg = phantomPaths.length > 0 ? buildPhantomCorrectionMessage(phantomPaths) : HALLUCINATION_CORRECTION_MESSAGE;
+        const reasoningField = outcome.reasoningContent ? { reasoning_content: outcome.reasoningContent } : host.providerId === "deepseek" ? { reasoning_content: "" } : {};
+        extraMessages.push(
+          { role: "assistant", content, ...reasoningField },
+          { role: "user", content: correctionMsg }
+        );
+        continue;
+      }
+      if (!content || content.trim() === "") {
+        const decision = emptyGuard.onEmpty(round < maxToolRounds - 1, outcome.finishReason);
+        host.onEmptyResponse?.(decision, { alreadyRendered, round });
+        if (decision.action === "nudge") {
+          extraMessages.push({ role: "user", content: decision.injectMessage });
+          continue;
+        }
+        return { reason: "empty-response", usage };
+      }
+      emptyGuard.onNonEmpty();
+      await host.onFinalContent(content, { reasoningContent: outcome.reasoningContent, alreadyRendered });
+      return { reason: "final", usage };
+    }
+    emptyGuard.onNonEmpty();
+    const saveCall = toolCalls.find((tc) => tc.name === "save_last_response");
+    const savePath = saveCall ? String(saveCall.arguments["path"] ?? "") : "";
+    if (saveCall && savePath && host.runSaveLastResponseTee) {
+      const directive = await host.runSaveLastResponseTee({
+        toolCalls,
+        call: saveCall,
+        saveToFile: savePath,
+        extraMessages,
+        reasoningContent: outcome.reasoningContent
+      });
+      if (directive === "stop") return { reason: "tee-stop", usage };
+      freeRounds.apply(toolCalls.map((tc) => tc.name));
+      continue;
+    }
+    const toolResults = await host.executeTools(toolCalls, extraMessages);
+    if (host.isInterrupted?.() || host.signal?.aborted) {
+      host.onInterrupted?.();
+      return { reason: "aborted", usage };
+    }
+    roundToolHistory.push({ round: round + 1, tools: toolCalls.map((tc) => tc.name) });
+    host.onToolsExecuted?.(toolCalls, toolResults, extraMessages);
+    extraMessages.push(...host.buildToolResultMessages(toolCalls, toolResults, outcome.reasoningContent));
+    for (const tc of toolCalls) {
+      if (tc.name.startsWith("mcp__")) host.onMcpToolUsed?.(tc.name);
+    }
+    host.persistRound?.(toolCalls, toolResults, {
+      assistantContent: outcome.content,
+      reasoningContent: outcome.reasoningContent
+    });
+    host.afterToolRoundPersist?.(toolCalls, toolResults, extraMessages);
+    if (freeRounds.apply(toolCalls.map((tc) => tc.name))) {
+      round--;
+    }
+    if (host.checkLoopHealth?.(toolCalls, extraMessages) === "skip-checkpoint") continue;
+    const postInterjection = host.pollInterjection?.();
+    if (postInterjection) extraMessages.push({ role: "user", content: postInterjection });
+    const effectiveRound = round + 1;
+    const remaining = maxToolRounds - effectiveRound;
+    if (autoPauseInterval > 0 && effectiveRound > 0 && effectiveRound % autoPauseInterval === 0 && remaining > 0 && !host.signal?.aborted && host.requestAutoPause) {
+      const toolSummary = summarizeRecentTools(roundToolHistory, autoPauseInterval);
+      const resp = await host.requestAutoPause({ effectiveRound, maxToolRounds, remaining, toolSummary });
+      if (host.signal?.aborted) return { reason: "aborted", usage };
+      if (resp.action === "stop") {
+        extraMessages.push({ role: "user", content: buildUserStopMessage(effectiveRound, maxToolRounds) });
+        break;
+      } else if (resp.action === "redirect" && resp.message) {
+        extraMessages.push({ role: "user", content: resp.message });
+      }
+    }
+    host.onRoundEnd?.(round);
+  }
+  let summaryContent = null;
+  try {
+    const summaryExtra = [
+      ...extraMessages,
+      { role: "user", content: buildRoundsExhaustedPrompt(maxToolRounds) }
+    ];
+    const summary = await host.callSummary(summaryExtra);
+    accumulateUsage(usage, summary.usage);
+    summaryContent = summary.content && summary.content.trim() ? summary.content : null;
+  } catch {
+    summaryContent = null;
+  }
+  await host.onRoundsExhausted(summaryContent);
+  return { reason: "rounds-exhausted", usage };
+}
+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(", ");
+}
+async function runLeanAgentLoop(opts) {
+  const extraMessages = [];
+  const usage = { inputTokens: 0, outputTokens: 0 };
+  let content = "";
+  let roundsUsed = 0;
+  let toolCallCount = 0;
+  try {
+    for (let round = 0; round < opts.maxRounds; round++) {
+      roundsUsed = round + 1;
+      opts.onRoundStart?.(round, opts.maxRounds);
+      const result = await opts.provider.chatWithTools(
+        {
+          messages: opts.messages,
+          model: opts.model,
+          systemPrompt: opts.systemPromptForRound(round, opts.maxRounds - round),
+          stream: false,
+          temperature: opts.chatParams?.temperature,
+          maxTokens: opts.chatParams?.maxTokens,
+          timeout: opts.chatParams?.timeout,
+          thinking: opts.chatParams?.thinking,
+          ...extraMessages.length > 0 ? { _extraMessages: extraMessages } : {}
+        },
+        opts.toolDefsForRound(round)
+      );
+      if (result.usage) {
+        usage.inputTokens += result.usage.inputTokens;
+        usage.outputTokens += result.usage.outputTokens;
+      }
+      if ("content" in result) {
+        content = result.content;
+        break;
+      }
+      toolCallCount += result.toolCalls.length;
+      const toolResults = await opts.executeTools(result.toolCalls);
+      const reasoningContent = "reasoningContent" in result ? result.reasoningContent : void 0;
+      extraMessages.push(
+        ...opts.provider.buildToolResultMessages(result.toolCalls, toolResults, reasoningContent)
+      );
+    }
+    if (!content) content = opts.onRoundsExhausted(toolCallCount);
+  } catch (err) {
+    const errMsg = err instanceof Error ? err.message : String(err);
+    content = opts.onError(errMsg);
+  }
+  return { content, usage, roundsUsed, toolCallCount };
+}
+
+export {
+  isFileWriteTool,
+  getDangerLevel,
+  schemaToJsonSchema,
+  detectsHallucinatedFileOp,
+  TOOL_CALL_REMINDER,
+  buildWriteRoundReminder,
+  extractWrittenFilePaths,
+  stripToolCallReminder,
+  TEE_FINAL_USER_NUDGE,
+  CONTENT_ONLY_STREAM_REMINDER,
+  evaluateTeeContent,
+  teeStreamErrorSummary,
+  ThinkTagFilter,
+  repairToolCallArguments,
+  consumeToolCallStream,
+  accumulateUsage,
+  buildRoundBudgetHint,
+  runAgentLoop,
+  runLeanAgentLoop
+};