lint(providers): enforce canonical identifiers

Add a focused ESLint rule for canonical providerIdentifiers usage, migrate remaining provider and embedding literals, and update production and test coverage.

Author: WebMad

pnpm-lock.yaml

@@ -0,0 +1,137 @@
+import { Linter } from "eslint"
+import typescriptParser from "@typescript-eslint/parser"
+import { describe, expect, it } from "vitest"
+
+import { noRawProviderIdentifiers } from "../eslint-rules/no-raw-provider-identifiers.mjs"
+
+const linter = new Linter({ configType: "eslintrc" })
+
+linter.defineRule("zoo/no-raw-provider-identifiers", noRawProviderIdentifiers)
+linter.defineParser("@typescript-eslint/parser", typescriptParser)
+
+function lint(code) {
+	return linter.verify(code, {
+		parserOptions: { ecmaVersion: 2022, sourceType: "module" },
+		rules: { "zoo/no-raw-provider-identifiers": "error" },
+	})
+}
+
+function lintTypeScript(code) {
+	return linter.verify(code, {
+		parser: "@typescript-eslint/parser",
+		parserOptions: {
+			ecmaVersion: 2022,
+			sourceType: "module",
+			warnOnUnsupportedTypeScriptVersion: false,
+		},
+		rules: { "zoo/no-raw-provider-identifiers": "error" },
+	})
+}
+
+describe("no-raw-provider-identifiers", () => {
+	it("rejects a canonical provider literal in an apiProvider property", () => {
+		const messages = lint('const config = { apiProvider: "poe" }')
+
+		expect(messages).toHaveLength(1)
+		expect(messages[0]).toMatchObject({
+			ruleId: "zoo/no-raw-provider-identifiers",
+			message: 'Use providerIdentifiers.poe instead of the raw provider identifier "poe".',
+		})
+	})
+
+	it("allows a non-canonical literal and a canonical registry member", () => {
+		expect(lint('const config = { apiProvider: "external-provider" }')).toHaveLength(0)
+		expect(lint("const config = { apiProvider: providerIdentifiers.poe }")).toHaveLength(0)
+	})
+
+	it("matches provider-like property names and static template literals", () => {
+		const messages = lint('const config = { provider: "poe", imageProvider: `openrouter` }')
+
+		expect(messages).toHaveLength(2)
+	})
+
+	it("allows an empty static template in a provider-like context", () => {
+		expect(lint("const config = { apiProvider: `` }")).toHaveLength(0)
+	})
+
+	it("rejects canonical literals in provider-like variable declarations", () => {
+		const messages = lint(`
+			const apiProvider = "poe"
+			let fallbackProvider = \`openrouter\`
+			const label = "poe"
+		`)
+
+		expect(messages.map(({ message }) => message)).toEqual([
+			'Use providerIdentifiers.poe instead of the raw provider identifier "poe".',
+			'Use providerIdentifiers.openrouter instead of the raw provider identifier "openrouter".',
+		])
+	})
+
+	it("rejects canonical provider literals wrapped in TypeScript expressions", () => {
+		const messages = lintTypeScript(`
+			const apiProvider = "poe" as ApiProvider
+			const fallbackProvider = "openrouter" satisfies ApiProvider
+			const imageProvider = <ApiProvider>"openai-native"
+			const nestedProvider = ("anthropic" as ApiProvider)!
+		`)
+
+		expect(messages.map(({ message }) => message)).toEqual([
+			'Use providerIdentifiers.poe instead of the raw provider identifier "poe".',
+			'Use providerIdentifiers.openrouter instead of the raw provider identifier "openrouter".',
+			'Use providerIdentifiers.openaiNative instead of the raw provider identifier "openai-native".',
+			'Use providerIdentifiers.anthropic instead of the raw provider identifier "anthropic".',
+		])
+	})
+
+	it("rejects canonical literals in provider-like class fields", () => {
+		const messages = lintTypeScript(`
+			class Settings {
+				apiProvider = "poe"
+				label = "openrouter"
+			}
+		`)
+
+		expect(messages.map(({ message }) => message)).toEqual([
+			'Use providerIdentifiers.poe instead of the raw provider identifier "poe".',
+		])
+	})
+
+	it("rejects canonical literals in provider-like assignments and comparisons", () => {
+		const messages = lint(`
+			config["apiProvider"] = "poe"
+			if (imageProvider === "openrouter") {}
+			if ("openai-native" !== config.fallbackProvider) {}
+		`)
+
+		expect(messages.map(({ message }) => message)).toEqual([
+			'Use providerIdentifiers.poe instead of the raw provider identifier "poe".',
+			'Use providerIdentifiers.openrouter instead of the raw provider identifier "openrouter".',
+			'Use providerIdentifiers.openaiNative instead of the raw provider identifier "openai-native".',
+		])
+	})
+
+	it("rejects canonical literals in provider-like switch cases", () => {
+		const messages = lint(`
+			switch (config.apiProvider) {
+				case "poe": break
+				case providerIdentifiers.openrouter: break
+			}
+		`)
+
+		expect(messages).toHaveLength(1)
+		expect(messages[0].message).toContain("providerIdentifiers.poe")
+	})
+
+	it("does not report canonical values outside provider-like contexts", () => {
+		const messages = lint(`
+			const label = "poe"
+			const config = { protocol: "anthropic", format: "openai" }
+			config[dynamicKey] = "poe"
+			if (apiProtocol === "anthropic") {}
+			if (provider > "poe") {}
+			switch (format) { case "openai": break }
+		`)
+
+		expect(messages).toHaveLength(0)
+	})
+})

src/__tests__/no-raw-provider-identifiers.spec.mjs

@@ -8,6 +8,7 @@ import { TaskScheduler } from "../core/task/TaskScheduler"
 import { type Task } from "../core/task/Task"
 import { API } from "../extension/api"
 import * as ProfileValidatorMod from "../shared/ProfileValidator"
+import { providerIdentifiers } from "@roo-code/types/provider-identifiers"
 
 type PrivateClineProviderMethods = {
 	createTask: (
@@ -45,7 +46,7 @@ vi.mock("../core/task/Task", () => {
 		}) {
 			this.taskId = opts.historyItem?.id ?? `task-${Math.random().toString(36).slice(2, 8)}`
 			this.parentTask = opts.parentTask
-			this.apiConfiguration = opts.apiConfiguration ?? { apiProvider: "anthropic" }
+			this.apiConfiguration = opts.apiConfiguration ?? { apiProvider: providerIdentifiers.anthropic }
 			opts.onCreated?.(this)
 		}
 		start() {}
@@ -86,7 +87,7 @@ describe("Single-open-task invariant", () => {
 			},
 			setValues: vi.fn(),
 			getState: vi.fn().mockResolvedValue({
-				apiConfiguration: { apiProvider: "anthropic", consecutiveMistakeLimit: 0 },
+				apiConfiguration: { apiProvider: providerIdentifiers.anthropic, consecutiveMistakeLimit: 0 },
 				organizationAllowList: "*",
 				enableCheckpoints: true,
 				checkpointTimeout: 60,
@@ -130,7 +131,7 @@ describe("Single-open-task invariant", () => {
 			taskScheduler: new TaskScheduler(),
 			setValues: vi.fn(),
 			getState: vi.fn().mockResolvedValue({
-				apiConfiguration: { apiProvider: "anthropic", consecutiveMistakeLimit: 0 },
+				apiConfiguration: { apiProvider: providerIdentifiers.anthropic, consecutiveMistakeLimit: 0 },
 				organizationAllowList: "*",
 				enableCheckpoints: true,
 				checkpointTimeout: 60,
@@ -182,7 +183,7 @@ describe("Single-open-task invariant", () => {
 				listConfig: vi.fn().mockResolvedValue([]),
 			},
 			getState: vi.fn().mockResolvedValue({
-				apiConfiguration: { apiProvider: "anthropic", consecutiveMistakeLimit: 0 },
+				apiConfiguration: { apiProvider: providerIdentifiers.anthropic, consecutiveMistakeLimit: 0 },
 				enableCheckpoints: true,
 				checkpointTimeout: 60,
 				experiments: {},
@@ -256,7 +257,7 @@ describe("Single-open-task invariant", () => {
 				listConfig: vi.fn().mockResolvedValue([]),
 			},
 			getState: vi.fn().mockResolvedValue({
-				apiConfiguration: { apiProvider: "anthropic", consecutiveMistakeLimit: 0 },
+				apiConfiguration: { apiProvider: providerIdentifiers.anthropic, consecutiveMistakeLimit: 0 },
 				enableCheckpoints: true,
 				checkpointTimeout: 60,
 				experiments: {},
@@ -328,7 +329,7 @@ describe("Single-open-task invariant", () => {
 				listConfig: vi.fn().mockResolvedValue([]),
 			},
 			getState: vi.fn().mockResolvedValue({
-				apiConfiguration: { apiProvider: "anthropic", consecutiveMistakeLimit: 0 },
+				apiConfiguration: { apiProvider: providerIdentifiers.anthropic, consecutiveMistakeLimit: 0 },
 				enableCheckpoints: true,
 				checkpointTimeout: 60,
 				experiments: {},

src/__tests__/single-open-invariant.spec.ts

@@ -5,6 +5,7 @@ import { BedrockRuntimeClient, ConverseStreamCommand } from "@aws-sdk/client-bed
 import { logger } from "../../../utils/logging"
 
 import { clearAllMocks } from "../../../test-utils/reset"
+import { providerIdentifiers } from "@roo-code/types/provider-identifiers"
 
 // Mock the AWS SDK
 vi.mock("@aws-sdk/client-bedrock-runtime")
@@ -45,7 +46,7 @@ describe("AwsBedrockHandler - Extended Thinking", () => {
 	describe("Extended Thinking Support", () => {
 		it("should include thinking parameter for Claude Sonnet 4 when reasoning is enabled", async () => {
 			handler = new AwsBedrockHandler({
-				apiProvider: "bedrock",
+				apiProvider: providerIdentifiers.bedrock,
 				apiModelId: "anthropic.claude-sonnet-4-20250514-v1:0",
 				awsRegion: "us-east-1",
 				enableReasoningEffort: true,
@@ -113,7 +114,7 @@ describe("AwsBedrockHandler - Extended Thinking", () => {
 
 		it("should pass thinking parameters from metadata", async () => {
 			handler = new AwsBedrockHandler({
-				apiProvider: "bedrock",
+				apiProvider: providerIdentifiers.bedrock,
 				apiModelId: "anthropic.claude-3-7-sonnet-20250219-v1:0",
 				awsRegion: "us-east-1",
 			})
@@ -156,7 +157,7 @@ describe("AwsBedrockHandler - Extended Thinking", () => {
 
 		it("should log when extended thinking is enabled", async () => {
 			handler = new AwsBedrockHandler({
-				apiProvider: "bedrock",
+				apiProvider: providerIdentifiers.bedrock,
 				apiModelId: "anthropic.claude-opus-4-20250514-v1:0",
 				awsRegion: "us-east-1",
 				enableReasoningEffort: true,
@@ -188,7 +189,7 @@ describe("AwsBedrockHandler - Extended Thinking", () => {
 
 		it("should not include topP when thinking is disabled (global removal)", async () => {
 			handler = new AwsBedrockHandler({
-				apiProvider: "bedrock",
+				apiProvider: providerIdentifiers.bedrock,
 				apiModelId: "anthropic.claude-3-7-sonnet-20250219-v1:0",
 				awsRegion: "us-east-1",
 				// Note: no enableReasoningEffort = true, so thinking is disabled
@@ -234,7 +235,7 @@ describe("AwsBedrockHandler - Extended Thinking", () => {
 
 		it("should enable reasoning when enableReasoningEffort is true in settings", async () => {
 			handler = new AwsBedrockHandler({
-				apiProvider: "bedrock",
+				apiProvider: providerIdentifiers.bedrock,
 				apiModelId: "anthropic.claude-sonnet-4-20250514-v1:0",
 				awsRegion: "us-east-1",
 				enableReasoningEffort: true, // This should trigger reasoning
@@ -288,7 +289,7 @@ describe("AwsBedrockHandler - Extended Thinking", () => {
 
 		it("should support API key authentication", async () => {
 			handler = new AwsBedrockHandler({
-				apiProvider: "bedrock",
+				apiProvider: providerIdentifiers.bedrock,
 				apiModelId: "anthropic.claude-3-5-sonnet-20241022-v2:0",
 				awsRegion: "us-east-1",
 				awsUseApiKey: true,

src/api/providers/__tests__/bedrock-reasoning.spec.ts

@@ -10,6 +10,7 @@ import { getModelMaxOutputTokens } from "../../../shared/api"
 import { FriendliHandler } from "../friendli"
 import { asyncStreamFrom, collectStream } from "../../../test-utils/stream"
 import { clearAllMocks } from "../../../test-utils/reset"
+import { providerIdentifiers } from "@roo-code/types/provider-identifiers"
 
 // Create mock functions
 const mockCreate = vi.fn()
@@ -324,7 +325,7 @@ describe("FriendliHandler", () => {
 
 describe("buildApiHandler friendli wiring", () => {
 	it("returns a FriendliHandler for apiProvider='friendli'", () => {
-		const handler = buildApiHandler({ apiProvider: "friendli", friendliApiKey: "test-key" })
+		const handler = buildApiHandler({ apiProvider: providerIdentifiers.friendli, friendliApiKey: "test-key" })
 		expect(handler).toBeInstanceOf(FriendliHandler)
 	})
 })
@@ -335,7 +336,7 @@ describe("Friendli model max output tokens (clamping behavior)", () => {
 		const result = getModelMaxOutputTokens({
 			modelId: "zai-org/GLM-5.2",
 			model,
-			settings: { apiProvider: "friendli" },
+			settings: { apiProvider: providerIdentifiers.friendli },
 			format: "openai",
 		})
 		// 1_000_000 * 0.2 = 200_000 > 131_072 → no clamping
@@ -347,7 +348,7 @@ describe("Friendli model max output tokens (clamping behavior)", () => {
 		const result = getModelMaxOutputTokens({
 			modelId: "zai-org/GLM-5.1",
 			model,
-			settings: { apiProvider: "friendli" },
+			settings: { apiProvider: providerIdentifiers.friendli },
 			format: "openai",
 		})
 		// 200_000 * 0.2 = 40_000 < 131_072 → clamped to 40_000
@@ -359,7 +360,7 @@ describe("Friendli model max output tokens (clamping behavior)", () => {
 		const result = getModelMaxOutputTokens({
 			modelId: "zai-org/GLM-5.1",
 			model,
-			settings: { apiProvider: "friendli", modelMaxTokens: 80_000 },
+			settings: { apiProvider: providerIdentifiers.friendli, modelMaxTokens: 80_000 },
 			format: "openai",
 		})
 		// supportsMaxTokens=true, user set 80k, model ceiling 131072 → min(80000, 131072) = 80000