refactor: finish canonical provider identifier audit

Author: WebMad

packages/types/src/__tests__/provider-settings.test.ts

@@ -1,4 +1,4 @@
-import { getApiProtocol } from "../provider-settings.js"
+import { getApiProtocol, providerIdentifiers, type ProviderName } from "../index.js"
 
 describe("getApiProtocol", () => {
 	describe("Anthropic-style providers", () => {
@@ -15,6 +15,19 @@ describe("getApiProtocol", () => {
 	})
 
 	describe("Vertex provider with Claude models", () => {
+		it("uses the canonical Vertex identifier for Claude protocol selection", () => {
+			const identifiers = providerIdentifiers as Record<string, string>
+			const originalIdentifier = identifiers.vertex!
+
+			try {
+				identifiers.vertex = "canonical-vertex"
+
+				expect(getApiProtocol(identifiers.vertex as ProviderName, "claude-3-opus")).toBe("anthropic")
+			} finally {
+				identifiers.vertex = originalIdentifier
+			}
+		})
+
 		it("should return 'anthropic' for vertex provider with claude models", () => {
 			expect(getApiProtocol("vertex", "claude-3-opus")).toBe("anthropic")
 			expect(getApiProtocol("vertex", "Claude-3-Sonnet")).toBe("anthropic")
@@ -34,6 +47,27 @@ describe("getApiProtocol", () => {
 	})
 
 	describe("Vercel AI Gateway provider", () => {
+		it("uses canonical gateway identifiers for Anthropic model protocol selection", () => {
+			const identifiers = providerIdentifiers as Record<string, string>
+			const originalVercelIdentifier = identifiers.vercelAiGateway!
+			const originalZooIdentifier = identifiers.zooGateway!
+
+			try {
+				identifiers.vercelAiGateway = "canonical-vercel-ai-gateway"
+				identifiers.zooGateway = "canonical-zoo-gateway"
+
+				expect(getApiProtocol(identifiers.vercelAiGateway as ProviderName, "anthropic/claude-3-opus")).toBe(
+					"anthropic",
+				)
+				expect(getApiProtocol(identifiers.zooGateway as ProviderName, "anthropic/claude-3-opus")).toBe(
+					"anthropic",
+				)
+			} finally {
+				identifiers.vercelAiGateway = originalVercelIdentifier
+				identifiers.zooGateway = originalZooIdentifier
+			}
+		})
+
 		it("should return 'anthropic' for vercel-ai-gateway provider with anthropic models", () => {
 			expect(getApiProtocol("vercel-ai-gateway", "anthropic/claude-3-opus")).toBe("anthropic")
 			expect(getApiProtocol("vercel-ai-gateway", "anthropic/claude-3.5-sonnet")).toBe("anthropic")
@@ -54,6 +88,19 @@ describe("getApiProtocol", () => {
 	})
 
 	describe("Opencode Go provider", () => {
+		it("uses the canonical OpenCode Go identifier for model-specific protocol selection", () => {
+			const identifiers = providerIdentifiers as Record<string, string>
+			const originalIdentifier = identifiers.opencodeGo!
+
+			try {
+				identifiers.opencodeGo = "canonical-opencode-go"
+
+				expect(getApiProtocol(identifiers.opencodeGo as ProviderName, "qwen3.7-max")).toBe("anthropic")
+			} finally {
+				identifiers.opencodeGo = originalIdentifier
+			}
+		})
+
 		it("should return 'anthropic' for opencode-go Anthropic-format models (Qwen/MiniMax)", () => {
 			expect(getApiProtocol("opencode-go", "qwen3.7-max")).toBe("anthropic")
 			expect(getApiProtocol("opencode-go", "qwen3.7-plus")).toBe("anthropic")

packages/types/src/provider-settings.ts

@@ -581,21 +581,25 @@ export const modelIdKeysByProvider: Record<TypicalProvider, ModelIdKey> = {
  */
 
 // Providers that use Anthropic-style API protocol.
-export const ANTHROPIC_STYLE_PROVIDERS: ProviderName[] = ["anthropic", "bedrock", "minimax"]
+export const ANTHROPIC_STYLE_PROVIDERS: ProviderName[] = [
+	providerIdentifiers.anthropic,
+	providerIdentifiers.bedrock,
+	providerIdentifiers.minimax,
+]
 
 export const getApiProtocol = (provider: ProviderName | undefined, modelId?: string): "anthropic" | "openai" => {
 	if (provider && ANTHROPIC_STYLE_PROVIDERS.includes(provider)) {
 		return "anthropic"
 	}
 
-	if (provider && provider === "vertex" && modelId && modelId.toLowerCase().includes("claude")) {
+	if (provider && provider === providerIdentifiers.vertex && modelId && modelId.toLowerCase().includes("claude")) {
 		return "anthropic"
 	}
 
 	// Vercel AI Gateway and Zoo Gateway use the anthropic protocol for anthropic models.
 	if (
 		provider &&
-		["vercel-ai-gateway", "zoo-gateway"].includes(provider) &&
+		(provider === providerIdentifiers.vercelAiGateway || provider === providerIdentifiers.zooGateway) &&
 		modelId &&
 		modelId.toLowerCase().startsWith("anthropic/")
 	) {
@@ -609,7 +613,12 @@ export const getApiProtocol = (provider: ProviderName | undefined, modelId?: str
 	// models must use the anthropic protocol so token/cost aggregation adds the
 	// cache tokens back into the input total — otherwise the cached prefix is
 	// dropped from `contextTokens`, undercounting context-window usage.
-	if (provider && provider === "opencode-go" && modelId && isOpencodeGoAnthropicFormatModel(modelId)) {
+	if (
+		provider &&
+		provider === providerIdentifiers.opencodeGo &&
+		modelId &&
+		isOpencodeGoAnthropicFormatModel(modelId)
+	) {
 		return "anthropic"
 	}
 

src/shared/__tests__/checkExistApiConfig.spec.ts

@@ -1,6 +1,6 @@
 // npx vitest run src/shared/__tests__/checkExistApiConfig.spec.ts
 
-import type { ProviderSettings } from "@roo-code/types"
+import { providerIdentifiers, type ProviderSettings } from "@roo-code/types"
 
 import { checkExistKey } from "../checkExistApiConfig"
 
@@ -66,6 +66,19 @@ describe("checkExistKey", () => {
 		expect(checkExistKey(config)).toBe(true)
 	})
 
+	it("recognizes keyless providers through their canonical identifiers", () => {
+		const identifiers = providerIdentifiers as Record<string, string>
+		const originalIdentifier = identifiers.fakeAi!
+
+		try {
+			identifiers.fakeAi = "canonical-fake-ai"
+
+			expect(checkExistKey({ apiProvider: identifiers.fakeAi } as ProviderSettings)).toBe(true)
+		} finally {
+			identifiers.fakeAi = originalIdentifier
+		}
+	})
+
 	it("should return true for openai-codex provider without API key", () => {
 		const config: ProviderSettings = {
 			apiProvider: "openai-codex",
@@ -95,6 +108,21 @@ describe("checkExistKey", () => {
 		expect(checkExistKey(config)).toBe(true)
 	})
 
+	it("recognizes OAuth authentication through the canonical Kimi Code identifier", () => {
+		const identifiers = providerIdentifiers as Record<string, string>
+		const originalIdentifier = identifiers.kimiCode!
+
+		try {
+			identifiers.kimiCode = "canonical-kimi-code"
+
+			expect(
+				checkExistKey({ apiProvider: identifiers.kimiCode, kimiCodeAuthMethod: "oauth" } as ProviderSettings),
+			).toBe(true)
+		} finally {
+			identifiers.kimiCode = originalIdentifier
+		}
+	})
+
 	it("should return true for kimi-code provider without auth method (defaults to OAuth)", () => {
 		const config: ProviderSettings = {
 			apiProvider: "kimi-code",
@@ -128,6 +156,19 @@ describe("checkExistKey", () => {
 		expect(checkExistKey(config, false)).toBe(false)
 	})
 
+	it("recognizes session authentication through the canonical Zoo Gateway identifier", () => {
+		const identifiers = providerIdentifiers as Record<string, string>
+		const originalIdentifier = identifiers.zooGateway!
+
+		try {
+			identifiers.zooGateway = "canonical-zoo-gateway"
+
+			expect(checkExistKey({ apiProvider: identifiers.zooGateway } as ProviderSettings, true)).toBe(true)
+		} finally {
+			identifiers.zooGateway = originalIdentifier
+		}
+	})
+
 	it("should return true for zoo-gateway when profile has zooSessionToken", () => {
 		const config: ProviderSettings = {
 			apiProvider: "zoo-gateway",

src/shared/checkExistApiConfig.ts

@@ -1,4 +1,4 @@
-import { SECRET_STATE_KEYS, GLOBAL_SECRET_KEYS, ProviderSettings } from "@roo-code/types"
+import { SECRET_STATE_KEYS, GLOBAL_SECRET_KEYS, providerIdentifiers, ProviderSettings } from "@roo-code/types"
 
 /**
  * Returns whether a provider profile is sufficiently configured to leave the
@@ -14,17 +14,22 @@ export function checkExistKey(config: ProviderSettings | undefined, zooCodeIsAut
 	}
 
 	// Special case for fake-ai, openai-codex, and qwen-code providers which don't need any configuration.
-	if (config.apiProvider && ["fake-ai", "openai-codex", "qwen-code"].includes(config.apiProvider)) {
+	const configurationFreeProviders: ProviderSettings["apiProvider"][] = [
+		providerIdentifiers.fakeAi,
+		providerIdentifiers.openaiCodex,
+		providerIdentifiers.qwenCode,
+	]
+	if (config.apiProvider && configurationFreeProviders.includes(config.apiProvider)) {
 		return true
 	}
 
-	if (config.apiProvider === "kimi-code" && (config.kimiCodeAuthMethod ?? "oauth") === "oauth") {
+	if (config.apiProvider === providerIdentifiers.kimiCode && (config.kimiCodeAuthMethod ?? "oauth") === "oauth") {
 		return true
 	}
 
 	// Zoo Gateway uses session auth (profile token and/or global Zoo Code login),
 	// not a traditional API key listed in SECRET_STATE_KEYS.
-	if (config.apiProvider === "zoo-gateway") {
+	if (config.apiProvider === providerIdentifiers.zooGateway) {
 		return Boolean(config.zooSessionToken) || Boolean(zooCodeIsAuthenticated)
 	}