@xingjisoft/neutrino 0.1.3 → 0.1.4

package/README.md

@@ -76,7 +76,7 @@ Type a message on the start screen and press `Enter` to begin a new chat.
 | Scroll wheel | Scroll the chat/log, or move through lists |
 | Right-click | Go back (like `Esc`) |
 
-The selection highlight is drawn over whatever is on screen, so it works uniformly on the chat log, the input box and every menu. Selected text is copied with trailing whitespace trimmed per line (shell-style), so it can be pasted straight back into a terminal.
+The selection highlight is drawn over whatever is on screen, so it works uniformly on the chat log, the input box and every menu. Selected text is copied with trailing whitespace trimmed per line (shell-style), so it can be pasted straight back into a terminal. UI chrome (such as the scrollbar) is skipped when copying and highlighting, so a copy never picks up the bar or the padding in front of it.
 
 ## Configuration
 
@@ -121,17 +121,43 @@ node scripts/test-paste.mjs      # verify pasted newlines are flattened to space
 node scripts/test-mouse.mjs      # verify mouse escape-sequence parsing
 node scripts/test-cursor.mjs     # verify click-to-position-cursor math
 node scripts/test-selection.mjs  # verify selection highlighting & text extraction
+node scripts/test-copy.mjs       # verify a copy never includes the scrollbar or trailing padding
 node scripts/test-scrollbar.mjs  # verify the conversation scrollbar size/position and drag maths
 node scripts/test-markdown.mjs   # verify markdown/table rendering (incl. ragged rows)
 node scripts/test-wrap.mjs       # verify indentation & spacing are preserved when wrapping
 node scripts/test-render.mjs     # fuzz the diff renderer + render the chat screen,
                                  # asserting no stale/residual cells are left behind
+node scripts/test-sanitize.mjs   # verify ANSI/control codes never reach the screen
+node scripts/test-drift.mjs      # verify the input area self-heals after terminal drift
+node scripts/test-fetch.mjs      # verify streamed requests release aborts and retry drops
+node scripts/test-compact.mjs    # verify context-compression planning
+node scripts/test-tools.mjs      # verify tool-output folding
 ```
 
 ### Rendering model
 
 The screen is drawn into a `Buffer` of cells which is diffed against the previous frame, so only changed rows are emitted. Rows are erased to the end of the line before being repainted, and the buffer keeps double-width glyphs consistent (writing over one half of a wide character blanks the other half). Together these guarantee that a repainted row can never leave a stale cell behind.
 
+Because only *changed* rows are emitted, a row whose contents happen to be identical from one frame to the next is never rewritten — so if the terminal shifts its own contents behind our back (ConPTY reflowing the buffer mid-resize, a size-race repaint, a stray scroll) that row would stay stale. Two defences cover this: the persistent chrome (input box, tabs, key hints) is repainted on every frame via `Screen.alwaysRepaintRows()`, and the app periodically re-emits the whole cached frame (`Renderer.repaint()`) as a safety net. Both are no-ops when nothing drifted.
+
+### Text hygiene
+
+A cell's glyph is copied straight into the output stream, so a cell holding a *control* character becomes a command the terminal executes — an ESC sequence can move the cursor, clear the screen or leave the alternate buffer, and a TAB shifts the rest of the row. Tool output (ANSI colours from `ls --color`, `git`, `npm`, progress bars, …), file contents and pasted text all carry such bytes, so they are neutralised in three places:
+
+1. `src/sanitize.ts` — `sanitizeText()` removes whole escape sequences (not just the ESC byte, which would leave `[31m` behind as literal text), expands tabs so measured widths match what the terminal draws, and drops any remaining control code. It is applied where untrusted text enters the display (chat messages, tool results, pasted input).
+2. `Buffer` — writing a control character stores a space instead, preserving the column width the caller measured, so no cell can ever hold one.
+3. `Renderer` — a last-resort check when emitting a row, so the byte stream cannot carry a control code even if a cell were populated another way.
+
+### Network resilience
+
+Model responses arrive over a streamed connection that can drop at any point. A single blip should not end the session, so three cases are handled:
+
+- **The request never goes out** (`fetch` rejects) — retried a couple of times with a short backoff, bounded by a connect timeout.
+- **The stream dies before the first byte** — the server or a proxy closed the connection mid-flight (`TypeError: terminated`, `other side closed`, …). Nothing has reached the user, so the request is simply re-issued.
+- **The stream dies after output has started** — retrying would duplicate text, so the error is surfaced instead, with the real reason expanded out of the `error.cause` chain (`fetch failed` alone says nothing useful).
+
+Any stream the consumer walks away from (pause, or a newer turn taking over) always has its body cancelled, so sockets are not leaked.
+
 ## License
 
 Apache-2.0. See [LICENSE](./LICENSE).

package/dist/app.js

@@ -16,6 +16,10 @@ import { SettingsScreen } from "./screens/settings.js";
 import { StartScreen } from "./screens/start.js";
 const CURSOR_BLINK_MS = 530;
 const TOAST_MS = 1600;
+// How often the whole frame is re-emitted as a safety net, so terminal-side
+// drift (ConPTY reflow, stray scroll) can never leave any row stale for long.
+// Re-emitting the cached frame is a no-op when nothing drifted.
+const REPAINT_MS = 2000;
 export class App {
     state = defaultState();
     width;
@@ -28,6 +32,7 @@ export class App {
     blinkTimer = null;
     cursorTimer = null;
     toastTimer = null;
+    repaintTimer = null;
     toast = "";
     // Most recently rendered frame. Kept so a selection can be turned back into
     // text without having to re-run the screen's render.
@@ -81,6 +86,7 @@ export class App {
             if (this.syncSize())
                 this.render();
         }, 200);
+        this.repaintTimer = setInterval(() => this.renderer.repaint(), REPAINT_MS);
         this.pushScreen(new StartScreen());
     }
     onResize() {
@@ -133,7 +139,7 @@ export class App {
         if (this.state.selection)
             applySelection(buf, this.state.selection);
         this.drawToast(buf);
-        this.renderer.render(buf);
+        this.renderer.render(buf, this.top?.alwaysRepaintRows() ?? []);
     }
     drawToast(buf) {
         if (!this.toast)
@@ -240,6 +246,15 @@ export class App {
             return;
         }
         if (ev.type === "move") {
+            // A release can be lost (the pointer left the window, the terminal did
+            // not report button-up, …). Motion with no button held means the gesture
+            // is over, so drop any stale press/drag instead of letting a bare hover
+            // keep scrolling the log or grow a phantom selection.
+            if (!ev.drag) {
+                this.pressed = false;
+                this.pressStart = null;
+                this.barDrag = null;
+            }
             if (this.barDrag) {
                 const bar = this.top?.scrollbar();
                 if (bar) {
@@ -373,6 +388,10 @@ export class App {
         this.running = true;
         if (this.sizeTimer)
             clearInterval(this.sizeTimer);
+        if (this.repaintTimer) {
+            clearInterval(this.repaintTimer);
+            this.repaintTimer = null;
+        }
         if (this.blinkTimer) {
             clearInterval(this.blinkTimer);
             this.blinkTimer = null;

package/dist/compact.js

@@ -0,0 +1,68 @@
+/**
+ * Helpers for compressing a long conversation so it fits back inside the
+ * model's context window.
+ *
+ * Everything here is pure: deciding *what* to summarise, and flattening that
+ * part into a plain transcript. The actual "ask the model to summarise" step
+ * lives in `LLMClient.summarize`, so this module stays trivially unit-testable.
+ */
+/** How many trailing messages are always kept verbatim when compressing. */
+export const COMPACT_KEEP = 4;
+/** Per-message character budget fed to the summariser, to bound its own input. */
+export const COMPACT_MAX_CHARS_PER_MESSAGE = 4000;
+/**
+ * Split `messages` into an older prefix to summarise and a recent suffix to
+ * keep. The kept suffix never begins with a bare tool result — that would be an
+ * orphan without the assistant tool-call that produced it — so such messages
+ * are folded into the prefix instead.
+ *
+ * Returns null when there is nothing worth compressing (the conversation is
+ * already short enough).
+ */
+export function planCompaction(messages, keep = COMPACT_KEEP) {
+    if (keep < 1)
+        keep = 1;
+    const head = [];
+    const tail = [];
+    for (let i = messages.length - 1; i >= 0; i--) {
+        if (tail.length < keep)
+            tail.unshift(messages[i]);
+        else
+            head.push(messages[i]);
+    }
+    head.reverse();
+    // Never open the kept suffix with an orphan tool result.
+    while (tail.length > 1 && tail[0].role === "tool") {
+        head.push(tail.shift());
+    }
+    if (head.length === 0 || tail.length === 0)
+        return null;
+    return { head, tail };
+}
+/**
+ * Flatten messages into a plain transcript for the summariser, clipping each
+ * message so a single huge tool result cannot dominate the summary request.
+ */
+export function transcriptFor(messages, maxCharsPerMessage = COMPACT_MAX_CHARS_PER_MESSAGE) {
+    const clip = (s) => {
+        const t = s.replace(/\r\n?/g, "\n").trim();
+        return t.length > maxCharsPerMessage ? t.slice(0, maxCharsPerMessage) + "\n…[truncated]" : t;
+    };
+    const parts = [];
+    for (const m of messages) {
+        const body = clip(m.content ?? "");
+        if (m.role === "tool") {
+            parts.push(`TOOL ${m.name ?? ""} RESULT:\n${body}`);
+        }
+        else if (m.role === "assistant") {
+            parts.push(`ASSISTANT:\n${body}`);
+        }
+        else if (m.role === "user") {
+            parts.push(`USER:\n${body}`);
+        }
+        else {
+            parts.push(`${m.role.toUpperCase()}:\n${body}`);
+        }
+    }
+    return parts.join("\n\n");
+}

package/dist/config.js

@@ -36,6 +36,9 @@ export const DEFAULT_CONFIG = {
     language: "en",
     theme: "default",
     default_intensity: "High",
+    // Estimated prompt tokens above which the conversation is auto-compressed.
+    // 0 disables auto-compression.
+    context_compress_threshold: 32000,
 };
 export const INTENSITY_LEVELS = ["Low", "Medium", "High", "Max", "Ultra"];
 export const INTENSITY_PARAMS = {
@@ -45,6 +48,18 @@ export const INTENSITY_PARAMS = {
     Max: { temperature: 1.0, top_p: 1.0 },
     Ultra: { temperature: 1.5, top_p: 1.0 },
 };
+/**
+ * Selectable auto-compression thresholds, in estimated prompt tokens.
+ * `0` turns the feature off. Rendered as-is in the settings screen.
+ */
+export const COMPRESS_THRESHOLD_OPTIONS = [
+    { value: 0, label: "Off" },
+    { value: 8000, label: "8K tokens" },
+    { value: 16000, label: "16K tokens" },
+    { value: 32000, label: "32K tokens" },
+    { value: 64000, label: "64K tokens" },
+    { value: 128000, label: "128K tokens" },
+];
 export function ensureDirs() {
     fs.mkdirSync(NEUTRINO_DIR, { recursive: true });
     fs.mkdirSync(SESSION_DIR, { recursive: true });

package/dist/llm/client.js

@@ -1,4 +1,138 @@
 import { INTENSITY_PARAMS } from "../config.js";
+/** How many extra times a request is retried when the connection drops. */
+const NETWORK_RETRIES = 2;
+/** Give up if the server has not started to respond within this window. */
+const CONNECT_TIMEOUT_MS = 120_000;
+/**
+ * System prompt used when compressing a long conversation. The instruction
+ * spells out exactly what must survive compression (goals, decisions, files,
+ * commands) so the summary stays useful for continuing the work.
+ */
+const SUMMARY_SYSTEM_PROMPT = "You compress the conversation history of an AI coding assistant so it fits in a smaller context window. " +
+    "Write a dense, factual summary in the same language as the conversation. Preserve: the user's goals and " +
+    "constraints, decisions that were made, files created or modified (with their paths), commands that were run " +
+    "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.
+ *
+ * `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.
+ */
+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;
+    }
+    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;
+    }
+    // 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));
+}
+/**
+ * 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.
+ */
+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;
+}
 export class LLMClient {
     model;
     provider;
@@ -15,6 +149,25 @@ export class LLMClient {
         this.temperature = params.temperature;
         this.top_p = params.top_p;
     }
+    /**
+     * Ask the model to compress a transcript into a short summary. Returns an
+     * empty string on any failure so the caller can fall back to simply dropping
+     * 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) {
+        const messages = [
+            { role: "system", content: SUMMARY_SYSTEM_PROMPT },
+            { role: "user", content: transcript },
+        ];
+        let out = "";
+        for await (const chunk of this.streamTurn(messages))
+            out += chunk;
+        const text = out.trim();
+        if (!text || text.startsWith("[Error"))
+            return "";
+        return text;
+    }
     async *streamTurn(messages, tools) {
         this.toolCalls = [];
         this.usage = null;
@@ -26,10 +179,38 @@ export class LLMClient {
             yield* this.streamOpenAI(messages, tools);
         }
         catch (e) {
-            yield `\n[Error: ${e instanceof Error ? e.message : String(e)}]`;
+            yield `\n[Error: ${describeError(e)}]`;
         }
     }
+    /**
+     * Drive one request, retrying if the stream dies before it produced anything.
+     *
+     * 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.
+     */
     async *streamOpenAI(messages, tools) {
+        for (let attempt = 0;; attempt++) {
+            this.toolCalls = [];
+            let produced = false;
+            try {
+                for await (const token of this.openAIAttempt(messages, tools)) {
+                    produced = true;
+                    yield token;
+                }
+                return;
+            }
+            catch (e) {
+                if (produced || attempt >= NETWORK_RETRIES || !isRetriableNetworkError(e))
+                    throw e;
+                await sleep(400 * (attempt + 1));
+            }
+        }
+    }
+    /** A single streaming attempt; see `streamOpenAI` for the retry policy. */
+    async *openAIAttempt(messages, tools) {
         const url = this.model.url.replace(/\/+$/, "") + "/chat/completions";
         const headers = {
             "Content-Type": "application/json",
@@ -45,7 +226,7 @@ export class LLMClient {
         };
         if (tools && tools.length)
             payload.tools = tools;
-        const resp = await fetch(url, {
+        const resp = await requestStream(url, {
             method: "POST",
             headers,
             body: JSON.stringify(payload),
@@ -64,66 +245,100 @@ export class LLMClient {
         const decoder = new TextDecoder();
         let buf = "";
         let stopped = false;
-        while (!stopped) {
-            const { done, value } = await reader.read();
-            if (done)
-                break;
-            buf += decoder.decode(value, { stream: true });
-            let idx;
-            while ((idx = buf.indexOf("\n")) >= 0) {
-                const raw = buf.slice(0, idx).replace(/\r$/, "");
-                buf = buf.slice(idx + 1);
-                const line = raw.trim();
-                if (!line)
-                    continue;
-                if (!line.startsWith("data:"))
-                    continue;
-                const data = line.slice(5).trim();
-                if (data === "[DONE]") {
-                    stopped = true;
+        try {
+            while (!stopped) {
+                const { done, value } = await reader.read();
+                if (done)
                     break;
-                }
-                let chunk;
-                try {
-                    chunk = JSON.parse(data);
-                }
-                catch {
-                    continue;
-                }
-                const usage = chunk.usage;
-                if (usage) {
-                    this.usage = {
-                        prompt: usage.prompt_tokens ?? 0,
-                        completion: usage.completion_tokens ?? 0,
-                        total: usage.total_tokens ?? (usage.prompt_tokens ?? 0) + (usage.completion_tokens ?? 0),
-                    };
-                }
-                const choice = chunk.choices?.[0];
-                const delta = choice?.delta ?? {};
-                const content = delta.content;
-                if (typeof content === "string" && content)
-                    yield content;
-                const toolCalls = delta.tool_calls;
-                if (toolCalls) {
-                    for (const tc of toolCalls) {
-                        const i = tc.index ?? 0;
-                        const entry = (toolCallsByIndex[i] ??= { id: "", name: "", arguments: "" });
-                        if (tc.id)
-                            entry.id = tc.id;
-                        if (tc.function?.name)
-                            entry.name = tc.function.name;
-                        if (tc.function?.arguments)
-                            entry.arguments += tc.function.arguments;
+                buf += decoder.decode(value, { stream: true });
+                let idx;
+                while ((idx = buf.indexOf("\n")) >= 0) {
+                    const raw = buf.slice(0, idx).replace(/\r$/, "");
+                    buf = buf.slice(idx + 1);
+                    const line = raw.trim();
+                    if (!line)
+                        continue;
+                    if (!line.startsWith("data:"))
+                        continue;
+                    const data = line.slice(5).trim();
+                    if (data === "[DONE]") {
+                        stopped = true;
+                        break;
+                    }
+                    let chunk;
+                    try {
+                        chunk = JSON.parse(data);
+                    }
+                    catch {
+                        continue;
+                    }
+                    const usage = chunk.usage;
+                    if (usage) {
+                        this.usage = {
+                            prompt: usage.prompt_tokens ?? 0,
+                            completion: usage.completion_tokens ?? 0,
+                            total: usage.total_tokens ?? (usage.prompt_tokens ?? 0) + (usage.completion_tokens ?? 0),
+                        };
+                    }
+                    const choice = chunk.choices?.[0];
+                    const delta = choice?.delta ?? {};
+                    const content = delta.content;
+                    if (typeof content === "string" && content)
+                        yield content;
+                    const toolCalls = delta.tool_calls;
+                    if (toolCalls) {
+                        for (const tc of toolCalls) {
+                            const i = tc.index ?? 0;
+                            const entry = (toolCallsByIndex[i] ??= { id: "", name: "", arguments: "" });
+                            if (tc.id)
+                                entry.id = tc.id;
+                            if (tc.function?.name)
+                                entry.name = tc.function.name;
+                            if (tc.function?.arguments)
+                                entry.arguments += tc.function.arguments;
+                        }
                     }
                 }
             }
         }
+        finally {
+            // The consumer may walk away mid-stream (pause, a newer turn taking over,
+            // or `[DONE]` arriving before the body ends). Always release the reader so
+            // the socket is torn down instead of lingering — leaked streaming bodies
+            // are what eventually make every request fail with "fetch failed".
+            try {
+                await reader.cancel();
+            }
+            catch {
+                // Already closed / errored; nothing left to release.
+            }
+        }
         this.toolCalls = Object.keys(toolCallsByIndex)
             .map((k) => Number(k))
             .sort((a, b) => a - b)
             .map((k) => toolCallsByIndex[k]);
     }
+    /** Anthropic counterpart of `streamOpenAI`, with the same retry policy. */
     async *streamAnthropic(messages) {
+        for (let attempt = 0;; attempt++) {
+            this.toolCalls = [];
+            let produced = false;
+            try {
+                for await (const token of this.anthropicAttempt(messages)) {
+                    produced = true;
+                    yield token;
+                }
+                return;
+            }
+            catch (e) {
+                if (produced || attempt >= NETWORK_RETRIES || !isRetriableNetworkError(e))
+                    throw e;
+                await sleep(400 * (attempt + 1));
+            }
+        }
+    }
+    /** A single streaming attempt; see `streamAnthropic` for the retry policy. */
+    async *anthropicAttempt(messages) {
         const url = this.model.url.replace(/\/+$/, "") + "/messages";
         const headers = {
             "Content-Type": "application/json",
@@ -147,7 +362,7 @@ export class LLMClient {
         };
         if (systemMsg)
             payload.system = systemMsg;
-        const resp = await fetch(url, {
+        const resp = await requestStream(url, {
             method: "POST",
             headers,
             body: JSON.stringify(payload),
@@ -165,41 +380,51 @@ export class LLMClient {
         const decoder = new TextDecoder();
         let buf = "";
         let stopped = false;
-        while (!stopped) {
-            const { done, value } = await reader.read();
-            if (done)
-                break;
-            buf += decoder.decode(value, { stream: true });
-            let idx;
-            while ((idx = buf.indexOf("\n")) >= 0) {
-                const raw = buf.slice(0, idx).replace(/\r$/, "");
-                buf = buf.slice(idx + 1);
-                const line = raw.trim();
-                if (!line || !line.startsWith("data:"))
-                    continue;
-                const data = line.slice(5).trim();
-                if (data === "[DONE]") {
-                    stopped = true;
-                    break;
-                }
-                let chunk;
-                try {
-                    chunk = JSON.parse(data);
-                }
-                catch {
-                    continue;
-                }
-                const type = chunk.type;
-                if (type === "content_block_delta") {
-                    const text = chunk.delta?.text;
-                    if (text)
-                        yield text;
-                }
-                else if (type === "message_stop") {
-                    stopped = true;
+        try {
+            while (!stopped) {
+                const { done, value } = await reader.read();
+                if (done)
                     break;
+                buf += decoder.decode(value, { stream: true });
+                let idx;
+                while ((idx = buf.indexOf("\n")) >= 0) {
+                    const raw = buf.slice(0, idx).replace(/\r$/, "");
+                    buf = buf.slice(idx + 1);
+                    const line = raw.trim();
+                    if (!line || !line.startsWith("data:"))
+                        continue;
+                    const data = line.slice(5).trim();
+                    if (data === "[DONE]") {
+                        stopped = true;
+                        break;
+                    }
+                    let chunk;
+                    try {
+                        chunk = JSON.parse(data);
+                    }
+                    catch {
+                        continue;
+                    }
+                    const type = chunk.type;
+                    if (type === "content_block_delta") {
+                        const text = chunk.delta?.text;
+                        if (text)
+                            yield text;
+                    }
+                    else if (type === "message_stop") {
+                        stopped = true;
+                        break;
+                    }
                 }
             }
         }
+        finally {
+            try {
+                await reader.cancel();
+            }
+            catch {
+                // Already closed / errored; nothing left to release.
+            }
+        }
     }
 }