@@ -81,6 +81,20 @@ vitest.mock("../fetchers/modelCache", () => ({
 				description: "Claude 4.5 Sonnet",
 				thinking: false,
 			},
+			// Not in OPEN_ROUTER_PROMPT_CACHING_MODELS: stands in for a Claude
+			// model released after the static allowlist was last edited.
+			"anthropic/claude-opus-4.8": {
+				maxTokens: 128000,
+				contextWindow: 1000000,
+				supportsImages: true,
+				supportsPromptCache: true,
+				inputPrice: 5,
+				outputPrice: 25,
+				cacheWritesPrice: 6.25,
+				cacheReadsPrice: 0.5,
+				description: "Claude 4.8 Opus",
+				thinking: false,
+			},
 			"anthropic/claude-3.7-sonnet:thinking": {
 				maxTokens: 128000,
 				contextWindow: 200000,
@@ -485,6 +499,201 @@ describe("OpenRouterHandler", () => {
 			)
 		})
 
+		it("adds cache control for a Claude model missing from the static allowlist", async () => {
+			const handler = new OpenRouterHandler(
+				makeApiHandlerOptions({
+					...mockOptions,
+					openRouterModelId: "anthropic/claude-opus-4.8",
+				}),
+			)
+
+			const mockStream = asyncStreamFrom([{ id: "test-id", choices: [{ delta: { content: "test response" } }] }])
+			const mockCreate = vitest.fn().mockResolvedValue(mockStream)
+			const chatStub = { completions: { create: mockCreate } }
+			const openAiPrototype = OpenAI as unknown as { prototype: { chat?: unknown } }
+			const originalChat = openAiPrototype.prototype.chat
+			openAiPrototype.prototype.chat = chatStub
+
+			try {
+				await handler.createMessage("test system", [{ role: "user", content: "test message" }]).next()
+
+				const [requestParams] = mockCreate.mock.calls[0] as [Record<string, unknown>]
+				expect(requestParams).toMatchObject({
+					messages: expect.arrayContaining([
+						expect.objectContaining({
+							role: "system",
+							content: expect.arrayContaining([
+								expect.objectContaining({ cache_control: { type: "ephemeral" } }),
+							]),
+						}),
+					]),
+				})
+			} finally {
+				openAiPrototype.prototype.chat = originalChat
+			}
+		})
+
+		it("keeps Gemini cache breakpoints allowlist-only", async () => {
+			// A Gemini model absent from the allowlist must not gain Anthropic-style
+			// breakpoints just because its catalog record advertises cache pricing.
+			const handler = new OpenRouterHandler(
+				makeApiHandlerOptions({
+					...mockOptions,
+					openRouterModelId: "google/gemini-9-pro",
+				}),
+			)
+
+			const mockStream = asyncStreamFrom([{ id: "test-id", choices: [{ delta: { content: "test response" } }] }])
+			const mockCreate = vitest.fn().mockResolvedValue(mockStream)
+			const chatStub = { completions: { create: mockCreate } }
+			const openAiPrototype = OpenAI as unknown as { prototype: { chat?: unknown } }
+			const originalChat = openAiPrototype.prototype.chat
+			openAiPrototype.prototype.chat = chatStub
+
+			try {
+				await handler.createMessage("test system", [{ role: "user", content: "test message" }]).next()
+
+				const [requestParams] = mockCreate.mock.calls[0] as [Record<string, unknown>]
+				expect(requestParams).toMatchObject({
+					messages: [{ role: "system", content: "test system" }, expect.anything()],
+				})
+			} finally {
+				openAiPrototype.prototype.chat = originalChat
+			}
+		})
+
+		it("sends the task ID as the OpenRouter cache session affinity key", async () => {
+			const handler = new OpenRouterHandler(mockOptions)
+
+			const mockStream = asyncStreamFrom([{ id: "test-id", choices: [{ delta: { content: "test response" } }] }])
+			const mockCreate = vitest.fn().mockResolvedValue(mockStream)
+			const chatStub = { completions: { create: mockCreate } }
+			const openAiPrototype = OpenAI as unknown as { prototype: { chat?: unknown } }
+			const originalChat = openAiPrototype.prototype.chat
+			openAiPrototype.prototype.chat = chatStub
+
+			try {
+				await handler
+					.createMessage("test system", [{ role: "user", content: "test message" }], { taskId: "task-123" })
+					.next()
+
+				const [requestParams] = mockCreate.mock.calls[0] as [Record<string, unknown>]
+				expect(requestParams).toMatchObject({ session_id: "task-123" })
+			} finally {
+				openAiPrototype.prototype.chat = originalChat
+			}
+		})
+
+		it("omits session_id when no task ID is available", async () => {
+			const handler = new OpenRouterHandler(mockOptions)
+
+			const mockStream = asyncStreamFrom([{ id: "test-id", choices: [{ delta: { content: "test response" } }] }])
+			const mockCreate = vitest.fn().mockResolvedValue(mockStream)
+			const chatStub = { completions: { create: mockCreate } }
+			const openAiPrototype = OpenAI as unknown as { prototype: { chat?: unknown } }
+			const originalChat = openAiPrototype.prototype.chat
+			openAiPrototype.prototype.chat = chatStub
+
+			try {
+				await handler.createMessage("test system", [{ role: "user", content: "test message" }]).next()
+
+				const [requestParams] = mockCreate.mock.calls[0] as [Record<string, unknown>]
+				expect(requestParams).not.toHaveProperty("session_id")
+			} finally {
+				openAiPrototype.prototype.chat = originalChat
+			}
+		})
+
+		it("truncates an over-long task ID to OpenRouter's 256-character session_id limit", async () => {
+			const handler = new OpenRouterHandler(mockOptions)
+
+			const mockStream = asyncStreamFrom([{ id: "test-id", choices: [{ delta: { content: "test response" } }] }])
+			const mockCreate = vitest.fn().mockResolvedValue(mockStream)
+			const chatStub = { completions: { create: mockCreate } }
+			const openAiPrototype = OpenAI as unknown as { prototype: { chat?: unknown } }
+			const originalChat = openAiPrototype.prototype.chat
+			openAiPrototype.prototype.chat = chatStub
+
+			try {
+				await handler
+					.createMessage("test system", [{ role: "user", content: "test message" }], {
+						taskId: "a".repeat(300),
+					})
+					.next()
+
+				const [requestParams] = mockCreate.mock.calls[0] as [Record<string, unknown>]
+				expect(requestParams.session_id).toBe("a".repeat(256))
+			} finally {
+				openAiPrototype.prototype.chat = originalChat
+			}
+		})
+
+		it("maps OpenRouter cache read and write usage tokens", async () => {
+			const handler = new OpenRouterHandler(mockOptions)
+
+			const mockStream = asyncStreamFrom([
+				{
+					id: "test-id",
+					choices: [{ delta: {} }],
+					usage: {
+						prompt_tokens: 10,
+						completion_tokens: 2,
+						prompt_tokens_details: { cached_tokens: 6, cache_write_tokens: 4 },
+					},
+				},
+			])
+			const mockCreate = vitest.fn().mockResolvedValue(mockStream)
+			const chatStub = { completions: { create: mockCreate } }
+			const openAiPrototype = OpenAI as unknown as { prototype: { chat?: unknown } }
+			const originalChat = openAiPrototype.prototype.chat
+			openAiPrototype.prototype.chat = chatStub
+
+			try {
+				const chunks = await collectStream(
+					handler.createMessage("test system", [{ role: "user", content: "test message" }]),
+				)
+
+				expect(chunks).toContainEqual({
+					type: "usage",
+					inputTokens: 10,
+					outputTokens: 2,
+					cacheReadTokens: 6,
+					cacheWriteTokens: 4,
+					totalCost: 0,
+				})
+			} finally {
+				openAiPrototype.prototype.chat = originalChat
+			}
+		})
+
+		it("leaves cache token fields unset when OpenRouter reports no cache usage", async () => {
+			const handler = new OpenRouterHandler(mockOptions)
+
+			const mockStream = asyncStreamFrom([
+				{
+					id: "test-id",
+					choices: [{ delta: {} }],
+					usage: { prompt_tokens: 10, completion_tokens: 2 },
+				},
+			])
+			const mockCreate = vitest.fn().mockResolvedValue(mockStream)
+			const chatStub = { completions: { create: mockCreate } }
+			const openAiPrototype = OpenAI as unknown as { prototype: { chat?: unknown } }
+			const originalChat = openAiPrototype.prototype.chat
+			openAiPrototype.prototype.chat = chatStub
+
+			try {
+				const chunks = await collectStream(
+					handler.createMessage("test system", [{ role: "user", content: "test message" }]),
+				)
+
+				const usageChunk = chunks.find((chunk) => chunk.type === "usage")
+				expect(usageChunk).toMatchObject({ cacheReadTokens: undefined, cacheWriteTokens: undefined })
+			} finally {
+				openAiPrototype.prototype.chat = originalChat
+			}
+		})
+
 		it("handles API errors and captures telemetry", async () => {
 			const handler = new OpenRouterHandler(mockOptions)
 			const mockStream = asyncStreamFrom([{ error: { message: "API Error", code: 500 } }])
 
@@ -49,10 +49,16 @@ import { applyRouterToolPreferences } from "./utils/router-tool-preferences"
 type OpenRouterChatCompletionParams = OpenAI.Chat.ChatCompletionCreateParams & {
 	transforms?: string[]
 	include_reasoning?: boolean
+	// https://openrouter.ai/docs/guides/best-practices/prompt-caching#using-session_id-for-sticky-sessions
+	session_id?: string
 	// https://openrouter.ai/docs/use-cases/reasoning-tokens
 	reasoning?: OpenRouterReasoningParams
 }
 
+// OpenRouter rejects a `session_id` longer than this.
+// https://openrouter.ai/docs/guides/best-practices/prompt-caching#using-session_id-for-sticky-sessions
+const OPENROUTER_MAX_SESSION_ID_LENGTH = 256
+
 // Zod schema for OpenRouter error response structure (for caught exceptions)
 const OpenRouterErrorResponseSchema = z.object({
 	error: z
@@ -125,6 +131,8 @@ interface CompletionUsage {
 	prompt_tokens?: number
 	prompt_tokens_details?: {
 		cached_tokens?: number
+		// https://openrouter.ai/docs/guides/best-practices/prompt-caching#usage-object-fields
+		cache_write_tokens?: number
 	}
 	total_tokens?: number
 	cost?: number
@@ -219,6 +227,10 @@ export class OpenRouterHandler extends BaseProvider implements SingleCompletionH
 
 		let { id: modelId, maxTokens, temperature, topP, reasoning } = model
 
+		// OpenRouter caps `session_id` at 256 characters. Task IDs are UUIDs and
+		// far shorter, so this only guards against an over-long caller value.
+		const sessionId = metadata?.taskId?.slice(0, OPENROUTER_MAX_SESSION_ID_LENGTH)
+
 		// Reset reasoning_details accumulator for this request
 		this.currentReasoningDetails = []
 
@@ -302,9 +314,19 @@ export class OpenRouterHandler extends BaseProvider implements SingleCompletionH
 			})
 		}
 
-		// https://openrouter.ai/docs/features/prompt-caching
-		// TODO: Add a `promptCacheStratey` field to `ModelInfo`.
-		if (OPEN_ROUTER_PROMPT_CACHING_MODELS.has(modelId)) {
+		// https://openrouter.ai/docs/guides/best-practices/prompt-caching
+		// TODO: Add a `promptCacheStrategy` field to `ModelInfo`.
+		// The allowlist is a static snapshot, so a Claude model released after it
+		// was last edited got no breakpoints even though OpenRouter advertises
+		// cache pricing for it. Trust the live capability flag for Claude and keep
+		// the allowlist as the fallback; Gemini and every other provider keep
+		// allowlist-only behavior because breakpoint placement is not
+		// interchangeable between them.
+		const supportsCacheBreakpoints =
+			OPEN_ROUTER_PROMPT_CACHING_MODELS.has(modelId) ||
+			(modelId.startsWith("anthropic/") && model.info.supportsPromptCache)
+
+		if (supportsCacheBreakpoints) {
 			if (modelId.startsWith("google")) {
 				addGeminiCacheBreakpoints(systemPrompt, openAiMessages)
 			} else {
@@ -315,6 +337,11 @@ export class OpenRouterHandler extends BaseProvider implements SingleCompletionH
 		// https://openrouter.ai/docs/transforms
 		const completionParams: OpenRouterChatCompletionParams = {
 			model: modelId,
+			// OpenRouter derives its sticky-routing key from the opening messages
+			// unless `session_id` is sent, and without it stickiness only starts
+			// after a cache hit is observed. A task ID pins every turn of the task
+			// to the endpoint holding its warm cache from the first request.
+			...(sessionId ? { session_id: sessionId } : {}),
 			...(maxTokens && maxTokens > 0 && { max_tokens: maxTokens }),
 			temperature,
 			top_p: topP,
@@ -540,6 +567,7 @@ export class OpenRouterHandler extends BaseProvider implements SingleCompletionH
 				inputTokens: lastUsage.prompt_tokens || 0,
 				outputTokens: lastUsage.completion_tokens || 0,
 				cacheReadTokens: lastUsage.prompt_tokens_details?.cached_tokens,
+				cacheWriteTokens: lastUsage.prompt_tokens_details?.cache_write_tokens,
 				reasoningTokens: lastUsage.completion_tokens_details?.reasoning_tokens,
 				totalCost: (lastUsage.cost_details?.upstream_inference_cost || 0) + (lastUsage.cost || 0),
 			}