@devries-cameron20 / t3code Mirror · read-only / commits / 976a601b87
Fork 0

The best way to control Claude Code, Codex and more from any computer or phone

Mirrored from https://github.com/Camo67/t3code.git

Synced Nov 22, 19:30 UTC

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 +}