@timo972/cc-router 0.7.0 → 0.9.0-rc.1

package/CHANGELOG.md

@@ -6,6 +6,140 @@ This project follows [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ---
 
+## [Unreleased]
+
+Nothing yet.
+
+---
+
+## [0.9.0] — 2026-08-04
+
+### Added
+
+- **Non-streaming `/v1/responses` requests are served correctly.** A caller that
+  posts `stream: false` — the public Responses API default — now receives a
+  single JSON Responses object. The Codex backend is SSE-only, so the router
+  reconciles the forced event stream into one body instead of returning raw SSE
+  bytes the client cannot parse. Streaming callers (the Codex CLI) are
+  unaffected.
+- A distinct `warn` activity type with its own `logWarn` console channel,
+  rendered as its own row style on the status dashboard so advisories are
+  visually separate from routing errors.
+
+### Changed
+
+- `/v1/responses` rejects an explicit `store: true` with a `400`
+  `invalid_request_error` instead of silently rewriting it to `false`. The Codex
+  subscription backend is stateless and cannot offer server-side response
+  retrieval by id. An omitted `store` is still normalized to `false` silently.
+- An explicit `max_output_tokens` is still dropped — the backend does not
+  support it — but each drop now surfaces as a warning in both the console log
+  and the dashboard activity feed, so the ignored cap is observable.
+
+### Fixed
+
+- Malformed upstream data from the Codex backend (a bad JSON body or a malformed
+  SSE stream) maps to a `502 upstream_error` instead of throwing out of the
+  async Express handler, which left the client connection hanging indefinitely.
+- Non-2xx Codex passthrough preserves the upstream content-type instead of
+  hardcoding `text/plain`, which broke SDK clients that parse errors by
+  content-type.
+
+---
+
+## [0.8.3] — 2026-08-04
+
+### Fixed
+
+- Accounts added while the proxy is running (`accounts add`, `add-openai`,
+  `login-openai`) are now loaded into the live pool immediately — routable and
+  visible in `accounts list` without a restart. Previously only removals were
+  applied at runtime; adds required restarting the proxy. When no proxy is
+  running the add still falls back to a plain disk write.
+
+---
+
+## [0.8.2] — 2026-08-03
+
+### Fixed
+
+- The interactive status dashboard no longer crashes when model-scoped usage
+  reports an unknown reset timestamp as zero.
+
+### Internal
+
+- GitHub Actions bumped to v7.
+- The Codex config-path test uses the platform-native location instead of a
+  hardcoded POSIX path.
+
+---
+
+## [0.8.1] — 2026-08-03
+
+### Fixed
+
+- Anthropic model-scoped usage rows using the current nested `scope.model`
+  shape are parsed correctly, so exhausting Fable capacity no longer creates
+  an account-global cooldown that also blocks Opus routing.
+
+### Changed
+
+- Hosting guidance about sharing accounts across a team was removed from the
+  docs.
+
+### Internal
+
+- CI installs with pnpm and runs the suite across the supported Node versions.
+
+---
+
+## [0.8.0] — 2026-08-01
+
+### Added
+
+- **Model-aware Anthropic allowance routing.** Requested Messages models now
+  participate in account eligibility and headroom ranking through dynamic
+  model-scoped weekly limits. Account-based session affinity is retained while
+  the bound account can serve the requested model.
+- Authenticated dashboard, health, and accounts views now show safe global and
+  model-scoped capacity, usage freshness, paid-extra state, and global or
+  requested-model cooldown summaries.
+
+### Changed
+
+- Anthropic cooldowns, upstream quota exhaustion, disabled or unhealthy state,
+  and invalid authentication are hard routing exclusions. The only fallback is
+  an explicit bypass of configured per-account percentage caps when every
+  otherwise eligible account is capped.
+- Usage snapshots refresh in memory from Anthropic's internal OAuth usage
+  endpoint with bounded concurrency, timeout, and backoff, while response
+  headers remain the graceful-degradation source when that endpoint is
+  unavailable.
+- The README leads with the fork's positioning, and the account-sharing use
+  case was dropped.
+
+### Fixed
+
+- When all accounts are hard-blocked, the router now returns a local
+  Anthropic-shaped 429 when any blocker is rate-limit or quota related, adding
+  the earliest trustworthy `Retry-After` only when known. A 503 is used only
+  for entirely non-rate-limit unavailability. These local errors make no
+  Anthropic Messages request, and fallback no longer sends requests to cooling
+  or upstream-rate-limited accounts.
+- `accounts remove` now removes the account from the running proxy instead of
+  only rewriting `accounts.json`, so a removed account stops being routed
+  without a restart.
+- A per-account cap of 100% is no longer treated as over-cap at full
+  utilization, so sessions on accounts running on paid extra usage stay sticky
+  on their bound account.
+
+### Internal
+
+- Package management switched from npm to pnpm (`pnpm-lock.yaml`,
+  `pnpm-workspace.yaml`).
+
+---
+
 ## [0.7.0] — 2026-07-26
 
 First release of `@timo972/cc-router`, an independently maintained fork of
@@ -93,4 +227,9 @@ cache-aware session routing and a round of security hardening.
 - `http-proxy-middleware` 3.0.5 → 3.0.7 for GHSA-gcq2-9pq2-cxqm (high). The
   affected APIs are not used here.
 
+[0.9.0]: https://github.com/Timo972/cc-router/releases/tag/v0.9.0
+[0.8.3]: https://github.com/Timo972/cc-router/releases/tag/v0.8.3
+[0.8.2]: https://github.com/Timo972/cc-router/releases/tag/v0.8.2
+[0.8.1]: https://github.com/Timo972/cc-router/releases/tag/v0.8.1
+[0.8.0]: https://github.com/Timo972/cc-router/releases/tag/v0.8.0
 [0.7.0]: https://github.com/Timo972/cc-router/releases/tag/v0.7.0

package/README.md

@@ -22,8 +22,8 @@ Distribute Claude Code requests across Claude subscriptions, and expose an OpenA
 - **Transparent Claude proxy** — Claude Code works normally; streaming, thinking, tool use, prompt caching all pass through
 - **Codex CLI support** — configure Codex to use CC-Router as a Responses-compatible provider
 - **Automatic token refresh** — OAuth tokens are refreshed before they expire, saved atomically to disk
-- **Rate limit awareness** — detects 429/529 responses and coolsdown accounts; picks the least-loaded one
-- **Client mode** — connect to a remote CC-Router from any machine with one command (`cc-router client connect <url>`)
+- **Model-aware rate limits** — avoids accounts whose requested-model or global allowance is exhausted, and respects scoped cooldowns
+- **Client mode** — connect another device you own to your private CC-Router (`cc-router client connect <url>`)
 - **Claude Desktop support** — route Cowork / Agent-mode traffic through CC-Router via mitmproxy interception (macOS, Windows, Linux)
 - **Guided setup wizard** — interactive `cc-router setup` extracts tokens from Keychain or credentials file, configures everything
 - **Live dashboard** — real-time terminal UI showing account health, request counts, token usage, recent activity
@@ -71,16 +71,16 @@ All standard Claude Code features work transparently on the Claude route: stream
 
 ### Cache-aware Claude account routing
 
-CC-Router keeps requests from one Claude Code session on the same healthy Anthropic subscription account. This session affinity preserves prompt-cache locality instead of scattering a conversation's shared prefix across account-specific caches. New sessions prefer the account with the fewest in-flight requests, then the fewest bound sessions, then the most rate-limit headroom; exact ties use a rotating round-robin order.
+CC-Router keeps requests from one Claude Code session on the same eligible Anthropic subscription account. This session affinity remains account-based and preserves prompt-cache locality instead of scattering a conversation's shared prefix across account-specific caches. The model requested by each Messages call affects whether the bound account is still eligible; changing models does not create a second binding, but it can make the existing binding fail over when that account cannot serve the new model. New sessions prefer the account with the fewest in-flight requests, then the fewest bound sessions, then included allowance over paid extra usage, then the most applicable global and requested-model headroom; exact ties use a rotating round-robin order.
 
-If an upstream account returns 401, 429, or 529, CC-Router passes that response through unchanged and invalidates the session's affinity. The client's next retry can then select another usable account; the router never retries after response bytes have started. Affinity mappings exist only in process memory, expire after one hour of inactivity, and are capped in size. Session IDs are never persisted or logged.
+Anthropic cooldowns, effective global or requested-model quota exhaustion, disabled accounts, invalid authentication, and unhealthy accounts are hard exclusions. The configured per-account percentage caps are softer policy controls: when at least one account is otherwise usable but every usable account is over a configured cap, CC-Router may explicitly fall back to the least-loaded capped account. It never uses that fallback to bypass an Anthropic cooldown or exhausted effective quota.
+
+If an upstream account returns 401, 429, or 529, CC-Router passes that response through unchanged and invalidates the session's affinity. The client's next retry can then select another usable account; the router never retries after response bytes have started. If no account is usable before forwarding begins, the router instead returns a local Anthropic-shaped 429 whenever any account is blocked by a rate limit or exhausted quota. That 429 includes `Retry-After` only when a trustworthy unblock time is known. A local 503 is reserved for entirely non-rate-limit unavailability, such as all accounts being disabled or unhealthy. Either local response makes no Anthropic Messages request. Affinity mappings exist only in process memory, expire after one hour of inactivity, and are capped in size. Session IDs are never persisted or logged.
 
 Streaming remains byte-transparent. In particular, CC-Router never appends a synthetic `message_stop` event. `proxyRequestTimeoutMs` protects only the phase before Anthropic response headers arrive; once a response starts, its body continues through the native byte-exact proxy pipe. Automatic `cc-router configure` setup manages Claude Code's event-level and byte-level stream idle watchdogs at 30 minutes. Restart any existing Claude Code process after configuration so it inherits those values.
 
 **Claude Desktop support** is opt-in and requires a small interceptor (mitmproxy) because Claude Desktop doesn't expose a custom API endpoint setting. See [Claude Desktop support](#claude-desktop-support).
 
-📖 **Running this for a team?** [docs/session-routing.md](docs/session-routing.md) covers how accounts are picked, what per-account throttles do, how to monitor affinity, and how to read the failure modes.
-
 ---
 
 ## Use cases
@@ -98,82 +98,6 @@ With two accounts you double your effective rate limit. With three, you triple i
 
 ---
 
-### Hosting cc-router on a shared machine
-
-Run cc-router on a machine everyone on the team can reach — a home server, a VPS, or a spare machine on the office network.
-
-#### On the server
-
-```bash
-npm install -g @timo972/cc-router
-cc-router setup          # configure the accounts
-cc-router start          # first run asks: background/boot/server mode — choose "server mode"
-```
-
-When you enable server mode during `cc-router start`, the proxy automatically binds to all interfaces (`0.0.0.0`) and prints instructions for connecting clients.
-
-#### On each developer's machine
-
-No installation needed. Just set two environment variables in `~/.claude/settings.json`:
-
-```json
-{
-  "env": {
-    "ANTHROPIC_BASE_URL": "http://192.168.1.50:3456",
-    "ANTHROPIC_AUTH_TOKEN": "proxy-managed"
-  }
-}
-```
-
-Replace `192.168.1.50` with the server's IP or hostname. Then run `claude` normally.
-
-Or use the CLI to write the settings automatically:
-
-```bash
-cc-router configure --port 3456
-# Then manually update ANTHROPIC_BASE_URL to the remote IP
-```
-
----
-
-### Hosting on a VPS (internet-accessible)
-
-If your team is distributed or works remotely, run cc-router on a VPS and expose it over HTTPS via a reverse proxy.
-
-#### Recommended nginx config
-
-```nginx
-server {
-    listen 443 ssl;
-    server_name cc-router.yourcompany.com;
-
-    # ... SSL cert config (e.g. Let's Encrypt) ...
-
-    location / {
-        proxy_pass http://127.0.0.1:3456;
-        proxy_buffering off;          # required for SSE streaming
-        proxy_read_timeout 1800s;     # outer-proxy body idle timeout
-        proxy_set_header X-Forwarded-For $remote_addr;
-    }
-}
-```
-
-These settings protect different phases. CC-Router's `proxyRequestTimeoutMs` in `~/.cc-router/config.json` applies only while waiting for Anthropic response headers. An outer proxy's `proxy_read_timeout` applies while reading the response body, so configure that outer timeout separately with enough headroom for long thinking pauses. Neither timeout repairs a missing upstream terminal event, and CC-Router never synthesizes `message_stop`.
-
-Each developer then points to:
-```json
-{
-  "env": {
-    "ANTHROPIC_BASE_URL": "https://cc-router.yourcompany.com",
-    "ANTHROPIC_AUTH_TOKEN": "proxy-managed"
-  }
-}
-```
-
-**Security note:** if the proxy is internet-accessible, add authentication at the nginx level (basic auth, mTLS, or IP allowlist) so only your team can use it. cc-router does not implement user authentication itself.
-
----
-
 ## Quickstart
 
 ```bash
@@ -443,9 +367,9 @@ This prompts for the OpenAI access token, refresh token, expiry timestamp, and s
 
 ---
 
-## Client mode — connecting to an existing CC-Router
+## Client mode — connecting your own devices
 
-If someone on your team already hosts a CC-Router instance (on a VPS, home server, or another machine on the LAN), you don't need to install accounts locally. You just point your Claude Code at the remote proxy.
+Client mode lets you connect another device you own to your private CC-Router over a trusted private network. It is not intended for sharing subscription accounts or proxy access with other people, or for exposing CC-Router to the public internet.
 
 The setup wizard asks about this at the very first step:
 
@@ -453,13 +377,13 @@ The setup wizard asks about this at the very first step:
 cc-router setup
 # → What do you want to do?
 #   • Host CC-Router on this machine
-#   • Connect to an existing CC-Router server  ← pick this
+#   • Connect to your existing CC-Router server  ← pick this
 ```
 
 Or use the dedicated command directly:
 
 ```bash
-# Quick connect — just point Claude Code at the remote proxy
+# Connect another device you own over your private network
 cc-router client connect http://192.168.1.50:3456 --secret cc-rtr-abc123...
 
 # Check status
@@ -615,7 +539,7 @@ cc-router status
 
 Press `q` to quit. Run with `--json` for non-interactive output; the JSON includes an `operational` block with capabilities, endpoints, provider readiness, auth status, and model routing. Secrets and account tokens are never included.
 
-The dashboard is also a control surface. In local mode it controls the local proxy; in client mode it controls the remote CC-Router configured by `cc-router client connect`.
+The dashboard is also a control surface. In local mode it controls the local proxy; in client mode it controls the remote CC-Router configured by `cc-router client connect`. Authenticated account views include dynamic model-scoped allowance rows, their reset times, applicable global or requested-model cooldowns, paid-extra state, and whether the usage snapshot is fresh, stale, or unavailable. A stale row is shown as unknown rather than as authoritative available capacity.
 
 | Key | Action |
 |-----|--------|
@@ -693,6 +617,7 @@ Check status anytime: `cc-router telemetry status`.
 >
 > **Read Anthropic's Terms of Service before using this tool.**  
 > Using multiple Max subscriptions to increase throughput may violate the ToS. Anthropic has been known to ban accounts for unusual OAuth usage patterns.
+> Do not share subscription accounts, OAuth credentials, or CC-Router proxy access with other people.
 >
 > The authors are not responsible for any account bans, loss of access, or other consequences resulting from the use of this software. Use at your own risk.
 

package/dist/cli/cmd-accounts.js

@@ -1,5 +1,5 @@
 import chalk from "chalk";
-import { loadAccounts, loadOpenAIAccounts, accountsFileExists, upsertAccountRecord, removeAccountRecordById } from "../config/manager.js";
+import { loadAccounts, loadOpenAIAccounts, accountsFileExists, upsertAccountRecord, removeAccountRecordById, readConfig, serialize } from "../config/manager.js";
 import { saveAccounts } from "../proxy/token-refresher.js";
 import { formatExpiry, redactToken } from "../utils/token-extractor.js";
 import { PROXY_PORT } from "../config/paths.js";
@@ -94,9 +94,12 @@ export function registerAccounts(program) {
             ...existing.filter(a => a.id !== account.id),
             account,
         ];
-        saveAccounts(merged);
+        const { mode } = await addAccountRuntimeAware(serialize([account])[0], {
+            tryAddLive: tryAddAccountToRunningProxy,
+            addStored: () => saveAccounts(merged),
+        });
         console.log(chalk.green(`\n✓ Account "${account.id}" added (${merged.length} total).\n`));
-        console.log(chalk.gray("  Restart the proxy to load the new account: cc-router start\n"));
+        printAddOutcome(mode);
     });
     // ── accounts add-openai ──────────────────────────────────────────────────
     accounts
@@ -135,9 +138,9 @@ export function registerAccounts(program) {
             expiresAt,
             scopes,
         });
-        upsertAccountRecord(record);
+        const { mode } = await addAccountRuntimeAware(record);
         console.log(chalk.green(`\n✓ OpenAI account "${record.id}" saved.\n`));
-        console.log(chalk.gray("  Restart the proxy to load the new account: cc-router start\n"));
+        printAddOutcome(mode);
         console.log(chalk.yellow("  Treat this as experimental until the OAuth login wizard lands.\n"));
     });
     // ── accounts login-openai ────────────────────────────────────────────────
@@ -163,9 +166,9 @@ export function registerAccounts(program) {
                 console.log(chalk.gray("Waiting for authorization..."));
             },
         });
-        upsertAccountRecord(record);
+        const { mode } = await addAccountRuntimeAware(record);
         console.log(chalk.green(`\n✓ OpenAI account "${record.id}" saved via device login.\n`));
-        console.log(chalk.gray("  Restart the proxy to load the new account: cc-router start\n"));
+        printAddOutcome(mode);
     });
     // ── accounts remove ───────────────────────────────────────────────────────
     accounts
@@ -196,13 +199,17 @@ export function registerAccounts(program) {
             console.log(chalk.gray("Cancelled."));
             return;
         }
-        const removed = removeAccountRecordById(id);
-        if (!removed) {
-            console.log(chalk.red(`✗ Account "${id}" disappeared before it could be removed.`));
+        const isOpenAI = openAIAccounts.some(account => account.id === id);
+        try {
+            await removeAccountRuntimeAware(id);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            console.log(chalk.red(`✗ Could not remove "${id}": ${message}`));
             process.exit(1);
         }
         const remaining = loadAccounts().length + loadOpenAIAccounts().length;
-        const providerLabel = removed.provider === "openai_subscription" ? "OpenAI account" : "Account";
+        const providerLabel = isOpenAI ? "OpenAI account" : "Account";
         console.log(chalk.green(`✓ Removed ${providerLabel} "${id}". ${remaining} account(s) remaining.`));
         if (remaining === 0) {
             console.log(chalk.yellow("  No accounts left. Run: cc-router setup"));
@@ -210,6 +217,12 @@ export function registerAccounts(program) {
     });
 }
 // ─── Helpers ──────────────────────────────────────────────────────────────────
+/** Tell the user whether the new account is already live or needs a restart. */
+function printAddOutcome(mode) {
+    console.log(mode === "live"
+        ? chalk.gray("  Loaded into the running proxy — available now, no restart needed.\n")
+        : chalk.gray("  Restart the proxy to load the new account: cc-router start\n"));
+}
 export function buildStoredAccountsJson(anthropicAccounts, openAIAccounts) {
     return [
         ...anthropicAccounts.map(a => ({
@@ -227,6 +240,96 @@ export function buildStoredAccountsJson(anthropicAccounts, openAIAccounts) {
         })),
     ];
 }
+/** Return false only when no running proxy can be reached; HTTP errors remain authoritative. */
+export async function tryRemoveAccountFromRunningProxy(id, options = {}) {
+    const fetchImpl = options.fetch ?? globalThis.fetch;
+    const baseUrl = (options.baseUrl ?? `http://localhost:${PROXY_PORT}`).replace(/\/+$/, "");
+    const authToken = options.authToken ?? readConfig().proxySecret;
+    let response;
+    try {
+        response = await fetchImpl(`${baseUrl}/cc-router/accounts/${encodeURIComponent(id)}`, {
+            method: "DELETE",
+            headers: authToken ? { authorization: `Bearer ${authToken}` } : {},
+            signal: AbortSignal.timeout(3_000),
+        });
+    }
+    catch {
+        return false;
+    }
+    if (!response.ok) {
+        let detail = "";
+        try {
+            const payload = await response.json();
+            if (typeof payload.error === "string")
+                detail = `: ${payload.error}`;
+        }
+        catch { /* best effort */ }
+        throw new Error(`HTTP ${response.status}${detail}`);
+    }
+    return true;
+}
+export async function removeAccountRuntimeAware(id, dependencies = {
+    tryRemoveLive: tryRemoveAccountFromRunningProxy,
+    removeStored: removeAccountRecordById,
+}) {
+    if (await dependencies.tryRemoveLive(id))
+        return { mode: "live" };
+    const removed = dependencies.removeStored(id);
+    if (!removed)
+        throw new Error(`Account "${id}" disappeared before it could be removed`);
+    return { mode: "stored", removed };
+}
+/**
+ * Add an account to a running proxy so it becomes routable without a restart.
+ * Returns false only when no running proxy can be reached (the caller then
+ * persists to disk itself); HTTP error responses — e.g. 409 for a duplicate —
+ * are authoritative and thrown so the caller does not silently write to disk.
+ */
+export async function tryAddAccountToRunningProxy(record, options = {}) {
+    const fetchImpl = options.fetch ?? globalThis.fetch;
+    const baseUrl = (options.baseUrl ?? `http://localhost:${PROXY_PORT}`).replace(/\/+$/, "");
+    const authToken = options.authToken ?? readConfig().proxySecret;
+    let response;
+    try {
+        response = await fetchImpl(`${baseUrl}/cc-router/accounts`, {
+            method: "POST",
+            headers: {
+                "content-type": "application/json",
+                ...(authToken ? { authorization: `Bearer ${authToken}` } : {}),
+            },
+            body: JSON.stringify(record),
+            signal: AbortSignal.timeout(3_000),
+        });
+    }
+    catch {
+        return false;
+    }
+    if (!response.ok) {
+        let detail = "";
+        try {
+            const payload = await response.json();
+            if (typeof payload.error === "string")
+                detail = `: ${payload.error}`;
+        }
+        catch { /* best effort */ }
+        throw new Error(`HTTP ${response.status}${detail}`);
+    }
+    return true;
+}
+/**
+ * Persist a newly added account so it is usable immediately. When a proxy is
+ * running the record is handed to it (live pool + disk in one step); otherwise
+ * it is written to disk via `addStored` and picked up on the next start.
+ */
+export async function addAccountRuntimeAware(record, dependencies = {
+    tryAddLive: tryAddAccountToRunningProxy,
+    addStored: upsertAccountRecord,
+}) {
+    if (await dependencies.tryAddLive(record))
+        return { mode: "live" };
+    dependencies.addStored(record);
+    return { mode: "stored" };
+}
 async function fetchLiveStats() {
     try {
         const res = await fetch(`http://localhost:${PROXY_PORT}/cc-router/health`, {

package/dist/protocol/openai-responses-collect.js

@@ -0,0 +1,71 @@
+import { parseSseLines } from "./sse.js";
+function upstreamError(message) {
+    return { kind: "json", status: 502, body: { error: { type: "upstream_error", message } } };
+}
+/**
+ * Collapse the Codex backend's forced SSE stream into a single Responses
+ * object for callers that did not ask to stream. The backend's terminal
+ * `response.completed` payload is returned verbatim, preserving tool calls,
+ * reasoning, and usage.
+ */
+export async function collectCodexResponseStream(upstream) {
+    if (!upstream.ok) {
+        const contentType = upstream.headers.get("content-type") ?? undefined;
+        return { kind: "text", status: upstream.status, contentType, body: await upstream.text() };
+    }
+    const contentType = upstream.headers.get("content-type") ?? "";
+    if (contentType.includes("application/json")) {
+        try {
+            return { kind: "json", status: upstream.status, body: await upstream.json() };
+        }
+        catch {
+            return upstreamError("Malformed upstream JSON body");
+        }
+    }
+    const reader = upstream.body?.getReader();
+    if (!reader)
+        return upstreamError("Empty upstream body");
+    const decoder = new TextDecoder();
+    let remainder = "";
+    let completed;
+    let failure;
+    const applyEvent = (event) => {
+        if (typeof event !== "object" || event === null)
+            return;
+        const e = event;
+        if (e.type === "response.completed") {
+            completed = e.response;
+        }
+        else if (e.type === "response.failed") {
+            const err = e.response?.error;
+            failure = err?.message ?? "Response failed";
+        }
+        else if (e.type === "error") {
+            failure = e.error?.message ?? "Upstream error event";
+        }
+    };
+    try {
+        while (true) {
+            const { value, done } = await reader.read();
+            if (done)
+                break;
+            const parsed = parseSseLines(remainder + decoder.decode(value, { stream: true }));
+            remainder = parsed.remainder;
+            for (const event of parsed.events)
+                applyEvent(event);
+        }
+        const tail = remainder + decoder.decode();
+        if (tail.length > 0) {
+            for (const event of parseSseLines(tail + "\n").events)
+                applyEvent(event);
+        }
+    }
+    catch {
+        return upstreamError("Malformed upstream stream");
+    }
+    if (failure !== undefined)
+        return upstreamError(failure);
+    if (completed === undefined)
+        return upstreamError("Stream ended before response.completed");
+    return { kind: "json", status: upstream.status, body: completed };
+}