Skip to content

Claude Code. Any Model. The most powerful AI coding agent now speaks every language.

test(adapters): pin internal call abort and client cancel outcomes

Jack Rudenko696acfd0666c
diff --git a/packages/cli/src/handlers/shared/call-abort.test.ts b/packages/cli/src/handlers/shared/call-abort.test.ts
new file mode 100644
index 00000000..5aa5ba67
--- /dev/null
+++ b/packages/cli/src/handlers/shared/call-abort.test.ts
@@ -0,0 +1,413 @@
+import { afterEach, describe, expect, mock, spyOn, test } from "bun:test";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import type { ProviderTransport } from "../../providers/transport/types.js";
+
+// Import production modules only in a fresh process: Bun caches homedir(), so
+// changing HOME in this process would not isolate config or credential reads.
+if (process.env.CLAUDISH_T2_ABORT_CHILD !== "1") {
+ test("G1 abort contracts in an isolated HOME", async () => {
+ const home = mkdtempSync(join(tmpdir(), "claudish-t2-abort-"));
+ try {
+ const child = Bun.spawn([process.execPath, "test", import.meta.path], {
+ cwd: home,
+ env: {
+ PATH: process.env.PATH,
+ HOME: home,
+ TMPDIR: home,
+ XDG_CONFIG_HOME: home,
+ CLAUDISH_T2_ABORT_CHILD: "1",
+ },
+ stdout: "inherit",
+ stderr: "inherit",
+ });
+ expect(await child.exited).toBe(0);
+ } finally {
+ rmSync(home, { recursive: true, force: true });
+ }
+ }, 20_000);
+} else {
+ const { Hono } = await import("hono");
+ const { DefaultAPIFormat } = await import("../../adapters/base-api-format.js");
+ const { ComposedHandler } = await import("../composed-handler.js");
+ const { FallbackHandler } = await import("../fallback-handler.js");
+ const { OpenAIProviderTransport } = await import("../../providers/transport/openai.js");
+ const { AnthropicProviderTransport } = await import(
+ "../../providers/transport/anthropic-compat.js"
+ );
+ const { GeminiRequestQueue } = await import("./gemini-queue.js");
+ const { OpenRouterRequestQueue } = await import("./openrouter-queue.js");
+ const { LocalModelQueue } = await import("./local-queue.js");
+ const { CALL_ABORT_SIGNAL_KEY, CALL_ABORTED_HEADER, raceCallAbort, sleepUnlessAborted } =
+ await import("./call-context.js");
+ const logger = await import("../../logger.js");
+ const stats = await import("../../stats.js");
+
+ function deferred<T>() {
+ let resolve!: (value: T) => void;
+ let reject!: (error: Error) => void;
+ const promise = new Promise<T>((yes, no) => {
+ resolve = yes;
+ reject = no;
+ });
+ return { promise, resolve, reject };
+ }
+
+ async function ticks() {
+ for (let i = 0; i < 80; i++) await Promise.resolve();
+ }
+
+ // Fake only the timer API used by the queues/retry waits. No real-time sleeps.
+ function fakeClock() {
+ let now = 2_000_000;
+ const pending = new Map<object, { at: number; run: () => void }>();
+ spyOn(Date, "now").mockImplementation(() => now);
+ spyOn(globalThis, "setTimeout").mockImplementation(((
+ fn: (...args: unknown[]) => void,
+ delay = 0,
+ ...args: unknown[]
+ ) => {
+ const id = {
+ unref() {
+ return this;
+ },
+ ref() {
+ return this;
+ },
+ };
+ pending.set(id, { at: now + Number(delay), run: () => fn(...args) });
+ return id;
+ }) as unknown as typeof setTimeout);
+ spyOn(globalThis, "clearTimeout").mockImplementation(((id: object) => {
+ pending.delete(id);
+ }) as unknown as typeof clearTimeout);
+ spyOn(Bun, "sleep").mockImplementation(
+ ((delay: number | Date) =>
+ new Promise((resolve) => {
+ const id = {};
+ pending.set(id, {
+ at: now + (delay instanceof Date ? delay.getTime() - now : delay),
+ run: () => resolve(undefined),
+ });
+ })) as typeof Bun.sleep
+ );
+ return {
+ async advance(ms: number) {
+ const end = now + ms;
+ for (let n = 0; n < 1000; n++) {
+ await ticks();
+ const next = [...pending.entries()]
+ .filter(([, t]) => t.at <= end)
+ .sort((a, b) => a[1].at - b[1].at)[0];
+ if (!next) break;
+ now = next[1].at;
+ pending.delete(next[0]);
+ next[1].run();
+ }
+ now = end;
+ await ticks();
+ },
+ size: () => pending.size,
+ };
+ }
+
+ // Derived from the recorded inbound request, omitting tools/metadata/system:
+ // test-fixtures/code-mode/cc-2.1.304-inbound-system.jsonl. No invented messages.
+ const inbound = JSON.parse(
+ (
+ await Bun.file(
+ new URL("../../test-fixtures/code-mode/cc-2.1.304-inbound-system.jsonl", import.meta.url)
+ ).text()
+ )
+ .trim()
+ .split("\n")[0]
+ ).body;
+ const payload = {
+ model: inbound.model,
+ messages: inbound.messages,
+ max_tokens: inbound.max_tokens,
+ stream: inbound.stream,
+ };
+
+ function appFor(signal: AbortSignal, handle: (c: import("hono").Context) => Promise<Response>) {
+ const app = new Hono();
+ app.post("/", (c) => {
+ c.set(CALL_ABORT_SIGNAL_KEY, signal);
+ return handle(c);
+ });
+ return async () => await app.request("http://t2.invalid/", { method: "POST" });
+ }
+
+ function transport(overrides: Partial<ProviderTransport> = {}): ProviderTransport {
+ return {
+ name: "t2-metered",
+ displayName: "T2",
+ streamFormat: "openai-sse",
+ getEndpoint: () => "http://t2.invalid/v1/chat/completions",
+ getHeaders: async () => ({}),
+ ...overrides,
+ };
+ }
+
+ const handlers: InstanceType<typeof ComposedHandler>[] = [];
+ function handler(provider: ProviderTransport) {
+ const h = new ComposedHandler(provider, "t2-model", "t2-model", 0, {
+ adapter: new DefaultAPIFormat("t2-model", "openai-sse"),
+ requestRole: "advisor",
+ codeMode: "off",
+ catalogCachePath: join(process.env.HOME!, "absent-catalog.json"),
+ });
+ handlers.push(h);
+ return h;
+ }
+
+ afterEach(async () => {
+ for (const h of handlers.splice(0)) await h.shutdown();
+ mock.restore();
+ });
+
+ describe("G1 — the internal deadline stops upstream work", () => {
+ test("already aborted handler starts no auth, queue or fetch", async () => {
+ const controller = new AbortController();
+ controller.abort();
+ const auth = mock(async () => undefined);
+ const queue = mock(async (fetchFn: () => Promise<Response>) => fetchFn());
+ const fetchSpy = spyOn(globalThis, "fetch").mockRejectedValue(
+ new Error("unexpected network")
+ );
+ spyOn(stats, "recordStats").mockImplementation(() => {});
+ const h = handler(transport({ refreshAuth: auth, enqueueRequest: queue }));
+ const response = await appFor(controller.signal, (c) => h.handle(c, payload))();
+ expect(response.status).toBe(408);
+ expect(response.headers.get(CALL_ABORTED_HEADER)).toBe("1");
+ expect(auth).not.toHaveBeenCalled();
+ expect(queue).not.toHaveBeenCalled();
+ expect(fetchSpy).not.toHaveBeenCalled();
+ await response.text();
+ }, 10_000);
+
+ test("abort stops waiting for a shared refresh and owns its late rejection", async () => {
+ const controller = new AbortController();
+ const refresh = deferred<void>();
+ const entered = deferred<void>();
+ const fetchSpy = spyOn(globalThis, "fetch").mockRejectedValue(
+ new Error("unexpected network")
+ );
+ spyOn(stats, "recordStats").mockImplementation(() => {});
+ const h = handler(
+ transport({
+ refreshAuth: () => {
+ entered.resolve();
+ return refresh.promise;
+ },
+ })
+ );
+ let settled = false;
+ const work = appFor(controller.signal, (c) => h.handle(c, payload))().then((response) => {
+ settled = true;
+ return response;
+ });
+ await entered.promise;
+ controller.abort();
+ await ticks();
+ expect(settled).toBe(true);
+ expect((await work).headers.get(CALL_ABORTED_HEADER)).toBe("1");
+ refresh.reject(new Error("late shared refresh failure"));
+ await ticks();
+ expect(fetchSpy).not.toHaveBeenCalled();
+ }, 10_000);
+
+ test("a queued closure invoked after abort never reaches injected fetch", async () => {
+ const controller = new AbortController();
+ const queued = deferred<() => Promise<Response>>();
+ const result = deferred<Response>();
+ let queuedSignal: AbortSignal | undefined;
+ const fetchSpy = spyOn(globalThis, "fetch").mockRejectedValue(
+ new Error("unexpected network")
+ );
+ spyOn(stats, "recordStats").mockImplementation(() => {});
+ const h = handler(
+ transport({
+ enqueueRequest: (fn, opts) => {
+ queuedSignal = opts?.signal;
+ queued.resolve(fn);
+ return result.promise;
+ },
+ })
+ );
+ const work = appFor(controller.signal, (c) => h.handle(c, payload))();
+ const queuedFetch = await queued.promise;
+ controller.abort();
+ expect(queuedSignal?.aborted).toBe(true);
+ try {
+ await expect(queuedFetch()).rejects.toHaveProperty("name", "AbortError");
+ } finally {
+ const error = new Error("cancelled queued work");
+ error.name = "AbortError";
+ result.reject(error);
+ await work;
+ }
+ expect(fetchSpy).not.toHaveBeenCalled();
+ }, 10_000);
+
+ for (const name of ["gemini", "openrouter", "local"] as const) {
+ test(`${name} queue removes an aborted waiter before its busy slot frees`, async () => {
+ const clock = fakeClock();
+ const controller = new AbortController();
+ const held = deferred<Response>();
+ const busy = deferred<void>();
+ const queue =
+ name === "gemini"
+ ? GeminiRequestQueue.getInstance()
+ : name === "openrouter"
+ ? OpenRouterRequestQueue.getInstance()
+ : LocalModelQueue.getInstance();
+ const enqueue = (fn: () => Promise<Response>, signal?: AbortSignal) =>
+ name === "local"
+ ? (queue as ReturnType<typeof LocalModelQueue.getInstance>).enqueue(fn, "t2", 1, signal)
+ : (queue as ReturnType<typeof GeminiRequestQueue.getInstance>).enqueue(fn, { signal });
+ const first = enqueue(() => {
+ busy.resolve();
+ return held.promise;
+ });
+ await clock.advance(60_000);
+ await busy.promise;
+ let laterFetches = 0;
+ const second = enqueue(async () => {
+ laterFetches++;
+ return new Response(null);
+ }, controller.signal);
+ const outcome = second.catch((error: Error) => error);
+ controller.abort();
+ try {
+ await ticks();
+ expect(await outcome).toHaveProperty("name", "AbortError");
+ expect(queue.getStats().queueLength).toBe(0);
+ } finally {
+ held.resolve(new Response(null));
+ await clock.advance(600_000);
+ await first;
+ }
+ expect(laterFetches).toBe(0);
+ expect(queue.getStats().queueLength).toBe(0);
+ }, 10_000);
+ }
+
+ for (const name of ["openai", "anthropic-compat"] as const) {
+ test(`${name} retry wait ends at abort without a later fetch`, async () => {
+ const clock = fakeClock();
+ const controller = new AbortController();
+ const provider = {
+ name: "t2",
+ baseUrl: "http://t2.invalid",
+ apiPath: "/messages",
+ apiKeyEnvVar: "",
+ prefixes: [],
+ };
+ const p =
+ name === "openai"
+ ? new OpenAIProviderTransport(provider, "t2", "")
+ : new AnthropicProviderTransport(provider, "");
+ // Bodyless status/header input, not fabricated provider protocol data.
+ const fetchFn = mock(
+ async () =>
+ new Response(null, {
+ status: 429,
+ headers: { "retry-after": "60" },
+ })
+ );
+ let settled = false;
+ const work = p
+ .enqueueRequest(fetchFn, { signal: controller.signal })
+ .catch((error: Error) => {
+ settled = true;
+ return error;
+ });
+ await ticks();
+ expect(fetchFn).toHaveBeenCalledTimes(1);
+ expect(clock.size()).toBeGreaterThan(0);
+ controller.abort();
+ await ticks();
+ try {
+ expect(settled).toBe(true);
+ } finally {
+ await clock.advance(600_000);
+ }
+ expect(await work).toHaveProperty("name", "AbortError");
+ expect(fetchFn).toHaveBeenCalledTimes(1);
+ }, 10_000);
+ }
+
+ test("sleep and a pending abort race settle without advancing fake time", async () => {
+ const clock = fakeClock();
+ const controller = new AbortController();
+ const pending = deferred<void>();
+ let sleepSettled = false;
+ let raced: string | undefined;
+ const sleep = sleepUnlessAborted(60_000, controller.signal).then(() => {
+ sleepSettled = true;
+ });
+ const race = raceCallAbort(pending.promise, controller.signal).catch((error: Error) => {
+ raced = error.name;
+ });
+ controller.abort();
+ await ticks();
+ try {
+ expect(sleepSettled).toBe(true);
+ expect(raced).toBe("AbortError");
+ } finally {
+ pending.reject(new Error("late unbilled work"));
+ await clock.advance(60_000);
+ await Promise.all([sleep, race]);
+ }
+ }, 10_000);
+
+ for (const outcome of ["response", "throw"] as const) {
+ test(`routing chain never advances after hop 1 aborts (${outcome})`, async () => {
+ const controller = new AbortController();
+ const lines: string[] = [];
+ spyOn(logger, "logStderr").mockImplementation((line) => {
+ lines.push(line);
+ });
+ const next = mock(async () => new Response(null));
+ const original = new Response(null, { status: 503 });
+ const chain = new FallbackHandler([
+ {
+ name: "T2 first",
+ handler: {
+ async handle() {
+ controller.abort();
+ if (outcome === "throw") throw new Error("cancelled upstream");
+ return original;
+ },
+ async shutdown() {},
+ },
+ },
+ { name: "T2 next", handler: { handle: next, async shutdown() {} } },
+ ]);
+ const response = await appFor(controller.signal, (c) => chain.handle(c, payload))();
+ expect(next).not.toHaveBeenCalled();
+ if (outcome === "response") expect(response.status).toBe(503);
+ else expect(response.headers.get(CALL_ABORTED_HEADER)).toBe("1");
+ expect(
+ lines.filter((line) => line.includes("[Fallback]") && line.includes("failed"))
+ ).toEqual([]);
+ await chain.shutdown();
+ }, 10_000);
+ }
+
+ test("already aborted routing chain does not enter even its first hop", async () => {
+ const controller = new AbortController();
+ controller.abort();
+ const first = mock(async () => new Response(null));
+ const chain = new FallbackHandler([
+ { name: "T2", handler: { handle: first, async shutdown() {} } },
+ ]);
+ const response = await appFor(controller.signal, (c) => chain.handle(c, payload))();
+ expect(response.headers.get(CALL_ABORTED_HEADER)).toBe("1");
+ expect(first).not.toHaveBeenCalled();
+ await chain.shutdown();
+ }, 10_000);
+ });
+}
diff --git a/packages/cli/src/handlers/shared/stream-parsers/client-cancel.test.ts b/packages/cli/src/handlers/shared/stream-parsers/client-cancel.test.ts
new file mode 100644
index 00000000..5d70493f
--- /dev/null
+++ b/packages/cli/src/handlers/shared/stream-parsers/client-cancel.test.ts
@@ -0,0 +1,418 @@
+import { afterEach, describe, expect, mock, spyOn, test } from "bun:test";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import type { Context } from "hono";
+import type { StatsEvent } from "../../../stats.js";
+
+if (process.env.CLAUDISH_T2_CANCEL_CHILD !== "1") {
+ test("G2–G4 client-cancel contracts in an isolated HOME", async () => {
+ const home = mkdtempSync(join(tmpdir(), "claudish-t2-cancel-"));
+ try {
+ const child = Bun.spawn([process.execPath, "test", import.meta.path], {
+ cwd: home,
+ env: {
+ PATH: process.env.PATH,
+ HOME: home,
+ TMPDIR: home,
+ XDG_CONFIG_HOME: home,
+ CLAUDISH_T2_CANCEL_CHILD: "1",
+ },
+ stdout: "inherit",
+ stderr: "inherit",
+ });
+ expect(await child.exited).toBe(0);
+ } finally {
+ rmSync(home, { recursive: true, force: true });
+ }
+ }, 20_000);
+} else {
+ const { Hono } = await import("hono");
+ const { DefaultAPIFormat } = await import("../../../adapters/base-api-format.js");
+ const { MiddlewareManager } = await import("../../../middleware/manager.js");
+ const logger = await import("../../../logger.js");
+ const { acquireSigningLease, redactSigningValues } = await import("../../../redact.js");
+ const { releaseWhenBodyEnds } = await import("../call-context.js");
+ const { cancelEndsUpstreamWork, notifyOnDownstreamCancel } = await import("./upstream-cancel.js");
+ const { createStreamingResponseHandler } = await import("./openai-sse.js");
+ const { createGeminiSseStream } = await import("./gemini-sse.js");
+ const { createAnthropicPassthroughStream } = await import("./anthropic-sse.js");
+ const { createDevinConnectStream } = await import("./devin-connect.js");
+ const { createOllamaJsonlStream } = await import("./ollama-jsonl.js");
+ const { ComposedHandler } = await import("../../composed-handler.js");
+ const stats = await import("../../../stats.js");
+
+ function deferred<T>() {
+ let resolve!: (value: T) => void;
+ const promise = new Promise<T>((yes) => {
+ resolve = yes;
+ });
+ return { promise, resolve };
+ }
+
+ async function ticks() {
+ for (let i = 0; i < 80; i++) await Promise.resolve();
+ }
+
+ const encoder = new TextEncoder();
+ const dataUrl = (name: string) =>
+ new URL(`../../../test-fixtures/sse-responses/${name}`, import.meta.url);
+ const grok = await Bun.file(dataUrl("grok-4.6-openai-advisor-turn1.sse")).text();
+ const gemini = await Bun.file(dataUrl("gemini-3.6-flash-antigravity-ok-answer.sse")).text();
+ const anthropic = await Bun.file(
+ dataUrl("minimax-m3-anthropic-implicit-signature-r10324.sse")
+ ).text();
+ const frames = (s: string) => s.match(/[\s\S]*?(?:\r?\n){2}/g) ?? [];
+
+ // All delivered frames are byte-for-byte slices of the named captures. Drop
+ // later frames, not fields, to model a client leaving before provider usage.
+ const openaiPrefix = frames(grok).slice(0, 12).join("");
+ const anthropicPrefix = frames(anthropic)
+ .filter((frame) => /event: content_block_(?:start|delta)/.test(frame))
+ .slice(0, 4)
+ .join("");
+ const usageFrame = frames(grok).find((frame) => /"usage":\{/.test(frame))!;
+ const geminiFrame = frames(gemini)[0];
+ const anthropicUsage = frames(anthropic).find((frame) => /event: message_delta/.test(frame))!;
+
+ function upstream(prefix = "", teardown?: Promise<void>) {
+ const waiting = deferred<void>();
+ const events: string[] = [];
+ const response = new Response(
+ new ReadableStream<Uint8Array>({
+ start(c) {
+ if (prefix) c.enqueue(encoder.encode(prefix));
+ },
+ pull() {
+ waiting.resolve();
+ },
+ async cancel() {
+ events.push("upstream-cancel");
+ await teardown;
+ events.push("upstream-settled");
+ },
+ })
+ );
+ return { response, waiting, events };
+ }
+
+ interface Hooks {
+ tokens: (input: number, output: number) => void;
+ turnEnd: () => void;
+ text: (text: string) => void;
+ middlewareComplete: () => void;
+ }
+ type Factory = (c: Context, response: Response, hooks: Hooks) => Response;
+ const factories: Record<string, Factory> = {
+ "openai-sse": (c, r, h) => {
+ const middleware = new MiddlewareManager();
+ spyOn(middleware, "afterStreamComplete").mockImplementation(async () => {
+ h.middlewareComplete();
+ });
+ return createStreamingResponseHandler(
+ c,
+ r,
+ new DefaultAPIFormat("t2"),
+ "t2",
+ middleware,
+ h.tokens,
+ undefined,
+ undefined,
+ undefined,
+ { onTurnEnd: h.turnEnd, onAssistantText: h.text }
+ );
+ },
+ "gemini-sse": (c, r, h) =>
+ createGeminiSseStream(c, r, {
+ modelName: "t2",
+ unwrapResponse: true,
+ onTokenUpdate: h.tokens,
+ onTurnEnd: h.turnEnd,
+ onAssistantText: h.text,
+ }),
+ "anthropic-sse": (c, r, h) =>
+ createAnthropicPassthroughStream(c, r, {
+ modelName: "t2",
+ onTokenUpdate: h.tokens,
+ onTurnEnd: h.turnEnd,
+ onAssistantText: h.text,
+ }),
+ "devin-connect": (c, r, h) =>
+ createDevinConnectStream(c, r, {
+ modelName: "t2",
+ onTokenUpdate: h.tokens,
+ onTurnEnd: h.turnEnd,
+ onAssistantText: h.text,
+ }),
+ // The public Ollama factory exposes no behavior-layer hook.
+ "ollama-jsonl": (c, r, h) =>
+ createOllamaJsonlStream(c, r, { modelName: "t2", onTokenUpdate: h.tokens }),
+ };
+
+ function hooks(): Hooks {
+ return {
+ tokens: mock(() => {}),
+ turnEnd: mock(() => {}),
+ text: mock(() => {}),
+ middlewareComplete: mock(() => {}),
+ };
+ }
+
+ function captureLogs() {
+ const lines: string[] = [];
+ spyOn(logger, "log").mockImplementation((line) => {
+ lines.push(line);
+ });
+ return lines;
+ }
+
+ async function parse(factory: Factory, response: Response, h: Hooks) {
+ const app = new Hono();
+ app.get("/", (c) => factory(c, response, h));
+ return app.request("http://t2.invalid/");
+ }
+
+ afterEach(() => {
+ mock.restore();
+ });
+
+ describe("G2 — cancellation is not silent truncation", () => {
+ for (const name of Object.keys(factories)) {
+ test(`${name}: cancel before usage records no estimate or turn-end hook`, async () => {
+ const lines = captureLogs();
+ const h = hooks();
+ // Gemini's available capture includes usage in its FIRST frame; cancel
+ // before it. No Devin/Ollama streaming capture exists in test-fixtures,
+ // so those two cases deliberately exercise the pre-first-byte path.
+ const prefix =
+ name === "openai-sse" ? openaiPrefix : name === "anthropic-sse" ? anthropicPrefix : "";
+ const source = upstream(prefix);
+ const response = await parse(factories[name], source.response, h);
+ await source.waiting.promise;
+ await ticks();
+ try {
+ if (prefix) expect(h.text).toHaveBeenCalled();
+ } finally {
+ await response.body!.cancel("client left");
+ }
+ expect(source.events).toEqual(["upstream-cancel", "upstream-settled"]);
+ expect(h.tokens).not.toHaveBeenCalled();
+ expect(h.turnEnd).not.toHaveBeenCalled();
+ expect(h.middlewareComplete).not.toHaveBeenCalled();
+ expect(
+ lines.filter((line) =>
+ /Stream ending error|silent-truncation|ending.*failure/i.test(line)
+ )
+ ).toEqual([]);
+ expect(lines.filter((line) => line.includes("Client cancelled the stream"))).toHaveLength(
+ 1
+ );
+ }, 10_000);
+ }
+
+ for (const [name, frame] of [
+ ["openai-sse", usageFrame],
+ ["gemini-sse", geminiFrame],
+ ["anthropic-sse", anthropicUsage],
+ ] as const) {
+ test(`${name}: cancel preserves provider-sent usage without a turn-end hook`, async () => {
+ const lines = captureLogs();
+ const h = hooks();
+ const source = upstream(frame);
+ const response = await parse(factories[name], source.response, h);
+ await source.waiting.promise;
+ await ticks();
+ await response.body!.cancel("client left");
+ expect(h.tokens).toHaveBeenCalledTimes(1);
+ expect(h.turnEnd).not.toHaveBeenCalled();
+ expect(h.middlewareComplete).not.toHaveBeenCalled();
+ expect(lines.filter((line) => line.includes("Stream ending error"))).toEqual([]);
+ expect(lines.filter((line) => line.includes("Client cancelled the stream"))).toHaveLength(
+ 1
+ );
+ }, 10_000);
+ }
+ });
+
+ describe("G3 — a cancel retains its signing lease until work settles", () => {
+ test("outstanding parser read cannot release during delayed upstream cancellation", async () => {
+ const teardown = deferred<void>();
+ const source = upstream(openaiPrefix, teardown.promise);
+ const lease = acquireSigningLease();
+ const token = "OPAQUE_TEST_TOKEN_T2_parser";
+ lease.add([token]);
+ const release = mock(() => {
+ source.events.push("released");
+ lease.release();
+ });
+ const parsed = await parse(factories["openai-sse"], source.response, hooks());
+ const response = releaseWhenBodyEnds(parsed, release);
+ const reader = response.body!.getReader();
+ const consuming = (async () => {
+ while (!(await reader.read()).done) {
+ /* drain to the pending read */
+ }
+ })();
+ await source.waiting.promise;
+ await ticks();
+ const cancelled = reader.cancel("client left");
+ await ticks();
+ try {
+ expect(source.events).toEqual(["upstream-cancel"]);
+ expect(release).not.toHaveBeenCalled();
+ expect(redactSigningValues(token)).toBe("[redacted]");
+ } finally {
+ teardown.resolve();
+ await cancelled;
+ await consuming;
+ lease.release();
+ }
+ expect(source.events).toEqual(["upstream-cancel", "upstream-settled", "released"]);
+ expect(release).toHaveBeenCalledTimes(1);
+ expect(redactSigningValues(token)).toBe(token);
+ }, 10_000);
+
+ test("cancel awaits the parser task's delayed teardown, not only reader.cancel", async () => {
+ const teardown = deferred<void>();
+ const source = upstream();
+ const reader = source.response.body!.getReader();
+ const lease = acquireSigningLease();
+ const token = "OPAQUE_TEST_TOKEN_T2_task";
+ lease.add([token]);
+ const events: string[] = [];
+ const parsed = new Response(
+ new ReadableStream<Uint8Array>(
+ cancelEndsUpstreamWork(
+ { reader },
+ {
+ async start() {
+ await reader.read();
+ await teardown.promise;
+ events.push(`teardown:${redactSigningValues(token)}`);
+ },
+ }
+ )
+ )
+ );
+ const release = mock(() => {
+ events.push("released");
+ lease.release();
+ });
+ const wrapped = releaseWhenBodyEnds(parsed, release);
+ const downstream = wrapped.body!.getReader();
+ const pendingRead = downstream.read();
+ await source.waiting.promise;
+ const cancel = downstream.cancel();
+ await ticks();
+ try {
+ expect(source.events).toEqual(["upstream-cancel", "upstream-settled"]);
+ expect(release).not.toHaveBeenCalled();
+ expect(redactSigningValues(token)).toBe("[redacted]");
+ } finally {
+ teardown.resolve();
+ await cancel;
+ await pendingRead;
+ lease.release();
+ }
+ expect(events).toEqual(["teardown:[redacted]", "released"]);
+ expect(release).toHaveBeenCalledTimes(1);
+ expect(redactSigningValues(token)).toBe(token);
+ }, 10_000);
+ });
+
+ describe("G4 — cancellation stats", () => {
+ test("downstream cancel callback precedes the source's cancel", async () => {
+ const events: string[] = [];
+ const response = notifyOnDownstreamCancel(
+ new Response(
+ new ReadableStream({
+ cancel() {
+ events.push("source");
+ },
+ })
+ ),
+ () => {
+ events.push("callback");
+ }
+ );
+ await response.body!.cancel();
+ expect(events).toEqual(["callback", "source"]);
+ }, 10_000);
+
+ for (const withUsage of [false, true]) {
+ test(`ComposedHandler cancel ${withUsage ? "with" : "without"} provider usage`, async () => {
+ const events: Partial<StatsEvent>[] = [];
+ spyOn(stats, "recordStats").mockImplementation((event) => {
+ events.push(event);
+ });
+ const source = upstream(withUsage ? usageFrame : openaiPrefix);
+ const fetchSpy = spyOn(globalThis, "fetch").mockImplementation(
+ (async () => source.response) as unknown as typeof fetch
+ );
+ const handler = new ComposedHandler(
+ {
+ name: "t2-metered",
+ displayName: "T2",
+ streamFormat: "openai-sse",
+ getEndpoint: () => "http://t2.invalid/chat/completions",
+ getHeaders: async () => ({}),
+ },
+ "t2-model",
+ "t2-model",
+ 0,
+ {
+ adapter: new DefaultAPIFormat("t2-model", "openai-sse"),
+ requestRole: "advisor",
+ codeMode: "off",
+ catalogCachePath: join(process.env.HOME!, "absent-catalog.json"),
+ }
+ );
+ // Derived from the recorded Claude Code request: retain actual messages
+ // and limit, omit tool/system/metadata fields unrelated to cancellation.
+ const inbound = JSON.parse(
+ (
+ await Bun.file(
+ new URL(
+ "../../../test-fixtures/code-mode/cc-2.1.304-inbound-system.jsonl",
+ import.meta.url
+ )
+ ).text()
+ )
+ .trim()
+ .split("\n")[0]
+ ).body;
+ const payload = {
+ model: inbound.model,
+ messages: inbound.messages,
+ max_tokens: inbound.max_tokens,
+ stream: inbound.stream,
+ };
+ const app = new Hono();
+ app.post("/", (c) => handler.handle(c, payload));
+ try {
+ const response = await app.request("http://t2.invalid/", { method: "POST" });
+ expect(fetchSpy).toHaveBeenCalledTimes(1);
+ await source.waiting.promise;
+ await ticks();
+ await response.body!.cancel("client left");
+ if (withUsage) {
+ expect(events).toHaveLength(1);
+ expect(events[0]).toMatchObject({
+ success: false,
+ error_class: "cancelled",
+ error_code: "client_cancelled",
+ request_role: "advisor",
+ });
+ const captured = JSON.parse(usageFrame.split("data: ")[1]);
+ expect(events[0].input_tokens).toBe(captured.usage.prompt_tokens);
+ } else {
+ expect(events).toEqual([]);
+ expect(handler.getTokenTracker().getTotalCost()).toBe(0);
+ }
+ } finally {
+ await handler.shutdown();
+ }
+ }, 10_000);
+ }
+ });
+}