🤖 fix: disable extended thinking for workspace name generation

When generating workspace names with reasoning models (e.g., claude-opus-4-5),
the API sometimes returns thinking content that breaks JSON parsing, causing
'Invalid JSON response' errors.

Fix: Explicitly pass providerOptions with thinking disabled to generateObject().

- Add buildProviderOptions(modelString, 'off') to ensure no thinking content
- Add ModelProvider interface for easier testing without full AIService
- Add unit/integration tests for workspace title generation
- Add testUtils.ts with minimal model creation for tests

Author: ammar-agent

src/node/services/testUtils.ts

@@ -0,0 +1,42 @@
+/**
+ * Test utilities for AI service tests
+ *
+ * Provides minimal implementations for testing without full service infrastructure.
+ */
+
+import type { LanguageModel } from "ai";
+import type { Result } from "@/common/types/result";
+import { Ok, Err } from "@/common/types/result";
+import type { SendMessageError } from "@/common/types/errors";
+
+/**
+ * Create a model for testing - minimal implementation that uses the AI SDK directly.
+ * Supports Anthropic models only (add more providers as needed).
+ */
+export async function createModelForTest(
+  modelString: string
+): Promise<Result<LanguageModel, SendMessageError>> {
+  const [provider, modelId] = modelString.split(":");
+
+  if (!provider || !modelId) {
+    return Err({
+      type: "invalid_model_string",
+      message: `Invalid model string: ${modelString}`,
+    });
+  }
+
+  if (provider === "anthropic") {
+    const apiKey = process.env.ANTHROPIC_API_KEY ?? process.env.ANTHROPIC_AUTH_TOKEN;
+    if (!apiKey) {
+      return Err({ type: "api_key_not_found", provider: "anthropic" });
+    }
+
+    // Dynamic import is acceptable here - test utility only, not production code
+    // eslint-disable-next-line no-restricted-syntax
+    const { createAnthropic } = await import("@ai-sdk/anthropic");
+    const anthropic = createAnthropic({ apiKey });
+    return Ok(anthropic(modelId));
+  }
+
+  return Err({ type: "provider_not_supported", provider });
+}

src/node/services/workspaceTitleGenerator.test.ts

@@ -0,0 +1,82 @@
+/**
+ * Tests for workspace title generator
+ *
+ * Uses real API calls (TEST_INTEGRATION=1) to verify:
+ * - Small prompts work correctly
+ * - Reasoning/thinking models don't break JSON parsing
+ */
+
+import { generateWorkspaceName, generatePlaceholderName } from "./workspaceTitleGenerator";
+import { createModelForTest } from "./testUtils";
+
+// Unit tests - always run
+describe("generatePlaceholderName", () => {
+  it("should generate git-safe placeholder from message", () => {
+    expect(generatePlaceholderName("Fix the login bug")).toBe("fix-the-login-bug");
+  });
+
+  it("should handle empty message", () => {
+    expect(generatePlaceholderName("")).toBe("new-workspace");
+  });
+
+  it("should truncate long messages", () => {
+    const longMessage =
+      "This is a very long message that should be truncated to fit within the limit";
+    const result = generatePlaceholderName(longMessage);
+    expect(result.length).toBeLessThanOrEqual(30);
+  });
+
+  it("should sanitize special characters", () => {
+    expect(generatePlaceholderName("Fix: the @login #bug!")).toBe("fix-the-login-bug");
+  });
+});
+
+// Integration tests - require TEST_INTEGRATION=1
+const describeIntegration = process.env.TEST_INTEGRATION === "1" ? describe : describe.skip;
+
+describeIntegration("generateWorkspaceName - integration", () => {
+  // Minimal AIService-like object that only provides createModel
+  const aiService = { createModel: createModelForTest };
+
+  // Test with a small prompt that triggered the bug
+  it("should handle small prompts with opus-4-5 (reasoning model)", async () => {
+    const message = "Solve https://github.com/coder/registry/issues/42";
+    const model = "anthropic:claude-opus-4-5";
+
+    const result = await generateWorkspaceName(message, model, aiService);
+
+    // The result should be successful, not fail with "Invalid JSON response"
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.data).toMatch(/^[a-z0-9-]+$/);
+      expect(result.data.length).toBeGreaterThanOrEqual(3);
+      expect(result.data.length).toBeLessThanOrEqual(50);
+    }
+  }, 30000);
+
+  // Test with very short prompt
+  it("should handle very short prompts", async () => {
+    const message = "fix bug";
+    const model = "anthropic:claude-opus-4-5";
+
+    const result = await generateWorkspaceName(message, model, aiService);
+
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.data).toMatch(/^[a-z0-9-]+$/);
+    }
+  }, 30000);
+
+  // Test with claude-sonnet-4-5 (thinking model but different config)
+  it("should handle sonnet-4-5 with small prompts", async () => {
+    const message = "update README";
+    const model = "anthropic:claude-sonnet-4-5";
+
+    const result = await generateWorkspaceName(message, model, aiService);
+
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.data).toMatch(/^[a-z0-9-]+$/);
+    }
+  }, 30000);
+});

src/node/services/workspaceTitleGenerator.ts

@@ -1,10 +1,10 @@
-import { generateObject } from "ai";
+import { generateObject, type LanguageModel } from "ai";
 import { z } from "zod";
-import type { AIService } from "./aiService";
 import { log } from "./log";
 import type { Result } from "@/common/types/result";
 import { Ok, Err } from "@/common/types/result";
 import type { SendMessageError } from "@/common/types/errors";
+import { buildProviderOptions } from "@/common/utils/ai/providerOptions";
 
 const workspaceNameSchema = z.object({
   name: z
@@ -15,26 +15,40 @@ const workspaceNameSchema = z.object({
     .describe("Git-safe branch/workspace name: lowercase, hyphens only"),
 });
 
+/** Minimal interface for model creation - allows testing without full AIService */
+interface ModelProvider {
+  createModel(modelString: string): Promise<Result<LanguageModel, SendMessageError>>;
+}
+
 /**
  * Generate workspace name using AI.
  * If AI cannot be used (e.g. missing credentials, unsupported provider, invalid model),
  * returns a SendMessageError so callers can surface the standard provider error UX.
+ *
+ * Explicitly disables extended thinking to ensure clean JSON responses.
  */
 export async function generateWorkspaceName(
   message: string,
   modelString: string,
-  aiService: AIService
+  aiService: ModelProvider
 ): Promise<Result<string, SendMessageError>> {
   try {
     const modelResult = await aiService.createModel(modelString);
     if (!modelResult.success) {
       return Err(modelResult.error);
     }
 
+    // Explicitly disable extended thinking for workspace name generation.
+    // Reasoning models sometimes return thinking content that breaks JSON parsing.
+    const providerOptions = buildProviderOptions(modelString, "off");
+
     const result = await generateObject({
       model: modelResult.data,
       schema: workspaceNameSchema,
       prompt: `Generate a git-safe branch/workspace name for this development task:\n\n"${message}"\n\nRequirements:\n- Git-safe identifier (e.g., "automatic-title-generation")\n- Lowercase, hyphens only, no spaces\n- Concise (2-5 words) and descriptive of the task`,
+      // Cast needed: our ProviderOptions type is stricter than AI SDK's generic type
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-assignment
+      providerOptions: providerOptions as any,
     });
 
     return Ok(validateBranchName(result.object.name));