🤖 feat: persist per-workspace model + thinking

[ThomasK33]

Persist per-workspace model and thinking/reasoning level on the backend so that opening the same workspace from another browser/device restores the same AI configuration.

Changes

• New shared schema WorkspaceAISettings (model, thinkingLevel) added to workspace config and metadata schemas.
• New ORPC endpoint workspace.updateAISettings to explicitly persist settings changes.
• Backend safety net: sendMessage and resumeStream also persist "last used" settings for older/CLI clients.
• Frontend thinking is now workspace-scoped (thinkingLevel:{workspaceId}) with migration from legacy per-model keys.
• LocalStorage seeding from backend metadata ensures cross-device convergence.
• UI changes back-persist model and thinking to backend immediately.
• Creation flow copies project-scoped preferences and best-effort persists to backend.

Testing

• Updated ThinkingContext.test.tsx for workspace-scoped thinking + migration.
• Added WorkspaceContext.test.tsx test for backend metadata seeding localStorage.
• Added IPC test tests/ipc/workspaceAISettings.test.ts verifying persistence + list/getInfo.

---

📋 Implementation Plan

Persist per-workspace model + reasoning (thinking) on the backend

Goal

Make model selection and thinking/reasoning level:

• Workspace-scoped (not per-model, not global)
• Persisted server-side so opening the same workspace from another browser/device restores the same configuration

Non-goals (for this change): persisting provider options (e.g. truncation), global default model, or draft input.

---

Recommended approach (net +250–400 LoC product)

1) Define a single workspace AI settings shape (shared types)

Why: avoid ad-hoc keys and keep the IPC/API boundary strongly typed.

• Add a reusable schema/type (common):

  • WorkspaceAISettings:
    • model: string (canonical provider:model, not mux-gateway:provider/model)
    • thinkingLevel: ThinkingLevel (off|low|medium|high|xhigh)

• Extend persisted config shape:

  • WorkspaceConfigSchema (in src/common/orpc/schemas/project.ts): add optional aiSettings?: WorkspaceAISettings

• Extend workspace metadata returned to clients:

  • WorkspaceMetadataSchema (in src/common/orpc/schemas/workspace.ts): add optional aiSettings?: WorkspaceAISettings
  • (Frontend schema automatically inherits via FrontendWorkspaceMetadataSchema.extend(...))

2) Backend: persist + serve workspace AI settings

Persistence location: ~/.mux/config.json under each workspace entry (alongside runtimeConfig, mcp, etc.)

2.1 Add an API to update settings explicitly

• Add a new ORPC endpoint:

  • workspace.updateAISettings (name bikesheddable)
  • Input: { workspaceId: string, aiSettings: WorkspaceAISettings }
  • Output: Result<void, string>

• Node implementation (WorkspaceService):

  • Validate workspace exists via config.findWorkspace(workspaceId).
  • config.editConfig(...) to locate the workspace entry and set workspaceEntry.aiSettings = normalizedSettings.
  • Normalize defensively:
    • model = normalizeGatewayModel(model) (from src/common/utils/ai/models.ts)
    • thinkingLevel = enforceThinkingPolicy(model, thinkingLevel) (single source of truth)
  • After save, re-fetch via config.getAllWorkspaceMetadata() and emit onMetadata update only if the value changed (avoid spam).

2.2 Also persist “last used” settings on message send (safety net)

Even if a client forgets to call updateAISettings (CLI/extension/old client), the backend should learn the last used values.

• In WorkspaceService.sendMessage(...) and resumeStream(...):
  • Extract options.model + options.thinkingLevel and write to workspaceEntry.aiSettings (same normalization as above).
  • Only write when different.

This makes “chatted with it earlier” reliably populate the backend state.

3) Frontend: treat backend as source of truth, but keep localStorage as a fast cache

3.1 Change thinking persistence to be workspace-scoped

• Add a new storage helper:

  • getThinkingLevelKey(scopeId: string): string → thinkingLevel:${scopeId}
  • Update PERSISTENT_WORKSPACE_KEY_FUNCTIONS to include it (so fork copies it, delete removes it).

• Update ThinkingProvider to use scope-based keying:

  • Scope priority similar to ModeProvider:
    • workspace: thinkingLevel:{workspaceId}
    • creation: thinkingLevel:__project__/{projectPath}
  • Remove the current “key depends on selected model” behavior.

• Update non-React send option reader:

  • getSendOptionsFromStorage(...) should read thinking via getThinkingLevelKey(scopeId).

• Update UI copy:

  • Thinking slider tooltip text from “Saved per model” → “Saved per workspace”.

3.2 Seed localStorage from backend workspace metadata

Where: WorkspaceContext.loadWorkspaceMetadata() + the workspace.onMetadata subscription handler.

• When metadata arrives for a workspace:
  • If metadata.aiSettings?.model exists → write it to localStorage key model:{workspaceId}.
  • If metadata.aiSettings?.thinkingLevel exists → write it to thinkingLevel:{workspaceId}.
  • Only write when the value differs (avoid unnecessary re-renders from updatePersistedState).

This ensures:

• new device with empty localStorage adopts backend settings
• existing device with stale localStorage is corrected to backend

3.3 Persist changes back to the backend when the user changes the UI

• Model changes:

  • In ChatInput’s setPreferredModel(...) (workspace variant only):
    • Update localStorage as today
    • Call api.workspace.updateAISettings({ workspaceId, aiSettings: { model, thinkingLevel: currentThinking } })

• Thinking changes:

  • Wrap setThinkingLevel in ThinkingProvider (workspace variant only):
    • Update localStorage
    • Call api.workspace.updateAISettings(...) with { model: currentModel, thinkingLevel: newLevel }

Notes:

• Use enforceThinkingPolicy client-side too (keep UI/BE consistent) but backend remains final authority.
• If api is unavailable, keep localStorage update (offline-friendly) and rely on sendMessage persistence later.

3.4 Creation flow

• Keep project-scoped model + thinking in localStorage while creating.
• When a workspace is created:
  • Continue copying project-scoped values into the new workspace-scoped keys (update syncCreationPreferences to include thinking).
  • Optionally call workspace.updateAISettings(...) right after creation (best effort) so the workspace is immediately portable even before the first message sends.

4) Migration + compatibility

• Config.json: new aiSettings fields are optional → old configs load fine; old mux versions should ignore unknown fields.
• localStorage: migrate legacy per-model thinking into the new per-workspace key:
  • On workspace open, if thinkingLevel:{workspaceId} is missing:
    • read model:{workspaceId} (or default)
    • read old thinkingLevel:model:{model}
    • set thinkingLevel:{workspaceId} to that value

Put this migration in a single place (e.g., the same “seed from metadata” helper) so it runs once.

---

Validation / tests

• Update unit tests that assert per-model thinking:
  • src/browser/contexts/ThinkingContext.test.tsx should instead verify thinking is stable across model changes (except clamping).
• Add a backend test that workspace.updateAISettings:
  • persists into config
  • is returned by workspace.list/getInfo
• Add a lightweight frontend test that WorkspaceContext seeding writes the expected localStorage keys when metadata contains aiSettings.

---

Alternatives considered

A) Persist only on sendMessage (no new endpoint) (net +120–200 LoC)

• Backend writes aiSettings from sendMessage/resumeStream options.
• Frontend only seeds localStorage from metadata when local keys are missing.

Pros: less surface area.
Cons: doesn’t sync if user changes model/thinking but hasn’t sent yet; stale localStorage on an existing device may never converge.

B) Remove localStorage for model/thinking entirely (net +500–900 LoC)

• Replace usePersistedState(getModelKey(...)) usage with a workspace settings store sourced from backend.

Pros: true single source of truth.
Cons: much bigger refactor; riskier.

---

Generated with mux • Model: openai:gpt-5.2 • Thinking: high