diff --git a/src/api/providers/fetchers/__tests__/openrouter.spec.ts b/src/api/providers/fetchers/__tests__/openrouter.spec.ts
index 89169c9c56..641532722d 100644
--- a/src/api/providers/fetchers/__tests__/openrouter.spec.ts
+++ b/src/api/providers/fetchers/__tests__/openrouter.spec.ts
@@ -43,7 +43,7 @@ describe("OpenRouter API", () => {
 				description: expect.any(String),
 				supportsReasoningBudget: true,
 				requiredReasoningBudget: true,
-				supportsReasoningEffort: true,
+				supportsReasoningEffort: ["low", "medium", "high", "xhigh", "max"],
 				supportedParameters: ["max_tokens", "temperature", "reasoning", "include_reasoning"],
 			})
 
@@ -539,5 +539,62 @@ describe("OpenRouter API", () => {
 
 			expect(resultWithoutTools.supportedParameters).toContain("max_tokens")
 		})
+
+		it("leaves supportsReasoningEffort undefined when reasoning is absent or supportedParameters is unset", () => {
+			const mockModel = {
+				name: "Reasoning Effort Model",
+				description: "Model without reasoning parameter support",
+				context_length: 128000,
+				max_completion_tokens: 8192,
+				pricing: {
+					prompt: "0.000003",
+					completion: "0.000015",
+				},
+			}
+
+			const resultWithoutReasoningParam = parseOpenRouterModel({
+				id: "test/no-reasoning-model",
+				model: mockModel,
+				inputModality: ["text"],
+				outputModality: ["text"],
+				maxTokens: 8192,
+				supportedParameters: ["max_tokens", "temperature"],
+			})
+
+			const resultWithoutSupportedParameters = parseOpenRouterModel({
+				id: "test/unset-parameters-model",
+				model: mockModel,
+				inputModality: ["text"],
+				outputModality: ["text"],
+				maxTokens: 8192,
+			})
+
+			expect(resultWithoutReasoningParam.supportsReasoningEffort).toBeUndefined()
+			expect(resultWithoutSupportedParameters.supportsReasoningEffort).toBeUndefined()
+		})
+
+		it("sets supportsReasoningEffort when supportedParameters includes reasoning", () => {
+			const mockModel = {
+				name: "Reasoning Effort Model",
+				description: "Model with reasoning parameter support",
+				context_length: 128000,
+				max_completion_tokens: 8192,
+				pricing: {
+					prompt: "0.000003",
+					completion: "0.000015",
+				},
+			}
+
+			const resultWithReasoningParam = parseOpenRouterModel({
+				id: "test/reasoning-effort-model",
+				model: mockModel,
+				inputModality: ["text"],
+				outputModality: ["text"],
+				maxTokens: 8192,
+				supportedParameters: ["reasoning", "max_tokens", "temperature"],
+			})
+
+			expect(resultWithReasoningParam.supportsReasoningEffort).toEqual(["low", "medium", "high", "xhigh", "max"])
+		})
 	})
 })
diff --git a/src/api/providers/fetchers/openrouter.ts b/src/api/providers/fetchers/openrouter.ts
index a25c1b96fa..16d9bdd2af 100644
--- a/src/api/providers/fetchers/openrouter.ts
+++ b/src/api/providers/fetchers/openrouter.ts
@@ -217,7 +217,9 @@ export const parseOpenRouterModel = ({
 		cacheWritesPrice,
 		cacheReadsPrice,
 		description: model.description,
-		supportsReasoningEffort: supportedParameters ? supportedParameters.includes("reasoning") : undefined,
+		supportsReasoningEffort: supportedParameters?.includes("reasoning")
+			? ["low", "medium", "high", "xhigh", "max"]
+			: undefined,
 		supportedParameters: supportedParameters ? supportedParameters.filter(isModelParameter) : undefined,
 	}
 
diff --git a/webview-ui/src/components/settings/providers/OpenRouter.tsx b/webview-ui/src/components/settings/providers/OpenRouter.tsx
index 2dba8c8459..2d8f23a9e4 100644
--- a/webview-ui/src/components/settings/providers/OpenRouter.tsx
+++ b/webview-ui/src/components/settings/providers/OpenRouter.tsx
@@ -1,4 +1,5 @@
-import { useCallback, useState } from "react"
+import { useCallback, useEffect, useRef, useState } from "react"
+import { useQueryClient } from "@tanstack/react-query"
 import { Checkbox } from "vscrui"
 import { VSCodeTextField } from "@vscode/webview-ui-toolkit/react"
 
@@ -7,17 +8,31 @@ import {
 	type OrganizationAllowList,
 	type RouterModels,
 	openRouterDefaultModelId,
+	allRouterModelsProvider,
+	providerIdentifiers,
+	RouterModelsMessageType,
+	type ExtensionMessage,
 } from "@roo-code/types"
+import type { RouterName } from "@roo/api"
 
 import { useAppTranslation } from "@src/i18n/TranslationContext"
 import { getOpenRouterAuthUrl } from "@src/oauth/urls"
 import { VSCodeButtonLink } from "@src/components/common/VSCodeButtonLink"
+import { vscode } from "@src/utils/vscode"
+import { Button } from "@src/components/ui"
 
 import { inputEventTransform } from "../transforms"
 
 import { ModelPicker } from "../ModelPicker"
 import { OpenRouterBalanceDisplay } from "./OpenRouterBalanceDisplay"
 
+enum RefreshStatus {
+	Idle = "idle",
+	Loading = "loading",
+	Success = "success",
+	Error = "error",
+}
+
 type OpenRouterProps = {
 	apiConfiguration: ProviderSettings
 	setApiConfigurationField: (field: keyof ProviderSettings, value: ProviderSettings[keyof ProviderSettings]) => void
@@ -42,6 +57,65 @@ export const OpenRouter = ({
 
 	const [openRouterBaseUrlSelected, setOpenRouterBaseUrlSelected] = useState(!!apiConfiguration?.openRouterBaseUrl)
 
+	const queryClient = useQueryClient()
+	const [refreshStatus, setRefreshStatus] = useState<RefreshStatus>(RefreshStatus.Idle)
+	const [refreshError, setRefreshError] = useState<string | undefined>()
+	// Stryker disable next-line BooleanLiteral : initial value never read before reset in handleRefreshModels
+	const errorJustReceived = useRef(false)
+
+	useEffect(() => {
+		const handleMessage = (event: MessageEvent<ExtensionMessage>) => {
+			const message = event.data
+			if (message.type === RouterModelsMessageType.singleRouterModelFetchResponse && !message.success) {
+				const providerName = message.values?.provider as RouterName
+				if (providerName === providerIdentifiers.openrouter && refreshStatus === RefreshStatus.Loading) {
+					errorJustReceived.current = true
+					setRefreshStatus(RefreshStatus.Error)
+					setRefreshError(message.error)
+				}
+			} else if (message.type === RouterModelsMessageType.routerModels) {
+				const providerName = message.values?.provider as RouterName | undefined
+				// Scoped responses must match our provider; unscoped (legacy/global)
+				// broadcasts are still accepted so Loading cannot hang.
+				if (
+					(providerName === undefined || providerName === providerIdentifiers.openrouter) &&
+					refreshStatus === RefreshStatus.Loading &&
+					!errorJustReceived.current
+				) {
+					setRefreshStatus(RefreshStatus.Success)
+					void queryClient.invalidateQueries({
+						queryKey: [RouterModelsMessageType.routerModels, providerIdentifiers.openrouter],
+					})
+					void queryClient.invalidateQueries({
+						queryKey: [RouterModelsMessageType.routerModels, allRouterModelsProvider],
+					})
+				}
+			}
+		}
+
+		window.addEventListener("message", handleMessage)
+		return () => window.removeEventListener("message", handleMessage)
+	}, [refreshStatus, queryClient])
+
+	const handleRefreshModels = useCallback(
+		() => {
+			errorJustReceived.current = false
+			setRefreshStatus(RefreshStatus.Loading)
+			// Stryker disable next-line CallExpression : refreshError is unobservable outside Error status; every Error transition re-sets it in the same batch
+			setRefreshError(undefined)
+
+			vscode.postMessage({
+				type: RouterModelsMessageType.requestRouterModels,
+				values: {
+					provider: providerIdentifiers.openrouter,
+					refresh: true,
+				},
+			})
+		},
+		// Stryker disable next-line ArrayDeclaration : deps array is constant; replacing it with any constant array is memoization-equivalent
+		[],
+	)
+
 	const handleInputChange = useCallback(
 		<K extends keyof ProviderSettings, E>(
 			field: K,
@@ -103,6 +177,33 @@ export const OpenRouter = ({
 					)}
 				</div>
 			)}
+			<Button
+				variant="outline"
+				onClick={handleRefreshModels}
+				disabled={refreshStatus === RefreshStatus.Loading}
+				className="w-full">
+				<div className="flex items-center gap-2">
+					{refreshStatus === RefreshStatus.Loading ? (
+						<span className="codicon codicon-loading codicon-modifier-spin" />
+					) : (
+						<span className="codicon codicon-refresh" />
+					)}
+					{t("settings:providers.refreshModels.label")}
+				</div>
+			</Button>
+			{refreshStatus === RefreshStatus.Loading && (
+				<div className="text-sm text-vscode-descriptionForeground">
+					{t("settings:providers.refreshModels.loading")}
+				</div>
+			)}
+			{refreshStatus === RefreshStatus.Success && (
+				<div className="text-sm text-vscode-foreground">{t("settings:providers.refreshModels.success")}</div>
+			)}
+			{refreshStatus === RefreshStatus.Error && (
+				<div className="text-sm text-vscode-errorForeground">
+					{refreshError || t("settings:providers.refreshModels.error")}
+				</div>
+			)}
 			<ModelPicker
 				apiConfiguration={apiConfiguration}
 				setApiConfigurationField={setApiConfigurationField}
diff --git a/webview-ui/src/components/settings/providers/__tests__/OpenRouter.spec.tsx b/webview-ui/src/components/settings/providers/__tests__/OpenRouter.spec.tsx
new file mode 100644
index 0000000000..d3ac6391ef
--- /dev/null
+++ b/webview-ui/src/components/settings/providers/__tests__/OpenRouter.spec.tsx
@@ -0,0 +1,531 @@
+import { render, screen, fireEvent, act } from "@testing-library/react"
+
+import { QueryClient, QueryClientProvider } from "@tanstack/react-query"
+
+import type { ReactNode, ChangeEvent } from "react"
+import type { ProviderSettings, OrganizationAllowList, ExtensionMessage } from "@roo-code/types"
+import {
+	openRouterDefaultModelId,
+	allRouterModelsProvider,
+	providerIdentifiers,
+	RouterModelsMessageType,
+} from "@roo-code/types"
+
+import { OpenRouter } from "../OpenRouter"
+
+// Explicit toolkit stub (vitest validates factory keys, so no Proxy tricks).
+// Uses React.createElement because this factory runs while the spec's own
+// imports are still initializing (hoisted vi.mock).
+vi.mock("@vscode/webview-ui-toolkit/react", async () => {
+	const React = await import("react")
+	type VSCodeTextFieldProps = {
+		children?: ReactNode
+		value?: string
+		onInput?: (event: ChangeEvent<HTMLInputElement>) => void
+		type?: string
+	}
+	const VSCodeTextField = ({ children, value, onInput, type }: VSCodeTextFieldProps) =>
+		React.createElement(
+			"div",
+			null,
+			children,
+			React.createElement("input", {
+				type,
+				value,
+				onChange: (e: ChangeEvent<HTMLInputElement>) => onInput?.(e),
+				"data-testid": type === "url" ? "base-url-input" : "api-key-input",
+			}),
+		)
+	type VSCodeLinkProps = { children?: ReactNode; href?: string }
+	const VSCodeLink = ({ children, href }: VSCodeLinkProps) =>
+		React.createElement("a", { href, "data-vscode-stub": "VSCodeLink" }, children)
+	return { VSCodeTextField, VSCodeLink }
+})
+
+vi.mock("@src/i18n/TranslationContext", () => ({
+	useAppTranslation: () => ({ t: (key: string) => key }),
+}))
+
+vi.mock("@src/oauth/urls", () => ({
+	getOpenRouterAuthUrl: () => "https://openrouter.ai/auth",
+}))
+
+// Alias-path mock (reliable across environments): prevents the real balance
+// display from issuing network requests during tests.
+vi.mock("@src/components/settings/providers/OpenRouterBalanceDisplay", () => ({
+	OpenRouterBalanceDisplay: () => null,
+}))
+
+vi.mock("@src/components/common/VSCodeButtonLink", () => ({
+	VSCodeButtonLink: ({ children, href }: { children?: ReactNode; href?: string }) => (
+		<a href={href} data-testid="get-api-key-link">
+			{children}
+		</a>
+	),
+}))
+
+// Stub the whole hook module: the real fetchRouterModels registers a
+// transient window "message" listener that only cleans up when a matching
+// response arrives or the 10s timeout fires. Stubbing removes that noise so
+// the unmount test below can assert listener balance for OpenRouter's own
+// effect pair in isolation.
+vi.mock("@src/components/ui/hooks/useRouterModels", () => ({
+	useRouterModels: ({ provider }: { provider?: string }) => ({
+		data: provider ? { [provider]: {} } : {},
+		isLoading: false,
+		isError: false,
+		refetch: vi.fn(),
+	}),
+}))
+
+const { postMessageMock } = vi.hoisted(() => ({
+	postMessageMock: vi.fn(),
+}))
+
+vi.mock("@src/utils/vscode", () => ({
+	vscode: {
+		postMessage: postMessageMock,
+	},
+}))
+
+// Keep every real export (Popover, Select, ...) so leaked child renders work,
+// and only stub Button to assert onClick/disabled without styling deps.
+vi.mock("@src/components/ui", async (importOriginal) => ({
+	...(await importOriginal<typeof import("@src/components/ui")>()),
+	Button: ({
+		children,
+		onClick,
+		disabled,
+		className,
+	}: {
+		children?: ReactNode
+		onClick?: React.MouseEventHandler<HTMLButtonElement>
+		disabled?: boolean
+		className?: string
+	}) => (
+		<button onClick={onClick} disabled={disabled} className={className} data-testid="refresh-button">
+			{children}
+		</button>
+	),
+}))
+
+vi.mock("vscrui", async (importOriginal) => ({
+	...(await importOriginal<typeof import("vscrui")>()),
+	Checkbox: ({
+		checked,
+		onChange,
+		children,
+	}: {
+		checked?: boolean
+		onChange?: (checked: boolean) => void
+		children?: ReactNode
+	}) => (
+		<label data-testid="base-url-checkbox" onClick={() => onChange?.(!checked)}>
+			{children}
+		</label>
+	),
+}))
+
+// The shared Button stub is also used by the real ModelPicker rendered
+// underneath, so identify OUR refresh button via its unique i18n label.
+const getRefreshButton = (): HTMLButtonElement => {
+	const button = screen.getByText("settings:providers.refreshModels.label").closest("button")
+	if (!(button instanceof HTMLButtonElement)) {
+		throw new Error("Refresh button element not found or not a <button>")
+	}
+	return button
+}
+
+describe("OpenRouter", () => {
+	const organizationAllowList: OrganizationAllowList = { allowAll: true, providers: {} }
+	const mockSetApiConfigurationField = vi.fn()
+
+	let queryClient: QueryClient
+	let invalidateQueriesSpy: ReturnType<typeof vi.spyOn>
+
+	const minimalApiConfiguration: ProviderSettings = {
+		apiProvider: providerIdentifiers.openrouter,
+		openRouterApiKey: "key",
+	}
+
+	const renderComponent = ({
+		apiConfiguration = minimalApiConfiguration,
+		simplifySettings = true,
+	}: {
+		apiConfiguration?: ProviderSettings
+		simplifySettings?: boolean
+	} = {}) =>
+		render(
+			<QueryClientProvider client={queryClient}>
+				<OpenRouter
+					apiConfiguration={apiConfiguration}
+					setApiConfigurationField={mockSetApiConfigurationField}
+					selectedModelId={openRouterDefaultModelId}
+					uriScheme="vscode"
+					simplifySettings={simplifySettings}
+					organizationAllowList={organizationAllowList}
+				/>
+			</QueryClientProvider>,
+		)
+
+	beforeEach(() => {
+		vi.clearAllMocks()
+		queryClient = new QueryClient({
+			defaultOptions: {
+				queries: { retry: false },
+				mutations: { retry: false },
+			},
+		})
+		invalidateQueriesSpy = vi.spyOn(queryClient, "invalidateQueries")
+	})
+
+	it("updates the API key via setApiConfigurationField on input", () => {
+		renderComponent()
+
+		fireEvent.change(screen.getByTestId("api-key-input"), { target: { value: "secret-key" } })
+
+		expect(mockSetApiConfigurationField).toHaveBeenCalledWith("openRouterApiKey", "secret-key")
+	})
+
+	it("shows the get-API-key CTA only when no API key is set", () => {
+		const { rerender } = renderComponent({ apiConfiguration: { openRouterApiKey: "" } })
+
+		expect(screen.getByTestId("get-api-key-link")).toBeInTheDocument()
+		expect(screen.getByTestId("get-api-key-link")).toHaveAttribute("href", "https://openrouter.ai/auth")
+
+		rerender(
+			<QueryClientProvider client={queryClient}>
+				<OpenRouter
+					apiConfiguration={{ openRouterApiKey: "already-set" }}
+					setApiConfigurationField={mockSetApiConfigurationField}
+					selectedModelId={openRouterDefaultModelId}
+					uriScheme="vscode"
+					organizationAllowList={organizationAllowList}
+				/>
+			</QueryClientProvider>,
+		)
+		expect(screen.queryByTestId("get-api-key-link")).not.toBeInTheDocument()
+	})
+
+	it("clears the base URL when the custom base URL checkbox is unchecked", () => {
+		renderComponent({
+			apiConfiguration: { openRouterApiKey: "key", openRouterBaseUrl: "https://proxy.example.com" },
+			simplifySettings: false,
+		})
+
+		fireEvent.click(screen.getByTestId("base-url-checkbox"))
+
+		expect(mockSetApiConfigurationField).toHaveBeenCalledWith("openRouterBaseUrl", "")
+	})
+
+	describe("refresh models", () => {
+		// Narrow fixture type matching the message shapes OpenRouter actually
+		// consumes (ExtensionMessage fields for routerModels refresh flows).
+		const dispatchMessage = (data: ExtensionMessage) =>
+			act(() => {
+				window.dispatchEvent(new MessageEvent("message", { data }))
+			})
+
+		it("renders the refresh button in idle state", () => {
+			renderComponent()
+
+			const button = getRefreshButton()
+			expect(button).not.toBeDisabled()
+			expect(button.querySelector(".codicon-refresh")).not.toBeNull()
+			expect(screen.getByText("settings:providers.refreshModels.label")).toBeInTheDocument()
+			expect(screen.queryByText("settings:providers.refreshModels.error")).not.toBeInTheDocument()
+		})
+
+		it("sends requestRouterModels for the openrouter provider when clicked", () => {
+			renderComponent()
+
+			fireEvent.click(getRefreshButton())
+
+			expect(postMessageMock).toHaveBeenCalledWith({
+				type: RouterModelsMessageType.requestRouterModels,
+				values: { provider: providerIdentifiers.openrouter, refresh: true },
+			})
+		})
+
+		it("enters loading state and disables the button while refreshing", () => {
+			renderComponent()
+
+			fireEvent.click(getRefreshButton())
+
+			const button = getRefreshButton()
+			expect(button).toBeDisabled()
+			expect(button.querySelector(".codicon-loading")).not.toBeNull()
+			expect(screen.getByText("settings:providers.refreshModels.loading")).toBeInTheDocument()
+		})
+
+		it("shows success and invalidates caches when a scoped routerModels response arrives", () => {
+			renderComponent()
+
+			fireEvent.click(getRefreshButton())
+			dispatchMessage({
+				type: RouterModelsMessageType.routerModels,
+				values: { provider: providerIdentifiers.openrouter },
+			})
+
+			expect(screen.getByText("settings:providers.refreshModels.success")).toBeInTheDocument()
+			expect(screen.queryByText("settings:providers.refreshModels.error")).not.toBeInTheDocument()
+			expect(invalidateQueriesSpy).toHaveBeenCalledTimes(2)
+			expect(invalidateQueriesSpy).toHaveBeenNthCalledWith(1, {
+				queryKey: [RouterModelsMessageType.routerModels, providerIdentifiers.openrouter],
+			})
+			expect(invalidateQueriesSpy).toHaveBeenNthCalledWith(2, {
+				queryKey: [RouterModelsMessageType.routerModels, allRouterModelsProvider],
+			})
+		})
+
+		it("still resolves on unscoped (legacy/global) routerModels broadcasts", () => {
+			renderComponent()
+
+			fireEvent.click(getRefreshButton())
+			dispatchMessage({ type: RouterModelsMessageType.routerModels })
+
+			expect(screen.getByText("settings:providers.refreshModels.success")).toBeInTheDocument()
+		})
+
+		it("ignores scoped routerModels responses belonging to other providers", () => {
+			renderComponent()
+
+			fireEvent.click(getRefreshButton())
+			dispatchMessage({
+				type: RouterModelsMessageType.routerModels,
+				values: { provider: providerIdentifiers.moonshot },
+			})
+
+			expect(screen.queryByText("settings:providers.refreshModels.success")).not.toBeInTheDocument()
+			expect(screen.getByText("settings:providers.refreshModels.loading")).toBeInTheDocument()
+			expect(invalidateQueriesSpy).not.toHaveBeenCalled()
+		})
+
+		it("shows error state with the received error message on fetch failure", () => {
+			renderComponent()
+
+			fireEvent.click(getRefreshButton())
+			dispatchMessage({
+				type: RouterModelsMessageType.singleRouterModelFetchResponse,
+				success: false,
+				values: { provider: providerIdentifiers.openrouter },
+				error: "Invalid API key",
+			})
+
+			expect(screen.getByText("Invalid API key")).toBeInTheDocument()
+		})
+
+		it("falls back to the default error translation when no error is provided", () => {
+			renderComponent()
+
+			fireEvent.click(getRefreshButton())
+			dispatchMessage({
+				type: RouterModelsMessageType.singleRouterModelFetchResponse,
+				success: false,
+				values: { provider: providerIdentifiers.openrouter },
+			})
+
+			expect(screen.getByText("settings:providers.refreshModels.error")).toBeInTheDocument()
+		})
+
+		it("does not show a stale error after re-clicking refresh", () => {
+			renderComponent()
+
+			fireEvent.click(getRefreshButton())
+			dispatchMessage({
+				type: RouterModelsMessageType.singleRouterModelFetchResponse,
+				success: false,
+				values: { provider: providerIdentifiers.openrouter },
+				error: "boom1",
+			})
+
+			expect(screen.getByText("boom1")).toBeInTheDocument()
+
+			// After an Error the button is re-enabled (only Loading disables it),
+			// so the user can retry. This second refresh must clear the previous
+			// error string, otherwise the stale "boom1" lingers even though the
+			// follow-up failure carries no error payload.
+			fireEvent.click(getRefreshButton())
+			dispatchMessage({
+				type: RouterModelsMessageType.singleRouterModelFetchResponse,
+				success: false,
+				values: { provider: providerIdentifiers.openrouter },
+			})
+
+			expect(screen.getByText("settings:providers.refreshModels.error")).toBeInTheDocument()
+			expect(screen.queryByText("boom1")).not.toBeInTheDocument()
+		})
+
+		it("ignores fetch failures for other providers", () => {
+			renderComponent()
+
+			fireEvent.click(getRefreshButton())
+			dispatchMessage({
+				type: RouterModelsMessageType.singleRouterModelFetchResponse,
+				success: false,
+				values: { provider: providerIdentifiers.moonshot },
+				error: "should not show",
+			})
+
+			expect(screen.queryByText("should not show")).not.toBeInTheDocument()
+			expect(screen.getByText("settings:providers.refreshModels.loading")).toBeInTheDocument()
+		})
+
+		it("does not show an error message when a failed fetch response arrives outside loading state", () => {
+			renderComponent()
+
+			// No refresh click: status stays Idle, so the `refreshStatus === Loading`
+			// guard must block the error transition. Mutating that sub-expression to
+			// true would flip the idle component into Error and render the payload.
+			dispatchMessage({
+				type: RouterModelsMessageType.singleRouterModelFetchResponse,
+				success: false,
+				values: { provider: providerIdentifiers.openrouter },
+				error: "not loading",
+			})
+
+			expect(screen.queryByText("not loading")).not.toBeInTheDocument()
+			expect(screen.queryByText("settings:providers.refreshModels.error")).not.toBeInTheDocument()
+			expect(getRefreshButton()).not.toBeDisabled()
+		})
+
+		it("ignores fetch failures carrying no values", () => {
+			renderComponent()
+
+			fireEvent.click(getRefreshButton())
+			// No `values` at all: `message.values?.provider` must short-circuit to
+			// undefined so the provider match fails and the error branch is skipped.
+			// fireEvent rethrows listener exceptions, so an OptionalChaining mutant
+			// (`?.` replaced by `.`) crashes here and is killed by this assertion.
+			expect(() =>
+				fireEvent(
+					window,
+					new MessageEvent("message", {
+						data: {
+							type: RouterModelsMessageType.singleRouterModelFetchResponse,
+							success: false,
+							error: "should not show",
+						} satisfies ExtensionMessage,
+					}),
+				),
+			).not.toThrow()
+
+			expect(screen.queryByText("should not show")).not.toBeInTheDocument()
+			expect(screen.getByText("settings:providers.refreshModels.loading")).toBeInTheDocument()
+		})
+
+		it("does not override an error with success when routerModels arrives after a failure", () => {
+			renderComponent()
+
+			fireEvent.click(getRefreshButton())
+
+			// Dispatch both within the same act batch so the handler still sees
+			// refreshStatus === "loading" and the errorJustReceived guard is exercised.
+			act(() => {
+				window.dispatchEvent(
+					new MessageEvent("message", {
+						data: {
+							type: RouterModelsMessageType.singleRouterModelFetchResponse,
+							success: false,
+							values: { provider: providerIdentifiers.openrouter },
+							error: "boom",
+						},
+					}),
+				)
+				window.dispatchEvent(
+					new MessageEvent("message", { data: { type: RouterModelsMessageType.routerModels } }),
+				)
+			})
+
+			expect(screen.getByText("boom")).toBeInTheDocument()
+			expect(screen.queryByText("settings:providers.refreshModels.success")).not.toBeInTheDocument()
+		})
+
+		it("ignores routerModels messages when not in loading state", () => {
+			renderComponent()
+
+			// No refresh initiated; an unsolicited routerModels message should be a no-op.
+			dispatchMessage({ type: RouterModelsMessageType.routerModels })
+
+			expect(screen.queryByText("settings:providers.refreshModels.success")).not.toBeInTheDocument()
+			expect(screen.queryByText("settings:providers.refreshModels.loading")).not.toBeInTheDocument()
+		})
+
+		it("ignores non-routerModels messages while refreshing", () => {
+			renderComponent()
+
+			fireEvent.click(getRefreshButton())
+			// A successful single-model fetch response is NOT a routerModels message,
+			// so it must not resolve the refresh. Mutating the else-if type test to
+			// true would enter the success branch (provider stays undefined) and
+			// invalidate the model caches.
+			dispatchMessage({
+				type: RouterModelsMessageType.singleRouterModelFetchResponse,
+				success: true,
+			})
+
+			expect(screen.queryByText("settings:providers.refreshModels.success")).not.toBeInTheDocument()
+			expect(screen.getByText("settings:providers.refreshModels.loading")).toBeInTheDocument()
+			expect(invalidateQueriesSpy).not.toHaveBeenCalled()
+		})
+
+		it("stops listening for messages after unmount", () => {
+			// Spy but delegate to the original methods (captured before spying,
+			// since jsdom rejects EventTarget.prototype.addEventListener.call(window))
+			// so the component still registers/unregisters listeners during the test.
+			type Listener = Parameters<typeof window.addEventListener>[1] & {}
+			const added: Array<[string, Listener]> = []
+			const removed: Array<[string, Listener]> = []
+
+			const originalAdd = window.addEventListener
+			const originalRemove = window.removeEventListener
+
+			const addSpy = vi
+				.spyOn(window, "addEventListener")
+				.mockImplementation((type: string, listener: Listener, options?: AddEventListenerOptions | boolean) => {
+					added.push([type, listener])
+					originalAdd.call(window, type, listener, options)
+				})
+
+			const removeSpy = vi
+				.spyOn(window, "removeEventListener")
+				.mockImplementation((type: string, listener: Listener, options?: EventListenerOptions | boolean) => {
+					removed.push([type, listener])
+					originalRemove.call(window, type, listener, options)
+				})
+
+			try {
+				const { unmount } = renderComponent()
+
+				unmount()
+
+				// Every "message" listener added must be removed (multiset compare).
+				const addedMessages = added.filter(([type]) => type === "message").map(([, listener]) => listener)
+				const removedMessages = removed.filter(([type]) => type === "message").map(([, listener]) => listener)
+				expect(addedMessages.length).toBeGreaterThan(0)
+
+				const remaining = [...addedMessages]
+				for (const listener of removedMessages) {
+					const index = remaining.indexOf(listener)
+					expect(index).toBeGreaterThanOrEqual(0)
+					if (index >= 0) {
+						remaining.splice(index, 1)
+					}
+				}
+				expect(remaining).toEqual([])
+
+				expect(() =>
+					act(() => {
+						window.dispatchEvent(
+							new MessageEvent("message", { data: { type: RouterModelsMessageType.routerModels } }),
+						)
+					}),
+				).not.toThrow()
+				expect(screen.queryByText("settings:providers.refreshModels.label")).not.toBeInTheDocument()
+			} finally {
+				addSpy.mockRestore()
+				removeSpy.mockRestore()
+			}
+		})
+	})
+})