@synqa/cli 1.2.0 → 1.2.1

package/README.md

@@ -85,6 +85,11 @@ nothing is saved.
 - Shift+Tab cycles the permission mode: `ask before edits`, `auto-accept edits` (file edits in the
   workspace apply without a question, like `--yes`; shell commands still ask) and `plan only` (no
   file is written and no command is run). The mode shows in the footer.
+- While an answer streams, the keyboard is locked: what you type is not echoed or kept. A tool call
+  that is still arriving (for example a large `write_file`) shows a live line such as
+  `⠋ write_file index.html · streaming 18.4 KB…`. Esc or Ctrl+C stops the request and returns to the
+  prompt; if a shell command is still running, press it a second time to leave. A tool call cut off
+  by the output limit is never run: the model is told to split the work into smaller files.
 
 ## Hooks
 
@@ -328,7 +333,9 @@ it. Use git for that.
 ## Develop
 
 From the repo root: `node --test 'cli/test/*.test.ts'` (or `npm test` inside `cli/`). Tests use fake
-`fetch`, fake terminals and temporary folders and never call the live API.
+`fetch`, fake terminals and temporary folders and never call the live API. `test/pty.test.ts` also
+runs the real CLI in a pseudo-terminal through a small Python driver (standard library only) with a
+throwaway home folder and no network; it skips with a message where Python or a PTY is missing.
 
 Sources are TypeScript run directly by Node (type stripping); only erasable syntax is allowed. Node
 will not strip types inside `node_modules`, so the published package ships plain JS: `npm run build`

package/dist/agent.js

@@ -1,6 +1,6 @@
 import { fenceText } from "./sanitize.js";
-import { chat, parseToolArguments } from "./api.js";
-                                                               
+import { AbortedError, chat } from "./api.js";
+                                                                             
 import { runTool, TOOL_DEFS } from "./tools.js";
                                               
                                                       
@@ -42,6 +42,8 @@ export function systemPrompt(tier      , cwd        , notes         , external =
                                   
                                                           
                                                                       
+                                                                                  
+                                                                                       
   
 
                           
@@ -57,6 +59,7 @@ export function systemPrompt(tier      , cwd        , notes         , external =
                                                                               
                                                                                          
                     
+                                                                                 
   
 
 // PreToolUse and PostToolUse hooks. pre returns a reason to block the tool, or undefined to run it.
@@ -73,6 +76,44 @@ export function systemPrompt(tier      , cwd        , notes         , external =
                                                                                     
   
 
+// What the model is told when a tool call was cut off by the output limit. No provider or model
+// name, and no file content: only what to do next.
+export const CUT_OFF_RESULT =
+  "error: this tool call was cut off before its arguments were complete (the output limit was reached), so nothing was run and nothing was written. Split the work into smaller modular files (for example styles.css, app.js and index.html), one short tool call each, and do not repeat the large call.";
+
+// A different failure, a different message: the stream ended early (a dropped connection), not the
+// output limit. The call may be fine to try again as it was.
+export const CONNECTION_LOST_RESULT =
+  "error: the connection ended before this tool call was complete, so nothing was run and nothing was written. This is not a size problem: try the same call again.";
+
+export const CONNECTION_LOST_NOTICE = "connection lost before the response finished; no tool was run";
+
+                                                                                                                                  
+
+// Decides whether a streamed tool call can run. Its arguments must be complete JSON (an object).
+// Policy for finish_reason "length": the cap can only cut the last call, and a call whose JSON
+// parsed is complete (a string closed with its quote cannot hold a truncated file), so it runs
+// as usual; a call with no arguments at all is treated as cut off, because a tool that needs
+// arguments was begun and never filled. Anything that does not parse is never run, and its
+// arguments are stored as "{}" so the next request stays valid.
+// complete: false when the stream ended without [DONE] and without a finish_reason (a dropped
+// connection): then no call is trusted, whatever its arguments look like. Whatever the outcome,
+// `stored` is always a valid JSON object text, so the next request cannot be refused for it.
+export function checkCall(raw        , finishReason         , complete = true)            {
+  if (!complete) return { ok: false, stored: "{}", result: CONNECTION_LOST_RESULT };
+  if (raw.trim() === "") {
+    return finishReason === "length" ? { ok: false, stored: "{}", result: CUT_OFF_RESULT } : { ok: true, args: {}, stored: "{}" };
+  }
+  let v         ;
+  try {
+    v = JSON.parse(raw);
+  } catch {
+    return { ok: false, stored: "{}", result: CUT_OFF_RESULT };
+  }
+  if (!v || typeof v !== "object" || Array.isArray(v)) return { ok: false, stored: "{}", result: "error: tool arguments must be a JSON object" };
+  return { ok: true, args: v                           , stored: raw };
+}
+
 // Runs model -> tools -> model until the model answers without tool calls. Mutates history.
 export async function runAgent(o            )                     {
   const total        = { prompt: 0, completion: 0 };
@@ -86,6 +127,7 @@ export async function runAgent(o            )                     {
   let routing                = null;
   let lastUsage        = { prompt: 0, completion: 0 };
   for (let step = 0; step < MAX_STEPS; step++) {
+    if (o.signal?.aborted) throw new AbortedError();
     o.events.onRequest?.();
     const r = await chat({
       apiKey: o.apiKey,
@@ -95,6 +137,8 @@ export async function runAgent(o            )                     {
       tools: TOOL_DEFS,
       fetchFn: o.fetchFn,
       onText: o.events.onText,
+      onToolProgress: o.events.onToolProgress,
+      signal: o.signal,
       timeoutMs: o.timeoutMs,
       reasoningEffort: o.effort && o.effort !== "default" ? o.effort : undefined,
       now: o.now,
@@ -111,25 +155,37 @@ export async function runAgent(o            )                     {
       lastUsage = r.usage;
     }
     o.events.onTurn(r);
+    if (r.complete === false && r.toolCalls.length) o.events.onNotice?.(CONNECTION_LOST_NOTICE);
+    const checks = r.toolCalls.map((c) => checkCall(c.arguments, r.finishReason, r.complete !== false));
     const assistant          = { role: "assistant", content: r.content || null };
     if (r.toolCalls.length) {
-      assistant.tool_calls = r.toolCalls.map((c) => ({ id: c.id, type: "function", function: { name: c.name, arguments: c.arguments } }));
+      assistant.tool_calls = r.toolCalls.map((c, i) => ({ id: c.id, type: "function", function: { name: c.name, arguments: (checks[i]             ).stored } }));
     }
     o.history.push(assistant);
     if (!r.toolCalls.length) return result();
-    for (const c of r.toolCalls) {
-      o.events.onTool(c.name, c.arguments);
+    // Every call gets exactly one result, also when the person stops the run between calls.
+    for (const [i, c] of r.toolCalls.entries()) {
+      const check = checks[i]             ;
+      const shownArgs = check.stored;
+      o.events.onTool(c.name, shownArgs);
       let result        ;
-      try {
-        const blocked = await o.hooks?.pre(c.name, c.arguments);
-        result = blocked !== undefined ? `blocked by a hook: ${blocked}` : await runTool(o.ctx, c.name, parseToolArguments(c.arguments));
-        if (blocked === undefined) await o.hooks?.post(c.name, c.arguments, result);
-      } catch (err) {
-        result = `error: ${err instanceof Error ? err.message : String(err)}`;
+      if (o.signal?.aborted) {
+        result = "error: stopped by the user before this tool ran";
+      } else if (!check.ok) {
+        result = check.result;
+      } else {
+        try {
+          const blocked = await o.hooks?.pre(c.name, c.arguments);
+          result = blocked !== undefined ? `blocked by a hook: ${blocked}` : await runTool(o.ctx, c.name, check.args);
+          if (blocked === undefined) await o.hooks?.post(c.name, c.arguments, result);
+        } catch (err) {
+          result = `error: ${err instanceof Error ? err.message : String(err)}`;
+        }
       }
-      o.events.onToolResult?.(c.name, c.arguments, result);
+      o.events.onToolResult?.(c.name, shownArgs, result);
       o.history.push({ role: "tool", tool_call_id: c.id, content: result });
     }
+    if (o.signal?.aborted) throw new AbortedError();
   }
   o.events.onText("\n[stopped: step limit reached]\n");
   return result();

package/dist/api.js

@@ -14,14 +14,42 @@ import { REQUEST_TIMEOUT_MS, MAX_OUTPUT_TOKENS, usageFrom } from "./tiers.js";
                          
                                                                
                                                                   
+                                                                                                    
+                                                                                                                
   
 
-                                                                   
+                                                                                                                    
+
+// What the terminal shows while a tool call is still streaming in.
+                            
+                                                        
+               
+                                                  
+                                                                          
+  
+
+const PATH_SCAN_CHARS = 4096;
+
+// The "path" argument out of a possibly cut-off JSON object. Only a string whose closing quote has
+// arrived counts, so a half-received path is never shown. A "path" key inside another string value
+// is escaped there (\"path\"), so it cannot match.
+export function partialPath(raw        )                     {
+  const m = /"path"\s*:\s*"((?:[^"\\]|\\.)*)"/.exec(raw);
+  if (!m) return undefined;
+  try {
+    const v = JSON.parse(`"${m[1]}"`);
+    return typeof v === "string" && v !== "" ? v : undefined;
+  } catch {
+    return undefined;
+  }
+}
 
 // Folds streamed chunks into text and complete tool calls.
 export class StreamAccumulator {
   content = "";
   usage                   ;
+  finishReason                    ;
+  onToolProgress                                         ;
           calls = new Map                     ();
 
   push(chunk     )         {
@@ -32,14 +60,27 @@ export class StreamAccumulator {
       text = delta.content;
       this.content += text;
     }
+    if (typeof choice?.finish_reason === "string") this.finishReason = choice.finish_reason;
     if (delta && Array.isArray(delta.tool_calls)) {
       for (const tc of delta.tool_calls) {
         const idx = typeof tc.index === "number" ? tc.index : 0;
-        const cur = this.calls.get(idx) ?? { id: "", name: "", arguments: "" };
+        const cur = this.calls.get(idx) ?? { id: "", name: "", arguments: "", bytes: 0 };
         if (tc.id) cur.id = tc.id;
         if (tc.function?.name) cur.name += tc.function.name;
-        if (typeof tc.function?.arguments === "string") cur.arguments += tc.function.arguments;
+        if (typeof tc.function?.arguments === "string") {
+          cur.arguments += tc.function.arguments;
+          cur.bytes += Buffer.byteLength(tc.function.arguments);
+        }
         this.calls.set(idx, cur);
+        if (this.onToolProgress && cur.name) {
+          // The path is looked for only near the start and only until it is found, so a 60 KB
+          // argument string is not rescanned on every chunk.
+          if (cur.path === undefined && !cur.scanned) {
+            cur.path = partialPath(cur.arguments.slice(0, PATH_SCAN_CHARS));
+            if (cur.arguments.length >= PATH_SCAN_CHARS) cur.scanned = true;
+          }
+          this.onToolProgress({ index: idx, name: cur.name, bytes: cur.bytes, path: cur.path });
+        }
       }
     }
     const u = usageFrom(chunk?.usage);
@@ -66,7 +107,7 @@ export function parseToolArguments(raw        )                          {
 }
 
 // Parses an SSE byte stream into JSON events; "[DONE]" ends it.
-export async function* sseEvents(body                           )                      {
+export async function* sseEvents(body                           , state                    )                      {
   const dec = new TextDecoder();
   let buf = "";
   for await (const part of body) {
@@ -77,7 +118,7 @@ export async function* sseEvents(body                           )
       buf = buf.slice(nl + 1);
       if (!line.startsWith("data:")) continue;
       const data = line.slice(5).trim();
-      if (data === "[DONE]") return;
+      if (data === "[DONE]") { if (state) state.done = true; return; }
       if (data) yield JSON.parse(data);
     }
   }
@@ -143,17 +184,30 @@ export async function checkKey(apiKey        , fetchFn            = fetch)
                       
                                                                             
                                
+                                                                                                           
+                                                           
                      
                                                                     
                                                           
   
 
+// Thrown when the person aborts a request; not a failure to report as an error.
+export class AbortedError extends Error {
+  constructor() {
+    super("interrupted");
+    this.name = "AbortedError";
+  }
+}
+
 export async function chat(o             )                      {
   const fetchFn = o.fetchFn ?? fetch;
   const now = o.now ?? (() => performance.now());
   const t0 = now();
   const ac = new AbortController();
   const timer = setTimeout(() => ac.abort(), o.timeoutMs ?? REQUEST_TIMEOUT_MS);
+  const onUserAbort = () => ac.abort();
+  if (o.signal?.aborted) { clearTimeout(timer); throw new AbortedError(); }
+  o.signal?.addEventListener("abort", onUserAbort, { once: true });
   try {
     const res = await fetchFn(`${(o.baseUrl ?? API_BASE).replace(/\/+$/, "")}/chat/completions`, {
       method: "POST",
@@ -172,8 +226,10 @@ export async function chat(o             )                      {
     if (!res.ok) throw new ApiError(res.status, friendlyStatus(res.status, res.status === 401 ? "" : await detailOf(res)));
     if (!res.body) throw new ApiError(res.status, "the service sent an empty answer");
     const acc = new StreamAccumulator();
+    acc.onToolProgress = o.onToolProgress;
     let firstAt                    ;
-    for await (const ev of sseEvents(res.body                                        )) {
+    const sseState = { done: false };
+    for await (const ev of sseEvents(res.body                                        , sseState)) {
       const t = acc.push(ev);
       if (firstAt === undefined && acc.hasOutput()) firstAt = now();
       if (t && o.onText) o.onText(t);
@@ -184,14 +240,18 @@ export async function chat(o             )                      {
       toolCalls: acc.toolCalls(),
       usage: acc.usage,
       routing: res.headers.get("x-synqa-routing"),
+      finishReason: acc.finishReason,
+      complete: sseState.done || acc.finishReason !== undefined,
       ttftMs: firstAt === undefined ? undefined : firstAt - t0,
       genMs: firstAt === undefined ? undefined : end - firstAt,
     };
   } catch (err) {
+    if (o.signal?.aborted) throw new AbortedError();
     if (ac.signal.aborted) throw new Error("request timed out");
     throw err;
   } finally {
     clearTimeout(timer);
+    o.signal?.removeEventListener("abort", onUserAbort);
   }
 }
 

package/dist/main.js

@@ -1,6 +1,6 @@
 import { createInterface } from "node:readline/promises";
 import { runAgent } from "./agent.js";
-import { ApiError, checkKey } from "./api.js";
+import { AbortedError, ApiError, checkKey } from "./api.js";
 import { announceNotes, freshHistory, runCommand, statusParts } from "./commands.js";
                                                   
 import { API_BASE, looksLikeKey, readConfig, resolveApiKey, resolveProviderKey, writeConfig, configPath } from "./config.js";
@@ -108,7 +108,7 @@ import { CONTEXT_TOKENS, DEFAULT_TIER, findEffort, findTier, routingLabel } from
 import { accent, dim, stone } from "./theme.js";
                                         
 import { fetchAccount } from "./account.js";
-import { balanceFrom, formatFooter, makeUi, promptText, readVersion, renderBanner, renderStatusLines, Spinner, styleOf, textWidth, TurnRenderer } from "./ui.js";
+import { balanceFrom, formatFooter, makeUi, promptText, readVersion, renderBanner, renderStatusLines, Spinner, styleOf, textWidth, ToolProgressLine, TurnRenderer } from "./ui.js";
 import { PromptFrame } from "./prompt.js";
                                        
 
@@ -242,15 +242,19 @@ export async function main(argv          , input            = process.stdin)
   // the plain text output they had before.
   const chrome = interactive && ui.tty;
   const spinner = new Spinner(process.stdout, { enabled: chrome, ui });
-  const renderer = new TurnRenderer(process.stdout, ui, spinner);
+  const progress = new ToolProgressLine(process.stdout, { enabled: chrome, ui });
+  const renderer = new TurnRenderer(process.stdout, ui, spinner, progress);
   const inCard = (t        ) => (chrome ? renderer.body(t) : t);
   // `detail` is the coloured diff the tools built; the question is sanitized, the diff is not
   // (the tools already escaped every file character in it).
   const confirm = async (q        , detail         )                   => {
     if (!input.isTTY) return false;
     spinner.stop();
+    progress.stop();
     if (detail) term.write(inCard(detail) + "\n"); // with the question, on the terminal
-    const ans = await rl.question(`${accent(style, "?")} ${sanitize(q)} [y/N] `);
+    // The turn lock lets keys through for the length of the question.
+    const ask = () => rl.question(`${accent(style, "?")} ${sanitize(q)} [y/N] `);
+    const ans = keys ? await keys.withKeys(ask) : await ask();
     return /^y(es)?$/i.test(ans.trim());
   };
 
@@ -314,12 +318,23 @@ export async function main(argv          , input            = process.stdin)
   };
   const refreshBalance = () => { void loadBalance().then((b) => { balance = b; }, () => {}); };
 
-  const turn = async (text        )                => {
+  // Returns true when the person stopped the turn with Esc or Ctrl+C.
+  const turn = async (text        )                   => {
     st.history.push({ role: "user", content: text });
+    const ac = new AbortController();
+    let stopped = false;
+    // While the turn runs the keyboard is locked: nothing typed is echoed; Esc or Ctrl+C stops the
+    // request. A second press, with the turn still not ended (a long shell command), leaves.
+    keys?.beginTurn(() => {
+      if (ac.signal.aborted) { restore(); process.exit(130); }
+      stopped = true;
+      ac.abort();
+    });
     try {
       const r = await runAgent({
         apiKey: st.apiKey, tier: st.tier, effort: st.effort, history: st.history, ctx,
         baseUrl: external() ? st.baseUrl : undefined, modelId: external() ? st.modelId : undefined, hooks: toolHooks,
+        signal: ac.signal,
         events: chrome
           ? {
             onRequest: () => renderer.requestStart(),
@@ -327,11 +342,14 @@ export async function main(argv          , input            = process.stdin)
             onTool: (name, a) => renderer.toolStart(name, a),
             onToolResult: (name, _a, result) => renderer.toolResult(name, result),
             onTurn: () => renderer.requestEnd(),
+            onToolProgress: (p) => renderer.toolProgress(p),
+            onNotice: (t) => { renderer.requestEnd(); say(dim(style, `[${t}]`)); },
           }
           : {
             onText: (t) => process.stdout.write(sanitize(t)),
             onTool: (name, a) => process.stdout.write(`\n${dim(style, `> ${sanitize(name)} ${sanitize(a.length > 120 ? a.slice(0, 117) + "..." : a)}`)}\n`),
             onTurn: () => {},
+            onNotice: (t) => console.error(`[${t}]`),
           },
       });
       st.total = { prompt: st.total.prompt + r.total.prompt, completion: st.total.completion + r.total.completion };
@@ -352,12 +370,21 @@ export async function main(argv          , input            = process.stdin)
       }
     } catch (err) {
       spinner.stop(); // the thinking timer ends on an error or an abort too
-      const msg = sanitize(err instanceof Error ? err.message : String(err));
-      const envNote = err instanceof ApiError && err.status === 401 && !external() && process.env.SYNQA_API_KEY?.trim() ? `\n${ENV_KEY_NOTE}` : "";
-      console.error(`\n${chrome ? accent(style, "error") : "error"}: ${msg}${envNote}`);
+      if (chrome) renderer.turnEnd(); // progress line off, cursor at the start of a line
+      if (err instanceof AbortedError) {
+        console.error(`\n${dim(style, "interrupted")}`);
+      } else {
+        const msg = sanitize(err instanceof Error ? err.message : String(err));
+        const envNote = err instanceof ApiError && err.status === 401 && !external() && process.env.SYNQA_API_KEY?.trim() ? `\n${ENV_KEY_NOTE}` : "";
+        console.error(`\n${chrome ? accent(style, "error") : "error"}: ${msg}${envNote}`);
+      }
+    } finally {
+      keys?.endTurn(); // the keyboard is unlocked on every way out
+      progress.stop();
     }
     await fire("Stop", { tokens: st.total.prompt + st.total.completion });
     refresh();
+    return stopped;
   };
 
   // Welcome screen and the Synqa-first gate: chat and every other provider stay locked until a
@@ -388,9 +415,9 @@ export async function main(argv          , input            = process.stdin)
       announceNotes(st, say);
       for (const w of startWarnings(process.env, cwd, undefined, apiKeyFromEnv())) console.error(`Warning: ${w}`);
       await fire("SessionStart", { source: "one-shot" });
-      await turn(prompt);
+      const stopped = await turn(prompt);
       say(dim(style, formatStatus(statusParts(st))));
-      return 0;
+      return stopped ? 130 : 0;
     }
 
     if (needSignIn) {

package/dist/prompt.js

@@ -131,6 +131,8 @@ export class PromptFrame                      {
           capture                                           ; // a selector or secret prompt owns the keys
           lastCols = 0;
           promptStr = "";
+          turnAbort                          ; // set while a response streams: keys are locked
+          holds = 0; // open questions during a turn (y/N): keys go to readline again meanwhile
   // Shift+Tab at the prompt (cycles the permission mode); the footer is redrawn after it.
   onShiftTab                          ;
 
@@ -176,8 +178,29 @@ export class PromptFrame                      {
     rl.on("close", () => this.stop());
   }
 
+  // While a turn runs, typed characters are not echoed or kept: Esc or Ctrl+C calls onAbort and
+  // every other key is dropped. Pasted text was already dropped outside the prompt.
+  beginTurn(onAbort            )       {
+    this.turnAbort = onAbort;
+  }
+
+  endTurn()       {
+    this.turnAbort = undefined;
+  }
+
+  // Runs a question that needs the keyboard (the y/N approval) inside a locked turn.
+  async withKeys   (fn                  )             {
+    this.holds++;
+    try {
+      return await fn();
+    } finally {
+      this.holds--;
+    }
+  }
+
   // Gives the terminal back: raw mode and bracketed paste off. Safe to call any number of times.
   stop()       {
+    this.turnAbort = undefined;
     if (!this.started) return;
     this.started = false;
     this.stdin.off("keypress", this.onKey);
@@ -328,6 +351,11 @@ export class PromptFrame                      {
       this.capture.fn(s, key);
       return;
     }
+    if (this.turnAbort && this.holds === 0) {
+      // A turn is streaming: nothing typed reaches readline, so nothing is echoed.
+      if (!this.pasting && (seq === "\x03" || key?.name === "escape")) this.turnAbort();
+      return;
+    }
     if (!this.pasting && seq === "\x03") this.ctrlC = true;
     if (this.pasting) {
       // Pasted text is never a key press. While a y/N question (or a turn) holds the input it is

package/dist/ui.js

@@ -9,6 +9,7 @@ import { readFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { formatUsd } from "./account.js";
                                                            
+                                             
 import { sanitize, visibleEscapes } from "./sanitize.js";
 import { groupDigits } from "./statusbar.js";
 import { CONTEXT_TOKENS } from "./tiers.js";
@@ -425,6 +426,94 @@ export class Spinner {
   }
 }
 
+// ---------------------------------------------------------------- tool-call progress
+
+export function formatBytes(n        )         {
+  return n < 1024 ? `${n} B` : `${(n / 1024).toFixed(1)} KB`;
+}
+
+export const PROGRESS_INTERVAL_MS = 120; // the line is redrawn at most this often, however fast chunks arrive
+
+// A live line for a tool call that is still streaming in, for example
+//   ⠋ write_file index.html · streaming 18.4 KB...
+// The frame is the terracotta dot-mark of the spinner family, the rest stone. It is one line,
+// always shorter than the terminal, redrawn in place by a throttled timer. With `enabled` false
+// (a pipe, TERM=dumb, a one-shot run) nothing is ever written: no animation, no control codes.
+export class ToolProgressLine {
+          out            ;
+          o                ;
+          timer          = undefined;
+          frame = 0;
+          drawn = false;
+          last                          ;
+
+  constructor(out            , o                ) {
+    this.out = out;
+    this.o = o;
+  }
+
+  get active()          {
+    return this.timer !== undefined;
+  }
+
+  // The newest state of the call being received. The first update draws at once; later ones only
+  // change what the next timed redraw shows.
+  update(p              )       {
+    if (!this.o.enabled) return;
+    this.last = p;
+    if (this.timer !== undefined) return;
+    this.draw();
+    const set = this.o.setTimer ?? ((fn            , ms        ) => {
+      const h = setInterval(fn, ms);
+      (h                          ).unref?.();
+      return h;
+    });
+    this.timer = set(() => this.draw(), this.o.intervalMs ?? PROGRESS_INTERVAL_MS);
+  }
+
+  // The plain line for the current state, cut to the terminal width.
+  line()         {
+    const p = this.last;
+    if (!p) return "";
+    const ui = this.o.ui;
+    const g = glyphs(ui);
+    const frames = g.spin;
+    const f = frames[this.frame % frames.length]          ;
+    const room = ui.columns - 1;
+    const tail = ` ${g.dot} streaming ${formatBytes(p.bytes)}${g.ell}`;
+    const lead = f + " ";
+    const avail = room - textWidth(lead) - textWidth(tail);
+    if (avail < 6) return fit(lead + oneLine(p.name) + tail, room, ui);
+    const name = fit(Array.from(oneLine(p.name)).slice(0, 40).join("") || "tool", avail, ui);
+    const pathRoom = avail - textWidth(name) - 1;
+    const path = p.path && pathRoom >= 4 ? " " + fitPath(oneLine(p.path), pathRoom, ui) : "";
+    return lead + name + path + tail;
+  }
+
+          draw()       {
+    const st = styleOf(this.o.ui);
+    const text = this.line();
+    const f = (glyphs(this.o.ui).spin[this.frame % glyphs(this.o.ui).spin.length]          );
+    this.frame++;
+    if (text === "") return;
+    this.out.write(CR_ERASE + terracotta(st, text.slice(0, f.length)) + stone(st, text.slice(f.length)));
+    this.drawn = true;
+  }
+
+  // Clears the line and stops. Safe to call at any time, any number of times.
+  stop()       {
+    if (this.timer !== undefined) {
+      (this.o.clearTimer ?? ((h         ) => clearInterval(h                                  )))(this.timer);
+      this.timer = undefined;
+    }
+    this.last = undefined;
+    if (this.drawn) {
+      this.out.write(CR_ERASE);
+      this.drawn = false;
+    }
+  }
+}
+
 // ---------------------------------------------------------------- tool cards
 
 // The one piece of an argument list worth showing in a card header.
@@ -543,12 +632,26 @@ export class TurnRenderer {
           out           ;
           ui    ;
           spinner         ;
+          progress                              ;
           midLine = false; // the last thing written was model text with no trailing newline
 
-  constructor(out           , ui    , spinner         ) {
+  constructor(out           , ui    , spinner         , progress                   ) {
     this.out = out;
     this.ui = ui;
     this.spinner = spinner;
+    this.progress = progress;
+  }
+
+  // A tool call is streaming in: the waiting spinner gives way to the live progress line. Text
+  // that ended without a newline is finished first, because the line is redrawn in place.
+  toolProgress(p              )       {
+    if (!this.progress) return;
+    this.spinner.stop();
+    if (!this.progress.active && this.midLine) {
+      this.out.write("\n");
+      this.midLine = false;
+    }
+    this.progress.update(p);
   }
 
   // A request is about to be sent: show that we are waiting for the first token.
@@ -559,6 +662,7 @@ export class TurnRenderer {
   // Model text. The spinner is erased first; the text is stripped of every escape sequence.
   text(t        )       {
     this.spinner.stop();
+    this.progress?.stop();
     const clean = sanitize(t);
     if (clean === "") return;
     this.out.write(clean);
@@ -568,10 +672,12 @@ export class TurnRenderer {
   // The request finished (with or without a tool call).
   requestEnd()       {
     this.spinner.stop();
+    this.progress?.stop();
   }
 
   toolStart(name        , rawArgs        )       {
     this.spinner.stop();
+    this.progress?.stop();
     this.out.write((this.midLine ? "\n" : "") + cardHeader(name, rawArgs, this.ui) + "\n");
     this.midLine = false;
   }
@@ -588,6 +694,7 @@ export class TurnRenderer {
   // Leaves the cursor at the start of a line after a turn.
   turnEnd()       {
     this.spinner.stop();
+    this.progress?.stop();
     if (this.midLine) this.out.write("\n");
     this.midLine = false;
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@synqa/cli",
-  "version": "1.2.0",
+  "version": "1.2.1",
   "description": "Synqa terminal coding agent",
   "type": "module",
   "bin": {