🤖 fix: auto-naming works with mux-gateway

When users only have mux-gateway configured (no direct Anthropic/OpenAI API
keys), getPreferredNameModel now tries gateway versions of preferred models.

The fix:
1. Frontend passes `useGateway: boolean` based on whether gateway is configured
2. Backend tries gateway versions of preferred models only when useGateway=true
3. Still prefers direct access when available for lower latency

This ensures auto-naming works for gateway-only users while maintaining
optimal performance for users with direct API keys.

---
_Generated with `mux` • Model: `anthropic:claude-opus-4-5` • Thinking: `high`_

Author: ammar-agent

src/browser/hooks/useWorkspaceName.ts

@@ -1,5 +1,6 @@
 import { useState, useRef, useCallback, useEffect, useMemo } from "react";
 import { useAPI } from "@/browser/contexts/API";
+import { useGateway } from "@/browser/hooks/useGatewayModels";
 
 export interface UseWorkspaceNameOptions {
   /** The user's message to generate a name for */
@@ -51,6 +52,7 @@ export interface UseWorkspaceNameReturn extends WorkspaceNameState {
 export function useWorkspaceName(options: UseWorkspaceNameOptions): UseWorkspaceNameReturn {
   const { message, debounceMs = 500, fallbackModel } = options;
   const { api } = useAPI();
+  const { isActive: gatewayActive } = useGateway();
 
   // Generated identity (name + title) from AI
   const [generatedIdentity, setGeneratedIdentity] = useState<WorkspaceIdentity | null>(null);
@@ -121,6 +123,7 @@ export function useWorkspaceName(options: UseWorkspaceNameOptions): UseWorkspace
         const result = await api.nameGeneration.generate({
           message: forMessage,
           fallbackModel,
+          useGateway: gatewayActive,
         });
 
         // Check if this request is still current (wasn't cancelled)
@@ -162,7 +165,7 @@ export function useWorkspaceName(options: UseWorkspaceNameOptions): UseWorkspace
         }
       }
     },
-    [api, fallbackModel]
+    [api, fallbackModel, gatewayActive]
   );
 
   // Debounced generation effect

src/common/orpc/schemas/api.ts

@@ -487,6 +487,8 @@ export const nameGeneration = {
       message: z.string(),
       /** Model to use if preferred small models (Haiku, GPT-Mini) aren't available */
       fallbackModel: z.string().optional(),
+      /** Whether to try mux-gateway versions of preferred models (set by frontend based on config) */
+      useGateway: z.boolean().optional(),
     }),
     output: ResultSchema(
       z.object({

src/node/orpc/router.ts

@@ -522,7 +522,9 @@ export const router = (authToken?: string) => {
         .output(schemas.nameGeneration.generate.output)
         .handler(async ({ context, input }) => {
           // Prefer small/fast models, fall back to user's configured model
-          const model = (await getPreferredNameModel(context.aiService)) ?? input.fallbackModel;
+          const model =
+            (await getPreferredNameModel(context.aiService, input.useGateway)) ??
+            input.fallbackModel;
           if (!model) {
             return {
               success: false,

src/node/services/workspaceTitleGenerator.test.ts

@@ -30,6 +30,9 @@ function createMockAIService(availableModels: string[]): AIService {
 describe("workspaceTitleGenerator", () => {
   const HAIKU_ID = getKnownModel("HAIKU").id;
   const GPT_MINI_ID = getKnownModel("GPT_MINI").id;
+  // Gateway format: mux-gateway:provider/model instead of provider:model
+  const HAIKU_GATEWAY = "mux-gateway:anthropic/claude-haiku-4-5";
+  const GPT_MINI_GATEWAY = "mux-gateway:openai/gpt-5.1-codex-mini";
 
   it("getPreferredNameModel returns null when no models available", async () => {
     const aiService = createMockAIService([]);
@@ -47,4 +50,32 @@ describe("workspaceTitleGenerator", () => {
     const model = await getPreferredNameModel(aiService);
     expect(model).toBe(GPT_MINI_ID);
   });
+
+  it("getPreferredNameModel uses gateway Haiku when direct is unavailable and useGateway=true", async () => {
+    // User has mux-gateway configured but no direct Anthropic/OpenAI API keys
+    const aiService = createMockAIService([HAIKU_GATEWAY, GPT_MINI_GATEWAY]);
+    const model = await getPreferredNameModel(aiService, true);
+    expect(model).toBe(HAIKU_GATEWAY);
+  });
+
+  it("getPreferredNameModel falls back to gateway GPT Mini when useGateway=true", async () => {
+    // Only GPT Mini available via gateway
+    const aiService = createMockAIService([GPT_MINI_GATEWAY]);
+    const model = await getPreferredNameModel(aiService, true);
+    expect(model).toBe(GPT_MINI_GATEWAY);
+  });
+
+  it("getPreferredNameModel prefers direct over gateway", async () => {
+    // Both direct and gateway available - should prefer direct
+    const aiService = createMockAIService([HAIKU_ID, HAIKU_GATEWAY]);
+    const model = await getPreferredNameModel(aiService, true);
+    expect(model).toBe(HAIKU_ID);
+  });
+
+  it("getPreferredNameModel ignores gateway models when useGateway=false", async () => {
+    // Gateway models available but useGateway not set - should return null
+    const aiService = createMockAIService([HAIKU_GATEWAY, GPT_MINI_GATEWAY]);
+    expect(await getPreferredNameModel(aiService)).toBeNull();
+    expect(await getPreferredNameModel(aiService, false)).toBeNull();
+  });
 });

src/node/services/workspaceTitleGenerator.ts

@@ -11,6 +11,16 @@ import crypto from "crypto";
 /** Models to try in order of preference for name generation (small, fast models) */
 const PREFERRED_MODELS = [getKnownModel("HAIKU").id, getKnownModel("GPT_MINI").id] as const;
 
+/**
+ * Convert a canonical model string (provider:model) to mux-gateway format.
+ * Example: "anthropic:claude-haiku-4-5" → "mux-gateway:anthropic/claude-haiku-4-5"
+ */
+function toGatewayModel(modelId: string): string {
+  const [provider, model] = modelId.split(":", 2);
+  if (!provider || !model) return modelId;
+  return `mux-gateway:${provider}/${model}`;
+}
+
 /** Schema for AI-generated workspace identity (area name + descriptive title) */
 const workspaceIdentitySchema = z.object({
   name: z
@@ -39,14 +49,29 @@ export interface WorkspaceIdentity {
  * 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.
+ *
+ * @param useGateway - If true, also try mux-gateway versions of preferred models.
+ *   This should be set by the frontend based on whether the user has gateway configured.
  */
-export async function getPreferredNameModel(aiService: AIService): Promise<string | null> {
+export async function getPreferredNameModel(
+  aiService: AIService,
+  useGateway?: boolean
+): Promise<string | null> {
   for (const modelId of PREFERRED_MODELS) {
-    const result = await aiService.createModel(modelId);
-    if (result.success) {
+    // Try direct provider access first
+    const directResult = await aiService.createModel(modelId);
+    if (directResult.success) {
       return modelId;
     }
-    // If it's an API key error, try the next model; other errors are also skipped
+
+    // Try via mux-gateway if the frontend indicates it's available
+    if (useGateway) {
+      const gatewayModelId = toGatewayModel(modelId);
+      const gatewayResult = await aiService.createModel(gatewayModelId);
+      if (gatewayResult.success) {
+        return gatewayModelId;
+      }
+    }
   }
   return null;
 }