feat: persist thinking level preference per model

ammar-agent · ammar-agent · commit 96987c2c6e60 · 2025-12-06T15:25:17.000-06:00
Thinking level is now stored per model instead of per workspace:
- When switching models, the thinking level for that model is loaded
- When changing thinking level, it's saved for the current model
- This allows different models to have different thinking preferences

Storage key changes:
- thinkingLevel:{modelName} - main thinking level per model
- lastActiveThinking:{modelName} - for toggle keybind restoration

Removed:
- lastThinkingByModel:{model} (consolidated into main storage)
- Workspace-based thinking level sync during workspace creation

The toggle keybind (Ctrl+Shift+T) still remembers the last active
(non-off) level for quick on/off toggling.
diff --git a/src/browser/App.tsx b/src/browser/App.tsx
@@ -30,7 +30,8 @@ import { buildCoreSources, type BuildSourcesParams } from "./utils/commands/sour
 import type { ThinkingLevel } from "@/common/types/thinking";
 import { CUSTOM_EVENTS } from "@/common/constants/events";
 import { isWorkspaceForkSwitchEvent } from "./utils/workspaceEvents";
-import { getThinkingLevelKey } from "@/common/constants/storage";
+import { getThinkingLevelKey, getModelKey } from "@/common/constants/storage";
+import { getDefaultModel } from "@/browser/hooks/useModelLRU";
 import type { BranchListResult } from "@/common/orpc/types";
 import { useTelemetry } from "./hooks/useTelemetry";
 import { getRuntimeTypeForTelemetry } from "@/common/telemetry";
@@ -272,7 +273,12 @@ function AppInner() {
     }
 
     try {
-      const key = getThinkingLevelKey(workspaceId);
+      // First get the model for this workspace, then get thinking level for that model
+      const modelKey = getModelKey(workspaceId);
+      const modelStored = window.localStorage.getItem(modelKey);
+      const model = modelStored ? (JSON.parse(modelStored) as string) : getDefaultModel();
+
+      const key = getThinkingLevelKey(model);
       const stored = window.localStorage.getItem(key);
       if (!stored || stored === "undefined") {
         return "off";
@@ -290,8 +296,13 @@ function AppInner() {
       return;
     }
 
+    // Get the model for this workspace to set thinking level for it
+    const modelKey = getModelKey(workspaceId);
+    const modelStored = window.localStorage?.getItem(modelKey);
+    const model = modelStored ? (JSON.parse(modelStored) as string) : getDefaultModel();
+
     const normalized = THINKING_LEVELS.includes(level) ? level : "off";
-    const key = getThinkingLevelKey(workspaceId);
+    const key = getThinkingLevelKey(model);
 
     // Use the utility function which handles localStorage and event dispatch
     // ThinkingProvider will pick this up via its listener
diff --git a/src/browser/components/ChatInput/useCreationWorkspace.test.tsx b/src/browser/components/ChatInput/useCreationWorkspace.test.tsx
@@ -404,9 +404,10 @@ describe("useCreationWorkspace", () => {
     });
 
     persistedPreferences[getModeKey(getProjectScopeId(TEST_PROJECT_PATH))] = "plan";
-    persistedPreferences[getThinkingLevelKey(getProjectScopeId(TEST_PROJECT_PATH))] = "high";
     // Set model preference for the project scope (read by getSendOptionsFromStorage)
     persistedPreferences[getModelKey(getProjectScopeId(TEST_PROJECT_PATH))] = "gpt-4";
+    // Thinking level is now stored per-model, not per-workspace/project
+    persistedPreferences[getThinkingLevelKey("gpt-4")] = "high";
 
     draftSettingsState = createDraftSettingsHarness({
       runtimeMode: "ssh",
@@ -460,15 +461,14 @@ describe("useCreationWorkspace", () => {
     expect(onWorkspaceCreated.mock.calls[0][0]).toEqual(TEST_METADATA);
 
     const projectModeKey = getModeKey(getProjectScopeId(TEST_PROJECT_PATH));
-    const projectThinkingKey = getThinkingLevelKey(getProjectScopeId(TEST_PROJECT_PATH));
     expect(readPersistedStateCalls).toContainEqual([projectModeKey, null]);
-    expect(readPersistedStateCalls).toContainEqual([projectThinkingKey, null]);
+    // Thinking level is now read per-model (gpt-4), not per-project
+    expect(readPersistedStateCalls).toContainEqual([getThinkingLevelKey("gpt-4"), "off"]);
 
     const modeKey = getModeKey(TEST_WORKSPACE_ID);
-    const thinkingKey = getThinkingLevelKey(TEST_WORKSPACE_ID);
     const pendingInputKey = getInputKey(getPendingScopeId(TEST_PROJECT_PATH));
     expect(updatePersistedStateCalls).toContainEqual([modeKey, "plan"]);
-    expect(updatePersistedStateCalls).toContainEqual([thinkingKey, "high"]);
+    // Note: Thinking level is now per-model, not per-workspace, so no sync to workspace
     expect(updatePersistedStateCalls).toContainEqual([pendingInputKey, ""]);
   });
 
diff --git a/src/browser/components/ChatInput/useCreationWorkspace.ts b/src/browser/components/ChatInput/useCreationWorkspace.ts
@@ -2,7 +2,6 @@ import { useState, useEffect, useCallback } from "react";
 import type { FrontendWorkspaceMetadata } from "@/common/types/workspace";
 import type { RuntimeConfig, RuntimeMode } from "@/common/types/runtime";
 import type { UIMode } from "@/common/types/mode";
-import type { ThinkingLevel } from "@/common/types/thinking";
 import { parseRuntimeString } from "@/browser/utils/chatCommands";
 import { useDraftWorkspaceSettings } from "@/browser/hooks/useDraftWorkspaceSettings";
 import { readPersistedState, updatePersistedState } from "@/browser/hooks/usePersistedState";
@@ -13,7 +12,6 @@ import {
   getModeKey,
   getPendingScopeId,
   getProjectScopeId,
-  getThinkingLevelKey,
 } from "@/common/constants/storage";
 import type { Toast } from "@/browser/components/ChatInputToast";
 import { createErrorToast } from "@/browser/components/ChatInputToasts";
@@ -43,13 +41,8 @@ function syncCreationPreferences(projectPath: string, workspaceId: string): void
     updatePersistedState(getModeKey(workspaceId), projectMode);
   }
 
-  const projectThinking = readPersistedState<ThinkingLevel | null>(
-    getThinkingLevelKey(projectScopeId),
-    null
-  );
-  if (projectThinking) {
-    updatePersistedState(getThinkingLevelKey(workspaceId), projectThinking);
-  }
+  // Note: Thinking level is now stored per-model, not per-workspace,
+  // so no syncing needed here
 }
 
 interface UseCreationWorkspaceReturn {
diff --git a/src/browser/components/ThinkingSlider.tsx b/src/browser/components/ThinkingSlider.tsx
@@ -5,7 +5,7 @@ import { TooltipWrapper, Tooltip } from "./Tooltip";
 import { formatKeybind, KEYBINDS } from "@/browser/utils/ui/keybinds";
 import { getThinkingPolicyForModel } from "@/browser/utils/thinking/policy";
 import { updatePersistedState } from "@/browser/hooks/usePersistedState";
-import { getLastThinkingByModelKey } from "@/common/constants/storage";
+import { getLastActiveThinkingKey } from "@/common/constants/storage";
 
 // Uses CSS variable --color-thinking-mode for theme compatibility
 // Glow is applied via CSS using color-mix with the theme color
@@ -144,12 +144,11 @@ export const ThinkingSliderComponent: React.FC<ThinkingControlProps> = ({ modelS
   };
 
   const handleThinkingLevelChange = (newLevel: ThinkingLevel) => {
+    // ThinkingContext handles per-model persistence automatically
     setThinkingLevel(newLevel);
-    // Also save to lastThinkingByModel for Ctrl+Shift+T toggle memory
-    // Only save active levels (not "off") - matches useAIViewKeybinds logic
+    // Also save active level for toggle keybind (Ctrl+Shift+T) to restore
     if (newLevel !== "off") {
-      const lastThinkingKey = getLastThinkingByModelKey(modelString);
-      updatePersistedState(lastThinkingKey, newLevel as ThinkingLevelOn);
+      updatePersistedState(getLastActiveThinkingKey(modelString), newLevel as ThinkingLevelOn);
     }
   };
 
diff --git a/src/browser/contexts/ThinkingContext.tsx b/src/browser/contexts/ThinkingContext.tsx
@@ -1,12 +1,18 @@
 import type { ReactNode } from "react";
-import React, { createContext, useContext } from "react";
+import React, { createContext, useContext, useEffect, useState, useCallback } from "react";
 import type { ThinkingLevel } from "@/common/types/thinking";
-import { usePersistedState } from "@/browser/hooks/usePersistedState";
+import {
+  usePersistedState,
+  readPersistedState,
+  updatePersistedState,
+} from "@/browser/hooks/usePersistedState";
 import {
   getThinkingLevelKey,
   getProjectScopeId,
+  getModelKey,
   GLOBAL_SCOPE_ID,
 } from "@/common/constants/storage";
+import { getDefaultModel } from "@/browser/hooks/useModelLRU";
 
 interface ThinkingContextType {
   thinkingLevel: ThinkingLevel;
@@ -16,23 +22,71 @@ interface ThinkingContextType {
 const ThinkingContext = createContext<ThinkingContextType | undefined>(undefined);
 
 interface ThinkingProviderProps {
-  workspaceId?: string; // Workspace-scoped storage (highest priority)
-  projectPath?: string; // Project-scoped storage (fallback if no workspaceId)
+  workspaceId?: string; // Workspace-scoped storage for model selection
+  projectPath?: string; // Project-scoped storage for model selection (fallback)
   children: ReactNode;
 }
 
+/**
+ * ThinkingProvider manages thinking level state per model.
+ *
+ * The thinking level is stored per model (e.g., "thinkingLevel:claude-sonnet-4-20250514")
+ * so users can set different levels for different models and have them remembered.
+ *
+ * When the selected model changes, the thinking level is loaded from that model's storage.
+ */
 export const ThinkingProvider: React.FC<ThinkingProviderProps> = ({
   workspaceId,
   projectPath,
   children,
 }) => {
-  // Priority: workspace-scoped > project-scoped > global
-  const scopeId = workspaceId ?? (projectPath ? getProjectScopeId(projectPath) : GLOBAL_SCOPE_ID);
-  const key = getThinkingLevelKey(scopeId);
-  const [thinkingLevel, setThinkingLevel] = usePersistedState<ThinkingLevel>(
-    key,
-    "off",
-    { listener: true } // Listen for changes from command palette and other sources
+  // Derive model storage scope (workspace or project)
+  const modelScopeId =
+    workspaceId ?? (projectPath ? getProjectScopeId(projectPath) : GLOBAL_SCOPE_ID);
+  const modelKey = getModelKey(modelScopeId);
+
+  // Listen for model changes in this scope
+  const [selectedModel] = usePersistedState<string | null>(modelKey, null, { listener: true });
+  const currentModel = selectedModel ?? getDefaultModel();
+
+  // Local state for thinking level (managed per model)
+  const [thinkingLevel, setThinkingLevelState] = useState<ThinkingLevel>(() => {
+    return readPersistedState<ThinkingLevel>(getThinkingLevelKey(currentModel), "off");
+  });
+
+  // When model changes, load that model's thinking level
+  useEffect(() => {
+    const modelThinkingKey = getThinkingLevelKey(currentModel);
+    const modelThinkingLevel = readPersistedState<ThinkingLevel>(modelThinkingKey, "off");
+    setThinkingLevelState(modelThinkingLevel);
+  }, [currentModel]);
+
+  // Listen for storage events (from command palette or other sources)
+  useEffect(() => {
+    const modelThinkingKey = getThinkingLevelKey(currentModel);
+
+    const handleStorage = (e: StorageEvent) => {
+      if (e.key === modelThinkingKey && e.newValue) {
+        try {
+          const parsed = JSON.parse(e.newValue) as ThinkingLevel;
+          setThinkingLevelState(parsed);
+        } catch {
+          // Invalid JSON, ignore
+        }
+      }
+    };
+
+    window.addEventListener("storage", handleStorage);
+    return () => window.removeEventListener("storage", handleStorage);
+  }, [currentModel]);
+
+  // Save thinking level to current model's storage
+  const setThinkingLevel = useCallback(
+    (level: ThinkingLevel) => {
+      setThinkingLevelState(level);
+      updatePersistedState(getThinkingLevelKey(currentModel), level);
+    },
+    [currentModel]
   );
 
   return (
diff --git a/src/browser/hooks/useAIViewKeybinds.ts b/src/browser/hooks/useAIViewKeybinds.ts
@@ -1,8 +1,8 @@
 import { useEffect } from "react";
 import type { ChatInputAPI } from "@/browser/components/ChatInput";
 import { matchesKeybind, KEYBINDS, isEditableElement } from "@/browser/utils/ui/keybinds";
-import { getLastThinkingByModelKey, getModelKey } from "@/common/constants/storage";
-import { updatePersistedState, readPersistedState } from "@/browser/hooks/usePersistedState";
+import { getModelKey, getLastActiveThinkingKey } from "@/common/constants/storage";
+import { readPersistedState, updatePersistedState } from "@/browser/hooks/usePersistedState";
 import type { ThinkingLevel, ThinkingLevelOn } from "@/common/types/thinking";
 import { DEFAULT_THINKING_LEVEL } from "@/common/types/thinking";
 import { getThinkingPolicyForModel } from "@/browser/utils/thinking/policy";
@@ -106,9 +106,6 @@ export function useAIViewKeybinds({
         const selectedModel = readPersistedState<string | null>(getModelKey(workspaceId), null);
         const modelToUse = selectedModel ?? currentModel ?? getDefaultModel();
 
-        // Storage key for remembering this model's last-used active thinking level
-        const lastThinkingKey = getLastThinkingByModelKey(modelToUse);
-
         // Special-case: if model has single-option policy (e.g., gpt-5-pro only supports HIGH),
         // the toggle is a no-op to avoid confusing state transitions.
         const allowed = getThinkingPolicyForModel(modelToUse);
@@ -117,18 +114,17 @@ export function useAIViewKeybinds({
         }
 
         if (currentWorkspaceThinking !== "off") {
-          // Thinking is currently ON - save the level for this model and turn it off
-          // Type system ensures we can only store active levels (not "off")
+          // Thinking is currently ON - save the active level and turn it off
           const activeLevel: ThinkingLevelOn = currentWorkspaceThinking;
-          updatePersistedState(lastThinkingKey, activeLevel);
+          updatePersistedState(getLastActiveThinkingKey(modelToUse), activeLevel);
           setThinkingLevel("off");
         } else {
-          // Thinking is currently OFF - restore the last level used for this model
-          const lastUsedThinkingForModel = readPersistedState<ThinkingLevelOn>(
-            lastThinkingKey,
+          // Thinking is currently OFF - restore last active level for this model
+          const lastActive = readPersistedState<ThinkingLevelOn>(
+            getLastActiveThinkingKey(modelToUse),
             DEFAULT_THINKING_LEVEL
           );
-          setThinkingLevel(lastUsedThinkingForModel);
+          setThinkingLevel(lastActive);
         }
         return;
       }
diff --git a/src/browser/utils/messages/sendOptions.ts b/src/browser/utils/messages/sendOptions.ts
@@ -40,9 +40,9 @@ export function getSendOptionsFromStorage(workspaceId: string): SendMessageOptio
   // Read model preference (workspace-specific), fallback to LRU default
   const model = readPersistedState<string>(getModelKey(workspaceId), getDefaultModel());
 
-  // Read thinking level (workspace-specific)
+  // Read thinking level (per-model)
   const thinkingLevel = readPersistedState<ThinkingLevel>(
-    getThinkingLevelKey(workspaceId),
+    getThinkingLevelKey(model),
     WORKSPACE_DEFAULTS.thinkingLevel
   );
 
diff --git a/src/common/constants/storage.ts b/src/common/constants/storage.ts
@@ -49,10 +49,26 @@ export const SELECTED_WORKSPACE_KEY = "selectedWorkspace";
 export const EXPANDED_PROJECTS_KEY = "expandedProjects";
 
 /**
- * Helper to create a thinking level storage key for a workspace
- * Format: "thinkingLevel:{workspaceId}"
+ * Helper to create a thinking level storage key for a model.
+ * Format: "thinkingLevel:{modelName}"
+ *
+ * Thinking level is now persisted per-model so users can set different
+ * levels for different models and have them remembered when switching.
+ */
+export function getThinkingLevelKey(modelName: string): string {
+  return `thinkingLevel:${modelName}`;
+}
+
+/**
+ * Get the localStorage key for the last *active* thinking level used for a model.
+ * Format: "lastActiveThinking:{modelName}"
+ *
+ * Used by the toggle keybind (Ctrl+Shift+T) to restore the previous non-off level.
+ * Stores only active levels ("low" | "medium" | "high"), never "off".
  */
-export const getThinkingLevelKey = (workspaceId: string): string => `thinkingLevel:${workspaceId}`;
+export function getLastActiveThinkingKey(modelName: string): string {
+  return `lastActiveThinking:${modelName}`;
+}
 
 /**
  * Get the localStorage key for the user's preferred model for a workspace
@@ -83,15 +99,6 @@ export function getRetryStateKey(workspaceId: string): string {
   return `${workspaceId}-retryState`;
 }
 
-/**
- * Get the localStorage key for the last active thinking level used for a model
- * Stores only active levels ("low" | "medium" | "high"), never "off"
- * Format: "lastThinkingByModel:{modelName}"
- */
-export function getLastThinkingByModelKey(modelName: string): string {
-  return `lastThinkingByModel:${modelName}`;
-}
-
 /**
  * Get storage key for cancelled compaction tracking.
  * Stores compaction-request user message ID to verify freshness across reloads.
@@ -226,15 +233,14 @@ const PERSISTENT_WORKSPACE_KEY_FUNCTIONS: Array<(workspaceId: string) => string>
   getModelKey,
   getInputKey,
   getModeKey,
-  getThinkingLevelKey,
   getAutoRetryKey,
   getRetryStateKey,
   getReviewExpandStateKey,
   getFileTreeExpandStateKey,
   getReviewSearchStateKey,
   getAutoCompactionEnabledKey,
   getStatusUrlKey,
-  // Note: getAutoCompactionThresholdKey is per-model, not per-workspace
+  // Note: getAutoCompactionThresholdKey and getThinkingLevelKey are per-model, not per-workspace
 ];
 
 /**
@@ -246,7 +252,7 @@ const EPHEMERAL_WORKSPACE_KEY_FUNCTIONS: Array<(workspaceId: string) => string>
 
 /**
  * Copy all workspace-specific localStorage keys from source to destination workspace
- * This includes: model, input, mode, thinking level, auto-retry, retry state, review expand state, file tree expand state
+ * This includes: model, input, mode, auto-retry, retry state, review expand state, file tree expand state
  */
 export function copyWorkspaceStorage(sourceWorkspaceId: string, destWorkspaceId: string): void {
   for (const getKey of PERSISTENT_WORKSPACE_KEY_FUNCTIONS) {
