fix(ai): preserve cache_write_tokens in completions stream usage closes #2802

packages/ai/test/openai-completions-tool-choice.test.ts

@@ -13,7 +13,7 @@ const mockState = vi.hoisted(() => ({
 				usage?: {
 					prompt_tokens: number;
 					completion_tokens: number;
-					prompt_tokens_details: { cached_tokens: number };
+					prompt_tokens_details: { cached_tokens: number; cache_write_tokens?: number };
 					completion_tokens_details: { reasoning_tokens: number };
 				};
 		  }>
@@ -430,6 +430,91 @@ describe("openai-completions tool_choice", () => {
 		expect(response.content).toEqual([{ type: "text", text: "OK" }]);
 	});
 
+	it("preserves prompt_tokens_details.cache_write_tokens from chunk usage", async () => {
+		mockState.chunks = [
+			{
+				id: "chatcmpl-cache-write",
+				choices: [{ delta: { content: "OK" }, finish_reason: null }],
+			},
+			{
+				id: "chatcmpl-cache-write",
+				choices: [{ delta: {}, finish_reason: "stop" }],
+				usage: {
+					prompt_tokens: 100,
+					completion_tokens: 5,
+					prompt_tokens_details: { cached_tokens: 50, cache_write_tokens: 30 },
+					completion_tokens_details: { reasoning_tokens: 0 },
+				},
+			},
+		];
+
+		const { compat: _compat, ...baseModel } = getModel("openai", "gpt-4o-mini")!;
+		const model = { ...baseModel, api: "openai-completions" } as const;
+		const response = await streamSimple(
+			model,
+			{
+				messages: [
+					{
+						role: "user",
+						content: "Reply with exactly OK",
+						timestamp: Date.now(),
+					},
+				],
+			},
+			{ apiKey: "test" },
+		).result();
+
+		expect(response.usage.input).toBe(50);
+		expect(response.usage.cacheRead).toBe(20);
+		expect(response.usage.cacheWrite).toBe(30);
+		expect(response.usage.totalTokens).toBe(105);
+	});
+
+	it("preserves prompt_tokens_details.cache_write_tokens from choice usage fallback", async () => {
+		mockState.chunks = [
+			{
+				id: "chatcmpl-cache-write-choice",
+				choices: [{ delta: { content: "OK" }, finish_reason: null }],
+			},
+			{
+				id: "chatcmpl-cache-write-choice",
+				choices: [
+					{
+						delta: {},
+						finish_reason: "stop",
+						usage: {
+							prompt_tokens: 100,
+							completion_tokens: 5,
+							prompt_tokens_details: { cached_tokens: 50, cache_write_tokens: 30 },
+							completion_tokens_details: { reasoning_tokens: 0 },
+						},
+					},
+				],
+			},
+		];
+
+		const { compat: _compat, ...baseModel } = getModel("openai", "gpt-4o-mini")!;
+		const model = { ...baseModel, api: "openai-completions" } as const;
+		const response = await streamSimple(
+			model,
+			{
+				messages: [
+					{
+						role: "user",
+						content: "Reply with exactly OK",
+						timestamp: Date.now(),
+					},
+				],
+			},
+			{ apiKey: "test" },
+		).result();
+
+		expect(response.usage.input).toBe(50);
+		expect(response.usage.cacheRead).toBe(20);
+		expect(response.usage.cacheWrite).toBe(30);
+		expect(response.usage.totalTokens).toBe(105);
+	});
+
 	it("uses OpenRouter reasoning object instead of reasoning_effort", async () => {
 		const model = getModel("openrouter", "deepseek/deepseek-r1")!;
 		let payload: unknown;

packages/ai/test/openrouter-cache-write-repro.test.ts

@@ -0,0 +1,78 @@
+import { describe, expect, it } from "vitest";
+import { getModel } from "../src/models.js";
+import { completeSimple } from "../src/stream.js";
+
+function createLongSystemPrompt(): string {
+	const nonce = `${Date.now()}-${Math.random()}`;
+	return `You are a concise assistant.\nCache nonce: ${nonce}\n\n${Array(80)
+		.fill(
+			"Prompt-caching probe content. Keep this exact text stable across requests so the provider can reuse prefix tokens and report cache read and cache write usage.",
+		)
+		.join("\n\n")}`;
+}
+
+describe.skipIf(!process.env.OPENROUTER_API_KEY)("OpenRouter cache_write repro E2E", () => {
+	it(
+		"regression: preserves cache_write_tokens on openai-completions stream path",
+		{ retry: 2, timeout: 90000 },
+		async () => {
+			const model = getModel("openrouter", "google/gemini-2.5-flash");
+			const context = {
+				systemPrompt: createLongSystemPrompt(),
+				messages: [
+					{
+						role: "user" as const,
+						content: "Reply with exactly: OK",
+						timestamp: Date.now(),
+					},
+				],
+			};
+
+			const options = {
+				apiKey: process.env.OPENROUTER_API_KEY!,
+				maxTokens: 32,
+				temperature: 0,
+				onPayload: (payload: unknown) => {
+					const params = payload as {
+						messages?: Array<{
+							role?: string;
+							content?: string | Array<{ type?: string; text?: string; cache_control?: { type: string } }>;
+						}>;
+					};
+					const messages = params.messages;
+					if (!Array.isArray(messages)) return payload;
+
+					for (let i = messages.length - 1; i >= 0; i--) {
+						const msg = messages[i];
+						if (msg.role !== "user") continue;
+						if (typeof msg.content === "string") {
+							msg.content = [{ type: "text", text: msg.content, cache_control: { type: "ephemeral" } }];
+							break;
+						}
+						if (!Array.isArray(msg.content)) continue;
+						for (let j = msg.content.length - 1; j >= 0; j--) {
+							const part = msg.content[j];
+							if (part.type === "text") {
+								part.cache_control = { type: "ephemeral" };
+								break;
+							}
+						}
+						break;
+					}
+					return payload;
+				},
+			};
+
+			const first = await completeSimple(model, context, options);
+			expect(first.stopReason, first.errorMessage).toBe("stop");
+
+			const second = await completeSimple(model, context, options);
+			expect(second.stopReason, second.errorMessage).toBe("stop");
+
+			// Regression expectation: cache_write_tokens from provider usage must be preserved.
+			// With the cache_control marker above, at least one of the two calls should create cache.
+			const hasCacheWrite = first.usage.cacheWrite > 0 || second.usage.cacheWrite > 0;
+			expect(hasCacheWrite).toBe(true);
+		},
+	);
+});