auto-model-router 0.2.15 → 0.2.20

package/src/context/agentdox.ts

@@ -18,7 +18,10 @@ export interface AgentDoxClientOptions {
 /** Bounds on what agentdox may select for one block. */
 export interface AssembleLimits {
 	memoryLimit: number;
+	docsLimit: number;
 	sessionLimit: number;
+	/** Character budget for the project brief; 0 omits it (pre-brief servers ignore it). */
+	briefChars: number;
 }
 
 export interface AgentDoxClient {
@@ -83,12 +86,16 @@ export function createAgentDoxClient(opts: AgentDoxClientOptions): AgentDoxClien
 	return {
 		async assemble(scope, query, limits) {
 			// camelCase: the REST endpoint ignores snake_case limit keys entirely,
-			// which silently reads as "unbounded".
+			// which silently reads as "unbounded". briefChars is sent even when 0:
+			// an older server ignores the unknown key, and 0 is the documented
+			// "no brief" value there.
 			const res = await request("POST", "/context/assemble", {
 				scope,
 				query,
 				memoryLimit: limits.memoryLimit,
+				docsLimit: limits.docsLimit,
 				sessionLimit: limits.sessionLimit,
+				briefChars: limits.briefChars,
 			});
 			if (res !== null && res.status === 200) {
 				const prompt = promptOf(res.json);

package/src/context/bridge.ts

@@ -36,7 +36,10 @@ export interface BridgeOptions {
 	 * useful entry instead of severing whatever straddles the cap.
 	 */
 	memoryLimit: number;
+	docsLimit: number;
 	sessionLimit: number;
+	/** Character budget for the project brief rendered first in the block; 0 omits it. */
+	briefChars: number;
 	/** Record settled turns back into agentdox sessions. */
 	recordTurns: boolean;
 	/** Bound on queued write-backs; excess is dropped rather than grown unbounded. */
@@ -80,7 +83,7 @@ function appendFragment(prior: string, next: string): string {
 }
 
 export function createContextBridge(opts: BridgeOptions): ContextBridge {
-	const { client, store, log, maxStalenessMs, maxBlockChars, memoryLimit, sessionLimit, recordTurns, maxQueue } = opts;
+	const { client, store, log, maxStalenessMs, maxBlockChars, memoryLimit, docsLimit, sessionLimit, briefChars, recordTurns, maxQueue } = opts;
 
 	// Serialized write-back queue. Session appends for one conversation must
 	// stay ordered, and agentdox is a local service — one worker is plenty.
@@ -118,7 +121,7 @@ export function createContextBridge(opts: BridgeOptions): ContextBridge {
 				return { ...pinned, fetchedAtMs: input.pinnedFetchedAtMs };
 			}
 
-			const raw = await client.assemble(input.scope, input.query, { memoryLimit, sessionLimit });
+			const raw = await client.assemble(input.scope, input.query, { memoryLimit, docsLimit, sessionLimit, briefChars });
 			if (raw === null) {
 				// agentdox unreachable or empty. Keep serving the pinned block if we
 				// have one: stale shared context beats none, and re-using it also

package/src/context/index.ts

@@ -28,7 +28,9 @@ export function createBridgeFromConfig(cfg: RouterConfig, db: Database): Context
 		maxStalenessMs: c.maxStalenessMs,
 		maxBlockChars: c.maxBlockChars,
 		memoryLimit: c.memoryLimit,
+		docsLimit: c.docsLimit,
 		sessionLimit: c.sessionLimit,
+		briefChars: c.briefChars,
 		recordTurns: c.recordTurns,
 		maxQueue: c.maxQueue,
 	});

package/src/cost/types.ts

@@ -124,7 +124,12 @@ export interface LedgerEntry {
 	/** Time to first content token, ms. */
 	ttftMs: number | null;
 	finishReason: string | null;
-	/** Tokens billed but discarded because the attempt was aborted and retried. */
+	/**
+	 * Attempt superseded by a retry or escalation. NOT a cost figure: by design
+	 * these rows never carry reported_usd, so "wasted spend" sums to $0.00.
+	 * The meaningful waste measure is retry spend — rows with attempt > 0 that
+	 * DID bill. Kept for compatibility; do not read it as money.
+	 */
 	wasted: boolean;
 	upstreamGenerationId: string | null;
 	error: string | null;

package/src/router/candidates.ts

@@ -134,6 +134,8 @@ export function buildCandidates(args: BuildCandidatesArgs): { candidates: Candid
 
 	const candidates: Candidate[] = [];
 	const rejected: Rejection[] = [];
+	// Carries the trust/latency-adjusted cost into the second scoring pass.
+	const effectiveUsdBySlug = new Map<string, number>();
 
 	for (const model of snapshot.models) {
 		const slug = model.slug;
@@ -231,6 +233,20 @@ export function buildCandidates(args: BuildCandidatesArgs): { candidates: Candid
 			continue;
 		}
 
+		// Every candidate is priced COLD, deliberately, and this has been measured
+		// rather than assumed. Two reasons:
+		//  1. `coldUsd` feeds the budget guard in select.ts, and a budget must
+		//     survive a cache miss.
+		//  2. Discounting the warm slug here only ever LOWERS its effective cost,
+		//     so it can only make the warm model win more often — and the warm
+		//     model is already either the cheapest candidate or kept by the
+		//     dedicated stay-vs-switch comparison in select.ts step 4, which does
+		//     price staying at `cacheRead` against switching at cold+`cacheWrite`.
+		//     So the ranking change has no headroom to alter an outcome.
+		// Verified with tools/replay.ts: scoring the warm candidate at hit rates
+		// 0.5 / 0.8 / 0.95 changed 0 of 897 decisions, and 0 of 702 on the subset
+		// whose conversations ran the expensive model. Cache economics belong in
+		// the switch decision, not in candidate scoring — do not "fix" this.
 		const fc = forecast(model, {
 			promptTokens: features.promptTokens,
 			completionTokens: expectedCompletionTokens,
@@ -249,7 +265,10 @@ export function buildCandidates(args: BuildCandidatesArgs): { candidates: Candid
 				: null;
 		const latencyMult = latencyMultiplier(latency, filters, expectedCompletionTokens);
 		const effectiveUsd = (fc.expectedUsd / Math.max(trustScore, 0.5)) * latencyMult;
-		const score = Math.pow(qualityScore / 100, tierCfg.qualityExponent) / Math.max(effectiveUsd, 1e-9);
+		// Score is assigned in a SECOND PASS below: both qualityNormalization and
+		// capabilityFloorUsd are properties of the candidate SET, not of one
+		// model, so no per-model value can be computed here. Placeholder only.
+		const score = 0;
 
 		const reasons: string[] = [
 			quality === null
@@ -267,6 +286,30 @@ export function buildCandidates(args: BuildCandidatesArgs): { candidates: Candid
 		}
 		if (pinned) reasons.push("pinned into tier");
 		candidates.push({ model, forecast: fc, qualityScore, trustScore, score, reasons });
+		effectiveUsdBySlug.set(slug, effectiveUsd);
+	}
+
+	// Second pass: both new tier modes need the whole set.
+	//  - qualityNormalization rescales quality to the set's own [worst, best]
+	//    range, so the exponent operates on a full 0-1 spread instead of the
+	//    raw index's compressed 69-78 band.
+	//  - capabilityFloorUsd ignores the ratio entirely and takes the highest
+	//    quality candidate affordable within the cap.
+	const qualities = candidates.map((c) => c.qualityScore);
+	const qMin = qualities.length > 0 ? Math.min(...qualities) : 0;
+	const qMax = qualities.length > 0 ? Math.max(...qualities) : 0;
+	const qSpread = qMax - qMin;
+	const normalize = tierCfg.qualityNormalization === true && qSpread > 0;
+	for (const c of candidates) {
+		const effectiveUsd = effectiveUsdBySlug.get(c.model.slug) ?? c.forecast.expectedUsd;
+		// Normalised quality is unitless in [0,1]: the set's cheapest-quality
+		// model scores 0, its best scores 1. A single-model set has no spread,
+		// so it keeps the raw path (guarded by qSpread > 0).
+		const q = normalize ? (c.qualityScore - qMin) / qSpread : c.qualityScore / 100;
+		c.score = Math.pow(q, tierCfg.qualityExponent) / Math.max(effectiveUsd, 1e-9);
+		if (normalize) {
+			c.reasons.push(`quality normalised ${q.toFixed(3)} within set [${qMin}, ${qMax}]`);
+		}
 	}
 
 	candidates.sort((a, b) => {
@@ -285,5 +328,28 @@ export function buildCandidates(args: BuildCandidatesArgs): { candidates: Candid
 		if (b.model.slug === warmSlug) return 1;
 		return a.model.slug < b.model.slug ? -1 : 1;
 	});
+
+	// Capability-floor mode: the top tier's job is "best model the work needs",
+	// which quality-per-dollar cannot express — a bargain model always wins the
+	// ratio however weak it is. Promote the highest-quality candidate whose
+	// forecast turn cost fits the cap to the front. Strictly an upgrade: when
+	// nothing is affordable, or the ranked winner is already the best quality,
+	// the order is untouched.
+	const floorUsd = tierCfg.capabilityFloorUsd;
+	if (floorUsd !== undefined && candidates.length > 1) {
+		let best: Candidate | undefined;
+		for (const c of candidates) {
+			if (c.forecast.coldUsd > floorUsd) continue;
+			if (best === undefined || c.qualityScore > best.qualityScore) best = c;
+		}
+		if (best !== undefined && best !== candidates[0]) {
+			const idx = candidates.indexOf(best);
+			candidates.splice(idx, 1);
+			candidates.unshift(best);
+			best.reasons.push(
+				`capability floor: highest quality ${best.qualityScore} within $${floorUsd}/turn (cold $${best.forecast.coldUsd.toFixed(4)})`,
+			);
+		}
+	}
 	return { candidates, rejected };
 }

package/src/server/http.ts

@@ -167,7 +167,7 @@ function isLoopbackHostHeader(hostHeader: string | null): boolean {
 export function startServer(cfg: RouterConfig): StartedServer {
 	const log = createLogger(cfg.logLevel);
 
-	mkdirSync(dirname(cfg.ledger.path), { recursive: true });
+	if (cfg.ledger.path !== ":memory:") mkdirSync(dirname(cfg.ledger.path), { recursive: true });
 	const db = openDb(cfg.ledger.path);
 	const ledger = createLedger(db, cfg);
 	const upstream = createOpenRouterClient(cfg);
@@ -258,7 +258,14 @@ export function startServer(cfg: RouterConfig): StartedServer {
 		runTurn(normReq, sink, turnDeps, req.signal)
 			.catch((err: unknown) => {
 				log.error("turn failed", { error: err instanceof Error ? err.message : String(err) });
-				return Promise.resolve(sink.error(toWireError(err))).catch(() => {});
+				// sink.error() is SYNCHRONOUS: it runs before Promise.resolve wraps
+				// anything, so a throw out of it escapes this .catch() handler and
+				// becomes an unhandled rejection that kills the process. Wrap it.
+				try {
+					Promise.resolve(sink.error(toWireError(err))).catch(() => {});
+				} catch {
+					// Stream already gone; the response cannot carry the error.
+				}
 			})
 			.finally(() => {
 				// Release the concurrency slot when the turn settles, not when the

package/src/wire/openai/sink.ts

@@ -26,12 +26,25 @@ export function createStreamingSink(virtualModel: string): { sink: ResponseSink;
 		},
 	});
 	const send = (bytes: Uint8Array): void => {
-		if (!closed) controller?.enqueue(bytes);
+		if (closed) return;
+		try {
+			controller?.enqueue(bytes);
+		} catch {
+			// The runtime can close the controller under us — a client cancelling
+			// the stream (reader.cancel()) is not exceptional and nothing above us
+			// observes it. Mark closed and drop the write; measured to throw
+			// ERR_INVALID_STATE synchronously on Bun 1.x otherwise.
+			closed = true;
+		}
 	};
 	const close = (): void => {
 		if (!closed) {
 			closed = true;
-			controller?.close();
+			try {
+				controller?.close();
+			} catch {
+				// Already closed by the runtime; nothing left to do.
+			}
 		}
 	};
 

package/test/context-bridge.test.ts

@@ -53,7 +53,9 @@ function mkBridge(client: AgentDoxClient, over: Partial<BridgeOpts> = {}) {
 		maxStalenessMs: 900_000,
 		maxBlockChars: 24_000,
 		memoryLimit: 8,
+		docsLimit: 2,
 		sessionLimit: 6,
+		briefChars: 0,
 		recordTurns: true,
 		maxQueue: 64,
 		...over,
@@ -95,16 +97,18 @@ describe("context bridge refresh policy", () => {
 	});
 
 	test("assembly is bounded, so the block cannot grow until bytes get severed", async () => {
-		// The block reached 23.5k chars (~5.9k tokens, 15 memory entries) against a
-		// 24k maxBlockChars cap, at which point renderBlock slices mid-entry. Byte
-		// truncation is blind to relevance, so the server must be told to rank and
-		// select instead. The REST endpoint ignores snake_case limit keys, which
-		// silently reads as unbounded — hence pinning that the limits are passed.
+		// The block reached 23.5k chars against a 24k maxBlockChars cap, at which
+		// point renderBlock slices mid-entry. Byte truncation is blind to relevance,
+		// so the server must be told to rank and select instead. `docsLimit`
+		// especially: docs are WHOLE documents and were left unbounded, and a single
+		// ashlands note-doc measured 41,921 chars — over the whole cap by itself.
+		// The REST endpoint also ignores snake_case limit keys, which silently reads
+		// as unbounded, so pin that all four limits actually reach the client.
 		const client = mkClient();
-		const { bridge, db } = mkBridge(client, { memoryLimit: 5, sessionLimit: 2 });
+		const { bridge, db } = mkBridge(client, { memoryLimit: 5, docsLimit: 1, sessionLimit: 2, briefChars: 9000 });
 		try {
 			await bridge.resolve(input());
-			expect(client.lastLimits).toEqual({ memoryLimit: 5, sessionLimit: 2 });
+			expect(client.lastLimits).toEqual({ memoryLimit: 5, docsLimit: 1, sessionLimit: 2, briefChars: 9000 });
 		} finally {
 			db.close();
 		}
@@ -239,7 +243,9 @@ describe("context bridge refresh policy", () => {
 				maxStalenessMs: 900_000,
 				maxBlockChars: 24_000,
 				memoryLimit: 8,
+				docsLimit: 2,
 				sessionLimit: 6,
+				briefChars: 0,
 				recordTurns: true,
 				maxQueue: 64,
 			};

package/test/failover.test.ts

@@ -69,7 +69,7 @@ function mkConfig(escalation: Partial<EscalationConfig> = {}): RouterConfig {
 		hysteresis: { holdTurns: 2, holdTurnsAfterEscalation: 4, switchMargin: 1.5, cacheWarmTtlMs: 600_000, maxDowngradePerTurn: 1 },
 		exploration: { enabled: false, rates: {}, stickyPolicy: "never", holdTurns: { enabled: false, values: [2, 3, 4] } },
 		cache: { injectBreakpoints: true, maxBreakpoints: 4, minPromptTokens: 1024, milestoneTokens: 20_000 },
-		context: { enabled: false, baseUrl: "", token: "", defaultScope: "", timeoutMs: 3_000, maxStalenessMs: 900_000, maxBlockChars: 24_000, memoryLimit: 8, sessionLimit: 6, recordTurns: false, maxQueue: 64 },
+		context: { enabled: false, baseUrl: "", token: "", defaultScope: "", timeoutMs: 3_000, maxStalenessMs: 900_000, maxBlockChars: 24_000, memoryLimit: 8, docsLimit: 2, sessionLimit: 6, briefChars: 0, recordTurns: false, maxQueue: 64 },
 		compaction: { enabled: false, budgetTokens: 40_000, fitToWindow: true, protectRecentTurns: 4, maxToolResultBytes: 4_096, keepHeadBytes: 512, keepTailBytes: 512, elideSupersededReads: true, collapseDuplicateResults: true },
 		budget: { onExceeded: "downgrade" },
 		profiles: [],

package/test/http-resilience.test.ts

@@ -0,0 +1,58 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { DEFAULT_CONFIG } from "../src/config/defaults.ts";
+import type { RouterConfig } from "../src/config/types.ts";
+import { startServer, type StartedServer } from "../src/server/http.ts";
+
+describe("HTTP server resilience against dead streams", () => {
+	let handle: StartedServer;
+	let baseUrl: string;
+
+	beforeAll(() => {
+		const cfg: RouterConfig = {
+			...DEFAULT_CONFIG,
+			server: { host: "127.0.0.1", port: 0 },
+			ledger: { ...DEFAULT_CONFIG.ledger, path: ":memory:" },
+			context: { ...DEFAULT_CONFIG.context, enabled: false },
+			logLevel: "silent",
+		};
+		handle = startServer(cfg);
+		baseUrl = `http://127.0.0.1:${handle.server.port}`;
+	});
+	afterAll(async () => {
+		await handle.stop();
+	});
+
+	test("server answers /v1/models cleanly initially", async () => {
+		const res = await fetch(`${baseUrl}/v1/models`);
+		expect(res.status).toBe(200);
+		const json = (await res.json()) as { data: unknown[] };
+		expect(Array.isArray(json.data)).toBe(true);
+	});
+
+	test("cancelling a streaming /v1/chat/completions client does not crash the server", async () => {
+		const res = await fetch(`${baseUrl}/v1/chat/completions`, {
+			method: "POST",
+			headers: { "content-type": "application/json" },
+			body: JSON.stringify({
+				model: "auto",
+				stream: true,
+				messages: [{ role: "user", content: "hello" }],
+			}),
+		});
+
+		// Immediately cancel the reader mid-stream (simulates client disconnect)
+		const reader = res.body?.getReader();
+		expect(reader).toBeDefined();
+		await reader?.cancel("client abruptly dropped");
+
+		// Allow microtasks and I/O ticks to settle without real wall-clock delays
+		await new Promise<void>((resolve) => {
+			setImmediate(() => resolve());
+		});
+		// and answers subsequent requests cleanly.
+		const modelsRes = await fetch(`${baseUrl}/v1/models`);
+		expect(modelsRes.status).toBe(200);
+		const json = (await modelsRes.json()) as { data: unknown[] };
+		expect(Array.isArray(json.data)).toBe(true);
+	});
+});

package/test/tier-plan.test.ts

@@ -354,3 +354,94 @@ describe("adaptive price ceilings", () => {
 		expect(on.rejected.some((r) => r.slug === "a/4" && r.reason === "over_price_ceiling")).toBe(true);
 	});
 });
+
+describe("quality normalization and capability floor (benchmark findings 4/6)", () => {
+	const req = parseChatRequest(
+		{
+			model: "auto",
+			tools: [{ type: "function", function: { name: "read", description: "Read", parameters: { type: "object", properties: {} } } }],
+			messages: [{ role: "user", content: "implement nested transaction savepoints" }],
+		},
+		new Headers(),
+	);
+	const features = extractFeatures(req, 100);
+
+	// The real catalog's shape: quality in a narrow band, price spanning ~100x.
+	// `hard` has a quality floor of 72, so cheap/1 is deliberately below it —
+	// it must be rejected, and mid/2 is the cheapest ELIGIBLE model, the one
+	// raw quality-per-dollar ranking picks at any sane exponent.
+	const spread = snapshot(
+		models([
+			["cheap/1", 70, 0.05],
+			["mid/2", 74, 1.0],
+			["good/3", 76, 3.0],
+			["best/4", 78, 5.0],
+		]),
+	);
+
+	const run = (tierOverride: Partial<(typeof BASE)["tiers"]["hard"]>) =>
+		buildCandidates({
+			req,
+			features,
+			tier: "hard",
+			task: "coding",
+			snapshot: spread,
+			ledger: null,
+			cfg: { ...BASE, tiers: { ...BASE.tiers, hard: { ...BASE.tiers.hard, ...tierOverride } } },
+			expectedCompletionTokens: 512,
+			warmSlug: null,
+		});
+
+	test("raw scoring at the shipped exponent picks the cheapest ELIGIBLE model", () => {
+		const { candidates, rejected } = run({ qualityExponent: 3 });
+		expect(candidates[0]?.model.slug).toBe("mid/2");
+		// cheap/1 is under the hard floor of 72 and never competes.
+		expect(rejected.some((r) => r.slug === "cheap/1" && r.reason === "below_quality_floor")).toBe(true);
+	});
+
+	test("normalization lets a single-digit exponent buy the best model, which raw cannot", () => {
+		// Raw at the same exponent still cannot reach it: that is the defect.
+		expect(run({ qualityExponent: 12 }).candidates[0]?.model.slug).toBe("mid/2");
+		// Normalised, the same 12 selects the top-quality model.
+		const normalised = run({ qualityExponent: 12, qualityNormalization: true });
+		expect(normalised.candidates[0]?.model.slug).toBe("best/4");
+		expect(normalised.candidates[0]?.reasons.some((r) => r.includes("quality normalised"))).toBe(true);
+	});
+
+	test("normalization is monotone in the exponent: higher never picks a weaker model", () => {
+		let lastQuality = 0;
+		for (const qualityExponent of [1, 4, 8, 12, 20]) {
+			const top = run({ qualityExponent, qualityNormalization: true }).candidates[0];
+			expect(top).toBeDefined();
+			expect(top?.qualityScore ?? 0).toBeGreaterThanOrEqual(lastQuality);
+			lastQuality = top?.qualityScore ?? 0;
+		}
+	});
+
+	test("capability floor takes the best model inside the cap, ignoring the ratio", () => {
+		// mid/2 costs ~$0.0016 and good/3 ~$0.0049, so this cap admits both but
+		// excludes best/4 (~$0.0082). The ranked winner is mid/2 (cheapest).
+		const cap = 0.005;
+		const capped = run({ capabilityFloorUsd: cap });
+		const top = capped.candidates[0];
+		expect(top).toBeDefined();
+		expect(top?.forecast.coldUsd ?? 1).toBeLessThanOrEqual(cap);
+		// It must be the highest-quality affordable one, not the cheapest: good/3.
+		expect(top?.model.slug).toBe("good/3");
+		expect(top?.reasons.some((r) => r.includes("capability floor"))).toBe(true);
+	});
+
+	test("capability floor is strictly an upgrade: an unaffordable cap changes nothing", () => {
+		const base = run({}).candidates.map((c) => c.model.slug);
+		// A cap below every candidate's cost promotes nobody.
+		const tiny = run({ capabilityFloorUsd: 1e-9 }).candidates.map((c) => c.model.slug);
+		expect(tiny).toEqual(base);
+	});
+
+	test("both modes stay inert by default, so shipped behaviour is unchanged", () => {
+		const shipped = run({});
+		expect(shipped.candidates[0]?.model.slug).toBe("mid/2");
+		expect(shipped.candidates.every((c) => !c.reasons.some((r) => r.includes("normalised")))).toBe(true);
+		expect(shipped.candidates.every((c) => !c.reasons.some((r) => r.includes("capability floor")))).toBe(true);
+	});
+});

package/test/turn.test.ts

@@ -70,7 +70,7 @@ function mkConfig(escalation: Partial<EscalationConfig> = {}): RouterConfig {
 		hysteresis: { holdTurns: 2, holdTurnsAfterEscalation: 4, switchMargin: 1.5, cacheWarmTtlMs: 600_000, maxDowngradePerTurn: 1 },
 		exploration: { enabled: false, rates: {}, stickyPolicy: "never", holdTurns: { enabled: false, values: [2, 3, 4] } },
 		cache: { injectBreakpoints: true, maxBreakpoints: 4, minPromptTokens: 1024, milestoneTokens: 20_000 },
-		context: { enabled: false, baseUrl: "", token: "", defaultScope: "", timeoutMs: 3_000, maxStalenessMs: 900_000, maxBlockChars: 24_000, memoryLimit: 8, sessionLimit: 6, recordTurns: false, maxQueue: 64 },
+		context: { enabled: false, baseUrl: "", token: "", defaultScope: "", timeoutMs: 3_000, maxStalenessMs: 900_000, maxBlockChars: 24_000, memoryLimit: 8, docsLimit: 2, sessionLimit: 6, briefChars: 0, recordTurns: false, maxQueue: 64 },
 		compaction: { enabled: false, budgetTokens: 40_000, fitToWindow: true, protectRecentTurns: 4, maxToolResultBytes: 4_096, keepHeadBytes: 512, keepTailBytes: 512, elideSupersededReads: true, collapseDuplicateResults: true },
 		budget: { onExceeded: "downgrade" },
 		profiles: [],

package/test/wire-sink.test.ts

@@ -70,6 +70,37 @@ describe("createStreamingSink", () => {
 			{ error: { message: "boom", type: "server_error", code: "upstream_error" } },
 		]);
 	});
+
+	test("chunk, error, and finish survive a client-cancelled body without throwing", async () => {
+		const { sink, response } = createStreamingSink("auto");
+		const reader = response.body?.getReader();
+		expect(reader).toBeDefined();
+		// Client disconnects mid-stream: reader cancels, controller closes.
+		await reader?.cancel("client closed connection");
+
+		// None of these may throw ERR_INVALID_STATE:
+		expect(() => {
+			sink.chunk(
+				chunk({
+					id: "gen-cancelled",
+					model: "openai/gpt-5.5",
+					choices: [{ index: 0, delta: { content: "trailing" }, finish_reason: null }],
+				}),
+			);
+		}).not.toThrow();
+
+		expect(() => {
+			sink.finish(SUMMARY);
+		}).not.toThrow();
+
+		// Repeated calls (e.g. error after chunk on dead stream) must also stay safe:
+		const { sink: sink2, response: response2 } = createStreamingSink("auto");
+		const reader2 = response2.body?.getReader();
+		await reader2?.cancel();
+		expect(() => {
+			sink2.error({ status: 500, code: "server_error", message: "late failure" });
+		}).not.toThrow();
+	});
 });
 
 describe("createBufferedSink", () => {