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.tsnew file mode 100644index 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.tsnew file mode 100644index 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);+ }+ });+}