The best way to control Claude Code, Codex and more from any computer or phone
refactor(web): ChatView's model, mode, and workspace choices live in useComposerSelection (#23069)
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
Julius Marminge committed
Oct 21, 2026 at 13:40 UTC
976a601b87342646913ee9f77226762a9f7ad82a
2 files changed
+298
-175
apps/web/src/components/ChatView.tsx
+32
-175
@@ -1,3 +1,4 @@
1
+import { useComposerSelection } from "./chat/useComposerSelection";
2
import { useProjectCloneBanner } from "./chat/useProjectCloneBanner";
3
import { useAttachmentPreviewHandoff } from "./chat/useAttachmentPreviewHandoff";
4
import { useTimelineRewind } from "./chat/useTimelineRewind";
@@ -200,10 +201,8 @@ import { useNowMinute } from "../hooks/useNowMinute";
201
import { usePanelAnimationSettings, usePanelPresence } from "../panelAnimations";
202
import { useNewThreadHandler } from "../hooks/useHandleNewThread";
203
import { useOpenPanelPullRequestUrl } from "../hooks/useOpenPanelPullRequestUrl";
203
-import { resolveAppModelSelectionForInstance } from "../modelSelection";
204
import { isPreviewFocused } from "../lib/previewFocus";
205
import { getTerminalFocusOwner } from "../lib/terminalFocus";
206
-import { resolveNewDraftStartFromOrigin } from "../lib/chatThreadActions";
206
import {
207
deriveLogicalProjectKeyFromSettings,
208
selectProjectGroupingSettings,
@@ -332,7 +331,6 @@ import {
331
dismissBranchMismatchForSession,
332
shouldShowPlanFollowUpPrompt,
333
shouldRenderPreviewMiniPlayer,
335
- getStartedThreadModelChangeBlockReason,
334
deriveLockedProvider,
335
resolveFileAttachmentUrl,
336
resolveComposerInteractionMode,
@@ -371,7 +369,6 @@ import { draftFanoutSelectionsAtom, draftSendState } from "./chat/chatViewSend";
369
import {
370
isCompactCommandMessage,
371
type LocalThreadErrorEntry,
374
- makeModelDisabledReason,
372
makeThreadErrorSetter,
373
} from "./ChatView.logic";
374
@@ -588,9 +585,6 @@ export default function ChatView(props: ChatViewProps) {
585
})();
586
const settings = useEnvironmentSettings(environmentId);
587
const clientSettingsHydrated = useClientSettingsHydrated();
591
- const setStickyComposerModelSelection = useComposerDraftStore(
592
- (store) => store.setStickyModelSelection,
593
- );
588
const timestampFormat = settings.timestampFormat;
589
const navigate = useNavigate();
590
// Selects primitives: an object here is new on every router store update, which
@@ -640,11 +634,6 @@ export default function ChatView(props: ChatViewProps) {
634
return draft ? composerDraftHasUserContent({ ...draft, prompt: "" }) : false;
635
});
636
const setComposerDraftPrompt = useComposerDraftStore((store) => store.setPrompt);
643
- const setComposerDraftModelSelection = useComposerDraftStore((store) => store.setModelSelection);
644
- const setComposerDraftRuntimeMode = useComposerDraftStore((store) => store.setRuntimeMode);
645
- const setComposerDraftInteractionMode = useComposerDraftStore(
646
- (store) => store.setInteractionMode,
647
- );
637
const setDraftThreadContext = useComposerDraftStore((store) => store.setDraftThreadContext);
638
const getDraftSessionByLogicalProjectKey = useComposerDraftStore(
639
(store) => store.getDraftSessionByLogicalProjectKey,
@@ -2103,39 +2092,6 @@ export default function ChatView(props: ChatViewProps) {
2092
scripts: activeProjectScripts,
2093
settings,
2094
});
2106
-
2107
- const handleRuntimeModeChange = (mode: RuntimeMode) => {
2108
- if (mode === runtimeMode) return;
2109
- setComposerDraftRuntimeMode(composerDraftTarget, mode);
2110
- if (isLocalDraftThread) {
2111
- setDraftThreadContext(composerDraftTarget, { runtimeMode: mode });
2112
- }
2113
- scheduleComposerFocus();
2114
- };
2115
- const handleRuntimeModeChangeStable = useStableCallback(handleRuntimeModeChange);
2116
-
2117
- const handleInteractionModeChange = (mode: ProviderInteractionMode) => {
2118
- if (mode === "plan" && !interactionModeEnabled) return;
2119
- if (mode === interactionMode) return;
2120
- setComposerDraftInteractionMode(composerDraftTarget, mode);
2121
- if (isLocalDraftThread) {
2122
- setDraftThreadContext(composerDraftTarget, { interactionMode: mode });
2123
- }
2124
- scheduleComposerFocus();
2125
- };
2126
- const handleInteractionModeChangeStable = useStableCallback(handleInteractionModeChange);
2127
- const toggleInteractionMode = () => {
2128
- if (!interactionModeEnabled) return;
2129
- handleInteractionModeChange(interactionMode === "plan" ? "default" : "plan");
2130
- };
2131
- const toggleInteractionModeStable = useStableCallback(toggleInteractionMode);
2132
- const openProviderSetup = (instanceId: ProviderInstanceId) => {
2133
- void navigate({
2134
- to: "/settings/providers",
2135
- search: { environmentId, instanceId },
2136
- });
2137
- };
2138
- const openProviderSetupStable = useStableCallback(openProviderSetup);
2095
const canOperatePreview = useEnvironmentScope(
2096
activeThreadRef?.environmentId ?? null,
2097
AuthPreviewOperateScope,
@@ -3178,6 +3134,37 @@ export default function ChatView(props: ChatViewProps) {
3134
void sendStandaloneCommand("/compact", "Failed to compact context.");
3135
};
3136
3137
+ const {
3138
+ getModelDisabledReason,
3139
+ handleInteractionModeChange,
3140
+ handleInteractionModeChangeStable,
3141
+ handleRuntimeModeChangeStable,
3142
+ onEnvModeChangeStable,
3143
+ onProviderModelSelectStable,
3144
+ onStartFromOriginChange,
3145
+ openProviderSetupStable,
3146
+ toggleInteractionModeStable,
3147
+ } = useComposerSelection({
3148
+ environmentId,
3149
+ composerDraftTarget,
3150
+ draftThread,
3151
+ activeThread,
3152
+ activeRuntime,
3153
+ activeProjectSettings,
3154
+ settings,
3155
+ providerStatuses,
3156
+ lockedProvider,
3157
+ supportsProviderSwitchingViaHandoff,
3158
+ multipleModelSelections,
3159
+ runtimeMode,
3160
+ interactionMode,
3161
+ interactionModeEnabled,
3162
+ isLocalDraftThread,
3163
+ canOverrideServerThreadEnvMode,
3164
+ setPendingServerThreadEnvModeEntry,
3165
+ setPendingServerThreadStartFromOriginByThreadId,
3166
+ scheduleComposerFocus,
3167
+ });
3168
const { onSend, onResume, onImplementPlanInNewThread, isResuming } = useComposerSend({
3169
environmentId,
3170
routeThreadKey,
@@ -3264,120 +3251,6 @@ export default function ChatView(props: ChatViewProps) {
3251
});
3252
const onImplementPlanInNewThreadStable = useStableCallback(onImplementPlanInNewThread);
3253
3267
- // Keyed on the fields it reads: the thread and runtime objects change with
3268
- // every streamed event, and a new function re-renders the whole model picker.
3269
- const hasStartedSession = activeRuntime !== null;
3270
- const runtimeProviderInstanceId = activeRuntime?.providerInstanceId ?? null;
3271
- const currentModelSelection = activeThread?.modelSelection ?? null;
3272
- const getModelDisabledReason = makeModelDisabledReason(
3273
- currentModelSelection
3274
- ? {
3275
- providers: providerStatuses,
3276
- hasStartedSession,
3277
- supportsProviderSwitchingViaHandoff,
3278
- currentModelSelection,
3279
- currentProviderInstanceId: runtimeProviderInstanceId,
3280
- }
3281
- : null,
3282
- );
3283
-
3284
- const onProviderModelSelect = (
3285
- instanceId: ProviderInstanceId,
3286
- model: string,
3287
- options?: { focusComposer?: boolean },
3288
- ) => {
3289
- if (!activeThread) return;
3290
- const entry = providerStatuses.find((snapshot) => snapshot.instanceId === instanceId);
3291
- const resolvedDriverKind = entry?.driver ?? null;
3292
- if (
3293
- !supportsProviderSwitchingViaHandoff &&
3294
- lockedProvider !== null &&
3295
- resolvedDriverKind !== null &&
3296
- resolvedDriverKind !== lockedProvider
3297
- ) {
3298
- if (options?.focusComposer !== false) scheduleComposerFocus();
3299
- return;
3300
- }
3301
- if (
3302
- !supportsProviderSwitchingViaHandoff &&
3303
- lockedProvider !== null &&
3304
- activeRuntime?.providerInstanceId
3305
- ) {
3306
- const currentEntry = providerStatuses.find(
3307
- (snapshot) => snapshot.instanceId === activeRuntime.providerInstanceId,
3308
- );
3309
- if (
3310
- currentEntry?.continuation?.groupKey &&
3311
- entry?.continuation?.groupKey &&
3312
- currentEntry.continuation.groupKey !== entry.continuation.groupKey
3313
- ) {
3314
- if (options?.focusComposer !== false) scheduleComposerFocus();
3315
- return;
3316
- }
3317
- }
3318
- const resolvedModel = resolveAppModelSelectionForInstance(
3319
- instanceId,
3320
- settings,
3321
- providerStatuses,
3322
- model,
3323
- );
3324
- if (!resolvedModel) {
3325
- if (options?.focusComposer !== false) scheduleComposerFocus();
3326
- return;
3327
- }
3328
- const rememberedOptions =
3329
- useComposerDraftStore.getState().stickyOptionsByModelByProvider[instanceId]?.[resolvedModel];
3330
- const nextModelSelection: ModelSelection =
3331
- rememberedOptions !== undefined && rememberedOptions.length > 0
3332
- ? { instanceId, model: resolvedModel, options: [...rememberedOptions] }
3333
- : { instanceId, model: resolvedModel };
3334
- const modelChangeBlockReason = getStartedThreadModelChangeBlockReason({
3335
- providers: providerStatuses,
3336
- hasStartedSession: activeRuntime !== null,
3337
- supportsProviderSwitchingViaHandoff,
3338
- currentModelSelection: activeThread.modelSelection,
3339
- currentProviderInstanceId: activeRuntime?.providerInstanceId ?? null,
3340
- nextModelSelection,
3341
- });
3342
- if (modelChangeBlockReason) {
3343
- toastManager.add({
3344
- type: "warning",
3345
- title: modelChangeBlockReason.title,
3346
- description: modelChangeBlockReason.description,
3347
- });
3348
- if (options?.focusComposer !== false) scheduleComposerFocus();
3349
- return;
3350
- }
3351
- setComposerDraftModelSelection(
3352
- scopeThreadRef(activeThread.environmentId, activeThread.id),
3353
- nextModelSelection,
3354
- { explicit: true, replaceOptions: true },
3355
- );
3356
- setStickyComposerModelSelection(nextModelSelection);
3357
- if (options?.focusComposer !== false) scheduleComposerFocus();
3358
- };
3359
- const onProviderModelSelectStable = useStableCallback(onProviderModelSelect);
3360
- const onEnvModeChange = (mode: DraftThreadEnvMode) => {
3361
- if (multipleModelSelections !== null) return;
3362
- if (canOverrideServerThreadEnvMode) {
3363
- if (activeThread) setPendingServerThreadEnvModeEntry({ threadId: activeThread.id, mode });
3364
- scheduleComposerFocus();
3365
- return;
3366
- }
3367
- if (isLocalDraftThread) {
3368
- setDraftThreadContext(composerDraftTarget, {
3369
- envMode: mode,
3370
- startFromOrigin: resolveNewDraftStartFromOrigin({
3371
- envMode: mode,
3372
- newWorktreesStartFromOrigin: activeProjectSettings.settings.newWorktreesStartFromOrigin,
3373
- }),
3374
- ...(mode === "worktree" && draftThread?.worktreePath ? { worktreePath: null } : {}),
3375
- });
3376
- }
3377
- scheduleComposerFocus();
3378
- };
3379
- const onEnvModeChangeStable = useStableCallback(onEnvModeChange);
3380
-
3254
const onWorktreeSetupWorkLocally = () => {
3255
if (!worktreeSetup || worktreeSetup.phase !== "running" || !draftId) {
3256
return;
@@ -3458,22 +3331,6 @@ export default function ChatView(props: ChatViewProps) {
3331
workLocallyResendReady,
3332
]);
3333
3461
- const onStartFromOriginChange = (nextStartFromOrigin: boolean) => {
3462
- if (canOverrideServerThreadEnvMode && activeThread) {
3463
- setPendingServerThreadStartFromOriginByThreadId((current) =>
3464
- current[activeThread.id] === nextStartFromOrigin
3465
- ? current
3466
- : { ...current, [activeThread.id]: nextStartFromOrigin },
3467
- );
3468
- return;
3469
- }
3470
- if (isLocalDraftThread) {
3471
- setDraftThreadContext(composerDraftTarget, {
3472
- startFromOrigin: nextStartFromOrigin,
3473
- });
3474
- }
3475
- };
3476
-
3334
const onExpandTimelineImage = (preview: ExpandedImagePreview) => {
3335
openExpandedImagePreview(routeThreadKey, preview);
3336
};
apps/web/src/components/chat/useComposerSelection.ts
new
+266
@@ -0,0 +1,266 @@
1
+import type { EnvironmentThreadShell } from "@t3tools/client-runtime/state/shell";
2
+import type { UnifiedSettings } from "@t3tools/contracts";
3
+import type { Dispatch } from "react";
4
+import type { ComposerThreadTarget, DraftSessionState } from "../../composerDraftStore";
5
+import { useStableCallback } from "../../hooks/useStableCallback";
6
+import {
7
+ type EnvironmentId,
8
+ type ModelSelection,
9
+ ProviderInstanceId,
10
+ type ServerProvider,
11
+ type ThreadId,
12
+ ProviderInteractionMode,
13
+ RuntimeMode,
14
+} from "@t3tools/contracts";
15
+import { deriveThreadRuntime } from "@t3tools/client-runtime/state/thread-execution";
16
+import { scopeThreadRef } from "@t3tools/client-runtime/environment";
17
+import { type SetStateAction } from "react";
18
+import { useNavigate } from "@tanstack/react-router";
19
+import { toastManager } from "../ui/toast";
20
+import { resolveAppModelSelectionForInstance } from "../../modelSelection";
21
+import { resolveNewDraftStartFromOrigin } from "../../lib/chatThreadActions";
22
+import { type DraftThreadEnvMode, useComposerDraftStore } from "../../composerDraftStore";
23
+import {
24
+ getStartedThreadModelChangeBlockReason,
25
+ deriveLockedProvider,
26
+ makeModelDisabledReason,
27
+} from "../ChatView.logic";
28
+interface ComposerSelectionInput {
29
+ readonly environmentId: EnvironmentId;
30
+ readonly composerDraftTarget: ComposerThreadTarget;
31
+ readonly draftThread: DraftSessionState | null;
32
+ readonly activeThread: EnvironmentThreadShell | undefined;
33
+ readonly activeRuntime: ReturnType<typeof deriveThreadRuntime>;
34
+ readonly activeProjectSettings: {
35
+ readonly settings: { readonly newWorktreesStartFromOrigin: boolean };
36
+ };
37
+ readonly settings: UnifiedSettings;
38
+ readonly providerStatuses: ReadonlyArray<ServerProvider>;
39
+ readonly lockedProvider: ReturnType<typeof deriveLockedProvider>;
40
+ readonly supportsProviderSwitchingViaHandoff: boolean;
41
+ readonly multipleModelSelections: ReadonlyArray<ModelSelection> | null;
42
+ readonly runtimeMode: RuntimeMode;
43
+ readonly interactionMode: ProviderInteractionMode;
44
+ readonly interactionModeEnabled: boolean;
45
+ readonly isLocalDraftThread: boolean;
46
+ readonly canOverrideServerThreadEnvMode: boolean;
47
+ readonly setPendingServerThreadEnvModeEntry: Dispatch<
48
+ SetStateAction<{ readonly threadId: ThreadId; readonly mode: DraftThreadEnvMode } | null>
49
+ >;
50
+ readonly setPendingServerThreadStartFromOriginByThreadId: Dispatch<
51
+ SetStateAction<Record<string, boolean>>
52
+ >;
53
+ readonly scheduleComposerFocus: () => void;
54
+}
55
+
56
+/**
57
+ * The composer's choices for the next turn: provider and model, runtime and interaction mode,
58
+ * and where a new thread runs (local or a new worktree, from the remote's tip or not).
59
+ */
60
+export function useComposerSelection(input: ComposerSelectionInput) {
61
+ const {
62
+ environmentId,
63
+ composerDraftTarget,
64
+ draftThread,
65
+ activeThread,
66
+ activeRuntime,
67
+ activeProjectSettings,
68
+ settings,
69
+ providerStatuses,
70
+ lockedProvider,
71
+ supportsProviderSwitchingViaHandoff,
72
+ multipleModelSelections,
73
+ runtimeMode,
74
+ interactionMode,
75
+ interactionModeEnabled,
76
+ isLocalDraftThread,
77
+ canOverrideServerThreadEnvMode,
78
+ setPendingServerThreadEnvModeEntry,
79
+ setPendingServerThreadStartFromOriginByThreadId,
80
+ scheduleComposerFocus,
81
+ } = input;
82
+ const navigate = useNavigate();
83
+ const setStickyComposerModelSelection = useComposerDraftStore(
84
+ (store) => store.setStickyModelSelection,
85
+ );
86
+ const setComposerDraftModelSelection = useComposerDraftStore((store) => store.setModelSelection);
87
+ const setComposerDraftRuntimeMode = useComposerDraftStore((store) => store.setRuntimeMode);
88
+ const setComposerDraftInteractionMode = useComposerDraftStore(
89
+ (store) => store.setInteractionMode,
90
+ );
91
+ const setDraftThreadContext = useComposerDraftStore((store) => store.setDraftThreadContext);
92
+
93
+ const handleRuntimeModeChange = (mode: RuntimeMode) => {
94
+ if (mode === runtimeMode) return;
95
+ setComposerDraftRuntimeMode(composerDraftTarget, mode);
96
+ if (isLocalDraftThread) {
97
+ setDraftThreadContext(composerDraftTarget, { runtimeMode: mode });
98
+ }
99
+ scheduleComposerFocus();
100
+ };
101
+ const handleRuntimeModeChangeStable = useStableCallback(handleRuntimeModeChange);
102
+
103
+ const handleInteractionModeChange = (mode: ProviderInteractionMode) => {
104
+ if (mode === "plan" && !interactionModeEnabled) return;
105
+ if (mode === interactionMode) return;
106
+ setComposerDraftInteractionMode(composerDraftTarget, mode);
107
+ if (isLocalDraftThread) {
108
+ setDraftThreadContext(composerDraftTarget, { interactionMode: mode });
109
+ }
110
+ scheduleComposerFocus();
111
+ };
112
+ const handleInteractionModeChangeStable = useStableCallback(handleInteractionModeChange);
113
+ const toggleInteractionMode = () => {
114
+ if (!interactionModeEnabled) return;
115
+ handleInteractionModeChange(interactionMode === "plan" ? "default" : "plan");
116
+ };
117
+ const toggleInteractionModeStable = useStableCallback(toggleInteractionMode);
118
+ const openProviderSetup = (instanceId: ProviderInstanceId) => {
119
+ void navigate({
120
+ to: "/settings/providers",
121
+ search: { environmentId, instanceId },
122
+ });
123
+ };
124
+ const openProviderSetupStable = useStableCallback(openProviderSetup);
125
+
126
+ // Keyed on the fields it reads: the thread and runtime objects change with
127
+ // every streamed event, and a new function re-renders the whole model picker.
128
+ const hasStartedSession = activeRuntime !== null;
129
+ const runtimeProviderInstanceId = activeRuntime?.providerInstanceId ?? null;
130
+ const currentModelSelection = activeThread?.modelSelection ?? null;
131
+ const getModelDisabledReason = makeModelDisabledReason(
132
+ currentModelSelection
133
+ ? {
134
+ providers: providerStatuses,
135
+ hasStartedSession,
136
+ supportsProviderSwitchingViaHandoff,
137
+ currentModelSelection,
138
+ currentProviderInstanceId: runtimeProviderInstanceId,
139
+ }
140
+ : null,
141
+ );
142
+
143
+ const onProviderModelSelect = (
144
+ instanceId: ProviderInstanceId,
145
+ model: string,
146
+ options?: { focusComposer?: boolean },
147
+ ) => {
148
+ if (!activeThread) return;
149
+ const entry = providerStatuses.find((snapshot) => snapshot.instanceId === instanceId);
150
+ const resolvedDriverKind = entry?.driver ?? null;
151
+ if (
152
+ !supportsProviderSwitchingViaHandoff &&
153
+ lockedProvider !== null &&
154
+ resolvedDriverKind !== null &&
155
+ resolvedDriverKind !== lockedProvider
156
+ ) {
157
+ if (options?.focusComposer !== false) scheduleComposerFocus();
158
+ return;
159
+ }
160
+ if (
161
+ !supportsProviderSwitchingViaHandoff &&
162
+ lockedProvider !== null &&
163
+ activeRuntime?.providerInstanceId
164
+ ) {
165
+ const currentEntry = providerStatuses.find(
166
+ (snapshot) => snapshot.instanceId === activeRuntime.providerInstanceId,
167
+ );
168
+ if (
169
+ currentEntry?.continuation?.groupKey &&
170
+ entry?.continuation?.groupKey &&
171
+ currentEntry.continuation.groupKey !== entry.continuation.groupKey
172
+ ) {
173
+ if (options?.focusComposer !== false) scheduleComposerFocus();
174
+ return;
175
+ }
176
+ }
177
+ const resolvedModel = resolveAppModelSelectionForInstance(
178
+ instanceId,
179
+ settings,
180
+ providerStatuses,
181
+ model,
182
+ );
183
+ if (!resolvedModel) {
184
+ if (options?.focusComposer !== false) scheduleComposerFocus();
185
+ return;
186
+ }
187
+ const rememberedOptions =
188
+ useComposerDraftStore.getState().stickyOptionsByModelByProvider[instanceId]?.[resolvedModel];
189
+ const nextModelSelection: ModelSelection =
190
+ rememberedOptions !== undefined && rememberedOptions.length > 0
191
+ ? { instanceId, model: resolvedModel, options: [...rememberedOptions] }
192
+ : { instanceId, model: resolvedModel };
193
+ const modelChangeBlockReason = getStartedThreadModelChangeBlockReason({
194
+ providers: providerStatuses,
195
+ hasStartedSession: activeRuntime !== null,
196
+ supportsProviderSwitchingViaHandoff,
197
+ currentModelSelection: activeThread.modelSelection,
198
+ currentProviderInstanceId: activeRuntime?.providerInstanceId ?? null,
199
+ nextModelSelection,
200
+ });
201
+ if (modelChangeBlockReason) {
202
+ toastManager.add({
203
+ type: "warning",
204
+ title: modelChangeBlockReason.title,
205
+ description: modelChangeBlockReason.description,
206
+ });
207
+ if (options?.focusComposer !== false) scheduleComposerFocus();
208
+ return;
209
+ }
210
+ setComposerDraftModelSelection(
211
+ scopeThreadRef(activeThread.environmentId, activeThread.id),
212
+ nextModelSelection,
213
+ { explicit: true, replaceOptions: true },
214
+ );
215
+ setStickyComposerModelSelection(nextModelSelection);
216
+ if (options?.focusComposer !== false) scheduleComposerFocus();
217
+ };
218
+ const onProviderModelSelectStable = useStableCallback(onProviderModelSelect);
219
+ const onEnvModeChange = (mode: DraftThreadEnvMode) => {
220
+ if (multipleModelSelections !== null) return;
221
+ if (canOverrideServerThreadEnvMode) {
222
+ if (activeThread) setPendingServerThreadEnvModeEntry({ threadId: activeThread.id, mode });
223
+ scheduleComposerFocus();
224
+ return;
225
+ }
226
+ if (isLocalDraftThread) {
227
+ setDraftThreadContext(composerDraftTarget, {
228
+ envMode: mode,
229
+ startFromOrigin: resolveNewDraftStartFromOrigin({
230
+ envMode: mode,
231
+ newWorktreesStartFromOrigin: activeProjectSettings.settings.newWorktreesStartFromOrigin,
232
+ }),
233
+ ...(mode === "worktree" && draftThread?.worktreePath ? { worktreePath: null } : {}),
234
+ });
235
+ }
236
+ scheduleComposerFocus();
237
+ };
238
+ const onEnvModeChangeStable = useStableCallback(onEnvModeChange);
239
+
240
+ const onStartFromOriginChange = (nextStartFromOrigin: boolean) => {
241
+ if (canOverrideServerThreadEnvMode && activeThread) {
242
+ setPendingServerThreadStartFromOriginByThreadId((current) =>
243
+ current[activeThread.id] === nextStartFromOrigin
244
+ ? current
245
+ : { ...current, [activeThread.id]: nextStartFromOrigin },
246
+ );
247
+ return;
248
+ }
249
+ if (isLocalDraftThread) {
250
+ setDraftThreadContext(composerDraftTarget, {
251
+ startFromOrigin: nextStartFromOrigin,
252
+ });
253
+ }
254
+ };
255
+ return {
256
+ getModelDisabledReason,
257
+ handleInteractionModeChange,
258
+ handleInteractionModeChangeStable,
259
+ handleRuntimeModeChangeStable,
260
+ onEnvModeChangeStable,
261
+ onProviderModelSelectStable,
262
+ onStartFromOriginChange,
263
+ openProviderSetupStable,
264
+ toggleInteractionModeStable,
265
+ };
266
+}