s-app-scoder-agent 0.6.0 → 0.8.0

package/dist/index.js

@@ -8,56 +8,65 @@ import { listSessions, resolveSessionId, pruneSessions } from "./session.js";
 import { JsonlLogger } from "./logger.js";
 import { collectUsage, formatCostReport } from "./cost.js";
 import { getVersion as getPackageVersion } from "./version.js";
-import { formatSlashHelp, parseSlashCommand } from "./tui/commands.js";
+import { dispatchCommand } from "./tui/command-registry.js";
 import * as ui from "./ui.js";
 // Single source of truth: read version from package.json (see src/version.ts).
 const VERSION = getPackageVersion();
-const HELP = `scoder — autonomous coding agent CLI
-
-USAGE
-  scoder [options] "<task>"        Run a task autonomously until the build passes
-  scoder                           Start interactive session (chat + tools)
-  scoder tui [task]                Full-screen terminal UI (chat pane, live tool feed)
-  scoder init                      First-run wizard: writes .scoderrc.json + tests the connection
-  scoder list                      List saved sessions for this directory
-  scoder resume <id|last> [task]   Resume a saved session (optionally with a follow-up task)
-  scoder logs [id|last] [filter]   Print a session's JSONL log (requires --log-file runs)
-  scoder cost [--session <id>] [--last <n>]
-                                    Token usage & estimated cost from JSONL logs
-  scoder serve [--port <n>] [--host <addr>]
-                                    Run as an HTTP server: POST tasks, stream
-                                    progress via Server-Sent Events (see below)
-  scoder --version | --help
-
-OPTIONS
-  -m, --model <name>        LLM model (env SCODER_MODEL / OPENAI_MODEL, default gpt-4o-mini)
-  --base-url <url>          OpenAI-compatible API base URL (env SCODER_BASE_URL / OPENAI_BASE_URL)
-  -k, --api-key <key>       API key (env SCODER_API_KEY / OPENAI_API_KEY)
-  --provider <name>         openai | anthropic (env SCODER_PROVIDER; auto-detected from model/baseUrl)
-  -B, --build <cmd>         Build command = stop condition (auto-detected if omitted)
-  -d, --dir <path>          Working directory (default: current directory)
-  -s, --max-steps <n>       Max autonomous loop iterations (default 40)
-  -y, --yes                 Non-interactive mode (auto-approves commands)
-  --permission <mode>       auto | ask | readonly (env SCODER_PERMISSION, default auto)
-  --no-save                 Disable session auto-save to .scoder/sessions/
-  --log-file                Write a JSONL event log to .scoder/logs/<session>.jsonl
-                            (or set SCODER_LOG_FILE=1 / =/path/to/log.jsonl)
-  --session <id>            (cost) Aggregate usage of one specific session
-  --last <n>                (cost) Aggregate usage of the n most recent sessions
-  -h, --help                Show this help
-  -v, --version             Show version
-
-CONFIG FILE
-  .scoderrc.json in the working directory (see .scoderrc.example.json):
-    { "model": "...", "baseUrl": "...", "buildCmd": "...", "maxSteps": 40,
-      "permissions": { "mode": "auto", "allowCommands": ["npm "], "denyCommands": ["curl "] } }
-
-EXAMPLES
-  scoder "add a divide function to src/math.ts with tests"
-  scoder --build "make test" "fix the failing test in utils"
-  scoder --permission ask "npm install express and wire up a route"
-  scoder -m claude-sonnet-4-5 "refactor the parser module"   # auto-detects Anthropic
-  scoder resume last "now add unit tests"
+// Safety net: a stray promise rejection (e.g. a provider socket aborting after
+// its consumer already moved on) must log — never hard-crash the agent.
+process.on("unhandledRejection", (reason) => {
+    const msg = reason instanceof Error ? `${reason.name}: ${reason.message}` : String(reason);
+    ui.warn(`background error (ignored): ${msg.slice(0, 200)}`);
+});
+const HELP = `scoder — autonomous coding agent CLI
+
+USAGE
+  scoder [options] "<task>"        Run a task autonomously until the build passes
+  scoder                           Start interactive session (chat + tools)
+  scoder tui [task]                Full-screen terminal UI (chat pane, live tool feed)
+  scoder init                      First-run wizard: writes .scoderrc.json + tests the connection
+  scoder list                      List saved sessions for this directory
+  scoder models [provider] [--refresh]
+                                    Model catalog (context window, pricing) —
+                                    synced from models.dev, cached 24h
+  scoder resume <id|last> [task]   Resume a saved session (optionally with a follow-up task)
+  scoder logs [id|last] [filter]   Print a session's JSONL log (requires --log-file runs)
+  scoder cost [--session <id>] [--last <n>]
+                                    Token usage & estimated cost from JSONL logs
+  scoder serve [--port <n>] [--host <addr>]
+                                    Run as an HTTP server: POST tasks, stream
+                                    progress via Server-Sent Events (see below)
+  scoder --version | --help
+
+OPTIONS
+  -m, --model <name>        LLM model (env SCODER_MODEL / OPENAI_MODEL, default gpt-4o-mini)
+  --base-url <url>          OpenAI-compatible API base URL (env SCODER_BASE_URL / OPENAI_BASE_URL)
+  -k, --api-key <key>       API key (env SCODER_API_KEY / OPENAI_API_KEY)
+  --provider <name>         openai | anthropic (env SCODER_PROVIDER; auto-detected from model/baseUrl)
+  -B, --build <cmd>         Build command = stop condition (auto-detected if omitted)
+  -d, --dir <path>          Working directory (default: current directory)
+  -s, --max-steps <n>       Max autonomous loop iterations (default 40)
+  -y, --yes                 Non-interactive mode (auto-approves commands)
+  --permission <mode>       auto | ask | readonly (env SCODER_PERMISSION, default auto)
+  --no-save                 Disable session auto-save to .scoder/sessions/
+  --log-file                Write a JSONL event log to .scoder/logs/<session>.jsonl
+                            (or set SCODER_LOG_FILE=1 / =/path/to/log.jsonl)
+  --session <id>            (cost) Aggregate usage of one specific session
+  --last <n>                (cost) Aggregate usage of the n most recent sessions
+  -h, --help                Show this help
+  -v, --version             Show version
+
+CONFIG FILE
+  .scoderrc.json in the working directory (see .scoderrc.example.json):
+    { "model": "...", "baseUrl": "...", "buildCmd": "...", "maxSteps": 40,
+      "permissions": { "mode": "auto", "allowCommands": ["npm "], "denyCommands": ["curl "] } }
+
+EXAMPLES
+  scoder "add a divide function to src/math.ts with tests"
+  scoder --build "make test" "fix the failing test in utils"
+  scoder --permission ask "npm install express and wire up a route"
+  scoder -m claude-sonnet-4-5 "refactor the parser module"   # auto-detects Anthropic
+  scoder resume last "now add unit tests"
 `;
 function parseArgs(argv) {
     const args = { task: null, yes: false, help: false, version: false };
@@ -181,6 +190,13 @@ function parseArgs(argv) {
         args.subcommand = "tui";
         args.task = rest.length > 1 ? rest.slice(1).join(" ") : null;
     }
+    else if (rest[0] === "models") {
+        // scoder models [provider] [--refresh] — models.dev catalog (I-02)
+        args.subcommand = "models";
+        args.modelsProvider = rest[1] && !rest[1].startsWith("--") ? rest[1] : undefined;
+        args.modelsRefresh = rest.includes("--refresh");
+        args.task = null;
+    }
     else if (rest[0] === "init") {
         args.subcommand = "init";
         args.task = null;
@@ -204,6 +220,9 @@ async function runOnce(cfg, task) {
         ui.error(err.message);
         return 2;
     }
+    finally {
+        agent.dispose();
+    }
 }
 /**
  * `scoder init` — first-run wizard: asks for the essentials, writes
@@ -227,9 +246,19 @@ export async function runInit() {
     }
     const rl = createInterface({ input: process.stdin, output: process.stdout });
     const ask = (q, def) => new Promise((res) => rl.question(`${q}${def ? ` [${def}]` : ""}: `, (a) => res(a.trim() || def)));
-    const baseUrl = await ask("API base URL (OpenAI-compatible)", "https://api.openai.com/v1");
+    // I-03: probe local engines first — suggest when found (no auto-switch when
+    // a cloud key exists; user always decides).
+    ui.info("probing local engines (ollama :11434, lmstudio :1234, vllm :8000)…");
+    const { discoverLocalEngines } = await import("./provider-registry.js");
+    const locals = await discoverLocalEngines();
+    for (const e of locals) {
+        ui.info(`  found ${e.provider.id} at ${e.provider.baseUrl} — ${e.models.length} model(s), e.g. ${e.models[0]}`);
+    }
+    const suggestBase = locals[0]?.provider.baseUrl ?? "https://api.openai.com/v1";
+    const suggestModel = locals[0]?.models[0] ?? "gpt-4o-mini";
+    const baseUrl = await ask("API base URL (OpenAI-compatible)", suggestBase);
     const apiKey = await ask("API key (SCODER_API_KEY/OPENAI_API_KEY also work at runtime)", "");
-    const model = await ask("Model", "gpt-4o-mini");
+    const model = await ask("Model", suggestModel);
     const buildCmd = await ask("Build command (empty = auto-detect)", "");
     const permission = (await ask("Permission mode (auto | ask | readonly)", "auto")).toLowerCase();
     rl.close();
@@ -290,35 +319,37 @@ async function repl(cfg) {
             continue;
         if (input === "exit" || input === "quit")
             break;
-        // Slash commands — handled by the UI, never sent to the LLM.
-        const slash = parseSlashCommand(input);
-        if (slash) {
-            if (slash.cmd === "/exit" || slash.cmd === "/quit")
-                break;
-            if (slash.cmd === "/help") {
-                console.log(formatSlashHelp("scoder"));
-                continue;
-            }
-            if (slash.cmd === "/clear") {
+        // Slash commands — registry dùng chung với TUI (T1). Command riêng của
+        // TUI (/review /undo /theme /diff turn-scope) do TUI tự xử lý trước.
+        const host = {
+            agent: () => agent,
+            config: cfg,
+            replaceAgent: (next) => {
                 agent.abort();
-                agent = new Agent(cfg);
+                agent.dispose();
+                agent = next ?? new Agent(cfg);
                 first = true;
-                ui.info("conversation cleared — context reset");
-                continue;
-            }
-            if (slash.cmd === "/cost") {
-                const u = agent.getUsage();
-                console.log(u.calls > 0
-                    ? `session usage: ${u.calls} LLM calls · tokens in ${u.inputTokens} / out ${u.outputTokens}` +
-                        (u.cachedTokens > 0 ? ` (+${u.cachedTokens} cached)` : "")
-                    : "no LLM calls yet in this session");
-                continue;
-            }
-            if (slash.cmd === "/model") {
-                console.log(`model: ${cfg.model} · provider: ${cfg.provider} · build: ${cfg.buildCmd ?? "auto-detect"}`);
-                continue;
-            }
-            ui.error(`unknown command ${slash.cmd} — try /help`);
+            },
+            resumeAndRun: async (s) => {
+                agent.abort();
+                agent.dispose();
+                agent = new Agent(cfg);
+                first = false;
+                await agent.resume(s);
+                return { success: true, steps: 0, buildCmd: cfg.buildCmd, summary: "resumed" };
+            },
+        };
+        const { handled, outcome } = await dispatchCommand(input, host, (text, level) => {
+            if (level === "error")
+                ui.error(text);
+            else
+                console.log(text);
+        });
+        if (handled) {
+            if (outcome?.quit)
+                break;
+            if (outcome?.notice)
+                ui.info(outcome.notice);
             continue;
         }
         try {
@@ -331,6 +362,7 @@ async function repl(cfg) {
             ui.error(err.message);
         }
     }
+    agent.dispose();
     ui.info("bye");
     process.exit(0);
 }
@@ -393,9 +425,11 @@ async function main() {
         });
         try {
             const result = await agent.resume(s, args.task ?? undefined);
+            agent.dispose();
             process.exit(result.success ? 0 : 1);
         }
         catch (err) {
+            agent.dispose();
             ui.error(err.message);
             process.exit(2);
         }
@@ -433,6 +467,25 @@ async function main() {
         console.log(formatCostReport(sessionCosts));
         return;
     }
+    if (args.subcommand === "models") {
+        const { loadCatalog, cacheAgeHours } = await import("./model-catalog.js");
+        const filter = args.modelsProvider ?? null;
+        const { models, source } = await loadCatalog(args.modelsRefresh === true);
+        const age = cacheAgeHours();
+        const ageStr = source === "fallback" ? "offline fallback snapshot" : age < 0 ? "?" : `${age.toFixed(1)}h ago`;
+        console.log(`models catalog — source: ${source} (updated ${ageStr}), ${Object.keys(models).length} entries\n`);
+        const rows = Object.values(models)
+            .filter((m) => !filter || m.provider === filter || m.id.includes(filter))
+            .sort((a, b) => a.provider.localeCompare(b.provider) || a.id.localeCompare(b.id))
+            .slice(0, 60);
+        for (const m of rows) {
+            const flags = [m.supportCache ? "cache" : null, m.supportReasoning ? "reasoning" : null].filter(Boolean).join(",");
+            console.log(`  ${m.provider}/${m.id}  ctx=${(m.contextWindow / 1000).toFixed(0)}k${m.pricing ? `  $${m.pricing.input}/$${m.pricing.output} per 1M` : ""}${flags ? `  [${flags}]` : ""}`);
+        }
+        if (rows.length === 0)
+            console.log(`  (no models match "${filter}")`);
+        return;
+    }
     if (args.subcommand === "tui") {
         if (!process.stdin.isTTY || !process.stdout.isTTY) {
             ui.warn("TUI requires an interactive terminal (TTY) — falling back to the classic REPL.");

package/dist/json-schema.js

@@ -0,0 +1,58 @@
+/**
+ * M2: JSON-Schema subset validator — không dependency. Hỗ trợ: type,
+ * required, properties, enum, items, additionalProperties=false khi khai báo.
+ * Trả về mảng lỗi (rỗng = hợp lệ). Dùng để validate MCP tool args trước
+ * tools/call — lỗi local, không gọi server.
+ */
+const TYPE_CHECKS = {
+    string: (v) => typeof v === "string",
+    number: (v) => typeof v === "number" && Number.isFinite(v),
+    integer: (v) => typeof v === "number" && Number.isInteger(v),
+    boolean: (v) => typeof v === "boolean",
+    object: (v) => typeof v === "object" && v !== null && !Array.isArray(v),
+    array: (v) => Array.isArray(v),
+    null: (v) => v === null,
+};
+/** Validate value theo schema subset. path dùng cho error message. */
+export function validateSchema(value, schema, path = "args") {
+    if (!schema || typeof schema !== "object")
+        return [];
+    const errors = [];
+    const type = schema.type;
+    if (type !== undefined) {
+        const types = Array.isArray(type) ? type : [type];
+        const ok = types.some((t) => TYPE_CHECKS[t]?.(value));
+        if (!ok) {
+            errors.push(`${path}: expected ${types.join("|")}, got ${jsonType(value)}`);
+            return errors; // sai type — không kiểm tra sâu hơn
+        }
+    }
+    if (Array.isArray(schema.enum) && !schema.enum.some((e) => e === value)) {
+        errors.push(`${path}: must be one of ${schema.enum.map((e) => JSON.stringify(e)).join(", ")}`);
+    }
+    if (TYPE_CHECKS.object(value)) {
+        const obj = value;
+        const props = (schema.properties ?? {});
+        for (const req of schema.required ?? []) {
+            if (!(req in obj))
+                errors.push(`${path}: missing required property "${req}"`);
+        }
+        for (const [k, v] of Object.entries(obj)) {
+            if (props[k])
+                errors.push(...validateSchema(v, props[k], `${path}.${k}`));
+            else if (schema.additionalProperties === false)
+                errors.push(`${path}: unexpected property "${k}"`);
+        }
+    }
+    if (Array.isArray(value) && schema.items) {
+        value.forEach((item, i) => errors.push(...validateSchema(item, schema.items, `${path}[${i}]`)));
+    }
+    return errors;
+}
+function jsonType(v) {
+    if (v === null)
+        return "null";
+    if (Array.isArray(v))
+        return "array";
+    return typeof v;
+}

package/dist/llm.js

@@ -3,6 +3,29 @@
  * and optional SSE streaming.
  */
 import { withRetry } from "./retry.js";
+// ---------------------------------------------------------------------------
+// Secrets redaction (H-13) — shared by LLM error bodies, MCP tool output,
+// compaction summaries and snapshot logs. Never log raw credentials.
+// ---------------------------------------------------------------------------
+const REDACTION_PATTERNS = [
+    [/Bearer\s+[^\s,&\]]+/gi, "Bearer ***REDACTED***"],
+    [/sk-[A-Za-z0-9_-]{8,}/g, "sk-***REDACTED***"],
+    [/sk-ant-[^\s,&\]]+/gi, "sk-ant-***REDACTED***"],
+    [/ghp_[A-Za-z0-9]{20,}/g, "ghp_***REDACTED***"],
+    [/github_pat_[A-Za-z0-9_]{20,}/g, "github_pat_***REDACTED***"],
+    [/xox[bap]-[A-Za-z0-9-]{10,}/g, "xox***REDACTED***"],
+    [/AKIA[0-9A-Z]{16}/g, "AKIA***REDACTED***"],
+    [/-----BEGIN [A-Z ]*PRIVATE KEY-----/g, "***PRIVATE-KEY***"],
+    [/\b(api[_-]?key|token|secret|password)["'\s:=]+[^\s"'&]{8,}/gi, "$1=***REDACTED***"],
+];
+/** Redact known secret shapes from arbitrary tool/LLM/log output. */
+export function redactSecrets(text) {
+    let out = text;
+    for (const [rx, replacement] of REDACTION_PATTERNS) {
+        out = out.replace(rx, replacement);
+    }
+    return out;
+}
 export class LlmError extends Error {
     status;
     retryAfterMs;
@@ -19,8 +42,7 @@ export class LlmError extends Error {
 async function toLlmError(res, url) {
     let body = await res.text().catch(() => "");
     // Redact Bearer token and raw key patterns to avoid leaking secrets in logs/errors
-    body = body.replace(/Bearer\s+[^\s,&\]]+/gi, "Bearer ***REDACTED***");
-    body = body.replace(/sk-[A-Za-z0-9_-]{8,}/g, "sk-***REDACTED***");
+    body = redactSecrets(body);
     const err = new LlmError(`LLM API error ${res.status} at ${url}: ${body.slice(0, 500)}`, res.status);
     // Only honor a REAL Retry-After value: Number("") === 0 would zero the backoff
     const retryAfterHeader = res.headers.get("retry-after");
@@ -53,6 +75,8 @@ export function combinedSignal(external, timeoutMs) {
     }
     return {
         signal: ac.signal,
+        /** Clear only the request timer — keep the SIGINT listener alive. */
+        stopTimer: () => clearTimeout(timer),
         cleanup: () => {
             clearTimeout(timer);
             external?.removeEventListener("abort", onExternal);
@@ -102,6 +126,8 @@ function toWireMessages(messages) {
 export class LlmClient {
     opts;
     streamEnabled;
+    /** Last interrupted stream's accumulated tool calls (H-09 continuation). */
+    lastPartialToolCalls = [];
     constructor(opts) {
         this.opts = opts;
         this.streamEnabled = opts.stream !== false; // default true
@@ -109,10 +135,17 @@ export class LlmClient {
     get model() {
         return this.opts.model;
     }
+    /** T-04: runtime hot-swap — next request uses the new model id. */
+    setModel(model) {
+        this.opts = { ...this.opts, model };
+    }
+    get timeoutMs() {
+        return this.opts.requestTimeoutMs ?? LLM_REQUEST_TIMEOUT_MS;
+    }
     // ── Non-streaming ──────────────────────────────────────────────────────────
     async chat(messages, tools, opts = {}) {
         const url = `${this.opts.baseUrl.replace(/\/$/, "")}/chat/completions`;
-        const { signal, cleanup } = combinedSignal(opts.signal, LLM_REQUEST_TIMEOUT_MS);
+        const { signal, cleanup } = combinedSignal(opts.signal, this.timeoutMs);
         const body = JSON.stringify({
             model: this.opts.model,
             messages: toWireMessages(messages),
@@ -135,10 +168,21 @@ export class LlmClient {
                 return r;
             }, {}, (attempt, delay, reason) => console.error(`⚠  LLM request failed (${reason}), retrying in ${(delay / 1000).toFixed(1)}s (attempt ${attempt}/3)...`));
         }
+        catch (err) {
+            cleanup(); // timer must not survive a failed request
+            throw err;
+        }
+        let data;
+        try {
+            // Keep the timeout alive through the body read — a hung body must also
+            // surface as a timeout, not an eternal await.
+            const pending = res.json();
+            pending.catch(() => { }); // no-op catch for the abort path; awaited below
+            data = (await pending);
+        }
         finally {
             cleanup();
         }
-        const data = (await res.json());
         const choice = data.choices?.[0]?.message;
         if (!choice)
             throw new LlmError("LLM API returned no message in response");
@@ -157,6 +201,7 @@ export class LlmClient {
                 role: "assistant",
                 content: choice.content ?? null,
                 stop_reason: choice.stop_reason ?? (choice.content ? "stop" : undefined),
+                reasoning: typeof choice.reasoning_content === "string" && choice.reasoning_content ? choice.reasoning_content : undefined,
                 tool_calls: choice.tool_calls?.map((tc) => ({
                     id: tc.id ?? "",
                     name: tc.function?.name ?? "",
@@ -173,7 +218,7 @@ export class LlmClient {
      */
     async *streamChat(messages, tools, opts = {}) {
         const url = `${this.opts.baseUrl.replace(/\/$/, "")}/chat/completions`;
-        const { signal, cleanup } = combinedSignal(opts.signal, LLM_REQUEST_TIMEOUT_MS);
+        const { signal, cleanup, stopTimer } = combinedSignal(opts.signal, this.timeoutMs);
         const bodyStr = JSON.stringify({
             model: this.opts.model,
             messages: toWireMessages(messages),
@@ -181,6 +226,9 @@ export class LlmClient {
             temperature: this.opts.temperature,
             max_tokens: this.opts.maxTokens,
             stream: true,
+            // OpenAI-compatible providers only include usage in streaming responses
+            // when this flag is set — without it token accounting silently zeros out.
+            stream_options: { include_usage: true },
         });
         let res;
         try {
@@ -203,15 +251,47 @@ export class LlmClient {
         if (!res.body) {
             throw new LlmError("Response body is not readable (not a streaming response)");
         }
+        // Headers received — the WHOLE-request timeout has served its purpose.
+        // A long stream is normal (big models can stream for minutes), so from
+        // here on we enforce an IDLE timeout instead: reset on every received
+        // chunk; only a truly silent connection for idleTimeoutMs kills the read.
+        // (The old whole-request timer fired mid-stream on long generations —
+        // "LLM stream timed out while reading the response".) SIGINT still aborts
+        // through the same signal — stopTimer keeps the external listener alive.
+        stopTimer();
+        const idleTimeoutMs = opts.idleTimeoutMs ?? this.timeoutMs;
+        const readWithIdleTimeout = async () => {
+            const ac = new AbortController();
+            const t = setTimeout(() => ac.abort(new DOMException(`stream idle for ${idleTimeoutMs / 1000}s`, "TimeoutError")), idleTimeoutMs);
+            try {
+                return await Promise.race([
+                    reader.read(),
+                    new Promise((_, rej) => ac.signal.addEventListener("abort", () => rej(ac.signal.reason), { once: true })),
+                ]);
+            }
+            finally {
+                clearTimeout(t);
+            }
+        };
         // Accumulators for tool_calls across chunks
         const accumulatedToolCalls = [];
         let finalResult;
+        let finalUsage;
         const reader = res.body.getReader();
         const decoder = new TextDecoder();
         let buffer = "";
+        // Reset the partial-call record for this stream (H-09 continuation).
+        this.lastPartialToolCalls = [];
+        // I-05: accumulate reasoning deltas for the final message.
+        let reasoningAccum = "";
         try {
             while (true) {
-                const { done, value } = await reader.read();
+                // Guard the pending read against a late abort (e.g. the idle timeout
+                // firing while the consumer paused at a yield): attaching a no-op
+                // catch prevents an unhandled rejection from crashing the process.
+                const pending = readWithIdleTimeout();
+                pending.catch(() => { });
+                const { done, value } = await pending;
                 if (done)
                     break;
                 buffer += decoder.decode(value, { stream: true });
@@ -229,6 +309,10 @@ export class LlmClient {
                     catch {
                         continue; // skip malformed JSON lines
                     }
+                    // Usage-only final chunk: many providers send usage in a chunk with
+                    // an empty choices array — must not be skipped.
+                    if (chunkData.usage)
+                        finalUsage = { ...chunkData.usage };
                     const choice = chunkData.choices?.[0];
                     if (!choice)
                         continue;
@@ -237,6 +321,11 @@ export class LlmClient {
                     if (delta?.content != null && delta.content.length > 0) {
                         yield { contentDelta: delta.content, done: false };
                     }
+                    // I-05: reasoning_content delta (DeepSeek/OpenRouter style)
+                    if (delta?.reasoning_content) {
+                        reasoningAccum += delta.reasoning_content;
+                        yield { reasoningDelta: delta.reasoning_content, done: false };
+                    }
                     // Tool call deltas
                     if (delta?.tool_calls) {
                         for (const tc of delta.tool_calls) {
@@ -278,6 +367,7 @@ export class LlmClient {
                                 content: null,
                                 stop_reason: choice.finish_reason,
                                 tool_calls: toolCalls.length > 0 ? toolCalls : undefined,
+                                reasoning: reasoningAccum || undefined,
                             },
                             usage: chunkData.usage,
                         };
@@ -285,15 +375,39 @@ export class LlmClient {
                 }
             }
         }
+        catch (err) {
+            // Normalize the abort timeout into LlmError so callers handle it as a
+            // normal provider failure instead of a stray DOMException.
+            const e = err;
+            if (e?.name === "TimeoutError" || /TimeoutError/.test(e?.message ?? "")) {
+                throw new LlmError(`LLM stream timed out (${(e?.message ?? "").includes("idle") ? `no data for ${e.message.replace(/^.*idle for /, "")}` : "while reading the response"})`);
+            }
+            throw err;
+        }
         finally {
-            // Cancel the body (frees the socket) and clear the request timeout
+            // H-09: record complete tool calls accumulated so far, for continuation.
+            this.lastPartialToolCalls = accumulatedToolCalls
+                .filter((tc) => tc.name)
+                .map((tc) => ({ id: tc.id ?? "", name: tc.name, arguments: tc.arguments }));
+            // Cancel the body (frees the socket) and clear the request timeout.
+            // cancel() returns a promise — a rejection after abort must be swallowed
+            // or it becomes an unhandled rejection that kills the process.
             try {
-                reader.cancel();
+                const c = reader.cancel();
+                if (c && typeof c.catch === "function")
+                    c.catch(() => { });
             }
             catch { /* already released */ }
-            reader.releaseLock();
+            try {
+                reader.releaseLock();
+            }
+            catch { /* lock already released */ }
             cleanup();
         }
+        // Attach usage collected from a usage-only chunk (choices: []) if the
+        // finish chunk itself didn't carry it.
+        if (finalResult && !finalResult.usage && finalUsage)
+            finalResult.usage = finalUsage;
         yield { done: true, final: finalResult };
     }
 }