fix: address provider identifier review feedback

Author: WebMad

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

@@ -1,4 +1,4 @@
-import { getApiProtocol, providerIdentifiers, type ProviderName } from "../index.js"
+import { getApiProtocol, providerIdentifiers } from "../index.js"
 
 describe("getApiProtocol", () => {
 	describe("Anthropic-style providers", () => {
@@ -15,21 +15,8 @@ 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(providerIdentifiers.vertex, "claude-3-opus")).toBe("anthropic")
 			expect(getApiProtocol("vertex", "Claude-3-Sonnet")).toBe("anthropic")
 			expect(getApiProtocol("vertex", "CLAUDE-instant")).toBe("anthropic")
 			expect(getApiProtocol("vertex", "anthropic/claude-3-haiku")).toBe("anthropic")
@@ -48,24 +35,8 @@ 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
-			}
+			expect(getApiProtocol(providerIdentifiers.vercelAiGateway, "anthropic/claude-3-opus")).toBe("anthropic")
+			expect(getApiProtocol(providerIdentifiers.zooGateway, "anthropic/claude-3-opus")).toBe("anthropic")
 		})
 
 		it("should return 'anthropic' for vercel-ai-gateway provider with anthropic models", () => {
@@ -88,21 +59,8 @@ 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(providerIdentifiers.opencodeGo, "qwen3.7-max")).toBe("anthropic")
 			expect(getApiProtocol("opencode-go", "qwen3.7-plus")).toBe("anthropic")
 			expect(getApiProtocol("opencode-go", "qwen3.6-plus")).toBe("anthropic")
 			expect(getApiProtocol("opencode-go", "minimax-m3")).toBe("anthropic")

packages/types/src/provider-settings.ts

@@ -587,21 +587,33 @@ export const ANTHROPIC_STYLE_PROVIDERS: ProviderName[] = [
 	providerIdentifiers.minimax,
 ]
 
+const CLAUDE_MODEL_ID_FRAGMENT = "claude"
+const ANTHROPIC_MODEL_ID_PREFIX = "anthropic/"
+const ANTHROPIC_MODEL_GATEWAY_PROVIDERS: ProviderName[] = [
+	providerIdentifiers.vercelAiGateway,
+	providerIdentifiers.zooGateway,
+]
+
 export const getApiProtocol = (provider: ProviderName | undefined, modelId?: string): "anthropic" | "openai" => {
 	if (provider && ANTHROPIC_STYLE_PROVIDERS.includes(provider)) {
 		return "anthropic"
 	}
 
-	if (provider && provider === providerIdentifiers.vertex && modelId && modelId.toLowerCase().includes("claude")) {
+	if (
+		provider &&
+		provider === providerIdentifiers.vertex &&
+		modelId &&
+		modelId.toLowerCase().includes(CLAUDE_MODEL_ID_FRAGMENT)
+	) {
 		return "anthropic"
 	}
 
 	// Vercel AI Gateway and Zoo Gateway use the anthropic protocol for anthropic models.
 	if (
 		provider &&
-		(provider === providerIdentifiers.vercelAiGateway || provider === providerIdentifiers.zooGateway) &&
+		ANTHROPIC_MODEL_GATEWAY_PROVIDERS.includes(provider) &&
 		modelId &&
-		modelId.toLowerCase().startsWith("anthropic/")
+		modelId.toLowerCase().startsWith(ANTHROPIC_MODEL_ID_PREFIX)
 	) {
 		return "anthropic"
 	}

src/shared/__tests__/checkExistApiConfig.spec.ts

@@ -67,16 +67,7 @@ describe("checkExistKey", () => {
 	})
 
 	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
-		}
+		expect(checkExistKey({ apiProvider: providerIdentifiers.fakeAi })).toBe(true)
 	})
 
 	it("should return true for openai-codex provider without API key", () => {
@@ -109,18 +100,7 @@ describe("checkExistKey", () => {
 	})
 
 	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
-		}
+		expect(checkExistKey({ apiProvider: providerIdentifiers.kimiCode, kimiCodeAuthMethod: "oauth" })).toBe(true)
 	})
 
 	it("should return true for kimi-code provider without auth method (defaults to OAuth)", () => {
@@ -157,16 +137,7 @@ describe("checkExistKey", () => {
 	})
 
 	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
-		}
+		expect(checkExistKey({ apiProvider: providerIdentifiers.zooGateway }, true)).toBe(true)
 	})
 
 	it("should return true for zoo-gateway when profile has zooSessionToken", () => {