Skip to content

Commit 7917ac8

Browse files
only21milclaudemaria-rcks
authored
fix(web): Resume keeps its thread's model when you switch threads (pingdotgg#24697)
Co-authored-by: Claude Opus 5.5 <[email protected]> Co-authored-by: maria-rcks <[email protected]>
1 parent e496db3 commit 7917ac8

2 files changed

Lines changed: 96 additions & 1 deletion

File tree

Lines changed: 93 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -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‎

Lines changed: 3 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -106,6 +106,9 @@ export function useComposerResume(input: ComposerResumeInput) {
106106
if (resumableRunId === null) {
107107
return resumeThreadQueue({ environmentId, input: { threadId } });
108108
}
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;
109112
const createdAt = new Date().toISOString();
110113
const settingsResult = await persistThreadSettingsForNextTurn({
111114
threadId,
@@ -117,7 +120,6 @@ export function useComposerResume(input: ComposerResumeInput) {
117120
interactionMode,
118121
});
119122
if (settingsResult._tag === "Failure") return settingsResult;
120-
const modelSelection = composerRef.current?.getSendContext().selectedModelSelection;
121123
const turnResult = await startThreadTurn({
122124
environmentId,
123125
input: {

0 commit comments

Comments
 (0)