refactor: delegate provider checking to AIService in getPreferredNameModel

- Changed getPreferredNameModel to async, calls aiService.createModel()
  to test if models are available instead of duplicating API key logic
- Removes dependency on Config, avoiding duplication of provider-specific
  env var checking (ANTHROPIC_API_KEY, ANTHROPIC_AUTH_TOKEN, etc.)
- Updated tests to use mock AIService instead of mock Config
- Single source of truth for provider availability in AIService

Author: ammar-agent

src/node/orpc/router.ts

@@ -174,7 +174,7 @@ export const router = (authToken?: string) => {
         .input(schemas.nameGeneration.generate.input)
         .output(schemas.nameGeneration.generate.output)
         .handler(async ({ context, input }) => {
-          const model = getPreferredNameModel(context.config);
+          const model = await getPreferredNameModel(context.aiService);
           if (!model) {
             return {
               success: false,

src/node/services/workspaceTitleGenerator.test.ts

@@ -1,59 +1,38 @@
 import { describe, it, expect } from "bun:test";
 import { getPreferredNameModel } from "./workspaceTitleGenerator";
-import type { Config } from "@/node/config";
+import type { AIService } from "./aiService";
+import { getKnownModel } from "@/common/constants/knownModels";
+
+// Helper to create a mock AIService that succeeds for specific models
+function createMockAIService(availableModels: string[]): AIService {
+  return {
+    createModel: async (modelString: string) => {
+      if (availableModels.includes(modelString)) {
+        return { success: true, data: {} as never };
+      }
+      return { success: false, error: { type: "api_key_not_found", provider: "test" } };
+    },
+  } as unknown as AIService;
+}
 
 describe("workspaceTitleGenerator", () => {
-  it("getPreferredNameModel returns null when no providers configured", () => {
-    // Save and clear env vars
-    const savedAnthropicKey = process.env.ANTHROPIC_API_KEY;
-    const savedAnthropicToken = process.env.ANTHROPIC_AUTH_TOKEN;
-    delete process.env.ANTHROPIC_API_KEY;
-    delete process.env.ANTHROPIC_AUTH_TOKEN;
+  const HAIKU_ID = getKnownModel("HAIKU").id;
+  const GPT_MINI_ID = getKnownModel("GPT_MINI").id;
 
-    try {
-      const mockConfig = {
-        loadProvidersConfig: () => null,
-      } as unknown as Config;
-
-      expect(getPreferredNameModel(mockConfig)).toBeNull();
-    } finally {
-      // Restore env vars
-      if (savedAnthropicKey) process.env.ANTHROPIC_API_KEY = savedAnthropicKey;
-      if (savedAnthropicToken) process.env.ANTHROPIC_AUTH_TOKEN = savedAnthropicToken;
-    }
+  it("getPreferredNameModel returns null when no models available", async () => {
+    const aiService = createMockAIService([]);
+    expect(await getPreferredNameModel(aiService)).toBeNull();
   });
 
-  it("getPreferredNameModel prefers anthropic when configured", () => {
-    const mockConfig = {
-      loadProvidersConfig: () => ({
-        anthropic: { apiKey: "test-key" },
-      }),
-    } as unknown as Config;
-
-    const model = getPreferredNameModel(mockConfig);
-    expect(model).toContain("anthropic");
+  it("getPreferredNameModel prefers Haiku when available", async () => {
+    const aiService = createMockAIService([HAIKU_ID, GPT_MINI_ID]);
+    const model = await getPreferredNameModel(aiService);
+    expect(model).toBe(HAIKU_ID);
   });
 
-  it("getPreferredNameModel falls back to openai when anthropic not configured", () => {
-    // Save and clear env vars
-    const savedAnthropicKey = process.env.ANTHROPIC_API_KEY;
-    const savedAnthropicToken = process.env.ANTHROPIC_AUTH_TOKEN;
-    delete process.env.ANTHROPIC_API_KEY;
-    delete process.env.ANTHROPIC_AUTH_TOKEN;
-
-    try {
-      const mockConfig = {
-        loadProvidersConfig: () => ({
-          openai: { apiKey: "test-key" },
-        }),
-      } as unknown as Config;
-
-      const model = getPreferredNameModel(mockConfig);
-      expect(model).toContain("openai");
-    } finally {
-      // Restore env vars
-      if (savedAnthropicKey) process.env.ANTHROPIC_API_KEY = savedAnthropicKey;
-      if (savedAnthropicToken) process.env.ANTHROPIC_AUTH_TOKEN = savedAnthropicToken;
-    }
+  it("getPreferredNameModel falls back to GPT Mini when Haiku unavailable", async () => {
+    const aiService = createMockAIService([GPT_MINI_ID]);
+    const model = await getPreferredNameModel(aiService);
+    expect(model).toBe(GPT_MINI_ID);
   });
 });

src/node/services/workspaceTitleGenerator.ts

@@ -1,7 +1,6 @@
 import { generateObject } from "ai";
 import { z } from "zod";
 import type { AIService } from "./aiService";
-import type { Config } from "@/node/config";
 import { log } from "./log";
 import type { Result } from "@/common/types/result";
 import { Ok, Err } from "@/common/types/result";
@@ -21,20 +20,17 @@ const workspaceNameSchema = z.object({
 });
 
 /**
- * Get the preferred model for name generation based on configured providers.
+ * Get the preferred model for name generation by testing which models the AIService
+ * can actually create. This delegates credential checking to AIService, avoiding
+ * duplication of provider-specific API key logic.
  */
-export function getPreferredNameModel(config: Config): string | null {
-  const providersConfig = config.loadProvidersConfig();
+export async function getPreferredNameModel(aiService: AIService): Promise<string | null> {
   for (const modelId of PREFERRED_MODELS) {
-    const provider = modelId.split(":")[0];
-    const providerConfig = providersConfig?.[provider];
-    const hasKey = providerConfig
-      ? !!(providerConfig as { apiKey?: string }).apiKey
-      : provider === "anthropic" &&
-        !!(process.env.ANTHROPIC_API_KEY ?? process.env.ANTHROPIC_AUTH_TOKEN);
-    if (hasKey) {
+    const result = await aiService.createModel(modelId);
+    if (result.success) {
       return modelId;
     }
+    // If it's an API key error, try the next model; other errors are also skipped
   }
   return null;
 }