@xingjisoft/neutrino 0.1.7 → 0.2.1

package/dist/bin.js

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 import process from "node:process";
 import { App } from "./app.js";
+import { loadConfig } from "./config.js";
 import { installCrashGuard } from "./terminal/restore.js";
 import { startWebServer } from "./web/server.js";
 const DEFAULT_WEB_PORT = 8765;
@@ -31,25 +32,28 @@ function printHelp() {
     process.stdout.write(`Neutrino
 
 Usage:
-  neutrino                     Start the terminal UI.
-  neutrino --web-port <port>   Start the terminal UI and mount the web UI.
+  neutrino                     Start the terminal UI (with the web UI).
+  neutrino --lan               Start both, reachable from other devices.
   neutrino web [--port <port>] Start only the web UI (serves saved history).
 
 Options:
-  -p, --port <port>   Web server port (web mode). Default: ${DEFAULT_WEB_PORT}
+  -p, --port <port>   Web UI port. Default: ${DEFAULT_WEB_PORT}
       --host <host>   Interface to bind. Default: 127.0.0.1
       --lan           Short for --host ${WILDCARD_HOST}: reachable from other
                       devices on your LAN or VPN.
+      --no-web        Do not start the web UI with the terminal UI.
       --no-auth       Serve without password login.
-      --web-port <n>  Also mount the web UI while the TUI runs.
+      --web-port <n>  Deprecated alias for --port while the TUI runs.
   -h, --help          Show this help.
 
 Environment:
-  NEUTRINO_WEB_PORT   Same as --web-port for the TUI, or the port in web mode.
+  NEUTRINO_WEB_PORT   Same as --port in either mode.
   NEUTRINO_WEB_HOST   Same as --host.
 
-The web UI can read every saved conversation and drive an agent with shell
-access, so it binds to loopback by default. Log in with the permanent password
+The web UI starts by default alongside the terminal UI on loopback. Turn it
+off for one run with --no-web, or permanently in Settings → Web console. It can
+read every saved conversation and drive an agent with shell access, so it binds
+to loopback unless you ask for --host/--lan. Log in with the permanent password
 (default: 114514). Change it in Settings. --no-auth disables password login.
 `);
 }
@@ -62,7 +66,7 @@ function requireValue(argv, index, flag) {
     return value;
 }
 function parseArgs(argv) {
-    const options = { mode: "tui", port: null, lan: false, noAuth: false };
+    const options = { mode: "tui", port: null, lan: false, noWeb: false, noAuth: false };
     for (let i = 0; i < argv.length; i += 1) {
         const arg = argv[i];
         if (arg === "web") {
@@ -89,6 +93,9 @@ function parseArgs(argv) {
         else if (arg === "--lan") {
             options.lan = true;
         }
+        else if (arg === "--no-web") {
+            options.noWeb = true;
+        }
         else if (arg === "--no-auth") {
             options.noAuth = true;
         }
@@ -103,6 +110,12 @@ function parseArgs(argv) {
     if (options.lan && options.host) {
         throw new Error("use either --lan or --host, not both");
     }
+    if (options.noWeb && options.mode === "web") {
+        throw new Error("--no-web cannot be used with the 'web' command");
+    }
+    if (options.noWeb && (options.port !== null || options.host !== undefined || options.lan)) {
+        throw new Error("use either --no-web or web UI options, not both");
+    }
     return options;
 }
 /** Print every address a client can open, plus what it takes to open one. */
@@ -140,10 +153,11 @@ catch (err) {
 installCrashGuard();
 const host = options.lan ? WILDCARD_HOST : options.host || process.env.NEUTRINO_WEB_HOST || undefined;
 const auth = !options.noAuth;
+const portFromEnv = envPort();
 if (options.mode === "web") {
     // Headless: serve the saved history (and any live sessions in this process,
     // which for a standalone server is none).
-    const port = options.port ?? envPort() ?? DEFAULT_WEB_PORT;
+    const port = options.port ?? portFromEnv ?? DEFAULT_WEB_PORT;
     try {
         const handle = await startWebServer({ port, host, auth });
         reportAccess(handle);
@@ -166,15 +180,26 @@ else {
         process.exit(1);
     }
     const app = new App();
-    const webPort = options.port ?? envPort();
-    if (webPort !== null) {
+    const webPort = options.port ?? portFromEnv ?? DEFAULT_WEB_PORT;
+    // Remember where the UI should live even when it is off right now, so the
+    // Settings toggle can mount it without restarting the terminal.
+    app.configureWeb(webPort, host, auth);
+    // Explicit web settings win over the saved preference; otherwise the web UI
+    // is part of a normal launch unless the user turned it off in Settings.
+    const requested = options.port !== null || options.host !== undefined || options.lan
+        || options.noAuth || portFromEnv !== null || Boolean(process.env.NEUTRINO_WEB_HOST);
+    const enabledByDefault = loadConfig().web_console !== false;
+    if (!options.noWeb && (requested || enabledByDefault)) {
         try {
             const handle = await app.enableWeb(webPort, host, auth);
             reportAccess(handle);
         }
         catch (err) {
-            process.stderr.write(`neutrino: failed to start web server: ${err instanceof Error ? err.message : String(err)}\n`);
-            process.exit(1);
+            // A console that cannot bind (usually a second instance on 8765) must
+            // never take the terminal down with it.
+            const detail = err instanceof Error ? err.message : String(err);
+            process.stderr.write(`neutrino: web UI not started: ${detail}\n`);
+            process.stderr.write("The terminal UI will keep running. Pass --port <port> to use another port, or --no-web to skip the web UI.\n");
         }
     }
     await app.start();

package/dist/config.js

@@ -11,6 +11,17 @@ export const NEUTRINO_DIR = path.join(os.homedir(), ".neutrino");
 export const MODEL_FILE = path.join(NEUTRINO_DIR, "model.json");
 export const SESSION_DIR = path.join(NEUTRINO_DIR, "session");
 export const CONFIG_FILE = path.join(NEUTRINO_DIR, "config.json");
+/**
+ * Whether assistant messages must be sent back with a `reasoning_content`
+ * field. DeepSeek's thinking mode requires one on *every* assistant message of
+ * a tools-bearing request (an empty string is accepted), and the plan message
+ * written by the planner is otherwise an assistant message without it.
+ */
+export function modelUsesReasoning(provider, model) {
+    if (typeof model.reasoning === "boolean")
+        return model.reasoning;
+    return provider === "DeepSeek" || /deepseek|reasoner|thinking/i.test(model.name);
+}
 export const DEFAULT_CONTEXT_WINDOW = 1_000_000;
 export const CONTEXT_COMPRESSION_RATIO = 0.8;
 export const CONTEXT_WINDOW_OPTIONS = [32_000, 64_000, 128_000, 200_000, 256_000, 512_000, 1_000_000, 2_000_000, 4_000_000];
@@ -56,6 +67,11 @@ export const DEFAULT_CONFIG = {
     language: "en",
     theme: "default",
     default_intensity: "High",
+    // Plan a request into steps before answering it: the planner agent writes the
+    // plan, the worker executes one step per turn. Requests that look like a
+    // single action are never planned (see needsPlan), and false turns planning
+    // off for every request.
+    plan_first: true,
     // Default for new conversations; each conversation can override it.
     approval_mode: "request",
     // Delete-class commands need a human unless this and Auto Approval are on.
@@ -64,6 +80,9 @@ export const DEFAULT_CONFIG = {
     sound_alerts: true,
     // Model that reviews approval requests. Empty = same model as the chat.
     approval_model: "",
+    // Mount the browser UI alongside the terminal UI unless it is turned off
+    // here or on the command line.
+    web_console: true,
     // Initialized as a salted hash of the default Web password on first use.
     web_password_hash: "",
 };
@@ -163,7 +182,7 @@ export function resolveModelSelection(value, requireKey = true) {
         throw new Error("this model has no API key configured");
     return { provider: provider.name, model: { ...model }, intensity: input.intensity };
 }
-export function saveSession(messages, modelName, provider, intensity, cwd, sessionId, tokens, context, approvalMode) {
+export function saveSession(messages, modelName, provider, intensity, cwd, sessionId, tokens, context, approvalMode, plan) {
     ensureDirs();
     const now = new Date();
     const id = sessionId ?? `${now.toISOString().replace(/[:.]/g, "-")}-${randomUUID().slice(0, 8)}`;
@@ -192,6 +211,10 @@ export function saveSession(messages, modelName, provider, intensity, cwd, sessi
     const validContext = normalizeContext(context, messages.filter((m) => m.role !== "system").length);
     if (validContext)
         session.context = validContext;
+    // A plan outlives the turn that produced it: reopening a conversation shows
+    // how far it got, and a stopped plan is still the record of what was agreed.
+    if (plan && plan.steps.length)
+        session.plan = plan;
     const filePath = path.join(SESSION_DIR, `${id}.json`);
     // Keep the last complete transcript intact if writing or replacing fails.
     // The temporary file shares the destination directory so rename is atomic.
@@ -302,6 +325,40 @@ export function loadPrompt() {
     return (readAsset(path.join(PKG_ROOT, "assets", "prompt.txt"), path.join(PKG_ROOT, "prompt.txt")) ??
         "You are Neutrino, a helpful AI coding assistant.");
 }
+/** The planning agent's system prompt. */
+export function loadPlannerPrompt() {
+    return (readAsset(path.join(PKG_ROOT, "assets", "planner.txt"), path.join(PKG_ROOT, "planner.txt")) ??
+        "Split the user's request into ordered, independent steps a coding agent can execute one at a " +
+            "time. Answer with JSON only: {\"goal\": \"...\", \"steps\": [{\"title\": \"...\"}]}.");
+}
+/** Template for the per-step system text; `{{index}}`, `{{plan}}`, … are filled in. */
+export function loadStepPrompt() {
+    return (readAsset(path.join(PKG_ROOT, "assets", "step.txt"), path.join(PKG_ROOT, "step.txt")) ??
+        "You are executing step {{index}} of {{total}} of this plan:\n{{plan}}\n\nDo only: {{step}}\n" +
+            "Verify it, then stop and report what you did.");
+}
+/** The system prompt a delegated sub-agent works from. */
+export function loadSubAgentPrompt() {
+    return (readAsset(path.join(PKG_ROOT, "assets", "subagent.txt"), path.join(PKG_ROOT, "subagent.txt")) ??
+        "You are a sub-agent working on one task delegated by another agent. You cannot ask the user " +
+            "anything and you cannot delegate further. Do the task with the tools you have, verify it, and " +
+            "report what you did and what you found in your final message.");
+}
+/**
+ * Whether a turn is planned before it is executed. Unset means on: the plan is
+ * the default workflow, and only an explicit `false` turns it off.
+ *
+ * `NEUTRINO_PLAN=off` overrides both ways for a single run, the way the other
+ * environment variables override the saved configuration.
+ */
+export function planFirstEnabled() {
+    const override = String(process.env.NEUTRINO_PLAN ?? "").trim().toLowerCase();
+    if (override === "off" || override === "0" || override === "false" || override === "no")
+        return false;
+    if (override === "on" || override === "1" || override === "true" || override === "yes")
+        return true;
+    return loadConfig().plan_first !== false;
+}
 let cachedVersion = null;
 /**
  * Read the CLI version straight from the package's `package.json` so the

package/dist/header.js

@@ -23,6 +23,11 @@ export function drawHeader(buf, state) {
     }
     buf.fillRect(0, 0, w, 1, { bg: C.highlightBg });
     let text = `${state.selectedProvider}/${state.selectedModelName} | ${state.selectedIntensity}`;
+    if (state.webUrl) {
+        // A short reminder that the browser console is live; the startup message
+        // prints the full addresses when more than one works.
+        text += `  ·  web ${state.webUrl.replace(/^https?:\/\//, "").replace(/\/$/, "")}`;
+    }
     text = truncateByWidth(text, w);
     buf.centerText(0, text, { fg: C.accent, bg: C.highlightBg, bold: true });
 }

package/dist/llm/client.js

@@ -1,6 +1,9 @@
-import { INTENSITY_PARAMS } from "../config.js";
-/** How many extra times a request is retried when the connection drops. */
-const NETWORK_RETRIES = 2;
+import { INTENSITY_PARAMS, modelUsesReasoning } from "../config.js";
+import { HttpStatusError, describeError, isRetriableFailure, retryDelayMs, retryPolicy, waitBeforeRetry, } from "./retry.js";
+// Callers import `describeError` from this module; it lives next to the
+// classification helpers that share the same "is this a dropped connection?"
+// knowledge, so it is re-exported rather than duplicated.
+export { describeError } from "./retry.js";
 /** Give up if the server has not started to respond within this window. */
 const CONNECT_TIMEOUT_MS = 120_000;
 /**
@@ -14,124 +17,34 @@ const SUMMARY_SYSTEM_PROMPT = "You compress the conversation history of an AI co
     "and their meaningful results, and any unresolved problems or next steps. Drop pleasantries, restated " +
     "instructions and redundant tool output. Output only the summary, with no preface.";
 /**
- * Terse transport messages that all mean "the connection dropped mid-flight".
- * The \b keeps "terminated" from matching unrelated text such as
- * "Unterminated string constant".
- */
-const DROP_HINT_RE = /\bterminated\b|other side closed|socket hang up|premature close/i;
-/**
- * Flatten an error and its `cause` chain into one readable line.
+ * One POST, bounded by a connect timeout.
  *
- * `fetch` reports almost every transport problem as a bare
- * `TypeError: fetch failed`; the actual reason (`ECONNRESET`, `EMFILE`,
- * `ENOTFOUND`, `UND_ERR_…`) is tucked away in `error.cause`. Without walking
- * that chain a failure is impossible to diagnose, so this always reports it.
+ * Retrying deliberately does *not* happen here: only the caller knows whether a
+ * token already reached the user, and nesting two retry loops would multiply
+ * both the request count and the total wait by the attempt budget.
  */
-export function describeError(e) {
-    if (!(e instanceof Error))
-        return String(e);
-    const parts = [];
-    const push = (msg, code) => {
-        const text = code && !msg.includes(code) ? `${msg} (${code})` : msg;
-        if (text && !parts.includes(text))
-            parts.push(text);
-    };
-    let cur = e;
-    const seen = new Set();
-    while (cur != null && !seen.has(cur)) {
-        if (typeof cur === "string") {
-            // fetch/undici sometimes stash the real reason in a plain string
-            // (`cause: "other side closed"`), which an object-only walk would miss.
-            push(cur);
-            break;
-        }
-        if (typeof cur !== "object")
-            break;
-        seen.add(cur);
-        const err = cur;
-        const message = typeof err.message === "string" && err.message ? err.message : String(err.name ?? "Error");
-        const code = typeof err.code === "string" ? err.code : undefined;
-        push(message, code);
-        cur = err.cause;
+async function postStream(url, init) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(new Error(`request timed out after ${CONNECT_TIMEOUT_MS / 1000}s`)), CONNECT_TIMEOUT_MS);
+    try {
+        return await fetch(url, { ...init, signal: controller.signal });
     }
-    const text = parts.join(": ") || e.message;
-    // A dropped mid-stream connection surfaces as a bare `TypeError: terminated`,
-    // which on its own tells the user nothing worth reading.
-    return DROP_HINT_RE.test(text) ? `${text} — the connection was closed before the response finished` : text;
-}
-/**
- * Whether a failed request is worth retrying: a transient connection problem
- * (reset / refused / DNS / timeout) rather than a real response from the API.
- */
-function isRetriableNetworkError(e) {
-    const transient = new Set([
-        "ECONNRESET",
-        "ECONNREFUSED",
-        "ECONNABORTED",
-        "EPIPE",
-        "ETIMEDOUT",
-        "ENETUNREACH",
-        "ENETDOWN",
-        "EAI_AGAIN",
-        "ERR_STREAM_PREMATURE_CLOSE",
-        "UND_ERR_SOCKET",
-        "UND_ERR_CONNECT_TIMEOUT",
-    ]);
-    let cur = e;
-    const seen = new Set();
-    while (cur != null && !seen.has(cur)) {
-        if (typeof cur === "string") {
-            if (DROP_HINT_RE.test(cur))
-                return true;
-            break;
-        }
-        if (typeof cur !== "object")
-            break;
-        seen.add(cur);
-        const err = cur;
-        if (typeof err.code === "string" && transient.has(err.code))
-            return true;
-        // Our own connect timeout aborts with a plain AbortError; undici wraps a
-        // dropped socket in a SocketError.
-        if (err.name === "AbortError" || err.name === "SocketError")
-            return true;
-        // A stream that dies mid-flight: "terminated", "socket hang up", …
-        if (typeof err.message === "string" && DROP_HINT_RE.test(err.message))
-            return true;
-        cur = err.cause;
+    finally {
+        clearTimeout(timer);
     }
-    // Undici's generic wrapper: assume the socket dropped and try again.
-    return e instanceof Error && /fetch failed/i.test(e.message);
 }
-function sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
+/** The policy a stream will actually use, with any per-call override applied. */
+function resolvePolicy(options) {
+    return { ...retryPolicy(), ...options.retry };
 }
 /**
- * Issue a streaming request, retrying a few times on transient network errors
- * and giving up with a clear error if the server never starts responding.
- *
- * Retries are safe here because they only ever happen *before* a response is
- * returned; once bytes start flowing the caller is responsible for the stream.
+ * Wait before the next attempt, telling the caller why the stream went quiet.
+ * Returns false when the caller stopped caring during the wait.
  */
-async function requestStream(url, init) {
-    let lastErr;
-    for (let attempt = 0; attempt <= NETWORK_RETRIES; attempt++) {
-        const controller = new AbortController();
-        const timer = setTimeout(() => controller.abort(new Error(`request timed out after ${CONNECT_TIMEOUT_MS / 1000}s`)), CONNECT_TIMEOUT_MS);
-        try {
-            const resp = await fetch(url, { ...init, signal: controller.signal });
-            clearTimeout(timer);
-            return resp;
-        }
-        catch (e) {
-            clearTimeout(timer);
-            lastErr = e;
-            if (attempt === NETWORK_RETRIES || !isRetriableNetworkError(e))
-                throw e;
-            await sleep(300 * (attempt + 1));
-        }
-    }
-    throw lastErr;
+async function pauseForRetry(attempt, policy, error, options) {
+    const delayMs = retryDelayMs(attempt - 1, policy);
+    options.onRetry?.({ attempt: attempt + 1, attempts: policy.attempts, delayMs, reason: describeError(error) });
+    return waitBeforeRetry(attempt - 1, policy, options.cancelled);
 }
 export class LLMClient {
     model;
@@ -141,6 +54,12 @@ export class LLMClient {
     top_p;
     toolCalls = [];
     usage = null;
+    /**
+     * The thinking text streamed alongside the reply. DeepSeek's thinking mode
+     * requires it to be echoed back on the assistant message that carries a tool
+     * call, so the agent loops attach it to that message.
+     */
+    reasoningContent = "";
     constructor(model, provider, intensity) {
         this.model = model;
         this.provider = provider;
@@ -155,13 +74,13 @@ export class LLMClient {
      * the old messages. Uses a throw-away request (no tools) via the normal
      * streaming path, so provider differences are handled for free.
      */
-    async summarize(transcript) {
+    async summarize(transcript, options = {}) {
         const messages = [
             { role: "system", content: SUMMARY_SYSTEM_PROMPT },
             { role: "user", content: transcript },
         ];
         let out = "";
-        for await (const chunk of this.streamTurn(messages))
+        for await (const chunk of this.streamTurn(messages, undefined, options))
             out += chunk;
         const text = out.trim();
         if (!text || text.startsWith("[Error"))
@@ -172,42 +91,48 @@ export class LLMClient {
      * One-shot completion with its own system prompt. The approval reviewers use
      * this so they never share context with the conversation they are judging.
      */
-    async complete(system, user) {
+    async complete(system, user, options = {}) {
         let out = "";
         for await (const chunk of this.streamTurn([
             { role: "system", content: system },
             { role: "user", content: user },
-        ])) {
+        ], undefined, options)) {
             out += chunk;
         }
         return out.trim();
     }
-    async *streamTurn(messages, tools) {
+    async *streamTurn(messages, tools, options = {}) {
         this.toolCalls = [];
         this.usage = null;
+        this.reasoningContent = "";
         try {
             if (this.provider === "Anthropic") {
-                yield* this.streamAnthropic(messages);
+                yield* this.streamAnthropic(messages, options);
                 return;
             }
-            yield* this.streamOpenAI(messages, tools);
+            yield* this.streamOpenAI(messages, tools, options);
         }
         catch (e) {
             yield `\n[Error: ${describeError(e)}]`;
         }
     }
     /**
-     * Drive one request, retrying if the stream dies before it produced anything.
+     * Drive one request, retrying while the failure is transient.
      *
      * A response can be cut off on the very first read — "terminated" when a
-     * proxy or the server closes the connection mid-flight. Nothing has reached
-     * the user yet, so re-issuing the request is invisible (and cannot duplicate
-     * text). Once a token has been emitted a retry is unsafe, so the error is
-     * surfaced instead.
+     * proxy or the server closes the connection mid-flight — or the request can
+     * never leave at all. Nothing has reached the user yet, so re-issuing is
+     * invisible and cannot duplicate text; the attempts and the 5s/10s/20s/…
+     * backoff live in `retry.ts`.
+     *
+     * Once a token has been emitted a retry would replay the reply from its
+     * beginning, so the error is surfaced instead and the partial text is kept.
      */
-    async *streamOpenAI(messages, tools) {
-        for (let attempt = 0;; attempt++) {
+    async *streamOpenAI(messages, tools, options) {
+        const policy = resolvePolicy(options);
+        for (let attempt = 1;; attempt++) {
             this.toolCalls = [];
+            this.reasoningContent = "";
             let produced = false;
             try {
                 for await (const token of this.openAIAttempt(messages, tools)) {
@@ -217,12 +142,35 @@ export class LLMClient {
                 return;
             }
             catch (e) {
-                if (produced || attempt >= NETWORK_RETRIES || !isRetriableNetworkError(e))
+                if (produced || attempt >= policy.attempts || !isRetriableFailure(e))
                     throw e;
-                await sleep(400 * (attempt + 1));
+                if (!(await pauseForRetry(attempt, policy, e, options)))
+                    return;
             }
         }
     }
+    /**
+     * DeepSeek's thinking mode rejects a tools-bearing request when any assistant
+     * message in its history carries no `reasoning_content` ("The
+     * `reasoning_content` in the thinking mode must be passed back to the API").
+     * An empty string is accepted, which is the honest value for a message that
+     * predates this turn's thinking: a compressed summary, the planner's plan, an
+     * error note or a session saved before this rule existed. Endpoints outside
+     * thinking mode must not receive the field at all.
+     */
+    wireMessages(messages) {
+        if (!modelUsesReasoning(this.provider, this.model)) {
+            return messages.map((message) => {
+                if (message.role !== "assistant" || message.reasoning_content === undefined)
+                    return message;
+                const { reasoning_content: _ignored, ...rest } = message;
+                return rest;
+            });
+        }
+        return messages.map((message) => message.role === "assistant" && typeof message.reasoning_content !== "string"
+            ? { ...message, reasoning_content: "" }
+            : message);
+    }
     /** A single streaming attempt; see `streamOpenAI` for the retry policy. */
     async *openAIAttempt(messages, tools) {
         const url = this.model.url.replace(/\/+$/, "") + "/chat/completions";
@@ -232,7 +180,7 @@ export class LLMClient {
         };
         const payload = {
             model: this.model.name,
-            messages,
+            messages: this.wireMessages(messages),
             temperature: this.temperature,
             top_p: this.top_p,
             stream: true,
@@ -240,15 +188,17 @@ export class LLMClient {
         };
         if (tools && tools.length)
             payload.tools = tools;
-        const resp = await requestStream(url, {
+        const resp = await postStream(url, {
             method: "POST",
             headers,
             body: JSON.stringify(payload),
         });
         if (!resp.ok) {
-            const text = await resp.text().catch(() => "");
-            yield `\n[Error: HTTP ${resp.status}${text ? " - " + text.slice(0, 500) : ""}]`;
-            return;
+            // Thrown rather than printed: a 502/503/504/429 is as transient as a
+            // reset and deserves the same retries, while a 400/401 must surface at
+            // once. `streamTurn` renders the final failure into the transcript.
+            const body = await resp.text().catch(() => "");
+            throw new HttpStatusError(resp.status, body.slice(0, 500));
         }
         if (!resp.body) {
             yield "\n[Error: empty response body]";
@@ -296,6 +246,11 @@ export class LLMClient {
                     }
                     const choice = chunk.choices?.[0];
                     const delta = choice?.delta ?? {};
+                    // DeepSeek calls it reasoning_content; other compatible endpoints use
+                    // the shorter `reasoning`. Neither is part of the visible reply.
+                    const reasoning = delta.reasoning_content ?? delta.reasoning;
+                    if (typeof reasoning === "string" && reasoning)
+                        this.reasoningContent += reasoning;
                     const content = delta.content;
                     if (typeof content === "string" && content)
                         yield content;
@@ -333,8 +288,9 @@ export class LLMClient {
             .map((k) => toolCallsByIndex[k]);
     }
     /** Anthropic counterpart of `streamOpenAI`, with the same retry policy. */
-    async *streamAnthropic(messages) {
-        for (let attempt = 0;; attempt++) {
+    async *streamAnthropic(messages, options) {
+        const policy = resolvePolicy(options);
+        for (let attempt = 1;; attempt++) {
             this.toolCalls = [];
             let produced = false;
             try {
@@ -345,9 +301,10 @@ export class LLMClient {
                 return;
             }
             catch (e) {
-                if (produced || attempt >= NETWORK_RETRIES || !isRetriableNetworkError(e))
+                if (produced || attempt >= policy.attempts || !isRetriableFailure(e))
                     throw e;
-                await sleep(400 * (attempt + 1));
+                if (!(await pauseForRetry(attempt, policy, e, options)))
+                    return;
             }
         }
     }
@@ -376,15 +333,17 @@ export class LLMClient {
         };
         if (systemMsg)
             payload.system = systemMsg;
-        const resp = await requestStream(url, {
+        const resp = await postStream(url, {
             method: "POST",
             headers,
             body: JSON.stringify(payload),
         });
         if (!resp.ok) {
-            const text = await resp.text().catch(() => "");
-            yield `\n[Error: HTTP ${resp.status}${text ? " - " + text.slice(0, 500) : ""}]`;
-            return;
+            // Thrown rather than printed: a 502/503/504/429 is as transient as a
+            // reset and deserves the same retries, while a 400/401 must surface at
+            // once. `streamTurn` renders the final failure into the transcript.
+            const body = await resp.text().catch(() => "");
+            throw new HttpStatusError(resp.status, body.slice(0, 500));
         }
         if (!resp.body) {
             yield "\n[Error: empty response body]";