refactor(core): use canonical provider identifiers

Author: WebMad

src/core/task/Task.ts

@@ -54,6 +54,7 @@ import {
 	ConsecutiveMistakeError,
 	MAX_MCP_TOOLS_THRESHOLD,
 	countEnabledMcpTools,
+	providerIdentifiers,
 } from "@roo-code/types"
 import { TelemetryService } from "@roo-code/telemetry"
 import { CloudService } from "@roo-code/cloud"
@@ -4220,7 +4221,7 @@ export class Task extends EventEmitter<TaskEvents> implements TaskLike {
 		// but uses allowedFunctionNames to restrict which tools can be called.
 		// Other providers (Anthropic, OpenAI, etc.) don't support this feature yet,
 		// so they continue to receive only the filtered tools for the current mode.
-		const supportsAllowedFunctionNames = apiConfiguration?.apiProvider === "gemini"
+		const supportsAllowedFunctionNames = apiConfiguration?.apiProvider === providerIdentifiers.gemini
 
 		{
 			const provider = this.providerRef.deref()

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 type { GlobalState, ProviderSettings, ModelInfo } from "@roo-code/types"
+import { providerIdentifiers, type GlobalState, type ProviderSettings, type ModelInfo } from "@roo-code/types"
 import { TelemetryService } from "@roo-code/telemetry"
 
 import { Task } from "../Task"
@@ -1902,6 +1902,52 @@ describe("Cline", () => {
 					expect(metadata!.abortSignal).toBe(task.currentRequestAbortController!.signal)
 				})
 
+				it("enables allowed function names through the canonical Gemini provider identifier", 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?.allowedFunctionNames).toEqual(expect.any(Array))
+					} finally {
+						identifiers.gemini = originalIdentifier
+					}
+				})
+
 				it("should invoke abort on currentRequestAbortController during first-chunk wait", async () => {
 					const task = new Task({
 						provider: mockProvider,

src/core/webview/ClineProvider.ts

@@ -50,6 +50,7 @@ import {
 	DEFAULT_CHECKPOINT_TIMEOUT_SECONDS,
 	getModelId,
 	isRetiredProvider,
+	providerIdentifiers,
 } from "@roo-code/types"
 import { RateLimitClock, createRateLimitClock } from "../task/RateLimitClock"
 import { aggregateTaskCostsRecursive, type AggregatedCosts } from "./aggregateTaskCosts"
@@ -478,7 +479,7 @@ export class ClineProvider
 	async performPreparationTasks(cline: Task) {
 		// LMStudio: We need to force model loading in order to read its context
 		// size; we do it now since we're starting a task with that model selected.
-		if (cline.apiConfiguration && cline.apiConfiguration.apiProvider === "lmstudio") {
+		if (cline.apiConfiguration && cline.apiConfiguration.apiProvider === providerIdentifiers.lmstudio) {
 			try {
 				if (!hasLoadedFullDetails(cline.apiConfiguration.lmStudioModelId!)) {
 					await forceFullModelDetailsLoad(
@@ -1003,7 +1004,7 @@ export class ClineProvider
 		// Using .find() would miss stale tokens in duplicate/renamed profiles since handleZooCodeCallback
 		// uses .filter() and updates all of them — the early-return guard must match.
 		const allProfiles = await this.providerSettingsManager.listConfig()
-		const zooGatewayProfiles = allProfiles.filter((p) => p.apiProvider === "zoo-gateway")
+		const zooGatewayProfiles = allProfiles.filter((p) => p.apiProvider === providerIdentifiers.zooGateway)
 
 		if (zooGatewayProfiles.length === 0) {
 			this.log("[ensureZooGatewayProfileSeeded] No zoo-gateway profile found, creating one")
@@ -1864,14 +1865,14 @@ export class ClineProvider
 
 			// Check if Zoo Gateway is the currently active profile by apiProvider identity,
 			// not by profile name (profile names are user-renameable).
-			const isZooGatewayActive = currentSettings.apiProvider === "zoo-gateway"
+			const isZooGatewayActive = currentSettings.apiProvider === providerIdentifiers.zooGateway
 
 			// Always scan ALL profiles and update every zoo-gateway profile with the new token.
 			// This ensures renamed profiles, duplicate profiles, and inactive profiles all stay
 			// in sync. The model lookup in requestRouterModels uses .find() which returns the
 			// first zoo-gateway profile it finds — if that profile has a stale token, requests fail.
 			const allProfiles = await this.providerSettingsManager.listConfig()
-			const zooProfiles = allProfiles.filter((p) => p.apiProvider === "zoo-gateway")
+			const zooProfiles = allProfiles.filter((p) => p.apiProvider === providerIdentifiers.zooGateway)
 
 			if (zooProfiles.length === 0) {
 				// No existing zoo-gateway profile — create the canonical default.

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

@@ -15,6 +15,7 @@ import {
 	DEFAULT_CHECKPOINT_TIMEOUT_SECONDS,
 	DEFAULT_DIFF_FUZZY_THRESHOLD,
 	DEFAULT_WRITE_DELAY_MS,
+	providerIdentifiers,
 } from "@roo-code/types"
 import { TelemetryService } from "@roo-code/telemetry"
 
@@ -28,6 +29,7 @@ import { safeWriteJson } from "../../../utils/safeWriteJson"
 import { ClineProvider } from "../ClineProvider"
 import { Terminal } from "../../../integrations/terminal/Terminal"
 import { MessageManager } from "../../message-manager"
+import { forceFullModelDetailsLoad } from "../../../api/providers/fetchers/lmstudio"
 
 // Mock setup must come before imports.
 vi.mock("../../prompts/sections/custom-instructions")
@@ -257,6 +259,11 @@ vi.mock("../../../api/providers/fetchers/modelCache", () => ({
 	getModelsFromCache: vi.fn().mockReturnValue(undefined),
 }))
 
+vi.mock("../../../api/providers/fetchers/lmstudio", () => ({
+	hasLoadedFullDetails: vi.fn().mockReturnValue(false),
+	forceFullModelDetailsLoad: vi.fn().mockResolvedValue(undefined),
+}))
+
 vi.mock("../../../services/zoo-code-auth", () => ({
 	getZooCodeBaseUrl: vi.fn(() => "https://www.zoocode.dev"),
 	getCachedZooCodeToken: vi.fn(),
@@ -520,6 +527,27 @@ 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)
+
+			expect(forceFullModelDetailsLoad).toHaveBeenCalledWith("http://localhost:1234", "test-model")
+		} finally {
+			identifiers.lmstudio = originalIdentifier
+		}
+	})
+
 	test("resolveWebviewView hydrates the saved terminalProfile into the process-wide Terminal state", async () => {
 		const setTerminalProfileSpy = vi.spyOn(Terminal, "setTerminalProfile").mockImplementation(() => {})
 		// Seed the persisted setting so the real getState() returns it during hydration.

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

@@ -51,7 +51,7 @@ vi.mock("../rulesMessageHandler", () => ({
 	handleOpenRulesDirectory: vi.fn(),
 }))
 
-import type { ModelRecord } from "@roo-code/types"
+import { providerIdentifiers, type ModelRecord } from "@roo-code/types"
 
 import { webviewMessageHandler } from "../webviewMessageHandler"
 import type { ClineProvider } from "../ClineProvider"
@@ -1540,6 +1540,40 @@ describe("zooCodeSignOut", () => {
 		expect(mockClineProvider.postStateToWebview).toHaveBeenCalled()
 	})
 
+	it("clears tokens using the canonical Zoo Gateway provider identifier", async () => {
+		const identifiers = providerIdentifiers as Record<string, string>
+		const originalIdentifier = identifiers.zooGateway
+		const upsertProviderProfile = 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 }]),
+				getProfile: vi.fn().mockResolvedValue({
+					apiProvider: identifiers.zooGateway,
+					zooSessionToken: "token-active",
+				}),
+				saveConfig: vi.fn(),
+			}
+			;(mockClineProvider as any).upsertProviderProfile = upsertProviderProfile
+
+			await webviewMessageHandler(mockClineProvider, { type: "zooCodeSignOut" })
+
+			expect(upsertProviderProfile).toHaveBeenCalledWith(
+				"Zoo Gateway",
+				expect.not.objectContaining({ zooSessionToken: expect.anything() }),
+				true,
+			)
+		} finally {
+			identifiers.zooGateway = originalIdentifier
+		}
+	})
+
 	it("still clears the in-memory handler when the active profile token is already empty on disk", async () => {
 		const upsertProviderProfile = vi.fn().mockResolvedValue(undefined)
 

src/core/webview/webviewMessageHandler.ts

@@ -22,6 +22,7 @@ import {
 	checkoutDiffPayloadSchema,
 	checkoutRestorePayloadSchema,
 	getCompletionCheckpoint,
+	providerIdentifiers,
 } from "@roo-code/types"
 import { customToolRegistry } from "@roo-code/core"
 import { CloudService } from "@roo-code/cloud"
@@ -2773,11 +2774,11 @@ export const webviewMessageHandler = async (
 					const allProfiles = await provider.providerSettingsManager.listConfig()
 					// Check if Zoo Gateway is the currently active profile by apiProvider identity
 					const currentSettings = provider.contextProxy.getProviderSettings()
-					const isZooGatewayActive = currentSettings.apiProvider === "zoo-gateway"
+					const isZooGatewayActive = currentSettings.apiProvider === providerIdentifiers.zooGateway
 					const currentApiConfigName = provider.contextProxy.getValues().currentApiConfigName
 
 					for (const entry of allProfiles) {
-						if (entry.apiProvider !== "zoo-gateway") {
+						if (entry.apiProvider !== providerIdentifiers.zooGateway) {
 							continue
 						}