fix(desktop): auto-name workspaces after setup completes

apps/desktop/src/lib/trpc/routers/workspaces/procedures/create.ts

@@ -5,7 +5,7 @@ import { localDb } from "main/lib/local-db";
 import { workspaceInitManager } from "main/lib/workspace-init-manager";
 import { z } from "zod";
 import { publicProcedure, router } from "../../..";
-import { generateWorkspaceNameFromPrompt } from "../utils/ai-name";
+import { attemptWorkspaceAutoRenameFromPrompt } from "../utils/ai-name";
 import { resolveWorkspaceBaseBranch } from "../utils/base-branch";
 import { setBranchBaseConfig } from "../utils/base-branch-config";
 import {
@@ -290,6 +290,7 @@ export const createCreateProcedures = () => {
 				z.object({
 					projectId: z.string(),
 					name: z.string().optional(),
+					prompt: z.string().optional(),
 					branchName: z.string().optional(),
 					baseBranch: z.string().optional(),
 					useExistingBranch: z.boolean().optional(),
@@ -411,6 +412,24 @@ export const createCreateProcedures = () => {
 							branch,
 							name: input.name ?? branch,
 						});
+						let autoRenameWarning: string | undefined;
+						try {
+							const autoRenameResult =
+								await attemptWorkspaceAutoRenameFromPrompt({
+									workspaceId: workspace.id,
+									prompt: input.prompt,
+								});
+							autoRenameWarning =
+								autoRenameResult.status === "skipped"
+									? autoRenameResult.warning
+									: undefined;
+						} catch (error) {
+							console.warn("[workspaces/create] Auto naming failed", {
+								workspaceId: workspace.id,
+								error: error instanceof Error ? error.message : String(error),
+							});
+							autoRenameWarning = "Couldn't auto-name this workspace.";
+						}
 						activateProject(project);
 						const setupConfig = loadSetupConfig({
 							mainRepoPath: project.mainRepoPath,
@@ -423,6 +442,7 @@ export const createCreateProcedures = () => {
 							worktreePath: orphanedWorktree.path,
 							projectId: project.id,
 							isInitializing: false,
+							autoRenameWarning,
 							wasExisting: true,
 						};
 					}
@@ -491,6 +511,7 @@ export const createCreateProcedures = () => {
 					worktreePath,
 					branch,
 					mainRepoPath: project.mainRepoPath,
+					namingPrompt: input.prompt,
 					useExistingBranch: input.useExistingBranch,
 				});
 
@@ -952,14 +973,6 @@ export const createCreateProcedures = () => {
 					workspaceName,
 				});
 			}),
-
-		generateName: publicProcedure
-			.input(z.object({ prompt: z.string().min(1) }))
-			.mutation(async ({ input }) => {
-				const name = await generateWorkspaceNameFromPrompt(input.prompt);
-				return { name };
-			}),
-
 		importAllWorktrees: publicProcedure
 			.input(z.object({ projectId: z.string() }))
 			.mutation(async ({ input }) => {

apps/desktop/src/lib/trpc/routers/workspaces/utils/ai-name.ts

@@ -1,71 +1,86 @@
 import { createAnthropic } from "@ai-sdk/anthropic";
 import { createOpenAI } from "@ai-sdk/openai";
-import { Agent } from "@mastra/core/agent";
+import type { Agent } from "@mastra/core/agent";
 import {
+	generateTitleFromMessage,
 	getCredentialsFromAnySource as getAnthropicCredentialsFromAnySource,
+	getAnthropicProviderOptions,
 	getOpenAICredentialsFromAnySource,
 } from "@superset/chat/host";
+import { workspaces } from "@superset/local-db";
+import { and, eq, isNull } from "drizzle-orm";
+import { localDb } from "main/lib/local-db";
+import { getWorkspaceAutoRenameDecision } from "./workspace-auto-rename";
+
+export type WorkspaceAutoRenameResult =
+	| { status: "renamed"; name: string }
+	| {
+			status: "skipped";
+			reason:
+				| "empty-prompt"
+				| "missing-credentials"
+				| "generation-failed"
+				| "missing-workspace"
+				| "empty-generated-name"
+				| "workspace-deleting"
+				| "workspace-named"
+				| "workspace-name-changed";
+			warning?: string;
+	  };
 
 type AgentModel = ConstructorParameters<typeof Agent>[0]["model"];
+type AnthropicCredentials = NonNullable<
+	ReturnType<typeof getAnthropicCredentialsFromAnySource>
+>;
+type OpenAICredentials = NonNullable<
+	ReturnType<typeof getOpenAICredentialsFromAnySource>
+>;
 
 interface TitleProvider {
 	name: "Anthropic" | "OpenAI";
 	agentId: string;
-	resolveApiKey: () => string | null;
-	createModel: (apiKey: string) => AgentModel;
+	resolveCredentials: () => AnthropicCredentials | OpenAICredentials | null;
+	createModel: (
+		credentials: AnthropicCredentials | OpenAICredentials,
+	) => AgentModel;
 }
 
 const TITLE_PROVIDERS: TitleProvider[] = [
 	{
 		name: "Anthropic",
 		agentId: "workspace-namer-anthropic",
-		resolveApiKey: () => getAnthropicCredentialsFromAnySource()?.apiKey ?? null,
-		createModel: (apiKey) =>
-			createAnthropic({ apiKey })("claude-haiku-4-5-20251001"),
+		resolveCredentials: () => getAnthropicCredentialsFromAnySource(),
+		createModel: (credentials) =>
+			createAnthropic(getAnthropicProviderOptions(credentials))(
+				"claude-haiku-4-5-20251001",
+			),
 	},
 	{
 		name: "OpenAI",
 		agentId: "workspace-namer-openai",
-		resolveApiKey: () => getOpenAICredentialsFromAnySource()?.apiKey ?? null,
-		createModel: (apiKey) => createOpenAI({ apiKey })("gpt-4o-mini"),
+		resolveCredentials: () => getOpenAICredentialsFromAnySource(),
+		createModel: (credentials) =>
+			createOpenAI({ apiKey: credentials.apiKey })("gpt-4o-mini"),
 	},
 ];
 
-async function generateTitleWithModel(
-	prompt: string,
-	agentId: string,
-	model: AgentModel,
-): Promise<string | null> {
-	const agent = new Agent({
-		id: agentId,
-		name: "Workspace Namer",
-		instructions: "You generate concise workspace titles.",
-		model,
-	});
-
-	const title = await agent.generateTitleFromUserMessage({
-		message: prompt,
-		tracingContext: {},
-	});
-
-	return title?.trim() || null;
-}
-
 export async function generateWorkspaceNameFromPrompt(
 	prompt: string,
 ): Promise<string | null> {
 	for (const provider of TITLE_PROVIDERS) {
-		const apiKey = provider.resolveApiKey();
-		if (!apiKey) {
+		const credentials = provider.resolveCredentials();
+		if (!credentials) {
 			continue;
 		}
 
 		try {
-			const title = await generateTitleWithModel(
-				prompt,
-				provider.agentId,
-				provider.createModel(apiKey),
-			);
+			const title = await generateTitleFromMessage({
+				message: prompt,
+				agentModel: provider.createModel(credentials),
+				agentId: provider.agentId,
+				agentName: "Workspace Namer",
+				instructions: "You generate concise workspace titles.",
+			});
 			if (title) {
 				return title;
 			}
@@ -79,3 +94,97 @@ export async function generateWorkspaceNameFromPrompt(
 
 	return null;
 }
+
+export async function attemptWorkspaceAutoRenameFromPrompt({
+	workspaceId,
+	prompt,
+}: {
+	workspaceId: string;
+	prompt?: string | null;
+}): Promise<WorkspaceAutoRenameResult> {
+	const cleanedPrompt = prompt?.trim();
+	if (!cleanedPrompt) {
+		return { status: "skipped", reason: "empty-prompt" };
+	}
+
+	const generatedName = await generateWorkspaceNameFromPrompt(cleanedPrompt);
+	if (!generatedName) {
+		const hasCredentials =
+			getAnthropicCredentialsFromAnySource() !== null ||
+			getOpenAICredentialsFromAnySource() !== null;
+		return {
+			status: "skipped",
+			reason: hasCredentials ? "generation-failed" : "missing-credentials",
+			warning: hasCredentials
+				? "Couldn't auto-name this workspace."
+				: "Couldn't auto-name this workspace because chat credentials aren't configured.",
+		};
+	}
+
+	const workspace = localDb
+		.select({
+			id: workspaces.id,
+			branch: workspaces.branch,
+			name: workspaces.name,
+			isUnnamed: workspaces.isUnnamed,
+			deletingAt: workspaces.deletingAt,
+		})
+		.from(workspaces)
+		.where(eq(workspaces.id, workspaceId))
+		.get();
+
+	const decision = getWorkspaceAutoRenameDecision({
+		workspace: workspace ?? null,
+		generatedName,
+	});
+	if (decision.kind === "skip") {
+		return { status: "skipped", reason: decision.reason };
+	}
+	if (!workspace) {
+		return { status: "skipped", reason: "missing-workspace" };
+	}
+
+	const renameResult = localDb
+		.update(workspaces)
+		.set({
+			name: decision.name,
+			isUnnamed: false,
+			updatedAt: Date.now(),
+		})
+		.where(
+			and(
+				eq(workspaces.id, workspace.id),
+				eq(workspaces.branch, workspace.branch),
+				eq(workspaces.name, workspace.branch),
+				eq(workspaces.isUnnamed, true),
+				isNull(workspaces.deletingAt),
+			),
+		)
+		.run();
+	if (renameResult.changes > 0) {
+		return { status: "renamed", name: decision.name };
+	}
+
+	const latestWorkspace = localDb
+		.select({
+			branch: workspaces.branch,
+			name: workspaces.name,
+			isUnnamed: workspaces.isUnnamed,
+			deletingAt: workspaces.deletingAt,
+		})
+		.from(workspaces)
+		.where(eq(workspaces.id, workspace.id))
+		.get();
+
+	const latestDecision = getWorkspaceAutoRenameDecision({
+		workspace: latestWorkspace ?? null,
+		generatedName,
+	});
+	return {
+		status: "skipped",
+		reason:
+			latestDecision.kind === "skip"
+				? latestDecision.reason
+				: "workspace-name-changed",
+	};
+}

apps/desktop/src/lib/trpc/routers/workspaces/utils/workspace-auto-rename.test.ts

@@ -0,0 +1,80 @@
+import { describe, expect, test } from "bun:test";
+import {
+	getWorkspaceAutoRenameDecision,
+	resolveWorkspaceAutoRename,
+} from "./workspace-auto-rename";
+
+describe("resolveWorkspaceAutoRename", () => {
+	test("returns generated name for untouched unnamed workspace", () => {
+		expect(
+			resolveWorkspaceAutoRename({
+				workspace: {
+					branch: "feat/test-branch",
+					name: "feat/test-branch",
+					isUnnamed: true,
+					deletingAt: null,
+				},
+				generatedName: "Fix auth flow",
+			}),
+		).toBe("Fix auth flow");
+	});
+
+	test("does not overwrite an already named workspace", () => {
+		expect(
+			resolveWorkspaceAutoRename({
+				workspace: {
+					branch: "feat/test-branch",
+					name: "Custom name",
+					isUnnamed: false,
+					deletingAt: null,
+				},
+				generatedName: "Fix auth flow",
+			}),
+		).toBeNull();
+	});
+
+	test("does not overwrite placeholder once another name has been applied", () => {
+		expect(
+			resolveWorkspaceAutoRename({
+				workspace: {
+					branch: "feat/test-branch",
+					name: "Running setup",
+					isUnnamed: true,
+					deletingAt: null,
+				},
+				generatedName: "Fix auth flow",
+			}),
+		).toBeNull();
+	});
+
+	test("ignores empty generated names", () => {
+		expect(
+			resolveWorkspaceAutoRename({
+				workspace: {
+					branch: "feat/test-branch",
+					name: "feat/test-branch",
+					isUnnamed: true,
+					deletingAt: null,
+				},
+				generatedName: "   ",
+			}),
+		).toBeNull();
+	});
+
+	test("reports skip reason for already named workspace", () => {
+		expect(
+			getWorkspaceAutoRenameDecision({
+				workspace: {
+					branch: "feat/test-branch",
+					name: "Custom name",
+					isUnnamed: false,
+					deletingAt: null,
+				},
+				generatedName: "Fix auth flow",
+			}),
+		).toEqual({
+			kind: "skip",
+			reason: "workspace-named",
+		});
+	});
+});