test(core): avoid mutating provider identifiers

Author: WebMad

src/core/task/__tests__/Task.spec.ts

@@ -6,7 +6,7 @@ import * as path from "path"
 import * as vscode from "vscode"
 import { Anthropic } from "@anthropic-ai/sdk"
 
-import { providerIdentifiers, type GlobalState, type ProviderSettings, type ModelInfo } from "@roo-code/types"
+import type { GlobalState, ProviderSettings, ModelInfo } from "@roo-code/types"
 import { TelemetryService } from "@roo-code/telemetry"
 
 import { Task } from "../Task"
@@ -1902,55 +1902,47 @@ describe("Cline", () => {
 					expect(metadata!.abortSignal).toBe(task.currentRequestAbortController!.signal)
 				})
 
-				it("uses the canonical Gemini identifier when configuring tool restrictions", async () => {
-					const identifiers = providerIdentifiers as Record<string, string>
-					const originalIdentifier = identifiers.gemini
-
-					try {
-						identifiers.gemini = "canonical-gemini"
-						const apiConfiguration = {
-							...mockApiConfig,
-							apiProvider: identifiers.gemini,
-						} as ProviderSettings
-						const task = new Task({
-							provider: mockProvider,
-							apiConfiguration,
-							task: "test task",
-							startTask: false,
-						})
-
-						vi.spyOn(task as any, "getSystemPrompt").mockResolvedValue("mock system prompt")
-						vi.spyOn(task.api, "getModel").mockReturnValue({
-							id: mockApiConfig.apiModelId!,
-							info: { contextWindow: 200000, maxTokens: 4096 } as ModelInfo,
-						})
-						const providerState = await mockProvider.getState()
-						vi.spyOn(mockProvider, "getState").mockResolvedValue({
-							...providerState,
-							apiConfiguration,
-							autoApprovalEnabled: true,
-							requestDelaySeconds: 0,
-						})
-						const mockStream = (async function* () {
-							yield { type: "text", text: "response" } as ApiStreamChunk
-						})()
-						const createMessageSpy = vi.spyOn(task.api, "createMessage").mockReturnValue(mockStream)
-						task.apiConversationHistory = [
-							{ role: "user", content: [{ type: "text", text: "test message" }], ts: Date.now() },
-						] as any
-
-						await task.attemptApiRequest(0).next()
-
-						const [, , metadata] = createMessageSpy.mock.calls[0]!
-						expect(metadata).toEqual(
-							expect.objectContaining({
-								tools: expect.any(Array),
-								allowedFunctionNames: expect.any(Array),
-							}),
-						)
-					} finally {
-						identifiers.gemini = originalIdentifier
-					}
+				it("configures tool restrictions for Gemini requests", async () => {
+					const apiConfiguration = {
+						...mockApiConfig,
+						apiProvider: "gemini",
+					} as ProviderSettings
+					const task = new Task({
+						provider: mockProvider,
+						apiConfiguration,
+						task: "test task",
+						startTask: false,
+					})
+
+					vi.spyOn(task as any, "getSystemPrompt").mockResolvedValue("mock system prompt")
+					vi.spyOn(task.api, "getModel").mockReturnValue({
+						id: mockApiConfig.apiModelId!,
+						info: { contextWindow: 200000, maxTokens: 4096 } as ModelInfo,
+					})
+					const providerState = await mockProvider.getState()
+					vi.spyOn(mockProvider, "getState").mockResolvedValue({
+						...providerState,
+						apiConfiguration,
+						autoApprovalEnabled: true,
+						requestDelaySeconds: 0,
+					})
+					const mockStream = (async function* () {
+						yield { type: "text", text: "response" } as ApiStreamChunk
+					})()
+					const createMessageSpy = vi.spyOn(task.api, "createMessage").mockReturnValue(mockStream)
+					task.apiConversationHistory = [
+						{ role: "user", content: [{ type: "text", text: "test message" }], ts: Date.now() },
+					] as any
+
+					await task.attemptApiRequest(0).next()
+
+					const [, , metadata] = createMessageSpy.mock.calls[0]!
+					expect(metadata).toEqual(
+						expect.objectContaining({
+							tools: expect.any(Array),
+							allowedFunctionNames: expect.any(Array),
+						}),
+					)
 				})
 
 				it("should invoke abort on currentRequestAbortController during first-chunk wait", async () => {

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

@@ -527,25 +527,16 @@ describe("ClineProvider", () => {
 		expect(ClineProvider.getVisibleInstance()).toBe(provider)
 	})
 
-	test("prepares LM Studio tasks through the canonical provider identifier", async () => {
-		const identifiers = providerIdentifiers as Record<string, string>
-		const originalIdentifier = identifiers.lmstudio
-
-		try {
-			identifiers.lmstudio = "canonical-lmstudio"
-
-			await provider.performPreparationTasks({
-				apiConfiguration: {
-					apiProvider: identifiers.lmstudio,
-					lmStudioBaseUrl: "http://localhost:1234",
-					lmStudioModelId: "test-model",
-				},
-			} as Task)
+	test("loads full model details when preparing an LM Studio task", async () => {
+		await provider.performPreparationTasks({
+			apiConfiguration: {
+				apiProvider: "lmstudio",
+				lmStudioBaseUrl: "http://localhost:1234",
+				lmStudioModelId: "test-model",
+			},
+		} as Task)
 
-			expect(forceFullModelDetailsLoad).toHaveBeenCalledWith("http://localhost:1234", "test-model")
-		} finally {
-			identifiers.lmstudio = originalIdentifier
-		}
+		expect(forceFullModelDetailsLoad).toHaveBeenCalledWith("http://localhost:1234", "test-model")
 	})
 
 	test("resolveWebviewView hydrates the saved terminalProfile into the process-wide Terminal state", async () => {

src/core/webview/__tests__/webviewMessageHandler.spec.ts

@@ -51,7 +51,7 @@ vi.mock("../rulesMessageHandler", () => ({
 	handleOpenRulesDirectory: vi.fn(),
 }))
 
-import { providerIdentifiers, type ModelRecord } from "@roo-code/types"
+import type { ModelRecord } from "@roo-code/types"
 
 import { webviewMessageHandler } from "../webviewMessageHandler"
 import type { ClineProvider } from "../ClineProvider"
@@ -1495,56 +1495,49 @@ describe("zooCodeSignOut", () => {
 		vi.clearAllMocks()
 	})
 
-	it("disconnects Zoo Code and clears tokens from all profiles using the canonical Zoo Gateway identifier", async () => {
+	it("disconnects Zoo Code and clears tokens from all Zoo Gateway profiles", async () => {
 		const { disconnectZooCode } = await import("../../../services/zoo-code-auth")
-		const identifiers = providerIdentifiers as Record<string, string>
-		const originalIdentifier = identifiers.zooGateway
 		const upsertProviderProfile = vi.fn().mockResolvedValue(undefined)
 		const saveConfig = vi.fn().mockResolvedValue(undefined)
 
-		try {
-			identifiers.zooGateway = "canonical-zoo-gateway"
-			;(mockClineProvider as any).contextProxy = {
-				...mockClineProvider.contextProxy,
-				getProviderSettings: vi.fn().mockReturnValue({ apiProvider: identifiers.zooGateway }),
-				getValues: vi.fn().mockReturnValue({ currentApiConfigName: "Zoo Gateway" }),
-			}
-			;(mockClineProvider as any).providerSettingsManager = {
-				listConfig: vi.fn().mockResolvedValue([
-					{ name: "Zoo Gateway", apiProvider: identifiers.zooGateway },
-					{ name: "Backup Zoo", apiProvider: identifiers.zooGateway },
-				]),
-				getProfile: vi
-					.fn()
-					.mockResolvedValueOnce({
-						apiProvider: identifiers.zooGateway,
-						zooSessionToken: "token-active",
-						zooGatewayModelId: "anthropic/claude-sonnet-4",
-					})
-					.mockResolvedValueOnce({
-						apiProvider: identifiers.zooGateway,
-						zooSessionToken: "token-backup",
-					}),
-				saveConfig,
-			}
-			;(mockClineProvider as any).upsertProviderProfile = upsertProviderProfile
-
-			await webviewMessageHandler(mockClineProvider, { type: "zooCodeSignOut" })
-
-			expect(disconnectZooCode).toHaveBeenCalled()
-			expect(upsertProviderProfile).toHaveBeenCalledWith(
-				"Zoo Gateway",
-				expect.not.objectContaining({ zooSessionToken: expect.anything() }),
-				true,
-			)
-			expect(saveConfig).toHaveBeenCalledWith(
-				"Backup Zoo",
-				expect.not.objectContaining({ zooSessionToken: expect.anything() }),
-			)
-			expect(mockClineProvider.postStateToWebview).toHaveBeenCalled()
-		} finally {
-			identifiers.zooGateway = originalIdentifier
+		;(mockClineProvider as any).contextProxy = {
+			...mockClineProvider.contextProxy,
+			getProviderSettings: vi.fn().mockReturnValue({ apiProvider: "zoo-gateway" }),
+			getValues: vi.fn().mockReturnValue({ currentApiConfigName: "Zoo Gateway" }),
+		}
+		;(mockClineProvider as any).providerSettingsManager = {
+			listConfig: vi.fn().mockResolvedValue([
+				{ name: "Zoo Gateway", apiProvider: "zoo-gateway" },
+				{ name: "Backup Zoo", apiProvider: "zoo-gateway" },
+			]),
+			getProfile: vi
+				.fn()
+				.mockResolvedValueOnce({
+					apiProvider: "zoo-gateway",
+					zooSessionToken: "token-active",
+					zooGatewayModelId: "anthropic/claude-sonnet-4",
+				})
+				.mockResolvedValueOnce({
+					apiProvider: "zoo-gateway",
+					zooSessionToken: "token-backup",
+				}),
+			saveConfig,
 		}
+		;(mockClineProvider as any).upsertProviderProfile = upsertProviderProfile
+
+		await webviewMessageHandler(mockClineProvider, { type: "zooCodeSignOut" })
+
+		expect(disconnectZooCode).toHaveBeenCalled()
+		expect(upsertProviderProfile).toHaveBeenCalledWith(
+			"Zoo Gateway",
+			expect.not.objectContaining({ zooSessionToken: expect.anything() }),
+			true,
+		)
+		expect(saveConfig).toHaveBeenCalledWith(
+			"Backup Zoo",
+			expect.not.objectContaining({ zooSessionToken: expect.anything() }),
+		)
+		expect(mockClineProvider.postStateToWebview).toHaveBeenCalled()
 	})
 
 	it("still clears the in-memory handler when the active profile token is already empty on disk", async () => {