@noobdemon/noob-cli 1.0.6 → 1.0.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@noobdemon/noob-cli",
-  "version": "1.0.6",
+  "version": "1.0.8",
   "publishConfig": {
     "access": "public"
   },

package/src/agent.js

@@ -1,3 +1,4 @@
+import os from "node:os";
 import { stream } from "./api.js";
 import { t } from "./i18n.js";
 
@@ -32,27 +33,86 @@ Available tools:
 - JSON in the tool block must be valid: escape newlines as \\n inside string values.
 - LANGUAGE: Always write your prose answers to the user in Vietnamese (tiếng Việt), unless the user explicitly writes in another language. Keep code, file paths, commands, and tool JSON unchanged.
 
+# Coding principles (Karpathy) — apply to EVERY code change
+1. THINK FIRST: state the key assumptions before you code. If a requirement is ambiguous or a step is hard to reverse, ask ONE sharp question instead of guessing.
+2. KEEP IT SIMPLE: write the simplest thing that works. No speculative abstractions, no extra flags/config/layers "for later". Prefer deleting code to adding it.
+3. SURGICAL: change only what the task needs. No drive-by refactors, renames, reformatting, or comment churn in unrelated code.
+4. VERIFIABLE GOAL: decide how you'll know it works, then check it (run the build/test, read the output). Report what you verified — and honestly state what you did NOT verify.
+
 # Example interaction
 ## USER
-how many lines are in app.js?
+do the tests pass?
 ## ASSISTANT
 \`\`\`tool
-{"name": "run_command", "input": {"command": "wc -l app.js"}}
+{"name": "run_command", "input": {"command": "npm test"}}
 \`\`\`
 ## TOOL RESULT (run_command)
-42 app.js
+12 passing (340ms)
 [exit code 0]
 ## ASSISTANT
-app.js has 42 lines.
+Có — cả 12 test đều pass.
 
 Follow this pattern exactly. Your very first response to a task that needs the filesystem MUST be a tool block — do not refuse or explain limitations.`;
 
 const MAX_STEPS = 30;
+const MAX_PROMPT_CHARS = 80000; // ngân sách ký tự cho phần hội thoại gửi lên model
+
+// Môi trường chạy thực: model cần biết OS + shell để emit lệnh ĐÚNG. Không có
+// khối này, trên Windows model hay emit lệnh Unix (wc/ls/cat/grep) → run_command
+// (PowerShell) báo lỗi.
+function runtimeContext() {
+  const isWin = process.platform === "win32";
+  const lines = [
+    "# ENVIRONMENT",
+    `- OS: ${process.platform} (${os.release()})`,
+    `- Shell for run_command: ${isWin ? "Windows PowerShell (powershell.exe)" : "bash"}`,
+    `- Current working directory: ${process.cwd()}`,
+  ];
+  if (isWin) {
+    lines.push(
+      "- IMPORTANT: run_command runs in PowerShell on Windows — do NOT use Unix tools.",
+      "  Use: Get-Content (not cat), Get-ChildItem (not ls), Select-String (not grep),",
+      "  (Get-Content f | Measure-Object -Line) (not wc -l). Paths use backslashes.",
+      "- Prefer the dedicated tools (read_file / list_dir / grep / glob) over shell commands;",
+      "  they are cross-platform. Use run_command mainly for builds/tests/installs.",
+    );
+  } else {
+    lines.push("- Prefer the dedicated tools (read_file/list_dir/grep/glob) over shell when possible.");
+  }
+  return lines.join("\n");
+}
+
+// Lược ngữ cảnh để không vượt context khi phiên dài. KHÔNG đụng vào history thật
+// (vẫn lưu/đầy đủ để resume) — chỉ thu gọn BẢN SAO dùng cho prompt.
+function compact(history, budget) {
+  const len = (m) => (m.content || "").length + 24;
+  let total = history.reduce((s, m) => s + len(m), 0);
+  if (total <= budget) return history;
+  const out = history.map((m) => ({ ...m }));
+  // (1) Rút gọn các TOOL RESULT cũ trước (giữ 5 cái gần nhất) — đây là phần phình
+  // nhất (đọc file lớn) và model đã xử lý xong rồi.
+  const toolIdx = out.map((m, i) => (m.role === "tool" ? i : -1)).filter((i) => i >= 0);
+  for (const i of toolIdx.slice(0, Math.max(0, toolIdx.length - 5))) {
+    if (total <= budget) break;
+    const before = len(out[i]);
+    out[i].content = "[kết quả công cụ cũ đã được lược bớt để tiết kiệm ngữ cảnh]";
+    total -= before - len(out[i]);
+  }
+  if (total <= budget) return out;
+  // (2) Vẫn dài → bỏ các lượt cũ nhất, giữ USER đầu tiên (mô tả nhiệm vụ gốc) +
+  // 12 message gần nhất.
+  const firstUser = out.findIndex((m) => m.role === "user");
+  const head = firstUser >= 0 ? [out[firstUser]] : [];
+  const tailStart = Math.max(firstUser + 1, out.length - 12);
+  const elided = { role: "tool", name: "context", content: "[… các lượt trước đã được lược bớt …]" };
+  return [...head, elided, ...out.slice(tailStart)];
+}
 
 // The proxy is stateless, so we serialize the whole transcript into one prompt.
 function buildPrompt(history) {
-  const parts = [SYSTEM, "", "=".repeat(60), "# CONVERSATION", ""];
-  for (const m of history) {
+  const msgs = compact(history, MAX_PROMPT_CHARS);
+  const parts = [SYSTEM, "", runtimeContext(), "", "=".repeat(60), "# CONVERSATION", ""];
+  for (const m of msgs) {
     if (m.role === "user") parts.push(`## USER\n${m.content}`);
     else if (m.role === "assistant") parts.push(`## ASSISTANT\n${m.content}`);
     else if (m.role === "tool") parts.push(`## TOOL RESULT (${m.name})\n${m.content}`);
@@ -95,11 +155,19 @@ export function parseToolCall(text) {
  * @param {(msg:string)=>void} opts.onStatus      thinking/streaming status
  * @returns {Promise<string>} the final assistant answer (no tool block)
  */
-export async function runAgent({ history, model, signal, onTool, onStatus }) {
+export async function runAgent({ history, model, signal, onTool, onStatus, onDelta }) {
   for (let step = 0; step < MAX_STEPS; step++) {
     const prompt = buildPrompt(history);
     onStatus?.("thinking");
-    const { text } = await stream({ mode: "chat", model, message: prompt, signal });
+    onDelta?.({ type: "step-start" });
+    const { text } = await stream({
+      mode: "chat",
+      model,
+      message: prompt,
+      signal,
+      onDelta: (d) => onDelta?.({ type: "delta", text: d }),
+    });
+    onDelta?.({ type: "step-end" });
     history.push({ role: "assistant", content: text });
 
     const call = parseToolCall(text);

package/src/api.js

@@ -43,57 +43,89 @@ async function parseError(resp) {
  * Stream a chat/merge/search request from the gateway.
  * @returns {Promise<{text:string, reasoning:string}>}
  */
-export async function stream({ mode = "chat", message, model, signal, onDelta, onReasoning, onStatus }) {
+export async function stream({ mode = "chat", message, model, signal, onDelta, onReasoning, onStatus, idleMs = 120000 }) {
   const endpoint = mode === "search" ? "/api/search" : mode === "merge" ? "/api/merge" : "/api/chat";
   const body = mode === "search" ? { query: message } : mode === "merge" ? { message } : { message, model };
 
-  const resp = await fetch(config.gatewayUrl + endpoint, {
-    method: "POST",
-    headers: authHeaders(),
-    body: JSON.stringify(body),
-    signal,
-  });
-
-  if (!resp.ok || !resp.body) throw await parseError(resp);
+  // Idle-timeout: nếu KHÔNG nhận được byte nào trong idleMs (kết nối treo), tự
+  // huỷ và báo lỗi rõ ràng — thay vì spinner quay vô tận. Vẫn tôn trọng signal
+  // của người dùng (Ctrl+C). Phân biệt 2 trường hợp qua cờ `timedOut`.
+  const ctrl = new AbortController();
+  let timedOut = false;
+  const onUserAbort = () => ctrl.abort();
+  signal?.addEventListener("abort", onUserAbort, { once: true });
+  let idle;
+  const arm = () => {
+    clearTimeout(idle);
+    idle = setTimeout(() => {
+      timedOut = true;
+      ctrl.abort();
+    }, idleMs);
+  };
 
-  const reader = resp.body.getReader();
-  const decoder = new TextDecoder();
-  let buf = "";
   let text = "";
   let reasoning = "";
 
-  while (true) {
-    const { done, value } = await reader.read();
-    if (done) break;
-    buf += decoder.decode(value, { stream: true });
-    let nl;
-    while ((nl = buf.indexOf("\n")) !== -1) {
-      const line = buf.slice(0, nl).trim();
-      buf = buf.slice(nl + 1);
-      if (!line.startsWith("data:")) continue;
-      const data = line.slice(5).trim();
-      if (!data) continue;
-      let p;
-      try {
-        p = JSON.parse(data);
-      } catch {
-        continue;
-      }
-      if (p.status && onStatus) onStatus(p.status);
-      if (p.delta) {
-        text += p.delta;
-        onDelta?.(p.delta);
-      }
-      if (p.reasoning) {
-        reasoning = p.reasoning;
-        onReasoning?.(p.reasoning);
-        if (p.answer) text = p.answer;
+  // Một dòng SSE → cập nhật text/reasoning. Tách ra để dùng lại khi flush dòng cuối.
+  const processLine = (rawLine) => {
+    const line = rawLine.trim();
+    if (!line.startsWith("data:")) return;
+    const data = line.slice(5).trim();
+    if (!data) return;
+    let p;
+    try {
+      p = JSON.parse(data);
+    } catch {
+      return;
+    }
+    if (p.status && onStatus) onStatus(p.status);
+    if (p.delta) {
+      text += p.delta;
+      onDelta?.(p.delta);
+    }
+    if (p.reasoning) {
+      reasoning = p.reasoning;
+      onReasoning?.(p.reasoning);
+      if (p.answer) text = p.answer;
+    }
+    if (p.error) throw new ApiError(p.error, {});
+  };
+
+  try {
+    arm();
+    const resp = await fetch(config.gatewayUrl + endpoint, {
+      method: "POST",
+      headers: authHeaders(),
+      body: JSON.stringify(body),
+      signal: ctrl.signal,
+    });
+    if (!resp.ok || !resp.body) throw await parseError(resp);
+
+    const reader = resp.body.getReader();
+    const decoder = new TextDecoder();
+    let buf = "";
+    while (true) {
+      const { done, value } = await reader.read();
+      arm(); // có hoạt động → gia hạn idle
+      if (done) break;
+      buf += decoder.decode(value, { stream: true });
+      let nl;
+      while ((nl = buf.indexOf("\n")) !== -1) {
+        processLine(buf.slice(0, nl));
+        buf = buf.slice(nl + 1);
       }
-      if (p.error) throw new ApiError(p.error, { status: resp.status });
     }
-  }
+    buf += decoder.decode(); // flush decoder
+    if (buf.trim()) processLine(buf); // dòng SSE cuối không có '\n' — đừng bỏ sót
 
-  return { text: text.trim(), reasoning: reasoning.trim() };
+    return { text: text.trim(), reasoning: reasoning.trim() };
+  } catch (err) {
+    if (timedOut) throw new ApiError("Kết nối tới máy chủ quá thời gian chờ (treo).", { code: "timeout" });
+    throw err;
+  } finally {
+    clearTimeout(idle);
+    signal?.removeEventListener("abort", onUserAbort);
+  }
 }
 
 /** Fetch the current key's quota/usage from the gateway (no request consumed). */

package/src/i18n.js

@@ -11,6 +11,9 @@ export const t = {
   pressAgainToExit: "nhấn Ctrl+C lần nữa để thoát",
   running: "đang chạy…",
   denied: "đã từ chối",
+  queued: (n, txt) => `⏎ đã xếp hàng [${n}] · gửi khi model xong: ${txt}`,
+  queueCleared: (n) => `(đã xoá ${n} tin đang xếp hàng)`,
+  permRetry: "→ gõ y (đồng ý) · n (từ chối) · a (luôn cho phép)",
 
   // auth
   notLoggedIn:
@@ -61,8 +64,8 @@ export const t = {
   cmdVersion: "/version /v    xem version hiện tại + trạng thái yolo",
   cmdExit: "/exit /quit     thoát",
   tip1: "• Mô tả việc cần làm; noob sẽ đọc/sửa file & chạy lệnh giúp bạn.",
-  tip2: "• Thao tác nguy hiểm sẽ hỏi phép, trừ khi bật yolo (Shift+Tab).",
-  tip3: "• Ctrl+C 1 lần = dừng lượt hiện tại, 2 lần = thoát. CLI không tự tắt sau khi xong.",
+  tip2: "• Đang chạy vẫn gõ tiếp được — tin sẽ xếp hàng & tự gửi khi model xong.",
+  tip3: "• Shift+Tab: bật/tắt yolo nhanh. Ctrl+C 1 lần = dừng lượt, 2 lần = thoát.",
 
   // misc
   yoloOn: "⚠ yolo BẬT — tự động duyệt mọi thao tác sửa file & chạy lệnh",

package/src/repl.js

@@ -44,9 +44,12 @@ export async function startRepl(opts = {}) {
   let closed = false; // đã ngừng đọc vĩnh viễn
   let exiting = false; // ta chủ động thoát (/exit, Ctrl+C ×2)
   let lastPrompt = ""; // áp lại sau khi dựng lại interface
-  const queue = []; // lines đã gõ/pipe, dùng theo thứ tự
-  let waiter = null; // resolver đang chờ dòng kế tiếp
-  let closeBurst = 0;
+  // Hàng đợi tin nhắn (giống Claude Code): khi model đang chạy, gõ thêm câu hỏi
+  // → xếp vào `pending`; xong turn, main loop tự lấy câu kế tiếp gửi lên. CHỈ
+  // main loop tiêu thụ `pending`. Câu trả lời permission đi qua `waiter` riêng,
+  // nên tin xếp hàng KHÔNG bị nhầm thành câu trả lời "cho phép?".
+  const pending = [];
+  let waiter = null; // resolver đang chờ một dòng tươi (prompt / permission)
   let closeAt = 0;
 
   function deliver(line) {
@@ -54,9 +57,11 @@ export async function startRepl(opts = {}) {
       const w = waiter;
       waiter = null;
       w(line);
-    } else {
-      queue.push(line); // type-ahead / buffered — không bao giờ mất
+      return;
     }
+    // Không ai đang hỏi → đây là tin xếp hàng cho lượt kế tiếp.
+    pending.push(line);
+    if (process.stdin.isTTY) console.log(c.dim("  " + t.queued(pending.length, truncate(line, 60))));
   }
   function endInput() {
     closed = true;
@@ -70,31 +75,41 @@ export async function startRepl(opts = {}) {
     const r = readline.createInterface({ input: process.stdin, output: process.stdout, prompt: "" });
     r.on("line", deliver);
     r.on("close", () => {
-      if (exiting || !process.stdin.isTTY) return endInput(); // thoát thật
-      const now = Date.now();
-      if (now - closeAt > 1500) {
-        closeAt = now;
-        closeBurst = 0;
-      }
-      if (++closeBurst > 8) return endInput(); // stdin mất thật → khỏi quay vòng
-      // 'close' bất thường: dựng lại interface, hiện lại prompt; reader vẫn chờ.
-      rl = buildRl();
-      if (lastPrompt) {
-        rl.setPrompt(lastPrompt);
-        rl.prompt();
+      if (exiting) return endInput(); // ta chủ động thoát
+      // EOF THẬT: stdin đã end/destroy (Ctrl+Z trên Windows, Ctrl+D trên *nix),
+      // hoặc stdin không phải TTY (piped) đã đọc hết. Chỉ lúc đó mới dừng.
+      if (!process.stdin.isTTY || process.stdin.readableEnded || process.stdin.destroyed) {
+        return endInput();
       }
+      // 'close' BẤT THƯỜNG trên một TTY còn sống (tranh chấp console khi
+      // paste/đa dòng, tiến trình con, v.v.) → KHÔNG BAO GIỜ thoát. Dựng lại
+      // interface và hiện lại prompt; reader đang chờ vẫn được giữ nguyên. Nếu
+      // close dồn dập thì hoãn 50ms để khỏi quay CPU — nhưng vẫn sống.
+      const now = Date.now();
+      const fast = now - closeAt < 50;
+      closeAt = now;
+      const rebuild = () => {
+        rl = buildRl();
+        if (lastPrompt) {
+          rl.setPrompt(lastPrompt);
+          rl.prompt();
+        }
+      };
+      if (fast) setTimeout(rebuild, 50);
+      else rebuild();
     });
     return r;
   }
   rl = buildRl();
 
   function nextLine() {
-    if (queue.length) return Promise.resolve(queue.shift());
     if (closed) return Promise.resolve(null);
     return new Promise((res) => (waiter = res));
   }
+  // Dòng "tươi": dùng cho prompt chính VÀ cho permission. KHÔNG đụng tới
+  // `pending` (hàng đợi tin nhắn) — chỉ main loop mới rút từ `pending`.
   function ask(prompt) {
-    if (closed && !queue.length) return Promise.resolve(null);
+    if (closed) return Promise.resolve(null);
     lastPrompt = prompt;
     rl.setPrompt(prompt);
     rl.prompt();
@@ -124,6 +139,11 @@ export async function startRepl(opts = {}) {
     if (abort) {
       abort.abort();
       abort = null;
+      if (pending.length) {
+        const n = pending.length;
+        pending.length = 0; // ngắt lượt → xoá luôn tin đang xếp hàng
+        console.log(c.dim("  " + t.queueCleared(n)));
+      }
       console.log(c.err("\n  ✗ " + t.interrupted));
       return; // the main loop will redraw the prompt
     }
@@ -260,9 +280,16 @@ export async function startRepl(opts = {}) {
 
   // Main loop — runs until /exit, double Ctrl+C, or EOF. Never exits after a task.
   while (true) {
-    const raw = await ask(promptStr());
-    if (raw == null) break; // stdin fully closed and drained
-    const input = raw.trim();
+    let input;
+    if (pending.length) {
+      // Có tin xếp hàng → tự gửi câu kế tiếp (không chờ gõ).
+      input = (pending.shift() ?? "").trim();
+      if (process.stdin.isTTY && input) console.log(promptStr() + input);
+    } else {
+      const raw = await ask(promptStr());
+      if (raw == null) break; // stdin fully closed and drained
+      input = raw.trim();
+    }
     if (!input) continue;
     // Bọc cả lượt: một lỗi trong xử lý lệnh/agent không được phép thoát ra
     // ngoài vòng lặp (sẽ rơi vào .catch ở bin/noob.js → process.exit(1) =
@@ -297,48 +324,77 @@ export async function startRepl(opts = {}) {
       const elapsed = ((Date.now() - t0) / 1000).toFixed(0);
       spinner.text = c.dim(`${label}… ${elapsed}s`);
     };
+    const stopSpin = () => {
+      if (timer) {
+        clearInterval(timer);
+        timer = null;
+      }
+      if (spinner.isSpinning) spinner.stop();
+    };
+    const startSpin = (label) => {
+      if (!spinner.isSpinning) spinner.start();
+      if (!timer) timer = setInterval(() => tick(label), 200);
+    };
 
     try {
       if (state.mode !== "chat") {
-        spinner.start();
-        timer = setInterval(() => tick(state.mode === "search" ? t.searching : t.merging), 200);
+        const name = state.mode === "search" ? "Tìm web" : "Merge AI";
+        const label = state.mode === "search" ? t.searching : t.merging;
+        startSpin(label);
+        const printer = makeStreamPrinter(name, "#f59e0b");
         const { text: answer } = await stream({
           mode: state.mode,
           message: text,
           signal: abort.signal,
-          onStatus: (s) => (spinner.text = c.dim("  " + s)),
+          onStatus: (s) => {
+            if (!printer.started) spinner.text = c.dim("  " + s);
+          },
+          onDelta: (d) => {
+            stopSpin();
+            printer.push(d);
+          },
         });
-        clearInterval(timer);
-        spinner.stop();
-        printAnswer(answer, state.mode === "search" ? "Tìm web" : "Merge AI", "#f59e0b");
+        stopSpin();
+        printer.flush();
+        if (!printer.started) printAnswer(answer, name, "#f59e0b");
         return;
       }
 
       state.history.push({ role: "user", content: text });
-      spinner.start();
-      timer = setInterval(() => tick(t.thinking), 200);
+      startSpin(t.thinking);
+      let printer = null;
 
       const answer = await runAgent({
         history: state.history,
         model: state.model.id,
         signal: abort.signal,
         onStatus: () => tick(t.thinking),
+        onDelta: (ev) => {
+          if (ev.type === "step-start") {
+            printer = makeStreamPrinter(state.model.name, providerColor(state.model.provider));
+          } else if (ev.type === "delta") {
+            if (printer.suppressing) return printer.push(ev.text); // nuốt tool JSON → để spinner chạy
+            stopSpin();
+            printer.push(ev.text);
+            if (printer.suppressing) startSpin(t.thinking); // vừa chuyển sang soạn tool
+          } else if (ev.type === "step-end") {
+            printer?.flush();
+          }
+        },
         onTool: async (name, input) => {
-          clearInterval(timer);
-          spinner.stop();
+          stopSpin();
           const res = await execTool(name, input);
-          spinner.start();
-          timer = setInterval(() => tick(t.thinking), 200);
+          startSpin(t.thinking);
           return res;
         },
       });
 
-      clearInterval(timer);
-      spinner.stop();
-      printAnswer(answer, state.model.name, providerColor(state.model.provider));
+      stopSpin();
+      // Lượt cuối không stream ra gì (vd model suy luận trả 1 cục) → in fallback.
+      if ((!printer || !printer.started) && answer?.trim())
+        printAnswer(answer, state.model.name, providerColor(state.model.provider));
     } catch (err) {
-      clearInterval(timer);
-      spinner.stop();
+      stopSpin();
       if (err.name === "AbortError") return;
       printError(err);
     } finally {
@@ -355,11 +411,9 @@ export async function startRepl(opts = {}) {
     else if (name === "edit_file") preview(`- ${truncate(input.old_string)}\n+ ${truncate(input.new_string)}`, input.path);
 
     if (DESTRUCTIVE.has(name) && !state.yolo && !state.autoApprove.has(name)) {
-      const a = ((await ask(c.tool("  cho phép? ") + c.dim("[y] có / [n] không / [a] luôn " + name + " › "))) ?? "n")
-        .trim()
-        .toLowerCase();
+      const a = await askPermission(name);
       if (a === "a") state.autoApprove.add(name);
-      else if (a !== "y" && a !== "") {
+      else if (a === "n") {
         console.log(c.err("  " + t.denied));
         return { allow: false };
       }
@@ -378,6 +432,27 @@ export async function startRepl(opts = {}) {
     }
   }
 
+  // Đọc câu trả lời cho phép một cách CHẮC CHẮN. Chỉ chấp nhận y/n/a (hoặc
+  // Enter = đồng ý). Nếu nhận một dòng lạ & dài — gần như chắc là một tin nhắn
+  // bị paste/gõ nhầm vào đúng lúc prompt hiện ra (đây là thủ phạm làm hỏng &
+  // "tự tắt" trước đây) — thì KHÔNG coi là từ chối: xếp nó vào hàng đợi tin
+  // nhắn rồi HỎI LẠI. Nhờ vậy không thao tác nào bị quyết định bởi rác.
+  async function askPermission(name) {
+    while (true) {
+      const raw = await ask(c.tool("  cho phép? ") + c.dim("[y] có / [n] không / [a] luôn " + name + " › "));
+      if (raw == null) return "n"; // stdin đóng thật
+      const a = raw.trim().toLowerCase();
+      if (a === "" || a === "y" || a === "yes" || a === "có") return "y";
+      if (a === "n" || a === "no" || a === "không") return "n";
+      if (a === "a" || a === "always" || a === "luôn") return "a";
+      if (raw.trim().length > 3) {
+        pending.push(raw); // tin nhắn lạc → xếp hàng, gửi sau khi xong lượt
+        console.log(c.dim("  " + t.queued(pending.length, truncate(raw, 60))));
+      }
+      console.log(c.dim("  " + t.permRetry));
+    }
+  }
+
   // ── slash commands ─────────────────────────────────────────────────────
   async function command(input) {
     const [cmd, ...rest] = input.slice(1).split(/\s+/);
@@ -540,6 +615,56 @@ function printAnswer(text, name, color) {
   );
 }
 
+// In câu trả lời theo dòng token thời gian thực. Vì model emit lời + (tuỳ chọn)
+// MỘT khối ```tool ở cuối, ta giấu mọi thứ từ ```tool trở đi (người dùng chỉ
+// thấy phần lời + hoạt động công cụ riêng). Giữ lại đuôi vài ký tự để không in
+// nửa vời "```to" trước khi kịp nhận ra đó là fence.
+function makeStreamPrinter(name, color) {
+  let buf = "";
+  let printed = 0;
+  let suppress = false;
+  let started = false;
+  let header = false;
+  const HOLD = 8;
+  const write = (s) => {
+    if (!s) return;
+    if (!header) {
+      process.stdout.write("\n" + chalk.hex(color).bold("  ● " + name) + "\n  ");
+      header = true;
+    }
+    process.stdout.write(s.replace(/\n/g, "\n  "));
+    started = true;
+  };
+  return {
+    get started() {
+      return started;
+    },
+    get suppressing() {
+      return suppress;
+    },
+    push(delta) {
+      buf += delta;
+      if (suppress) return;
+      const f = buf.indexOf("```tool");
+      if (f !== -1) {
+        write(buf.slice(printed, f));
+        printed = buf.length;
+        suppress = true;
+        return;
+      }
+      const safeEnd = Math.max(printed, buf.length - HOLD);
+      if (safeEnd > printed) {
+        write(buf.slice(printed, safeEnd));
+        printed = safeEnd;
+      }
+    },
+    flush() {
+      if (!suppress && printed < buf.length) write(buf.slice(printed));
+      if (started) process.stdout.write("\n");
+    },
+  };
+}
+
 function printError(err) {
   const map = {
     missing_key: t.errMissingKey,