🤖 refactor: centralize provider registry to prevent desync bugs

Problem: When adding OpenRouter, had to manually update PROVIDERS_LIST in
ipcMain.ts. This created a class of bugs where a provider could be
implemented in aiService but forgotten in the UI providers list.

Solution:
- Created src/constants/providers.ts with SUPPORTED_PROVIDERS constant
- Single source of truth for all provider names
- ipcMain.ts now uses [...SUPPORTED_PROVIDERS] instead of hardcoded list
- Added runtime check in aiService.ts to validate provider is supported
- Added unit tests for provider registry validation

Benefits:
- Adding a new provider only requires updating SUPPORTED_PROVIDERS
- Runtime check prevents silent failures if handler not implemented
- Type-safe with ProviderName type and isValidProvider() guard
- Impossible to have provider in list but not in implementation

Addresses Codex P1 comment about exposing OpenRouter in providers list.

Author: ammar-agent

src/constants/providers.test.ts

@@ -0,0 +1,26 @@
+/**
+ * Test that SUPPORTED_PROVIDERS stays in sync
+ */
+
+import { describe, test, expect } from "bun:test";
+import { SUPPORTED_PROVIDERS, isValidProvider } from "./providers";
+
+describe("Provider Registry", () => {
+  test("SUPPORTED_PROVIDERS includes all expected providers", () => {
+    const expected = ["anthropic", "openai", "ollama", "openrouter"];
+    expect(SUPPORTED_PROVIDERS).toEqual(expected);
+  });
+
+  test("isValidProvider correctly identifies valid providers", () => {
+    expect(isValidProvider("anthropic")).toBe(true);
+    expect(isValidProvider("openai")).toBe(true);
+    expect(isValidProvider("ollama")).toBe(true);
+    expect(isValidProvider("openrouter")).toBe(true);
+  });
+
+  test("isValidProvider rejects invalid providers", () => {
+    expect(isValidProvider("invalid")).toBe(false);
+    expect(isValidProvider("")).toBe(false);
+    expect(isValidProvider("gpt-4")).toBe(false);
+  });
+});

src/constants/providers.ts

@@ -0,0 +1,47 @@
+/**
+ * Centralized provider registry
+ *
+ * All supported AI providers must be listed here. This prevents bugs where
+ * a new provider is added to aiService but forgotten in PROVIDERS_LIST.
+ *
+ * When adding a new provider:
+ * 1. Add the provider name to this array
+ * 2. Implement provider handling in aiService.ts getModel()
+ * 3. The test in aiService will fail if not all providers are handled
+ */
+export const SUPPORTED_PROVIDERS = [
+  "anthropic",
+  "openai",
+  "ollama",
+  "openrouter",
+] as const;
+
+/**
+ * Union type of all supported provider names
+ */
+export type ProviderName = (typeof SUPPORTED_PROVIDERS)[number];
+
+/**
+ * Type guard to check if a string is a valid provider name
+ */
+export function isValidProvider(provider: string): provider is ProviderName {
+  return SUPPORTED_PROVIDERS.includes(provider as ProviderName);
+}
+
+/**
+ * Assert exhaustiveness at compile-time for switch/if-else chains
+ *
+ * Usage:
+ * ```ts
+ * if (provider === 'anthropic') { ... }
+ * else if (provider === 'openai') { ... }
+ * else if (provider === 'ollama') { ... }
+ * else if (provider === 'openrouter') { ... }
+ * else {
+ *   assertExhaustive(provider); // TypeScript error if a case is missing
+ * }
+ * ```
+ */
+export function assertExhaustive(value: never): never {
+  throw new Error(`Unhandled provider case: ${value}`);
+}

src/services/aiService.ts

@@ -7,6 +7,7 @@ import { sanitizeToolInputs } from "@/utils/messages/sanitizeToolInput";
 import type { Result } from "@/types/result";
 import { Ok, Err } from "@/types/result";
 import type { WorkspaceMetadata } from "@/types/workspace";
+import { SUPPORTED_PROVIDERS, type ProviderName } from "@/constants/providers";
 
 import type { CmuxMessage, CmuxTextPart } from "@/types/message";
 import { createCmuxMessage } from "@/types/message";
@@ -261,6 +262,15 @@ export class AIService extends EventEmitter {
         });
       }
 
+      // Check if provider is supported (prevents silent failures when adding to SUPPORTED_PROVIDERS
+      // but forgetting to implement handler below)
+      if (!SUPPORTED_PROVIDERS.includes(providerName as ProviderName)) {
+        return Err({
+          type: "provider_not_supported",
+          provider: providerName,
+        });
+      }
+
       // Load providers configuration - the ONLY source of truth
       const providersConfig = this.config.loadProvidersConfig();
       let providerConfig = providersConfig?.[providerName] ?? {};

src/services/ipcMain.ts

@@ -14,6 +14,7 @@ import { log } from "@/services/log";
 import { countTokens, countTokensBatch } from "@/utils/main/tokenizer";
 import { calculateTokenStats } from "@/utils/tokens/tokenStatsCalculator";
 import { IPC_CHANNELS, getChatChannel } from "@/constants/ipc-constants";
+import { SUPPORTED_PROVIDERS } from "@/constants/providers";
 import type { SendMessageError } from "@/types/errors";
 import type { SendMessageOptions, DeleteMessage } from "@/types/ipc";
 import { Ok, Err } from "@/types/result";
@@ -1120,9 +1121,9 @@ export class IpcMain {
 
     ipcMain.handle(IPC_CHANNELS.PROVIDERS_LIST, () => {
       try {
-        // Return all supported providers, not just configured ones
-        // This matches the providers defined in the registry
-        return ["anthropic", "openai"];
+        // Return all supported providers from centralized registry
+        // This automatically stays in sync as new providers are added
+        return [...SUPPORTED_PROVIDERS];
       } catch (error) {
         log.error("Failed to list providers:", error);
         return [];