s-app-scoder-agent 0.5.0 → 0.7.0

package/dist/index.js

@@ -8,53 +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 { 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 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 };
@@ -173,6 +185,22 @@ function parseArgs(argv) {
         args.subcommand = "serve";
         args.task = null;
     }
+    else if (rest[0] === "tui") {
+        // scoder tui [initial-task] — full-screen Ink interface
+        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;
+    }
     return args;
 }
 async function runOnce(cfg, task) {
@@ -193,13 +221,89 @@ async function runOnce(cfg, task) {
         return 2;
     }
 }
+/**
+ * `scoder init` — first-run wizard: asks for the essentials, writes
+ * .scoderrc.json, then offers a live connection test against the provider.
+ */
+export async function runInit() {
+    const { existsSync, writeFileSync } = await import("node:fs");
+    const rcPath = resolve(process.cwd(), ".scoderrc.json");
+    ui.banner("scoder init — configure this project", [
+        ["file", rcPath],
+        ["note", "answers are saved to .scoderrc.json (env vars still override)"],
+    ]);
+    if (existsSync(rcPath)) {
+        const rl0 = createInterface({ input: process.stdin, output: process.stdout });
+        const overwrite = await new Promise((res) => rl0.question(`.scoderrc.json already exists — overwrite? [y/N] `, res));
+        rl0.close();
+        if (!/^y(es)?$/i.test(overwrite.trim())) {
+            ui.info("kept the existing .scoderrc.json");
+            return;
+        }
+    }
+    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)));
+    // 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", suggestModel);
+    const buildCmd = await ask("Build command (empty = auto-detect)", "");
+    const permission = (await ask("Permission mode (auto | ask | readonly)", "auto")).toLowerCase();
+    rl.close();
+    const provider = /api\.anthropic\.com/.test(baseUrl) || /^claude-/i.test(model) ? "anthropic" : "openai";
+    const rc = {
+        model,
+        baseUrl,
+        provider,
+        ...(buildCmd ? { buildCmd } : {}),
+        permissions: { mode: ["auto", "ask", "readonly"].includes(permission) ? permission : "auto" },
+    };
+    writeFileSync(rcPath, JSON.stringify(rc, null, 2) + "\n");
+    ui.success(`wrote ${rcPath} (provider: ${provider})`);
+    const rl2 = createInterface({ input: process.stdin, output: process.stdout });
+    const doTest = await new Promise((res) => rl2.question("Test the connection now? [Y/n] ", res));
+    rl2.close();
+    if (!/^y(es)?$/i.test(doTest.trim()) && doTest.trim() !== "") {
+        ui.info("skipped connection test");
+        return;
+    }
+    if (!apiKey) {
+        ui.warn("no API key provided — set SCODER_API_KEY/OPENAI_API_KEY before running tasks");
+        return;
+    }
+    ui.info(`connecting to ${baseUrl} (${provider}) …`);
+    try {
+        const { LlmClient } = await import("./llm.js");
+        const { AnthropicClient } = await import("./provider-anthropic.js");
+        const client = provider === "anthropic"
+            ? new AnthropicClient({ baseUrl, apiKey, model, maxTokens: 16, temperature: 0 })
+            : new LlmClient({ baseUrl, apiKey, model, maxTokens: 16, temperature: 0 });
+        const res = await client.chat([{ role: "user", content: "Reply with exactly: OK" }], []);
+        const reply = (res.message.content ?? "").trim();
+        ui.success(`connection OK — model replied: ${JSON.stringify(reply)}`);
+    }
+    catch (err) {
+        ui.error(`connection test failed: ${err.message}`);
+        process.exitCode = 2;
+    }
+}
 async function repl(cfg) {
     ui.header(`scoder interactive — model: ${cfg.model}`);
     ui.info('Type a task and press Enter. "exit" or Ctrl+D to quit.');
     const rl = createInterface({ input: process.stdin, output: process.stdout, prompt: "you> " });
     // One shared session for the whole REPL conversation (plan P0.5 §4):
     // every input is a follow-up turn, context carries over, saved continuously.
-    const agent = new Agent(cfg);
+    // /clear swaps in a fresh Agent (the /clear branch reassigns this).
+    let agent = new Agent(cfg);
     process.on("SIGINT", () => {
         ui.warn("\nSIGINT — aborting current task...");
         agent.abort();
@@ -212,6 +316,37 @@ async function repl(cfg) {
             continue;
         if (input === "exit" || input === "quit")
             break;
+        // 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 = next ?? new Agent(cfg);
+                first = true;
+            },
+            resumeAndRun: async (s) => {
+                agent.abort();
+                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 {
             const result = first ? await agent.run(input) : await agent.runTurn(input);
             first = false;
@@ -256,6 +391,10 @@ async function main() {
         logFile: args.logFile,
     });
     // Subcommands
+    if (args.subcommand === "init") {
+        await runInit();
+        return;
+    }
     if (args.subcommand === "list") {
         const sessions = listSessions(cfg.workdir);
         if (sessions.length === 0) {
@@ -320,6 +459,38 @@ 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.");
+            await repl(cfg);
+            return;
+        }
+        if (!cfg.apiKey) {
+            ui.warn("No API key configured — tasks will fail until SCODER_API_KEY (or OPENAI_API_KEY) is set.");
+        }
+        const { runTui } = await import("./tui/app.js");
+        await runTui(cfg, args.task);
+        return;
+    }
     if (args.subcommand === "serve") {
         const { startServer } = await import("./server.js");
         if (!cfg.apiKey) {

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);
@@ -76,9 +100,34 @@ function parseSSELine(line) {
 // ---------------------------------------------------------------------------
 // LlmClient
 // ---------------------------------------------------------------------------
+/**
+ * Serialize conversation history to the OpenAI wire format. Internal ToolCall
+ * shape is `{id, name, arguments}`; the API expects
+ * `{id, type: "function", function: {name, arguments}}`. Some providers
+ * (Upstage/solar) reject assistant tool_calls in the internal shape with a
+ * misleading "Invalid function name: ''" error — always normalize here.
+ */
+function toWireMessages(messages) {
+    return messages.map((m) => {
+        if (m.role === "assistant" && m.tool_calls) {
+            return {
+                role: m.role,
+                content: m.content,
+                tool_calls: m.tool_calls.map((tc) => ({
+                    id: tc.id,
+                    type: "function",
+                    function: { name: tc.name, arguments: tc.arguments },
+                })),
+            };
+        }
+        return m;
+    });
+}
 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
@@ -86,13 +135,20 @@ 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,
+            messages: toWireMessages(messages),
             tools: tools.length > 0 ? tools : undefined,
             temperature: this.opts.temperature,
             max_tokens: this.opts.maxTokens,
@@ -112,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");
@@ -134,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 ?? "",
@@ -150,14 +218,17 @@ 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,
+            messages: toWireMessages(messages),
             tools: tools.length > 0 ? tools : undefined,
             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 {
@@ -180,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 });
@@ -206,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;
@@ -214,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) {
@@ -255,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,
                         };
@@ -262,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 };
     }
 }