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, 10:45 UTC
fix(web): Resume keeps its thread's model when you switch threads (#24697)
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com> Co-authored-by: maria-rcks <254055478+maria-rcks@users.noreply.github.com>
Victor Vogel committed
Oct 30, 2026 at 16:28 UTC
7917ac895bac1de8aecac4276a3478bc3eeb6182
2 files changed
+96
-1
apps/web/src/components/chat/useComposerResume.browser.test.tsx
new
+93
@@ -0,0 +1,93 @@
1
+import { EnvironmentId, ProviderInstanceId, RunId, ThreadId } from "@t3tools/contracts";
2
+import type { AtomCommandResult } from "@t3tools/client-runtime/state/runtime";
3
+import { AsyncResult } from "effect/reactivity";
4
+import { expect, it, vi } from "vite-plus/test";
5
+
6
+const state = vi.hoisted(() => ({
7
+ startedTurn: null as ReturnType<typeof deferred<unknown>> | null,
8
+}));
9
+
10
+vi.mock(import("../../state/use-orchestration-command"), async (importOriginal) => ({
11
+ ...(await importOriginal()),
12
+ useOrchestrationCommand: (() => async (value: { readonly input: unknown }) => {
13
+ state.startedTurn?.resolve(value.input);
14
+ return AsyncResult.success(undefined);
15
+ }) as never,
16
+}));
17
+
18
+import { render } from "../../../test/render";
19
+import type { ComposerHandleRef } from "../../composerHandleContext";
20
+import { useComposerResume } from "./useComposerResume";
21
+
22
+function deferred<T>() {
23
+ let resolve!: (value: T) => void;
24
+ const promise = new Promise<T>((complete) => {
25
+ resolve = complete;
26
+ });
27
+ return { promise, resolve };
28
+}
29
+
30
+function setup() {
31
+ const startedTurn = deferred<unknown>();
32
+ state.startedTurn = startedTurn;
33
+ return { startedTurn };
34
+}
35
+
36
+const threadA = ThreadId.make("thread:a");
37
+const threadAModel = { instanceId: ProviderInstanceId.make("codex"), model: "gpt-5.5" };
38
+const threadBModel = { instanceId: ProviderInstanceId.make("claudeAgent"), model: "claude-opus" };
39
+
40
+function composerShowing(selectedModelSelection: typeof threadAModel) {
41
+ return { getSendContext: () => ({ selectedModelSelection }) } as never;
42
+}
43
+
44
+function ResumeButton(props: {
45
+ readonly composerRef: ComposerHandleRef;
46
+ readonly persistSettings: () => Promise<AtomCommandResult<void, unknown>>;
47
+}) {
48
+ const { onResume } = useComposerResume({
49
+ environmentId: EnvironmentId.make("environment:test"),
50
+ routeThreadKey: "environment:test:thread:a",
51
+ currentRouteThreadKeyRef: { current: "environment:test:thread:a" },
52
+ activeThread: { id: threadA } as never,
53
+ resumableRunId: RunId.make("run:interrupted"),
54
+ hasHeldQueuedRuns: false,
55
+ isSendBusy: false,
56
+ isRevertingCheckpoint: false,
57
+ threadDetailLoading: false,
58
+ activeEnvironmentUnavailable: false,
59
+ runtimeMode: "full-access",
60
+ interactionMode: "default",
61
+ localCheckoutBranchMismatch: null,
62
+ composerRef: props.composerRef,
63
+ persistThreadSettingsForNextTurn: props.persistSettings,
64
+ clearUsageLimitsFor: () => undefined,
65
+ scrollToEnd: () => undefined,
66
+ setThreadError: () => undefined,
67
+ });
68
+ return (
69
+ <button type="button" onClick={() => void onResume()}>
70
+ Resume
71
+ </button>
72
+ );
73
+}
74
+
75
+it("continues on the resumed thread's model after the composer moves to another thread", async () => {
76
+ const { startedTurn } = setup();
77
+ const settingsPersisted = deferred<AtomCommandResult<void, unknown>>();
78
+ // ChatView keeps one composer across thread routes, so its ref follows navigation.
79
+ const composerRef: ComposerHandleRef = { current: composerShowing(threadAModel) };
80
+ await using screen = await render(
81
+ <ResumeButton composerRef={composerRef} persistSettings={() => settingsPersisted.promise} />,
82
+ );
83
+
84
+ await screen.getByRole("button", { name: "Resume" }).click();
85
+ composerRef.current = composerShowing(threadBModel);
86
+ settingsPersisted.resolve(AsyncResult.success(undefined));
87
+
88
+ expect(await startedTurn.promise).toMatchObject({
89
+ threadId: threadA,
90
+ manualContinuationOfRunId: "run:interrupted",
91
+ modelSelection: threadAModel,
92
+ });
93
+});
apps/web/src/components/chat/useComposerResume.ts
+3
-1
@@ -106,6 +106,9 @@ export function useComposerResume(input: ComposerResumeInput) {
106
if (resumableRunId === null) {
107
return resumeThreadQueue({ environmentId, input: { threadId } });
108
}
109
+ // Read before the first await: the composer follows the route, so after the user switches
110
+ // threads it holds the other thread's model.
111
+ const modelSelection = composerRef.current?.getSendContext().selectedModelSelection;
112
const createdAt = new Date().toISOString();
113
const settingsResult = await persistThreadSettingsForNextTurn({
114
threadId,
@@ -117,7 +120,6 @@ export function useComposerResume(input: ComposerResumeInput) {
120
interactionMode,
121
});
122
if (settingsResult._tag === "Failure") return settingsResult;
120
- const modelSelection = composerRef.current?.getSendContext().selectedModelSelection;
123
const turnResult = await startThreadTurn({
124
environmentId,
125
input: {