fix(provider): recover timed-out profile mutations

Author: edelauna

src/core/webview/ClineProvider.ts

@@ -205,18 +205,43 @@ export class ClineProvider
 
 	private enqueueProviderProfileMutation<T>(fn: () => Promise<T>): Promise<T> {
 		const run = this.providerProfileMutationQueue.then(fn, fn)
-		const callerResult = this.withProviderProfileMutationTimeout(run)
-		this.providerProfileMutationQueue = run.then(
+		let timedOut = false
+		const callerResult = this.withProviderProfileMutationTimeout(run, () => {
+			timedOut = true
+			this.log("Provider profile mutation timed out; releasing the mutation queue")
+		})
+
+		void run.then(
+			() => {
+				if (timedOut) {
+					this.log("Provider profile mutation completed after timing out")
+				}
+			},
+			(error) => {
+				if (timedOut) {
+					this.log(
+						`Provider profile mutation failed after timing out: ${
+							error instanceof Error ? error.message : String(error)
+						}`,
+					)
+				}
+			},
+		)
+
+		// Advance from the timeout-bounded caller result, rather than the raw operation. A
+		// provider call that never settles must not block all subsequent profile changes.
+		this.providerProfileMutationQueue = callerResult.then(
 			() => undefined,
 			() => undefined,
 		)
 		return callerResult
 	}
 
-	private withProviderProfileMutationTimeout<T>(operation: Promise<T>): Promise<T> {
+	private withProviderProfileMutationTimeout<T>(operation: Promise<T>, onTimeout: () => void): Promise<T> {
 		let timeoutId: ReturnType<typeof setTimeout> | undefined
 		const timeout = new Promise<never>((_, reject) => {
 			timeoutId = setTimeout(() => {
+				onTimeout()
 				reject(new Error("Provider profile mutation timed out"))
 			}, ClineProvider.PENDING_OPERATION_TIMEOUT_MS)
 		})
@@ -1535,8 +1560,10 @@ export class ClineProvider
 	 * @param targetTask The task whose in-memory mode should be updated. Defaults to the
 	 * current task. Pass null to apply only global mode/profile effects for a pending child.
 	 */
-	public async handleModeSwitch(newMode: Mode, targetTask: Task | null | undefined = this.getCurrentTask()) {
-		return this.enqueueProviderProfileMutation(() => this.handleModeSwitchUnlocked(newMode, targetTask))
+	public async handleModeSwitch(newMode: Mode, targetTask?: Task | null) {
+		return this.enqueueProviderProfileMutation(() =>
+			this.handleModeSwitchUnlocked(newMode, targetTask === undefined ? this.getCurrentTask() : targetTask),
+		)
 	}
 
 	private async handleModeSwitchUnlocked(newMode: Mode, targetTask: Task | null | undefined): Promise<void> {
@@ -1821,12 +1848,14 @@ export class ClineProvider
 		const persistTaskHistory = options?.persistTaskHistory ?? true
 		const skipCurrentTaskRebuild = options?.skipCurrentTaskRebuild ?? false
 
-		// See `upsertProviderProfile` for a description of what this is doing.
-		await Promise.all([
-			this.contextProxy.setValue("listApiConfigMeta", await this.providerSettingsManager.listConfig()),
-			this.contextProxy.setValue("currentApiConfigName", name),
-			this.contextProxy.setProviderSettings(providerSettings),
-		])
+		if (!skipCurrentTaskRebuild) {
+			// See `upsertProviderProfile` for a description of what this is doing.
+			await Promise.all([
+				this.contextProxy.setValue("listApiConfigMeta", await this.providerSettingsManager.listConfig()),
+				this.contextProxy.setValue("currentApiConfigName", name),
+				this.contextProxy.setProviderSettings(providerSettings),
+			])
+		}
 
 		const { mode } = await this.getState()
 

src/core/webview/__tests__/ClineProvider.apiHandlerRebuild.spec.ts

@@ -472,6 +472,63 @@ describe("ClineProvider - API Handler Rebuild Guard", () => {
 			await expect(provider.activateProviderProfile({ name: "second-profile" })).resolves.toBeUndefined()
 		})
 
+		test("provider profile mutation timeout releases later queued mutations", async () => {
+			vi.useFakeTimers()
+			const logSpy = vi.spyOn(provider, "log")
+			provider["providerSettingsManager"].activateProfile = vi
+				.fn()
+				.mockImplementationOnce(() => new Promise<never>(() => {}))
+				.mockResolvedValueOnce({
+					name: "second-profile",
+					id: "second-id",
+					apiProvider: "openrouter",
+					openRouterModelId: "openai/gpt-4.1-mini",
+				})
+
+			try {
+				const first = provider.activateProviderProfile({ name: "first-profile" })
+				const firstResult = expect(first).rejects.toThrow("Provider profile mutation timed out")
+				await vi.advanceTimersByTimeAsync(30_000)
+				await firstResult
+
+				await expect(provider.activateProviderProfile({ name: "second-profile" })).resolves.toBeUndefined()
+				expect(logSpy).toHaveBeenCalledWith("Provider profile mutation timed out; releasing the mutation queue")
+			} finally {
+				vi.useRealTimers()
+			}
+		})
+
+		test("mode switch resolves its default task when its queued mutation starts", async () => {
+			let releaseProfileActivation!: () => void
+			const profileActivation = new Promise<void>((resolve) => {
+				releaseProfileActivation = resolve
+			})
+			provider["providerSettingsManager"].activateProfile = vi.fn().mockImplementationOnce(async () => {
+				await profileActivation
+				return {
+					name: "first-profile",
+					id: "first-id",
+					apiProvider: "openrouter",
+					openRouterModelId: "openai/gpt-4",
+				}
+			})
+
+			const firstTask = new Task(defaultTaskOptions)
+			const secondTask = new Task(defaultTaskOptions)
+			await provider.addClineToStack(firstTask)
+
+			const profileSwitch = provider.activateProviderProfile({ name: "first-profile" })
+			const modeSwitch = provider.handleModeSwitch("ask" as Mode)
+			await provider.addClineToStack(secondTask)
+
+			releaseProfileActivation()
+			await profileSwitch
+			await modeSwitch
+
+			expect((firstTask as unknown as { _taskMode?: Mode })._taskMode).not.toBe("ask")
+			expect((secondTask as unknown as { _taskMode?: Mode })._taskMode).toBe("ask")
+		})
+
 		test("fan-out preparation leaves the focused task untouched", async () => {
 			const mockTask = new Task({
 				...defaultTaskOptions,
@@ -499,6 +556,8 @@ describe("ClineProvider - API Handler Rebuild Guard", () => {
 			})
 			const emitSpy = vi.spyOn(provider, "emit")
 			const postStateSpy = vi.spyOn(provider, "postStateToWebview").mockResolvedValue(undefined)
+			const setValueSpy = vi.spyOn(provider.contextProxy, "setValue")
+			const setProviderSettingsSpy = vi.spyOn(provider.contextProxy, "setProviderSettings")
 
 			await provider.handleModeSwitch("ask" as Mode, null)
 
@@ -509,6 +568,8 @@ describe("ClineProvider - API Handler Rebuild Guard", () => {
 				expect.objectContaining({ name: "ask-profile" }),
 			)
 			expect(postStateSpy).not.toHaveBeenCalled()
+			expect(setValueSpy).not.toHaveBeenCalledWith("currentApiConfigName", "ask-profile")
+			expect(setProviderSettingsSpy).not.toHaveBeenCalled()
 		})
 
 		test("calls updateApiConfiguration when provider/model unchanged but settings differ (explicit profile switch)", async () => {