fix(naming): force propose_name when the request serializes thinking off

Claude Haiku 4.5 with thinking off skipped the propose_name tool about 30%
of the time, so naming fell through to the next hardcoded candidate and left
the configured Claude route. Force the tool choice when the built provider
options leave thinking off (Anthropic: no thinking block or disabled; OpenAI:
reasoningEffort none) and keep the unforced request when thinking is on.

Author: ibetitsmike

src/node/services/workspaceTitleGenerator.test.ts

@@ -12,6 +12,7 @@ import type { AIService } from "./aiService";
 import type { SendMessageError } from "@/common/types/errors";
 import { NAME_GEN_MAX_OUTPUT_TOKENS } from "@/common/constants/nameGeneration";
 import type { ThinkingLevel } from "@/common/types/thinking";
+import type { MuxProviderOptions } from "@/common/types/providerOptions";
 import { attachLanguageModelCleanup } from "./languageModelCleanup";
 
 afterEach(() => {
@@ -85,7 +86,8 @@ function createTitleModel(modelId = "title-model"): LanguageModel {
 function pinnedOptionsFor(
   modelString: string,
   model: LanguageModel,
-  _opts?: { thinkingLevel?: ThinkingLevel; agentInitiated?: boolean }
+  _opts?: { thinkingLevel?: ThinkingLevel; agentInitiated?: boolean },
+  muxProviderOptions: MuxProviderOptions = {}
 ) {
   return Ok({
     model,
@@ -94,7 +96,7 @@ function pinnedOptionsFor(
     metadataModel: modelString,
     optionsModelString: modelString,
     optionsProvidersConfig: {},
-    optionsMuxProviderOptions: {},
+    optionsMuxProviderOptions: muxProviderOptions,
   });
 }
 
@@ -374,6 +376,82 @@ describe("generateWorkspaceIdentity candidate settings", () => {
     }
   );
 
+  const forcedProposeName = { type: "tool", toolName: "propose_name" } as const;
+  test.each([
+    // Fallback default "off" serializes no Anthropic thinking block.
+    { name: "Haiku default", model: "anthropic:claude-haiku-4-5", forced: true },
+    {
+      name: "Haiku off",
+      model: "anthropic:claude-haiku-4-5",
+      thinkingLevel: "off" as const,
+      forced: true,
+    },
+    // Luna "off" serializes reasoningEffort "none".
+    { name: "Luna default", model: "openai:gpt-6-luna", forced: true },
+    // Chat Completions pins Luna to effort "none" at any level.
+    {
+      name: "Luna high on Chat Completions",
+      model: "openai:gpt-6-luna",
+      thinkingLevel: "high" as const,
+      chat: true,
+      forced: true,
+    },
+    {
+      name: "Haiku medium",
+      model: "anthropic:claude-haiku-4-5",
+      thinkingLevel: "medium" as const,
+      forced: false,
+    },
+    // The per-model floor turns thinking on.
+    {
+      name: "Haiku off with low floor",
+      model: "anthropic:claude-haiku-4-5",
+      thinkingLevel: "off" as const,
+      minThinkingLevel: "low" as const,
+      forced: false,
+    },
+    // Policy keeps "off", but this route serializes adaptive thinking.
+    {
+      name: "Sonnet 5.5 off",
+      model: "anthropic:claude-sonnet-5-5",
+      thinkingLevel: "off" as const,
+      forced: false,
+    },
+    {
+      name: "Luna off with high floor",
+      model: "openai:gpt-6-luna",
+      thinkingLevel: "off" as const,
+      minThinkingLevel: "high" as const,
+      forced: false,
+    },
+  ])(
+    "forces propose_name only when the request serializes thinking off ($name)",
+    async ({ model, thinkingLevel, minThinkingLevel, chat, forced }) => {
+      const aiService = titleAIService((modelString) =>
+        Promise.resolve(
+          pinnedOptionsFor(
+            modelString,
+            createTitleModel(modelString),
+            undefined,
+            chat ? { openai: { wireFormat: "chatCompletions" } } : {}
+          )
+        )
+      );
+      const streamTextSpy = spyOn(aiSdk, "streamText").mockReturnValue(proposeNameStream);
+
+      const result = await generateWorkspaceIdentity(
+        "Add setting",
+        [{ model, thinkingLevel, minThinkingLevel }],
+        aiService
+      );
+
+      expect(result.success).toBe(true);
+      expect(streamTextSpy.mock.calls[0]?.[0].toolChoice).toEqual(
+        forced ? forcedProposeName : undefined
+      );
+    }
+  );
+
   test("skips a candidate whose model cannot be created and reports the last failure", async () => {
     const createModelWithPinnedOptions = mock((modelString: string) =>
       Promise.resolve(

src/node/services/workspaceTitleGenerator.ts

@@ -293,13 +293,9 @@ export async function generateWorkspaceIdentity(
       // streamText (not generateText): the Codex OAuth endpoint requires
       // stream:true in the request body; streamText sets it automatically.
       //
-      // No toolChoice — forced tool choice (toolChoice: "required" / "any" /
-      // { type: "tool" }) is incompatible with extended thinking models.
-      // Instead, the prompt instructs the model to call the tool, and the
-      // name_workspace builtin agent declares tools.require: [propose_name]
-      // which the StreamManager enforces via stopWhen for full agent sessions.
-      // For this direct streamText path, the candidate retry loop handles the
-      // (rare) case where the model ignores the instruction.
+      // Force propose_name only when the serialized request leaves thinking off:
+      // Anthropic rejects forced tool use with thinking enabled. With thinking on,
+      // the prompt asks for the call and the candidate loop covers a skipped call.
       const currentStream = streamText({
         model: pinned.model,
         prompt: buildWorkspaceIdentityPrompt(message, conversationContext, latestUserMessage),
@@ -309,6 +305,9 @@ export async function generateWorkspaceIdentity(
         ...(anthropicBudget !== undefined && {
           maxOutputTokens: anthropicBudget + NAME_GEN_MAX_OUTPUT_TOKENS,
         }),
+        ...(serializesThinkingOff(providerOptions) && {
+          toolChoice: { type: "tool", toolName: "propose_name" } as const,
+        }),
         tools: {
           // Defined inline so TypeScript preserves full schema inference on
           // toolResult.output (the propose_name tool is only used here).
@@ -399,6 +398,22 @@ function anthropicThinkingBudget(
   return thinking?.type === "enabled" ? thinking.budgetTokens : undefined;
 }
 
+/**
+ * Whether the serialized request leaves thinking off. An omitted Anthropic
+ * `thinking` is off because the policy keeps "off" away from models whose API
+ * defaults to adaptive; an omitted OpenAI effort runs the model's default reasoning.
+ */
+function serializesThinkingOff(providerOptions: ReturnType<typeof buildProviderOptions>): boolean {
+  if ("anthropic" in providerOptions) {
+    const thinking = providerOptions.anthropic.thinking;
+    return thinking === undefined || thinking.type === "disabled";
+  }
+  if ("openai" in providerOptions) {
+    return providerOptions.openai.reasoningEffort === "none";
+  }
+  return false;
+}
+
 /**
  * Sanitize a string to be git-safe: lowercase, hyphens only, no leading/trailing hyphens.
  */