refactor: remove all manual OpenAI message transforms from OpenRouter provider

- Remove buildOpenAiMessages(), extraBody.messages hack, and dummy messages
- Wire reasoning_details through AI SDK natively via providerOptions.openrouter
- Filter schema-invalid reasoning_details entries (malformed encrypted blocks)
- Filter [REDACTED] from thinking UI stream (upstream provider behavior)
- Remove unused imports: convertToOpenAiMessages, sanitizeGeminiMessages,
  consolidateReasoningDetails, convertToR1Format, addAnthropicCacheBreakpoints,
  addGeminiCacheBreakpoints
- All models now use convertToAiSdkMessages() → streamText() natively
- Prompt caching deferred (needs providerOptions.openrouter.cacheControl impl)

Author: hannesrudolph

src/api/providers/__tests__/openrouter.spec.ts

@@ -1040,26 +1040,21 @@ describe("OpenRouterHandler", () => {
 			)
 		})
 
-		it("uses R1 format for DeepSeek R1 models (extraBody.messages)", async () => {
+		it("does not use R1 format for DeepSeek R1 models (uses standard AI SDK path)", async () => {
 			const handler = new OpenRouterHandler({
 				openRouterApiKey: "test-key",
 				openRouterModelId: "deepseek/deepseek-r1",
 			})
 			mockStreamResult()
 			await consumeGenerator(handler, "system prompt")
 
-			// R1 models should pass OpenAI messages via extraBody (including system as user message)
-			expect(mockCreateOpenRouter).toHaveBeenCalledWith(
-				expect.objectContaining({
-					extraBody: expect.objectContaining({
-						messages: expect.any(Array),
-					}),
-				}),
-			)
+			// R1 models should NOT pass extraBody.messages (R1 format conversion removed)
+			const providerCall = mockCreateOpenRouter.mock.calls[0][0]
+			expect(providerCall?.extraBody?.messages).toBeUndefined()
 
-			// System prompt should NOT be passed to streamText (it is in extraBody.messages)
+			// System prompt should be passed normally via streamText
 			const streamTextCall = mockStreamText.mock.calls[0][0]
-			expect(streamTextCall.system).toBeUndefined()
+			expect(streamTextCall.system).toBe("system prompt")
 		})
 
 		it("applies Anthropic beta headers for Anthropic models", async () => {
@@ -1089,22 +1084,21 @@ describe("OpenRouterHandler", () => {
 			expect(call.headers).toBeUndefined()
 		})
 
-		it("applies prompt caching for Anthropic models in caching set", async () => {
+		it("passes system prompt directly for Anthropic models (no caching transform)", async () => {
 			const handler = new OpenRouterHandler({
 				openRouterApiKey: "test-key",
 				openRouterModelId: "anthropic/claude-sonnet-4",
 			})
 			mockStreamResult()
 			await consumeGenerator(handler)
 
-			// Should have extraBody.messages with cache_control applied
-			expect(mockCreateOpenRouter).toHaveBeenCalledWith(
-				expect.objectContaining({
-					extraBody: expect.objectContaining({
-						messages: expect.arrayContaining([expect.objectContaining({ role: "system" })]),
-					}),
-				}),
-			)
+			// System prompt should be passed directly via streamText
+			const streamTextCall = mockStreamText.mock.calls[0][0]
+			expect(streamTextCall.system).toBe("test")
+
+			// Messages should be the converted AI SDK messages (no system-role message injected)
+			const systemMsgs = streamTextCall.messages.filter((m: any) => m.role === "system")
+			expect(systemMsgs).toHaveLength(0)
 		})
 
 		it("disables reasoning for Gemini 2.5 Pro when not explicitly configured", async () => {
@@ -1124,22 +1118,36 @@ describe("OpenRouterHandler", () => {
 			)
 		})
 
-		it("applies Gemini sanitization and encrypted block injection", async () => {
+		it("passes system prompt directly for Gemini models (no caching transform)", async () => {
 			const handler = new OpenRouterHandler({
 				openRouterApiKey: "test-key",
 				openRouterModelId: "google/gemini-2.5-flash",
 			})
 			mockStreamResult()
 			await consumeGenerator(handler)
 
-			// Gemini models should have extraBody.messages set (via buildOpenAiMessages)
-			expect(mockCreateOpenRouter).toHaveBeenCalledWith(
-				expect.objectContaining({
-					extraBody: expect.objectContaining({
-						messages: expect.any(Array),
-					}),
-				}),
-			)
+			// System prompt should be passed directly via streamText
+			const streamTextCall = mockStreamText.mock.calls[0][0]
+			expect(streamTextCall.system).toBe("test")
+
+			// No system-role message should be injected
+			const systemMsgs = streamTextCall.messages.filter((m: any) => m.role === "system")
+			expect(systemMsgs).toHaveLength(0)
+		})
+
+		it("does not use extraBody.messages for Gemini models outside caching set", async () => {
+			const handler = new OpenRouterHandler({
+				openRouterApiKey: "test-key",
+				openRouterModelId: "google/gemini-3-pro-preview",
+			})
+			mockStreamResult()
+			await consumeGenerator(handler)
+
+			// Non-caching Gemini models should go through the AI SDK natively
+			// (no extraBody.messages — reasoning_details are wired via providerOptions)
+			const callArgs = mockCreateOpenRouter.mock.calls[0]?.[0] ?? {}
+			const extraBody = callArgs.extraBody ?? {}
+			expect(extraBody.messages).toBeUndefined()
 		})
 
 		it("passes topP to completePrompt for R1 models", async () => {

src/api/providers/openrouter.ts

@@ -1,5 +1,4 @@
 import { Anthropic } from "@anthropic-ai/sdk"
-import OpenAI from "openai"
 import { createOpenRouter } from "@openrouter/ai-sdk-provider"
 import { streamText, generateText } from "ai"
 
@@ -9,7 +8,6 @@ import {
 	openRouterDefaultModelId,
 	openRouterDefaultModelInfo,
 	OPENROUTER_DEFAULT_PROVIDER_NAME,
-	OPEN_ROUTER_PROMPT_CACHING_MODELS,
 	DEEP_SEEK_DEFAULT_TEMPERATURE,
 	ApiProviderError,
 } from "@roo-code/types"
@@ -18,15 +16,7 @@ import { TelemetryService } from "@roo-code/telemetry"
 import type { ApiHandlerOptions } from "../../shared/api"
 import { calculateApiCostOpenAI } from "../../shared/cost"
 
-import {
-	convertToOpenAiMessages,
-	sanitizeGeminiMessages,
-	consolidateReasoningDetails,
-	type ReasoningDetail,
-} from "../transform/openai-format"
-import { convertToR1Format } from "../transform/r1-format"
-import { addCacheBreakpoints as addAnthropicCacheBreakpoints } from "../transform/caching/anthropic"
-import { addCacheBreakpoints as addGeminiCacheBreakpoints } from "../transform/caching/gemini"
+import { type ReasoningDetail } from "../transform/openai-format"
 import { getModelParams } from "../transform/model-params"
 import { convertToAiSdkMessages, convertToolsForAiSdk, processAiSdkStreamPart } from "../transform/ai-sdk"
 
@@ -77,17 +67,13 @@ export class OpenRouterHandler extends BaseProvider implements SingleCompletionH
 	private createOpenRouterProvider(options?: {
 		reasoning?: { effort?: string; max_tokens?: number; exclude?: boolean }
 		headers?: Record<string, string>
-		openAiMessages?: OpenAI.Chat.ChatCompletionMessageParam[]
 	}) {
 		const apiKey = this.options.openRouterApiKey ?? "not-provided"
 		const baseURL = this.options.openRouterBaseUrl || "https://openrouter.ai/api/v1"
 		const extraBody: Record<string, unknown> = {}
 		if (options?.reasoning) {
 			extraBody.reasoning = options.reasoning
 		}
-		if (options?.openAiMessages) {
-			extraBody.messages = options.openAiMessages
-		}
 		return createOpenRouter({
 			apiKey,
 			baseURL,
@@ -142,59 +128,6 @@ export class OpenRouterHandler extends BaseProvider implements SingleCompletionH
 		}
 	}
 
-	private buildOpenAiMessages(
-		systemPrompt: string,
-		messages: Anthropic.Messages.MessageParam[],
-		modelId: string,
-	): OpenAI.Chat.ChatCompletionMessageParam[] | undefined {
-		const isR1 = modelId.startsWith("deepseek/deepseek-r1") || modelId === "perplexity/sonar-reasoning"
-		const isGemini = modelId.startsWith("google/gemini")
-		const needsCaching = OPEN_ROUTER_PROMPT_CACHING_MODELS.has(modelId)
-		if (!isR1 && !isGemini && !needsCaching) {
-			return undefined
-		}
-		let openAiMessages: OpenAI.Chat.ChatCompletionMessageParam[]
-		if (isR1) {
-			openAiMessages = convertToR1Format([{ role: "user", content: systemPrompt }, ...messages])
-		} else {
-			openAiMessages = [{ role: "system", content: systemPrompt }, ...convertToOpenAiMessages(messages)]
-		}
-		if (isGemini) {
-			openAiMessages = sanitizeGeminiMessages(openAiMessages, modelId)
-			openAiMessages = openAiMessages.map((msg) => {
-				if (msg.role === "assistant") {
-					const toolCalls = (msg as any).tool_calls as any[] | undefined
-					const existingDetails = (msg as any).reasoning_details as any[] | undefined
-					if (toolCalls && toolCalls.length > 0) {
-						const hasEncrypted = existingDetails?.some((d) => d.type === "reasoning.encrypted") ?? false
-						if (!hasEncrypted) {
-							const fakeEncrypted = {
-								type: "reasoning.encrypted",
-								data: "skip_thought_signature_validator",
-								id: toolCalls[0].id,
-								format: "google-gemini-v1",
-								index: 0,
-							}
-							return {
-								...msg,
-								reasoning_details: [...(existingDetails ?? []), fakeEncrypted],
-							}
-						}
-					}
-				}
-				return msg
-			})
-		}
-		if (needsCaching) {
-			if (modelId.startsWith("google/")) {
-				addGeminiCacheBreakpoints(systemPrompt, openAiMessages)
-			} else {
-				addAnthropicCacheBreakpoints(systemPrompt, openAiMessages)
-			}
-		}
-		return openAiMessages
-	}
-
 	override async *createMessage(
 		systemPrompt: string,
 		messages: Anthropic.Messages.MessageParam[],
@@ -216,12 +149,9 @@ export class OpenRouterHandler extends BaseProvider implements SingleCompletionH
 			? { "x-anthropic-beta": "fine-grained-tool-streaming-2025-05-14" }
 			: undefined
 
-		const openAiMessages = this.buildOpenAiMessages(systemPrompt, messages, modelId)
-		const openrouter = this.createOpenRouterProvider({ reasoning, headers, openAiMessages })
+		const aiSdkMessages = convertToAiSdkMessages(messages)
 
-		const coreMessages = openAiMessages
-			? convertToAiSdkMessages([{ role: "user", content: "." }])
-			: convertToAiSdkMessages(messages)
+		const openrouter = this.createOpenRouterProvider({ reasoning, headers })
 
 		const tools = convertToolsForAiSdk(metadata?.tools)
 
@@ -250,8 +180,8 @@ export class OpenRouterHandler extends BaseProvider implements SingleCompletionH
 		try {
 			const result = streamText({
 				model: openrouter.chat(modelId),
-				...(openAiMessages ? {} : { system: systemPrompt }),
-				messages: coreMessages,
+				system: systemPrompt,
+				messages: aiSdkMessages,
 				maxOutputTokens: maxTokens && maxTokens > 0 ? maxTokens : undefined,
 				temperature,
 				topP,
@@ -261,7 +191,7 @@ export class OpenRouterHandler extends BaseProvider implements SingleCompletionH
 			})
 
 			for await (const part of result.fullStream) {
-				if (part.type === "reasoning-delta") {
+				if (part.type === "reasoning-delta" && part.text !== "[REDACTED]") {
 					accumulatedReasoningText += part.text
 				}
 				yield* processAiSdkStreamPart(part)
@@ -283,7 +213,7 @@ export class OpenRouterHandler extends BaseProvider implements SingleCompletionH
 				| undefined
 
 			if (providerReasoningDetails && providerReasoningDetails.length > 0) {
-				this.currentReasoningDetails = consolidateReasoningDetails(providerReasoningDetails)
+				this.currentReasoningDetails = providerReasoningDetails
 			}
 
 			const usage = await result.usage