s-app-scoder-agent 0.9.3 → 0.9.6

package/dist/{mcp.js → mcp/manager.js}

@@ -1,26 +1,6 @@
-/**
- * Minimal MCP (Model Context Protocol) client.
- *
- * M3: pluggable transport — `StdioTransport` (JSON-RPC 2.0 over stdin/stdout,
- * line-delimited) và `HttpTransport` (Streamable HTTP: POST JSON-RPC, nhận
- * JSON hoặc SSE stream, echo `Mcp-Session-Id`). Config `url` → http, ngược
- * lại → stdio. Exposes discovered tools as `mcp__<server>__<tool>` prefixed
- * names in the agent's tool registry.
- */
-import { spawn, spawnSync } from "node:child_process";
-import { CLIENT_NAME, getVersion } from "./version.js";
-import { redactSecrets } from "./llm.js";
-export const MCP_TOOL_PREFIX = "mcp__";
-export function mcpToolKey(serverName, toolName) {
-    return `${MCP_TOOL_PREFIX}${serverName}__${toolName}`;
-}
-/** Phase 4: generic MCP resource/prompt tools (advertised only when available). */
-export const MCP_RESOURCE_TOOL_NAMES = new Set([
-    "mcp_list_resources",
-    "mcp_read_resource",
-    "mcp_list_prompts",
-    "mcp_get_prompt",
-]);
+import { redactSecrets } from "../llm/llm.js";
+import { MCP_RESOURCE_TOOL_NAMES, mcpToolKey } from "./types.js";
+import { McpConnection } from "./connection.js";
 const schemaObj = (properties, required) => ({
     type: "object",
     properties,
@@ -29,498 +9,6 @@ const schemaObj = (properties, required) => ({
 });
 const strProp = (description) => ({ type: "string", description });
 const boolProp = (description) => ({ type: "boolean", description });
-/** Expand {env:VAR} references in config env values. */
-export function expandEnv(env) {
-    const out = {};
-    for (const [k, v] of Object.entries(env ?? {})) {
-        out[k] = v.replace(/\{env:([A-Za-z_][A-Za-z0-9_]*)\}/g, (_, n) => process.env[n] ?? "");
-    }
-    return out;
-}
-/** stdio transport — spawn process, line-delimited JSON-RPC trên stdin/stdout. */
-export class StdioTransport {
-    cfg;
-    kind = "stdio";
-    proc = null;
-    /** Tail of the server's stderr (last 4KB) — surfaced on connect failures. */
-    stderrTail = "";
-    buf = "";
-    msgCb = null;
-    downCb = null;
-    constructor(cfg) {
-        this.cfg = cfg;
-    }
-    get alive() {
-        return this.proc !== null && this.proc.exitCode === null;
-    }
-    onMessage(cb) {
-        this.msgCb = cb;
-    }
-    onDown(cb) {
-        this.downCb = cb;
-    }
-    async start() {
-        const command = this.cfg.command;
-        if (!command)
-            throw new Error("MCP stdio transport requires \"command\" in the server config");
-        const p = spawn(command, this.cfg.args ?? [], {
-            stdio: ["pipe", "pipe", "pipe"],
-            env: { ...process.env, ...expandEnv(this.cfg.env) },
-            // Windows: npx/foo.cmd chỉ spawn được qua shell (libuv không tự tìm .cmd).
-            shell: process.platform === "win32",
-        });
-        this.proc = p;
-        p.stderr?.on("data", (c) => {
-            // Keep the tail for diagnostics (server logs/help output on crash);
-            // otherwise stderr is intentionally ignored.
-            this.stderrTail = (this.stderrTail + c.toString("utf8")).slice(-4096);
-        });
-        p.on("error", (e) => this.downCb?.(new Error(`spawn: ${e.message}`)));
-        p.on("exit", (code) => this.downCb?.(new Error(`process exited (code ${code ?? "?"})`)));
-        p.stdout?.on("data", (c) => this.onChunk(c));
-    }
-    send(msg) {
-        if (!this.proc?.stdin?.writable)
-            return Promise.resolve();
-        try {
-            this.proc.stdin.write(JSON.stringify(msg) + "\n");
-        }
-        catch { /* ignore */ }
-        return Promise.resolve();
-    }
-    close() {
-        const p = this.proc;
-        this.proc = null;
-        if (!p)
-            return;
-        // Release pipe handles so the parent process can exit immediately.
-        // On Windows shell:true (cmd.exe wrapper), p.kill() only kills cmd.exe —
-        // the real node child is orphaned and keeps stdout open. Use taskkill /T
-        // to kill the whole process tree; this also works for the plain node case.
-        try {
-            p.stdin?.end();
-        }
-        catch { /* ignore */ }
-        try {
-            p.stdout?.destroy();
-        }
-        catch { /* ignore */ }
-        try {
-            p.stderr?.destroy();
-        }
-        catch { /* ignore */ }
-        try {
-            p.kill();
-        }
-        catch { /* ignore */ }
-        if (process.platform === "win32" && p.pid) {
-            // Fire-and-forget; ignore errors — process may already be gone.
-            spawnSync("taskkill", ["/pid", String(p.pid), "/T", "/F"], { stdio: "ignore", windowsHide: true });
-        }
-    }
-    onChunk(chunk) {
-        this.buf += chunk.toString("utf8");
-        let i;
-        while ((i = this.buf.indexOf("\n")) !== -1) {
-            const line = this.buf.slice(0, i).trim();
-            this.buf = this.buf.slice(i + 1);
-            if (!line)
-                continue;
-            try {
-                this.msgCb?.(JSON.parse(line));
-            }
-            catch { /* skip malformed */ }
-        }
-    }
-}
-/**
- * M3: Streamable HTTP transport — POST một JSON-RPC message, server trả về
- * `application/json` (single response) hoặc `text/event-stream` (SSE; parse
- * các `data:` events). Echo `Mcp-Session-Id` từ initialize trên các request
- * sau. Stateless: lỗi request → reject call hiện tại; call sau tự retry
- * (không cần background reconnect như stdio).
- */
-export class HttpTransport {
-    cfg;
-    kind = "http";
-    sessionId = null;
-    msgCb = null;
-    closed = false;
-    constructor(cfg) {
-        this.cfg = cfg;
-    }
-    get alive() {
-        return !this.closed;
-    }
-    onMessage(cb) {
-        this.msgCb = cb;
-    }
-    onDown(_cb) {
-        // HTTP là stateless — không có channel chết để báo.
-    }
-    async start() {
-        this.closed = false;
-    }
-    async send(msg) {
-        if (this.closed)
-            throw new Error(`MCP HTTP transport "${this.cfg.url}" closed`);
-        const res = await this.post(msg, this.sessionId, undefined);
-        // Session expired (server restart) → thử lại một lần không session.
-        if ((res.status === 404 || res.status === 400) && this.sessionId) {
-            this.sessionId = null;
-            const retry = await this.post(msg, null, undefined);
-            return this.consume(retry);
-        }
-        return this.consume(res);
-    }
-    close() {
-        this.closed = true;
-        this.sessionId = null;
-    }
-    defaultTimeout() {
-        return this.cfg.timeoutMs ?? 120_000;
-    }
-    async post(msg, sessionId, signal) {
-        const url = this.cfg.url;
-        if (!url)
-            throw new Error("MCP HTTP transport requires \"url\" in the server config");
-        const headers = {
-            "content-type": "application/json",
-            accept: "application/json, text/event-stream",
-            ...expandEnv(this.cfg.headers),
-        };
-        if (sessionId)
-            headers["mcp-session-id"] = sessionId;
-        try {
-            // Combine the caller's abort signal (MCP A cancellation) with an idle
-            // timeout into one AbortSignal. AbortSignal.any needs ≥1 real signal.
-            const signals = [AbortSignal.timeout(this.defaultTimeout())];
-            if (signal)
-                signals.push(signal);
-            const combined = signals.length > 1 ? AbortSignal.any(signals) : signals[0];
-            return await fetch(url, {
-                method: "POST",
-                headers,
-                body: JSON.stringify(msg),
-                signal: combined,
-            });
-        }
-        catch (e) {
-            throw new Error(`MCP HTTP "${url}": ${e.message}`, { cause: e });
-        }
-    }
-    async consume(res) {
-        const sid = res.headers.get("mcp-session-id");
-        if (sid)
-            this.sessionId = sid;
-        if (!res.ok) {
-            res.body?.cancel().catch(() => { });
-            throw new Error(`MCP HTTP ${res.status} ${res.statusText}`);
-        }
-        const ct = res.headers.get("content-type") ?? "";
-        if (ct.includes("application/json")) {
-            const body = (await res.text()).trim();
-            if (body) {
-                try {
-                    this.msgCb?.(JSON.parse(body));
-                }
-                catch { /* skip malformed */ }
-            }
-            return;
-        }
-        if (ct.includes("text/event-stream")) {
-            // MCP A: incremental SSE — stream body, emit each JSON-RPC message as
-            // its `data:` event completes, instead of buffering the entire response.
-            await this.consumeSseStream(res.body);
-            return;
-        }
-        // 202/no-content (notifications) — nothing to parse
-    }
-    /** Incremental SSE: read the body as a stream and emit each JSON-RPC message
-     *  as its SSE block (blank-line-separated) completes — no full-body buffer. */
-    async consumeSseStream(body) {
-        if (!body)
-            return;
-        const reader = body.getReader();
-        const decoder = new TextDecoder();
-        let buf = "";
-        try {
-            for (;;) {
-                const { done, value } = await reader.read();
-                if (done)
-                    break;
-                buf += decoder.decode(value, { stream: true }).replace(/\r\n/g, "\n");
-                let sep;
-                while ((sep = buf.indexOf("\n\n")) !== -1) {
-                    const block = buf.slice(0, sep);
-                    buf = buf.slice(sep + 2);
-                    const msg = parseSseEvent(block);
-                    if (msg)
-                        this.msgCb?.(msg);
-                }
-            }
-        }
-        finally {
-            reader.releaseLock();
-        }
-        // Flush any trailing partial SSE block at EOF (no trailing \n\n).
-        if (buf.trim()) {
-            const msg = parseSseEvent(buf);
-            if (msg)
-                this.msgCb?.(msg);
-        }
-    }
-}
-/** Parse a single SSE block (blank-line-separated events) into one JSON-RPC message.
- *  Normalizes CRLF → LF before splitting on the event separator. */
-export function parseSseEvent(block) {
-    const data = block
-        .replace(/\r\n/g, "\n")
-        .split(/\n/)
-        .filter((l) => l.startsWith("data:"))
-        .map((l) => l.slice(5).trim())
-        .join("\n");
-    if (!data)
-        return null;
-    try {
-        return JSON.parse(data);
-    }
-    catch {
-        return null;
-    }
-}
-/** Parse SSE text (legacy buffer-based) thành JSON-RPC messages. */
-export function parseSseMessages(text) {
-    const out = [];
-    for (const block of text.split(/\r?\n\r?\n/)) {
-        const m = parseSseEvent(block);
-        if (m)
-            out.push(m);
-    }
-    return out;
-}
-const RECONNECT_MAX = 5;
-const RECONNECT_BASE_MS = 500; // backoff: 0.5s, 1s, 2s, 4s, 8s
-export class McpConnection {
-    name;
-    cfg;
-    transport;
-    nextId = 1;
-    pending = new Map();
-    /** M1: current state machine position. */
-    state = "connecting";
-    /** M1: status/state sink (AgentEvent mcp_status). */
-    onState = null;
-    /** MCP A: inbound server notifications (tools/list_changed, progress…). */
-    onNotification = null;
-    /** Server-reported metadata from `initialize` (surfaced on /mcp). */
-    serverInfo = {};
-    capabilities = {};
-    instructions = null;
-    /** Protocol version negotiated with the server. */
-    protocolVersion = "2024-11-05";
-    manuallyClosed = false;
-    reconnectAttempt = 0;
-    constructor(name, cfg) {
-        this.name = name;
-        this.cfg = cfg;
-        // M3: url → HTTP transport; ngược lại stdio (default).
-        const kind = cfg.type ?? (cfg.url ? "http" : "stdio");
-        if (kind === "http" && !cfg.url)
-            throw new Error(`MCP server "${name}": type "http" nhưng thiếu url`);
-        if (kind === "stdio" && !cfg.command)
-            throw new Error(`MCP server "${name}": thiếu command`);
-        this.transport = kind === "http" ? new HttpTransport(cfg) : new StdioTransport(cfg);
-    }
-    /** stdio process (null với HTTP) — dùng trong tests. */
-    get proc() {
-        return this.transport.kind === "stdio" ? this.transport.proc : null;
-    }
-    get stderrTail() {
-        return this.transport.kind === "stdio" ? this.transport.stderrTail : "";
-    }
-    get alive() {
-        return this.transport.alive;
-    }
-    setState(s, detail) {
-        this.state = s;
-        this.onState?.(s, detail);
-    }
-    async connect(timeoutMs = 15_000) {
-        this.manuallyClosed = false;
-        await this.startAndHandshake(timeoutMs);
-    }
-    async startAndHandshake(timeoutMs) {
-        await this.transport.start();
-        this.wireTransport();
-        // MCP handshake: initialize + notifications/initialized. Negotiate the
-        // highest protocol version we support that the server accepts.
-        const initRes = await this.rpc("initialize", {
-            protocolVersion: "2024-11-05",
-            capabilities: {},
-            clientInfo: { name: CLIENT_NAME, version: getVersion() },
-        }, timeoutMs);
-        this.protocolVersion = initRes.protocolVersion ?? "2024-11-05";
-        this.capabilities = initRes.capabilities ?? {};
-        this.serverInfo = initRes.serverInfo ?? {};
-        this.instructions = initRes.instructions ?? null;
-        void this.transport.send({ jsonrpc: "2.0", method: "notifications/initialized" }).catch(() => {
-            // notification — không có pending để reject; lỗi sẽ lộ ở call sau.
-        });
-        this.setState("ready", "connected");
-    }
-    /** Wire inbound messages + channel-death → reconnect (stdio only). */
-    wireTransport() {
-        this.transport.onMessage((msg) => {
-            if (msg.id === undefined) {
-                // Server notifications (tools/list_changed, progress, message) —
-                // route them to the manager so it can react (re-register tools etc.).
-                this.onNotification?.(msg);
-                return;
-            }
-            const pending = this.pending.get(msg.id);
-            if (!pending)
-                return;
-            this.pending.delete(msg.id);
-            const err = msg.error;
-            if (err)
-                pending.reject(new Error(`${err.code}: ${err.message}`));
-            else
-                pending.resolve((msg.result ?? {}));
-        });
-        if (this.transport.kind === "stdio") {
-            this.transport.onDown((err) => {
-                // M1: exit → drain pending (reject rõ ràng) → reconnect, trừ khi
-                // kill() chủ đích.
-                this.drain(new Error(`MCP server "${this.name}" ${err.message}`));
-                if (this.manuallyClosed)
-                    return;
-                void this.scheduleReconnect();
-            });
-        }
-    }
-    /** M1: exponential backoff reconnect — tools/list refresh do Manager lo. */
-    async scheduleReconnect() {
-        if (this.reconnectAttempt >= RECONNECT_MAX) {
-            this.setState("dead", `reconnect failed after ${RECONNECT_MAX} attempts`);
-            return;
-        }
-        this.reconnectAttempt++;
-        const delay = RECONNECT_BASE_MS * 2 ** (this.reconnectAttempt - 1);
-        this.setState("reconnecting", `attempt ${this.reconnectAttempt}/${RECONNECT_MAX} in ${delay}ms`);
-        await new Promise((r) => setTimeout(r, delay));
-        if (this.manuallyClosed)
-            return;
-        try {
-            await this.startAndHandshake(15_000);
-            this.reconnectAttempt = 0;
-            this.setState("ready", "reconnected");
-        }
-        catch (e) {
-            this.drain(e);
-            await this.scheduleReconnect();
-        }
-    }
-    /** MCP A: liveness probe — prefer ping (official MCP spec), fallback tools/list. */
-    async healthy(timeoutMs = 5_000) {
-        if (!this.alive)
-            return false;
-        try {
-            // ping was added in MCP 2025-03; fall back to tools/list for older servers.
-            if (this.capabilities.ping === true) {
-                await this.rpc("ping", {}, timeoutMs);
-            }
-            else {
-                await this.rpc("tools/list", {}, timeoutMs);
-            }
-            return true;
-        }
-        catch {
-            return false;
-        }
-    }
-    /** MCP A: explicit ping. */
-    async ping(timeoutMs = 5_000) {
-        await this.rpc("ping", {}, timeoutMs);
-    }
-    async listTools(timeoutMs = 120_000) {
-        const res = await this.rpc("tools/list", {}, timeoutMs);
-        return (res.tools ?? []).filter((t) => typeof t.name === "string");
-    }
-    // ── Phase 4: resources ────────────────────────────────────────────────────
-    async listResources(timeoutMs = 30_000) {
-        const res = await this.rpc("resources/list", {}, timeoutMs);
-        return (res.resources ?? []).filter((r) => typeof r.uri === "string");
-    }
-    async listResourceTemplates(timeoutMs = 30_000) {
-        const res = await this.rpc("resources/templates/list", {}, timeoutMs);
-        return (res.resourceTemplates ?? []).filter((r) => typeof r.uriTemplate === "string");
-    }
-    async readResource(uri, timeoutMs = 30_000) {
-        const res = await this.rpc("resources/read", { uri }, timeoutMs);
-        return { contents: res.contents ?? [] };
-    }
-    async subscribeResource(uri, timeoutMs = 30_000) {
-        await this.rpc("resources/subscribe", { uri }, timeoutMs);
-    }
-    async unsubscribeResource(uri, timeoutMs = 30_000) {
-        await this.rpc("resources/unsubscribe", { uri }, timeoutMs);
-    }
-    // ── Phase 4: prompts ──────────────────────────────────────────────────────
-    async listPrompts(timeoutMs = 30_000) {
-        const res = await this.rpc("prompts/list", {}, timeoutMs);
-        return (res.prompts ?? []).filter((p) => typeof p.name === "string");
-    }
-    async getPrompt(name, args, timeoutMs = 30_000) {
-        const res = await this.rpc("prompts/get", { name, arguments: args ?? {} }, timeoutMs);
-        return { description: res.description, messages: res.messages ?? [] };
-    }
-    async callTool(name, args, timeoutMs = 120_000) {
-        const res = await this.rpc("tools/call", { name, arguments: args }, timeoutMs);
-        const isErr = res.isError === true;
-        const parts = (res.content ?? []).map((c) => c.text ?? "").filter(Boolean);
-        // H-13: MCP servers are third-party — redact secret shapes from output
-        // before it enters the conversation or logs.
-        const structured = res.structuredContent
-            ? JSON.parse(redactSecrets(JSON.stringify(res.structuredContent)))
-            : undefined;
-        return { ok: !isErr, output: redactSecrets(parts.join("\n")) || "(empty result)", structured };
-    }
-    kill() {
-        this.manuallyClosed = true;
-        this.setState("dead", "closed by client");
-        this.drain(new Error("disconnected"));
-        this.transport.close();
-    }
-    // ── internals ─────────────────────────────────────────────────────────────
-    async rpc(method, params, timeoutMs) {
-        if (!this.alive)
-            throw new Error(`MCP server "${this.name}" not connected`);
-        const id = this.nextId++;
-        return new Promise((resolve, reject) => {
-            const timer = setTimeout(() => {
-                this.pending.delete(id);
-                reject(new Error(`MCP "${method}" timed out after ${(timeoutMs / 1000).toFixed(0)}s`));
-            }, timeoutMs);
-            this.pending.set(id, {
-                resolve: (v) => { clearTimeout(timer); resolve(v); },
-                reject: (e) => { clearTimeout(timer); reject(e); },
-            });
-            void Promise.resolve(this.transport.send({ jsonrpc: "2.0", id, method, params })).catch((e) => {
-                const p = this.pending.get(id);
-                if (p) {
-                    this.pending.delete(id);
-                    p.reject(e);
-                }
-            });
-        });
-    }
-    drain(err) {
-        for (const [, p] of this.pending)
-            p.reject(err);
-        this.pending.clear();
-    }
-}
 export class McpManager {
     configs;
     conns = new Map();

package/dist/mcp/sse.js

@@ -0,0 +1,28 @@
+/** Parse a single SSE block (blank-line-separated events) into one JSON-RPC message.
+ *  Normalizes CRLF → LF before splitting on the event separator. */
+export function parseSseEvent(block) {
+    const data = block
+        .replace(/\r\n/g, "\n")
+        .split(/\n/)
+        .filter((l) => l.startsWith("data:"))
+        .map((l) => l.slice(5).trim())
+        .join("\n");
+    if (!data)
+        return null;
+    try {
+        return JSON.parse(data);
+    }
+    catch {
+        return null;
+    }
+}
+/** Parse SSE text (legacy buffer-based) thành JSON-RPC messages. */
+export function parseSseMessages(text) {
+    const out = [];
+    for (const block of text.split(/\r?\n\r?\n/)) {
+        const m = parseSseEvent(block);
+        if (m)
+            out.push(m);
+    }
+    return out;
+}

package/dist/mcp/transport-http.js

@@ -0,0 +1,140 @@
+import { expandEnv } from "./env.js";
+import { parseSseEvent } from "./sse.js";
+/**
+ * M3: Streamable HTTP transport — POST một JSON-RPC message, server trả về
+ * `application/json` (single response) hoặc `text/event-stream` (SSE; parse
+ * các `data:` events). Echo `Mcp-Session-Id` từ initialize trên các request
+ * sau. Stateless: lỗi request → reject call hiện tại; call sau tự retry
+ * (không cần background reconnect như stdio).
+ */
+export class HttpTransport {
+    cfg;
+    kind = "http";
+    sessionId = null;
+    msgCb = null;
+    closed = false;
+    constructor(cfg) {
+        this.cfg = cfg;
+    }
+    get alive() {
+        return !this.closed;
+    }
+    onMessage(cb) {
+        this.msgCb = cb;
+    }
+    onDown(_cb) {
+        // HTTP là stateless — không có channel chết để báo.
+    }
+    async start() {
+        this.closed = false;
+    }
+    async send(msg) {
+        if (this.closed)
+            throw new Error(`MCP HTTP transport "${this.cfg.url}" closed`);
+        const res = await this.post(msg, this.sessionId, undefined);
+        // Session expired (server restart) → thử lại một lần không session.
+        if ((res.status === 404 || res.status === 400) && this.sessionId) {
+            this.sessionId = null;
+            const retry = await this.post(msg, null, undefined);
+            return this.consume(retry);
+        }
+        return this.consume(res);
+    }
+    close() {
+        this.closed = true;
+        this.sessionId = null;
+    }
+    defaultTimeout() {
+        return this.cfg.timeoutMs ?? 120_000;
+    }
+    async post(msg, sessionId, signal) {
+        const url = this.cfg.url;
+        if (!url)
+            throw new Error("MCP HTTP transport requires \"url\" in the server config");
+        const headers = {
+            "content-type": "application/json",
+            accept: "application/json, text/event-stream",
+            ...expandEnv(this.cfg.headers),
+        };
+        if (sessionId)
+            headers["mcp-session-id"] = sessionId;
+        try {
+            // Combine the caller's abort signal (MCP A cancellation) with an idle
+            // timeout into one AbortSignal. AbortSignal.any needs ≥1 real signal.
+            const signals = [AbortSignal.timeout(this.defaultTimeout())];
+            if (signal)
+                signals.push(signal);
+            const combined = signals.length > 1 ? AbortSignal.any(signals) : signals[0];
+            return await fetch(url, {
+                method: "POST",
+                headers,
+                body: JSON.stringify(msg),
+                signal: combined,
+            });
+        }
+        catch (e) {
+            throw new Error(`MCP HTTP "${url}": ${e.message}`, { cause: e });
+        }
+    }
+    async consume(res) {
+        const sid = res.headers.get("mcp-session-id");
+        if (sid)
+            this.sessionId = sid;
+        if (!res.ok) {
+            res.body?.cancel().catch(() => { });
+            throw new Error(`MCP HTTP ${res.status} ${res.statusText}`);
+        }
+        const ct = res.headers.get("content-type") ?? "";
+        if (ct.includes("application/json")) {
+            const body = (await res.text()).trim();
+            if (body) {
+                try {
+                    this.msgCb?.(JSON.parse(body));
+                }
+                catch { /* skip malformed */ }
+            }
+            return;
+        }
+        if (ct.includes("text/event-stream")) {
+            // MCP A: incremental SSE — stream body, emit each JSON-RPC message as
+            // its `data:` event completes, instead of buffering the entire response.
+            await this.consumeSseStream(res.body);
+            return;
+        }
+        // 202/no-content (notifications) — nothing to parse
+    }
+    /** Incremental SSE: read the body as a stream and emit each JSON-RPC message
+     *  as its SSE block (blank-line-separated) completes — no full-body buffer. */
+    async consumeSseStream(body) {
+        if (!body)
+            return;
+        const reader = body.getReader();
+        const decoder = new TextDecoder();
+        let buf = "";
+        try {
+            for (;;) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                buf += decoder.decode(value, { stream: true }).replace(/\r\n/g, "\n");
+                let sep;
+                while ((sep = buf.indexOf("\n\n")) !== -1) {
+                    const block = buf.slice(0, sep);
+                    buf = buf.slice(sep + 2);
+                    const msg = parseSseEvent(block);
+                    if (msg)
+                        this.msgCb?.(msg);
+                }
+            }
+        }
+        finally {
+            reader.releaseLock();
+        }
+        // Flush any trailing partial SSE block at EOF (no trailing \n\n).
+        if (buf.trim()) {
+            const msg = parseSseEvent(buf);
+            if (msg)
+                this.msgCb?.(msg);
+        }
+    }
+}