Stabilize composer provider state while typing

[cursor]

What Changed

• Split composer provider state derivation from raw prompt text by introducing a small prompt-injection state (none / ultrathink).
• Kept ultrathink styling behavior intact while avoiding provider option dispatch/model selection recomputation for ordinary prompt edits.
• Updated existing provider-state tests and removed placeholder empty prompt arguments from model selection call sites.

Why

React Doctor and a manual hot-path pass pointed at the chat composer/model controls as a performance-sensitive typing path. Previously, every keystroke invalidated getComposerProviderState, rebuilt provider option dispatch state, and changed selectedModelSelection identity even when the prompt did not cross the ultrathink boundary. The new dependency is stable for ordinary typing and only changes when prompt-injected effort state actually changes.

React Doctor scan after the fix still reports the broader existing repo baseline (166 performance issues; top unrelated items include HostedBrowserWebview, BranchToolbarBranchSelector, and ChatView), so this PR intentionally fixes one focused hotspot.

UI Changes

No intentional UI change. React Scan before/after recordings captured the real composer route with React Scan enabled:

• react_scan_before_provider_state_count.mp4: before state, repeated [react-scan] getComposerProviderState count logs during typing.
• react_scan_after_provider_state_count.mp4: after state, React Scan remains active while ordinary typing no longer triggers those provider-state count logs.

Checklist

• This PR is small and focused
• I explained what changed and why
• I included before/after screenshots for any UI changes
• I included a video for animation/interaction changes

Validation:

• corepack pnpm --filter @t3tools/web test -- src/components/chat/composerProviderState.test.tsx (web unit suite passed)
• corepack pnpm exec vp check
• corepack pnpm exec vp run typecheck
• corepack pnpm dlx react-doctor@latest --category performance --no-telemetry (completed; exits non-zero due existing baseline issues)

  

Note

Stabilize composer provider state by separating prompt injection state from raw prompt string

• Introduces ComposerPromptInjectionState (a 'none' | 'ultrathink' union) and getComposerPromptInjectionState in composerProviderState.tsx to map a prompt string to a discrete state value.
• Updates getComposerProviderState to accept promptInjectionState instead of prompt, defaulting to 'none', so the provider state no longer recomputes on every keystroke.
• Memoizes composerPromptInjectionState in ChatComposer.tsx and passes it to getComposerProviderState, decoupling provider state changes from raw prompt edits.
• Removes the prompt argument from getComposerProviderState call sites in modelSelection.ts, where no injection state is needed.

^{Macroscope summarized 2655576.}

---

Note

Low Risk
Focused memoization/API tweak on the composer typing path with unit tests; ultrathink styling logic is unchanged aside from when recomputation runs.

Overview
Reduces chat composer work on every keystroke by deriving provider/model dispatch state from a coarse prompt injection state (none | ultrathink) instead of the full prompt string.

getComposerPromptInjectionState maps the prompt via isClaudeUltrathinkPrompt; getComposerProviderState now takes promptInjectionState (default none) so ultrathink frame/chroma styling still toggles at the same boundary, but ordinary typing no longer invalidates modelOptionsForDispatch or selectedModelSelection on each character.

ChatComposer memoizes injection state separately and passes it into provider state; modelSelection call sites drop the unused empty prompt argument. Tests cover the new helper and updated ultrathink cases.

^{Reviewed by Cursor Bugbot for commit 2655576. Bugbot is set up for automated code reviews on this repo. Configure here.}

[macroscopeapp]

Approvability

Verdict: Approved

This is a performance optimization that memoizes prompt injection state derivation, preventing unnecessary recomputation on every keystroke. The functional behavior remains identical—only the timing of when the state is computed changes.

^{You can customize Macroscope's approvability policy. Learn more.}