Add minimal reasoning support to OpenRouter

Author: mrubens

src/api/transform/__tests__/reasoning.spec.ts

@@ -1,6 +1,6 @@
 // npx vitest run src/api/transform/__tests__/reasoning.spec.ts
 
-import type { ModelInfo, ProviderSettings } from "@roo-code/types"
+import type { ModelInfo, ProviderSettings, ReasoningEffortWithMinimal } from "@roo-code/types"
 
 import {
 	getOpenRouterReasoning,
@@ -154,24 +154,79 @@ describe("reasoning.ts", () => {
 
 			const result = getOpenRouterReasoning(optionsWithoutEffort)
 
-			expect(result).toEqual({ effort: undefined })
+			// When reasoningEffort is undefined, the function should return undefined
+			expect(result).toBeUndefined()
 		})
 
-		it("should handle all reasoning effort values", () => {
-			const efforts: Array<"low" | "medium" | "high"> = ["low", "medium", "high"]
+		it("should handle all reasoning effort values including minimal", () => {
+			const efforts: Array<ReasoningEffortWithMinimal> = ["minimal", "low", "medium", "high"]
 
 			efforts.forEach((effort) => {
 				const modelWithEffort: ModelInfo = {
 					...baseModel,
+					supportsReasoningEffort: true,
+					reasoningEffort: effort === "minimal" ? undefined : effort,
+				}
+
+				const settingsWithEffort: ProviderSettings = {
 					reasoningEffort: effort,
 				}
 
-				const options = { ...baseOptions, model: modelWithEffort, reasoningEffort: effort }
+				const options = {
+					...baseOptions,
+					model: modelWithEffort,
+					settings: settingsWithEffort,
+					reasoningEffort: effort,
+				}
 				const result = getOpenRouterReasoning(options)
 				expect(result).toEqual({ effort })
 			})
 		})
 
+		it("should handle minimal reasoning effort specifically", () => {
+			const modelWithSupported: ModelInfo = {
+				...baseModel,
+				supportsReasoningEffort: true,
+			}
+
+			const settingsWithEffort: ProviderSettings = {
+				reasoningEffort: "minimal",
+			}
+
+			const options = {
+				...baseOptions,
+				model: modelWithSupported,
+				settings: settingsWithEffort,
+				reasoningEffort: "minimal" as ReasoningEffortWithMinimal,
+			}
+
+			const result = getOpenRouterReasoning(options)
+
+			expect(result).toEqual({ effort: "minimal" })
+		})
+
+		it("should handle minimal reasoning effort from settings", () => {
+			const modelWithSupported: ModelInfo = {
+				...baseModel,
+				supportsReasoningEffort: true,
+			}
+
+			const settingsWithMinimal: ProviderSettings = {
+				reasoningEffort: "minimal" as ReasoningEffortWithMinimal,
+			}
+
+			const options = {
+				...baseOptions,
+				model: modelWithSupported,
+				settings: settingsWithMinimal,
+				reasoningEffort: "minimal" as ReasoningEffortWithMinimal,
+			}
+
+			const result = getOpenRouterReasoning(options)
+
+			expect(result).toEqual({ effort: "minimal" })
+		})
+
 		it("should handle zero reasoningBudget", () => {
 			const modelWithRequired: ModelInfo = {
 				...baseModel,

src/api/transform/reasoning.ts

@@ -6,7 +6,7 @@ import type { ModelInfo, ProviderSettings, ReasoningEffortWithMinimal } from "@r
 
 import { shouldUseReasoningBudget, shouldUseReasoningEffort } from "../../shared/api"
 
-type ReasoningEffort = "low" | "medium" | "high"
+type ReasoningEffort = "minimal" | "low" | "medium" | "high"
 
 export type OpenRouterReasoningParams = {
 	effort?: ReasoningEffort
@@ -36,7 +36,7 @@ export const getOpenRouterReasoning = ({
 	shouldUseReasoningBudget({ model, settings })
 		? { max_tokens: reasoningBudget }
 		: shouldUseReasoningEffort({ model, settings })
-			? reasoningEffort !== "minimal"
+			? reasoningEffort
 				? { effort: reasoningEffort }
 				: undefined
 			: undefined

webview-ui/src/components/settings/ThinkingBudget.tsx

@@ -32,14 +32,20 @@ export const ThinkingBudget = ({ apiConfiguration, setApiConfigurationField, mod
 	const isGemini25Pro = selectedModelId && selectedModelId.includes("gemini-2.5-pro")
 	const minThinkingTokens = isGemini25Pro ? GEMINI_25_PRO_MIN_THINKING_TOKENS : 1024
 
-	// Check if this is a GPT-5 model to show "minimal" option
-	// Only show minimal for OpenAI Native provider GPT-5 models
+	// Check model capabilities
+	const isReasoningBudgetSupported = !!modelInfo && modelInfo.supportsReasoningBudget
+	const isReasoningBudgetRequired = !!modelInfo && modelInfo.requiredReasoningBudget
+	const isReasoningEffortSupported = !!modelInfo && modelInfo.supportsReasoningEffort
+
+	// Check if this is a GPT-5 model or OpenRouter to show "minimal" option
 	const isOpenAiNativeProvider = apiConfiguration.apiProvider === "openai-native"
+	const isOpenRouterProvider = apiConfiguration.apiProvider === "openrouter"
 	const isGpt5Model = isOpenAiNativeProvider && selectedModelId && selectedModelId.startsWith("gpt-5")
-	// Add "minimal" option for GPT-5 models
+	// Add "minimal" option for GPT-5 models and OpenRouter models that support reasoning effort
 	// Spread to convert readonly tuple into a mutable array, then expose as readonly for safety
 	const baseEfforts = [...reasoningEfforts] as ReasoningEffortWithMinimal[]
-	const availableReasoningEfforts: ReadonlyArray<ReasoningEffortWithMinimal> = isGpt5Model
+	const showMinimalOption = isGpt5Model || (isOpenRouterProvider && isReasoningEffortSupported)
+	const availableReasoningEfforts: ReadonlyArray<ReasoningEffortWithMinimal> = showMinimalOption
 		? (["minimal", ...baseEfforts] as ReasoningEffortWithMinimal[])
 		: baseEfforts
 
@@ -50,10 +56,6 @@ export const ThinkingBudget = ({ apiConfiguration, setApiConfigurationField, mod
 	const currentReasoningEffort: ReasoningEffortWithMinimal =
 		(apiConfiguration.reasoningEffort as ReasoningEffortWithMinimal | undefined) || defaultReasoningEffort
 
-	const isReasoningBudgetSupported = !!modelInfo && modelInfo.supportsReasoningBudget
-	const isReasoningBudgetRequired = !!modelInfo && modelInfo.requiredReasoningBudget
-	const isReasoningEffortSupported = !!modelInfo && modelInfo.supportsReasoningEffort
-
 	// Set default reasoning effort when model supports it and no value is set
 	useEffect(() => {
 		if (isReasoningEffortSupported && !apiConfiguration.reasoningEffort && defaultReasoningEffort) {