[Fix] Reasoning models stop thinking after model selection

package.json

@@ -13,7 +13,7 @@
 		"check-types": "turbo check-types --log-order grouped --output-logs new-only",
 		"test": "turbo test --log-order grouped --output-logs new-only",
 		"test:mutation-ci": "node --test scripts/stryker-diff.test.mjs",
-		"lifecycle:model-check": "tsx scripts/check-task-lifecycle.ts && tsx scripts/check-task-store-concurrency.ts && pnpm cleanup-protocol:model-check",
+		"lifecycle:model-check": "tsx scripts/check-task-lifecycle.ts && tsx scripts/check-task-store-concurrency.ts && tsx scripts/check-reasoning-defaults.ts && pnpm cleanup-protocol:model-check",
 		"cleanup-protocol:model-check": "tsx scripts/check-task-cleanup-protocol.ts",
 		"test:coverage": "turbo test:coverage --log-order grouped --output-logs new-only",
 		"format": "turbo format --log-order grouped --output-logs new-only",

scripts/check-reasoning-defaults.ts

@@ -0,0 +1,104 @@
+import assert from "node:assert/strict"
+
+type Effort = "disable" | "none" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max"
+type Supported = true | readonly Effort[]
+
+interface ModelState {
+	supported: Supported
+	required: boolean
+	modelDefault?: Effort
+	stored?: Effort
+	enabled?: boolean
+}
+
+const canonicalEfforts = ["low", "medium", "high", "xhigh", "max"] as const
+const defaultEfforts = ["low", "medium", "high"] as const
+const supportedSets: Supported[] = [
+	true,
+	["disable", "low", "high"],
+	["low", "high"],
+	["none", "low", "high"],
+	["low", "medium", "high", "xhigh", "max"],
+]
+const values = [undefined, "disable", "none", "low", "high", "max"] as const
+const enabledValues = [undefined, false, true] as const
+
+function availableOptions(state: ModelState): readonly Effort[] {
+	return state.supported === true
+		? state.required
+			? defaultEfforts
+			: ["disable", ...defaultEfforts]
+		: state.supported
+}
+
+function supportsEffort(supported: Supported, effort: Effort): boolean {
+	return supported === true || supported.includes(effort)
+}
+
+function resolveSelection(state: ModelState): Effort {
+	const available = availableOptions(state)
+	const defaultEffort = state.modelDefault ?? (state.required ? "medium" : "disable")
+	const raw = state.stored ?? defaultEffort
+	const fallback = available.includes(defaultEffort) ? defaultEffort : (available[0] ?? raw)
+	return available.includes(raw) ? raw : fallback
+}
+
+function resolveRequest(state: ModelState): Effort | undefined {
+	const disabled = state.stored === "disable" || state.stored === "none" || state.enabled === false
+	const canDisable = supportsEffort(state.supported, "disable")
+	if (disabled && canDisable) return undefined
+
+	const candidates = [disabled ? undefined : state.stored, state.modelDefault]
+	const supported = state.supported
+	if (supported !== true && !supported.includes("disable")) {
+		candidates.push(canonicalEfforts.find((effort) => supported.includes(effort)))
+	}
+
+	for (const effort of candidates) {
+		if (
+			effort &&
+			effort !== "disable" &&
+			effort !== "none" &&
+			effort !== "minimal" &&
+			supportsEffort(state.supported, effort)
+		) {
+			return effort
+		}
+	}
+
+	return state.required && state.modelDefault && state.modelDefault !== "none" ? state.modelDefault : undefined
+}
+
+let checked = 0
+for (const supported of supportedSets) {
+	for (const required of [false, true]) {
+		for (const modelDefault of values) {
+			for (const stored of values) {
+				for (const enabled of enabledValues) {
+					const state: ModelState = { supported, required, modelDefault, stored, enabled }
+					const selection = resolveSelection(state)
+					const available = availableOptions(state)
+					assert.ok(available.length === 0 || available.includes(selection), "selection must be supported")
+					if (!available.includes("disable"))
+						assert.notEqual(selection, "disable", "required reasoning cannot disable")
+
+					const normalized: ModelState = {
+						...state,
+						stored: selection,
+						enabled: required || selection !== "disable",
+					}
+					const request = resolveRequest(normalized)
+					if (selection === "disable") {
+						assert.equal(request, undefined, "an explicit supported disable must omit reasoning")
+					} else if (canonicalEfforts.includes(selection as (typeof canonicalEfforts)[number])) {
+						assert.equal(request, selection, "a normalized effort must reach the request")
+					}
+
+					checked++
+				}
+			}
+		}
+	}
+}
+
+console.log(`Reasoning defaults model check passed (${checked} states)`)

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

@@ -204,6 +204,192 @@ describe("NanoGptHandler", () => {
 		expect(mockCreate.mock.calls[0][0]).not.toHaveProperty("temperature")
 	})
 
+	it("uses the model's advertised reasoning effort when settings are unset", async () => {
+		vi.mocked(getModels).mockResolvedValue({
+			"model:thinking": {
+				maxTokens: 128000,
+				contextWindow: 1050000,
+				supportsPromptCache: false,
+				supportsReasoningEffort: ["disable", "low", "high"],
+				reasoningEffort: "high",
+			},
+		})
+
+		await collectStream(new NanoGptHandler({ nanoGptModelId: "model:thinking" }).createMessage("sys", messages))
+
+		expect(mockCreate.mock.calls[0][0]).toMatchObject({ reasoning_effort: "high" })
+	})
+
+	it("uses the first supported effort when the model cannot disable reasoning", async () => {
+		vi.mocked(getModels).mockResolvedValue({
+			"model:thinking": {
+				maxTokens: 128000,
+				contextWindow: 1050000,
+				supportsPromptCache: false,
+				supportsReasoningEffort: ["high", "medium", "low"],
+			},
+		})
+
+		await collectStream(new NanoGptHandler({ nanoGptModelId: "model:thinking" }).createMessage("sys", messages))
+
+		expect(mockCreate.mock.calls[0][0]).toMatchObject({ reasoning_effort: "low" })
+	})
+
+	it.each([
+		["an unsupported configured effort", { reasoningEffort: "max" as const }, ["low", "high"] as const, undefined],
+		["a none model default", {}, ["none", "low"] as const, "none" as const],
+		["a minimal model default", {}, ["minimal", "low"] as const, "minimal" as const],
+	])("uses a canonical fallback for %s", async (_name, settings, supportsReasoningEffort, reasoningEffort) => {
+		vi.mocked(getModels).mockResolvedValue({
+			"model:thinking": {
+				maxTokens: 128000,
+				contextWindow: 1050000,
+				supportsPromptCache: false,
+				supportsReasoningEffort: [...supportsReasoningEffort],
+				reasoningEffort,
+			},
+		})
+
+		await collectStream(
+			new NanoGptHandler({ nanoGptModelId: "model:thinking", ...settings }).createMessage("sys", messages),
+		)
+
+		expect(mockCreate.mock.calls[0][0]).toMatchObject({ reasoning_effort: "low" })
+	})
+
+	it("uses a configured effort when reasoning support is boolean", async () => {
+		vi.mocked(getModels).mockResolvedValue({
+			"model:thinking": {
+				maxTokens: 128000,
+				contextWindow: 1050000,
+				supportsPromptCache: false,
+				supportsReasoningEffort: true,
+			},
+		})
+
+		await collectStream(
+			new NanoGptHandler({ nanoGptModelId: "model:thinking", reasoningEffort: "high" }).createMessage(
+				"sys",
+				messages,
+			),
+		)
+
+		expect(mockCreate.mock.calls[0][0]).toMatchObject({ reasoning_effort: "high" })
+	})
+
+	it("honors disable when optional reasoning support is boolean", async () => {
+		vi.mocked(getModels).mockResolvedValue({
+			"model:thinking": {
+				maxTokens: 128000,
+				contextWindow: 1050000,
+				supportsPromptCache: false,
+				supportsReasoningEffort: true,
+				reasoningEffort: "high",
+			},
+		})
+
+		await collectStream(
+			new NanoGptHandler({ nanoGptModelId: "model:thinking", reasoningEffort: "disable" }).createMessage(
+				"sys",
+				messages,
+			),
+		)
+
+		expect(mockCreate.mock.calls[0][0]).not.toHaveProperty("reasoning_effort")
+	})
+
+	it("omits an unset optional effort when disable is supported and no default is advertised", async () => {
+		vi.mocked(getModels).mockResolvedValue({
+			"model:thinking": {
+				maxTokens: 128000,
+				contextWindow: 1050000,
+				supportsPromptCache: false,
+				supportsReasoningEffort: ["disable", "low", "high"],
+			},
+		})
+
+		await collectStream(new NanoGptHandler({ nanoGptModelId: "model:thinking" }).createMessage("sys", messages))
+
+		expect(mockCreate.mock.calls[0][0]).not.toHaveProperty("reasoning_effort")
+	})
+
+	it.each([
+		["a stale disable effort", { reasoningEffort: "disable" as const }],
+		["a stale disabled toggle", { enableReasoningEffort: false }],
+	])("uses a supported fallback for %s when the model cannot disable reasoning", async (_name, settings) => {
+		vi.mocked(getModels).mockResolvedValue({
+			"model:thinking": {
+				maxTokens: 128000,
+				contextWindow: 1050000,
+				supportsPromptCache: false,
+				supportsReasoningEffort: ["low", "high"],
+			},
+		})
+
+		await collectStream(
+			new NanoGptHandler({ nanoGptModelId: "model:thinking", ...settings }).createMessage("sys", messages),
+		)
+
+		expect(mockCreate.mock.calls[0][0]).toMatchObject({ reasoning_effort: "low" })
+	})
+
+	it.each([undefined, true] as const)(
+		"omits reasoning effort when the disable option is selected and enableReasoningEffort is %s",
+		async (enableReasoningEffort) => {
+			vi.mocked(getModels).mockResolvedValue({
+				"model:thinking": {
+					maxTokens: 128000,
+					contextWindow: 1050000,
+					supportsPromptCache: false,
+					supportsReasoningEffort: ["disable", "low", "high"],
+					reasoningEffort: "high",
+				},
+			})
+			await collectStream(
+				new NanoGptHandler({
+					nanoGptModelId: "model:thinking",
+					enableReasoningEffort,
+					reasoningEffort: "disable",
+				}).createMessage("sys", messages),
+			)
+
+			expect(mockCreate.mock.calls[0][0]).not.toHaveProperty("reasoning_effort")
+		},
+	)
+
+	it("resolves none to the canonical lowest supported effort when reasoning is enabled", async () => {
+		await collectStream(
+			new NanoGptHandler({
+				nanoGptModelId: "model:thinking",
+				enableReasoningEffort: true,
+				reasoningEffort: "none",
+			}).createMessage("sys", messages),
+		)
+
+		expect(mockCreate.mock.calls[0][0]).toMatchObject({ reasoning_effort: "low" })
+	})
+
+	it("omits reasoning effort when reasoning is explicitly disabled", async () => {
+		vi.mocked(getModels).mockResolvedValue({
+			"model:thinking": {
+				maxTokens: 128000,
+				contextWindow: 1050000,
+				supportsPromptCache: false,
+				supportsReasoningEffort: ["disable", "low", "high"],
+				reasoningEffort: "high",
+			},
+		})
+		await collectStream(
+			new NanoGptHandler({
+				nanoGptModelId: "model:thinking",
+				enableReasoningEffort: false,
+				reasoningEffort: "high",
+			}).createMessage("sys", messages),
+		)
+
+		expect(mockCreate.mock.calls[0][0]).not.toHaveProperty("reasoning_effort")
+	})
+
 	it("keeps Muse Spark tool-result history contiguous across turns", async () => {
 		const modelId = "meta/muse-spark-1.2-contributor"
 		vi.mocked(getModels).mockResolvedValue({
@@ -370,6 +556,14 @@ describe("NanoGptHandler", () => {
 	})
 
 	describe("completePrompt", () => {
+		it("uses the same default reasoning effort as streaming requests", async () => {
+			mockCreate.mockResolvedValue({ choices: [{ message: { content: "response" } }] })
+
+			await new NanoGptHandler({ nanoGptModelId: "model:thinking" }).completePrompt("prompt")
+
+			expect(mockCreate.mock.calls[0][0]).toMatchObject({ reasoning_effort: "low" })
+		})
+
 		it("requests cache-capable routing without changing the completion model ID", async () => {
 			mockCreate.mockResolvedValue({ choices: [{ message: { content: "response" } }] })
 			const handler = new NanoGptHandler({

src/api/providers/nanogpt.ts

@@ -32,15 +32,32 @@ type NanoGptCachingRequest = { caching?: true }
 const NANO_GPT_MERGED_TOOL_RESULT_MODELS = new Set(["meta/muse-spark-1.2-contributor"])
 
 const NANO_GPT_ASTRA_MODEL_IDS = new Set(["openai/gpt-6-astra", "openai/gpt-6-astra-pro"])
+const NANO_GPT_REASONING_EFFORTS = ["low", "medium", "high", "xhigh", "max"] as const
 
 function getReasoningEffort(options: ApiHandlerOptions, info: ModelInfo): ReasoningEffortExtended | undefined {
 	const configured = options.reasoningEffort
 	const reasoningDisabled =
 		configured === "disable" || configured === "none" || options.enableReasoningEffort === false
 	const supported = info.supportsReasoningEffort
 
-	if (!reasoningDisabled && configured && configured !== "minimal") {
-		if (supported === true || (Array.isArray(supported) && supported.includes(configured))) return configured
+	if (reasoningDisabled && (supported === true || (Array.isArray(supported) && supported.includes("disable")))) {
+		return undefined
+	}
+
+	const candidates = [reasoningDisabled ? undefined : configured, info.reasoningEffort]
+	if (Array.isArray(supported) && !supported.includes("disable")) {
+		candidates.push(NANO_GPT_REASONING_EFFORTS.find((effort) => supported.includes(effort)))
+	}
+
+	for (const effort of candidates) {
+		if (
+			effort &&
+			effort !== "none" &&
+			effort !== "minimal" &&
+			(supported === true || (Array.isArray(supported) && supported.includes(effort)))
+		) {
+			return effort
+		}
 	}
 
 	const fallback = info.reasoningEffort

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

@@ -99,12 +99,10 @@ export const ThinkingBudget = ({ apiConfiguration, setApiConfigurationField, mod
 		? ["disable", ...baseAvailableOptions]
 		: baseAvailableOptions
 
-	// Default reasoning effort - use model's default if available
-	// GPT-5 models have "medium" as their default in the model configuration
+	// Use the model's declared default when present; otherwise fall back based on requiredReasoningEffort.
 	const modelDefaultReasoningEffort = modelInfo?.reasoningEffort as ReasoningEffortExtended | undefined
-	const defaultReasoningEffort: ReasoningEffortOption = modelInfo?.requiredReasoningEffort
-		? modelDefaultReasoningEffort || "medium"
-		: "disable"
+	const defaultReasoningEffort: ReasoningEffortOption =
+		modelDefaultReasoningEffort ?? (modelInfo?.requiredReasoningEffort ? "medium" : "disable")
 	// Current reasoning effort from settings, or fall back to default.
 	// Clamp to availableOptions so the Select trigger always renders a valid option.
 	const storedReasoningEffort = apiConfiguration.reasoningEffort as ReasoningEffortOption | undefined
@@ -116,23 +114,16 @@ export const ThinkingBudget = ({ apiConfiguration, setApiConfigurationField, mod
 		? rawReasoningEffort
 		: fallbackReasoningEffort
 
-	// Set default reasoning effort when model supports it and no value is set
+	// Keep normalized defaults pending so Save persists them to the provider profile.
 	useEffect(() => {
 		if (
 			isReasoningEffortSupported &&
-			modelInfo?.requiredReasoningEffort &&
 			storedReasoningEffort !== currentReasoningEffort &&
 			currentReasoningEffort !== "disable"
 		) {
-			setApiConfigurationField("reasoningEffort", currentReasoningEffort as ReasoningEffortExtended, false)
+			setApiConfigurationField("reasoningEffort", currentReasoningEffort as ReasoningEffortExtended)
 		}
-	}, [
-		isReasoningEffortSupported,
-		storedReasoningEffort,
-		currentReasoningEffort,
-		modelInfo?.requiredReasoningEffort,
-		setApiConfigurationField,
-	])
+	}, [isReasoningEffortSupported, storedReasoningEffort, currentReasoningEffort, setApiConfigurationField])
 
 	// Sync enableReasoningEffort based on selection
 	// "disable" turns off reasoning; "none" is a valid level (reasoning enabled)