fix(openrouter): enable reasoning support via AI SDK extraBody

- Add support for 'reasoning' and 'text' event types in AI SDK stream processing
- Pass reasoning parameters via createOpenRouter extraBody instead of providerOptions
- Support both effort-based (effort: 'high') and budget-based (max_tokens: N) reasoning
- Add comprehensive tests for reasoning parameter passing and stream event handling
- Fixes reasoning tokens not being displayed for models like DeepSeek R1 and Gemini Thinking

Changes:
- src/api/transform/ai-sdk.ts: Add 'text' and 'reasoning' event type handlers
- src/api/providers/openrouter.ts: Pass reasoning via extraBody in provider creation
- Add tests for new event types and reasoning parameter flow
- All 53 tests passing

Author: daniel-lxs

pnpm-lock.yaml

@@ -78,6 +78,16 @@ vitest.mock("../fetchers/modelCache", () => ({
 				cacheReadsPrice: 0.3,
 				description: "Claude 3.7 Sonnet with thinking",
 			},
+			"deepseek/deepseek-r1": {
+				maxTokens: 8192,
+				contextWindow: 64000,
+				supportsImages: false,
+				supportsPromptCache: false,
+				inputPrice: 0.55,
+				outputPrice: 2.19,
+				description: "DeepSeek R1",
+				supportsReasoningEffort: true,
+			},
 			"openai/gpt-4o": {
 				maxTokens: 16384,
 				contextWindow: 128000,
@@ -638,6 +648,86 @@ describe("OpenRouterHandler", () => {
 				}),
 			)
 		})
+
+		it("passes reasoning parameters via extraBody when reasoning effort is enabled", async () => {
+			const handler = new OpenRouterHandler({
+				openRouterApiKey: "test-key",
+				openRouterModelId: "deepseek/deepseek-r1",
+				reasoningEffort: "high",
+				enableReasoningEffort: true,
+			})
+
+			const mockFullStream = (async function* () {
+				yield { type: "reasoning-delta", text: "thinking...", id: "1" }
+				yield { type: "text-delta", text: "result", id: "2" }
+			})()
+
+			mockStreamText.mockReturnValue({
+				fullStream: mockFullStream,
+				usage: Promise.resolve({ inputTokens: 10, outputTokens: 20, totalTokens: 30 }),
+				totalUsage: Promise.resolve({ inputTokens: 10, outputTokens: 20, totalTokens: 30 }),
+			})
+
+			const generator = handler.createMessage("test", [{ role: "user", content: "test" }])
+
+			for await (const _ of generator) {
+				// consume
+			}
+
+			// Verify that reasoning was passed via extraBody when creating the provider
+			expect(mockCreateOpenRouter).toHaveBeenCalledWith(
+				expect.objectContaining({
+					extraBody: expect.objectContaining({
+						reasoning: expect.objectContaining({
+							effort: "high",
+						}),
+					}),
+				}),
+			)
+
+			// Verify that providerOptions does NOT contain extended_thinking
+			expect(mockStreamText).toHaveBeenCalledWith(
+				expect.objectContaining({
+					providerOptions: undefined,
+				}),
+			)
+		})
+
+		it("does not pass reasoning via extraBody when reasoning is disabled", async () => {
+			const handler = new OpenRouterHandler({
+				openRouterApiKey: "test-key",
+				openRouterModelId: "anthropic/claude-sonnet-4",
+			})
+
+			const mockFullStream = (async function* () {
+				yield { type: "text-delta", text: "test", id: "1" }
+			})()
+
+			mockStreamText.mockReturnValue({
+				fullStream: mockFullStream,
+				usage: Promise.resolve({ inputTokens: 10, outputTokens: 20, totalTokens: 30 }),
+				totalUsage: Promise.resolve({ inputTokens: 10, outputTokens: 20, totalTokens: 30 }),
+			})
+
+			const generator = handler.createMessage("test", [{ role: "user", content: "test" }])
+
+			for await (const _ of generator) {
+				// consume
+			}
+
+			// Verify that createOpenRouter was NOT called with extraBody
+			expect(mockCreateOpenRouter).toHaveBeenCalledWith({
+				apiKey: "test-key",
+				baseURL: "https://openrouter.ai/api/v1",
+			})
+
+			// Verify that providerOptions is undefined when no provider routing
+			expect(mockStreamText).toHaveBeenCalledWith(
+				expect.objectContaining({
+					providerOptions: undefined,
+				}),
+			)
+		})
 	})
 
 	describe("completePrompt", () => {
@@ -660,6 +750,41 @@ describe("OpenRouterHandler", () => {
 			)
 		})
 
+		it("passes reasoning parameters via extraBody when reasoning effort is enabled", async () => {
+			const handler = new OpenRouterHandler({
+				openRouterApiKey: "test-key",
+				openRouterModelId: "deepseek/deepseek-r1",
+				reasoningEffort: "medium",
+				enableReasoningEffort: true,
+			})
+
+			mockGenerateText.mockResolvedValue({
+				text: "test completion with reasoning",
+			})
+
+			const result = await handler.completePrompt("test prompt")
+
+			expect(result).toBe("test completion with reasoning")
+
+			// Verify that reasoning was passed via extraBody when creating the provider
+			expect(mockCreateOpenRouter).toHaveBeenCalledWith(
+				expect.objectContaining({
+					extraBody: expect.objectContaining({
+						reasoning: expect.objectContaining({
+							effort: "medium",
+						}),
+					}),
+				}),
+			)
+
+			// Verify that providerOptions does NOT contain extended_thinking
+			expect(mockGenerateText).toHaveBeenCalledWith(
+				expect.objectContaining({
+					providerOptions: undefined,
+				}),
+			)
+		})
+
 		it("handles API errors", async () => {
 			const handler = new OpenRouterHandler(mockOptions)
 

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

@@ -86,14 +86,16 @@ export class OpenRouterHandler extends BaseProvider implements SingleCompletionH
 
 	/**
 	 * Create the OpenRouter provider instance using the AI SDK
+	 * @param reasoning - Optional reasoning parameters to pass via extraBody
 	 */
-	private createOpenRouterProvider() {
+	private createOpenRouterProvider(reasoning?: { effort?: string; max_tokens?: number; exclude?: boolean }) {
 		const apiKey = this.options.openRouterApiKey ?? "not-provided"
 		const baseURL = this.options.openRouterBaseUrl || "https://openrouter.ai/api/v1"
 
 		return createOpenRouter({
 			apiKey,
 			baseURL,
+			...(reasoning && { extraBody: { reasoning } }),
 		})
 	}
 
@@ -182,14 +184,25 @@ export class OpenRouterHandler extends BaseProvider implements SingleCompletionH
 		this.currentReasoningDetails = []
 
 		const model = await this.fetchModel()
-		const { id: modelId, maxTokens, temperature } = model
+		const { id: modelId, maxTokens, temperature, reasoning } = model
 
-		const openrouter = this.createOpenRouterProvider()
+		// Pass reasoning parameters to extraBody when creating the provider
+		const openrouter = this.createOpenRouterProvider(reasoning)
 		const coreMessages = convertToAiSdkMessages(messages)
 		const tools = convertToolsForAiSdk(metadata?.tools)
 
 		// Build provider options for specific provider routing
-		const providerOptions =
+		const providerOptions:
+			| {
+					openrouter?: {
+						provider?: {
+							order: string[]
+							only: string[]
+							allow_fallbacks: boolean
+						}
+					}
+			  }
+			| undefined =
 			this.options.openRouterSpecificProvider &&
 			this.options.openRouterSpecificProvider !== OPENROUTER_DEFAULT_PROVIDER_NAME
 				? {
@@ -255,7 +268,7 @@ export class OpenRouterHandler extends BaseProvider implements SingleCompletionH
 				model.info,
 			)
 			yield usageChunk
-		} catch (error) {
+		} catch (error: any) {
 			const errorMessage = error instanceof Error ? error.message : String(error)
 			const apiError = new ApiProviderError(errorMessage, this.providerName, modelId, "createMessage")
 			TelemetryService.instance.captureException(apiError)
@@ -325,12 +338,23 @@ export class OpenRouterHandler extends BaseProvider implements SingleCompletionH
 	}
 
 	async completePrompt(prompt: string): Promise<string> {
-		const { id: modelId, maxTokens, temperature } = await this.fetchModel()
+		const { id: modelId, maxTokens, temperature, reasoning } = await this.fetchModel()
 
-		const openrouter = this.createOpenRouterProvider()
+		// Pass reasoning parameters to extraBody when creating the provider
+		const openrouter = this.createOpenRouterProvider(reasoning)
 
 		// Build provider options for specific provider routing
-		const providerOptions =
+		const providerOptions:
+			| {
+					openrouter?: {
+						provider?: {
+							order: string[]
+							only: string[]
+							allow_fallbacks: boolean
+						}
+					}
+			  }
+			| undefined =
 			this.options.openRouterSpecificProvider &&
 			this.options.openRouterSpecificProvider !== OPENROUTER_DEFAULT_PROVIDER_NAME
 				? {