Skip to content

Commit 11aeff9

Browse files
only21milclaude
andcommitted
fix(web): a failed send no longer leaves a ghost message when the composer has new text
When a send failed after the user had started typing the next message, the failed message stayed in the timeline as if it had been sent, because its optimistic row was only removed when the draft could be restored into an empty composer. The failure path now always removes the optimistic row and releases its image previews. The draft is still restored only into an empty composer; otherwise the new draft is kept and an error toast offers "Copy message" so the failed text is not lost. The toast also shows when a dropped connection interrupts the send, which shows no thread error. Co-Authored-By: Claude Opus 5.5 <[email protected]>
1 parent e455200 commit 11aeff9

3 files changed

Lines changed: 130 additions & 13 deletions

File tree

‎apps/web/src/components/ChatView.browser.test.tsx‎

Lines changed: 73 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -1,10 +1,15 @@
11
import { createMemoryHistory } from "@tanstack/react-router";
22
import { scopeProjectRef } from "@t3tools/client-runtime/environment";
3-
import { ThreadId } from "@t3tools/contracts";
3+
import {
4+
ORCHESTRATION_V2_WS_METHODS,
5+
OrchestrationDispatchCommandError,
6+
ThreadId,
7+
} from "@t3tools/contracts";
48
import { DEFAULT_CLIENT_SETTINGS } from "@t3tools/contracts/settings";
59
import type * as Context from "effect/Context";
10+
import * as Effect from "effect/Effect";
611
import { expect, it, vi } from "vite-plus/test";
7-
import { page } from "vite-plus/test/browser";
12+
import { page, userEvent } from "vite-plus/test/browser";
813

914
import { AppRoot } from "~/AppRoot";
1015
// The route loads ChatView lazily, and its first transform (React Compiler over ~4k lines)
@@ -16,7 +21,9 @@ import { getRouter } from "~/router";
1621
import {
1722
ENVIRONMENT_ID,
1823
PROJECT_ID,
24+
answerRpc,
1925
installFakeEnvironment,
26+
threadWithHistory,
2027
type FakeDriver,
2128
} from "../../test/fakeEnvironment";
2229
import { render } from "../../test/render";
@@ -65,3 +72,67 @@ it("a new draft does not load its reserved thread before the server lists it", a
6572
// A 404 here marks the thread deleted, and the view never loads it once the send creates it.
6673
expect(threadRequests).toEqual([]);
6774
});
75+
76+
it.each([
77+
{
78+
failure: "rejected",
79+
end: Effect.fail(
80+
new OrchestrationDispatchCommandError({ message: "Provider is unavailable." }),
81+
),
82+
banner: "Provider is unavailable.",
83+
},
84+
// A dropped connection interrupts the request and shows no thread error.
85+
{ failure: "interrupted", end: Effect.interrupt, banner: null },
86+
])(
87+
"a failed send ($failure) drops its message from the timeline and keeps the draft typed meanwhile",
88+
async ({ failure, end, banner }) => {
89+
// Drafts persist per thread, so each case gets its own.
90+
const thread = threadWithHistory(`thread-${failure}-send`, 1);
91+
using _environment = installFakeEnvironment([thread]);
92+
__setClientSettingsForTests({
93+
...DEFAULT_CLIENT_SETTINGS,
94+
onboardingCompletedAt: "2026-01-01T00:00:00.000Z",
95+
});
96+
let failDispatch = () => {};
97+
const dispatchHeld = new Promise<void>((resolve) => {
98+
failDispatch = resolve;
99+
});
100+
using _dispatch = answerRpc(ORCHESTRATION_V2_WS_METHODS.dispatchCommand, () =>
101+
Effect.promise(() => dispatchHeld).pipe(Effect.andThen(end)),
102+
);
103+
const router = getRouter(
104+
createMemoryHistory({ initialEntries: [`/${ENVIRONMENT_ID}/${thread.id}`] }),
105+
);
106+
await router.load();
107+
await using _app = await render(<AppRoot router={router} />, {
108+
// AppRoot brings its own router.
109+
router: false,
110+
});
111+
using write = vi.spyOn(navigator.clipboard, "writeText").mockResolvedValue(undefined);
112+
// Only timeline rows, so the composer and sidebar cannot match the text.
113+
const sentMessages = () =>
114+
Array.from(document.querySelectorAll('[data-message-role="user"]'), (row) => row.textContent);
115+
const failedText = "first message that will fail";
116+
const editor = page.getByTestId("composer-editor");
117+
await expect.element(editor).toBeVisible();
118+
119+
await userEvent.click(editor);
120+
await userEvent.keyboard(`${failedText}{Enter}`);
121+
await vi.waitFor(() =>
122+
expect(sentMessages()).toContainEqual(expect.stringContaining(failedText)),
123+
);
124+
await userEvent.keyboard("next draft");
125+
await expect.element(editor).toHaveTextContent("next draft");
126+
failDispatch();
127+
128+
await vi.waitFor(() =>
129+
expect(sentMessages()).not.toContainEqual(expect.stringContaining(failedText)),
130+
);
131+
await expect.element(page.getByText("Message not sent")).toBeVisible();
132+
if (banner) await expect.element(page.getByText(banner)).toBeVisible();
133+
await expect.element(editor).toHaveTextContent("next draft");
134+
// By text, since each timeline row has an icon button labelled the same.
135+
await page.getByText("Copy message", { exact: true }).click();
136+
expect(write).toHaveBeenCalledWith(failedText);
137+
},
138+
);

‎apps/web/src/components/chat/useComposerSend.ts‎

Lines changed: 45 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -64,6 +64,7 @@ import { recordPromptSent } from "../GitHubStarPrompt";
6464
import { stackedThreadToast, toastManager } from "../ui/toast";
6565
import { newMessageId, newThreadId } from "~/lib/utils";
6666
import { useNewThreadHandler } from "../../hooks/useHandleNewThread";
67+
import { writeTextToClipboard } from "../../hooks/useCopyToClipboard";
6768
import { buildThreadRouteParams } from "../../threadRoutes";
6869
import {
6970
beginBackgroundDraftSubmissionByRef,
@@ -258,6 +259,18 @@ interface ComposerSendInput {
258259
}) => Promise<AtomCommandResult<void, unknown>>;
259260
}
260261

262+
// Outside the hook, so a toast that stays open holds only the text, not the send's snapshots.
263+
function copyFailedMessageAction(text: string) {
264+
return {
265+
children: "Copy message",
266+
onClick: () => {
267+
void writeTextToClipboard(text, "message").catch(() =>
268+
toastManager.add({ type: "error", title: "Could not copy the message" }),
269+
);
270+
},
271+
};
272+
}
273+
261274
/**
262275
* Everything the composer's send button can start: a turn on this thread or a new one,
263276
* a multiple-model start, a queued or steering message, a plan follow-up or implementation
@@ -1468,17 +1481,20 @@ export function useComposerSend(input: ComposerSendInput) {
14681481
);
14691482
clearBackgroundDraftSubmissionByRef(scopeThreadRef(environmentId, threadIdForSend));
14701483
}
1471-
if (
1472-
!composerDraftHasUserContent(
1473-
useComposerDraftStore.getState().getComposerDraft(composerDraftTarget),
1474-
)
1475-
) {
1476-
setOptimisticUserMessages((existing) => {
1477-
const next = existing.filter((message) => message.id !== messageIdForSend);
1478-
return next.length === existing.length ? existing : next;
1479-
});
1480-
// The restored draft clones its images, so the sent copies are no longer used.
1481-
optimisticBlobPreviews.release(optimisticMessage);
1484+
setOptimisticUserMessages((existing) => {
1485+
const next = existing.filter((message) => message.id !== messageIdForSend);
1486+
return next.length === existing.length ? existing : next;
1487+
});
1488+
// The restored draft clones its images, so the sent copies are no longer used.
1489+
optimisticBlobPreviews.release(optimisticMessage);
1490+
const restoresDraft = !composerDraftHasUserContent(
1491+
useComposerDraftStore.getState().getComposerDraft(composerDraftTarget),
1492+
);
1493+
const copyFailedMessage =
1494+
!restoresDraft && messageTextForSend
1495+
? copyFailedMessageAction(messageTextForSend)
1496+
: undefined;
1497+
if (restoresDraft) {
14821498
const retryComposerImages = restoreComposerDraft(composerDraftTarget, sendSnapshot);
14831499
if (currentRouteThreadKeyRef.current === routeThreadKey) {
14841500
promptRef.current = messageTextForSend;
@@ -1492,6 +1508,7 @@ export function useComposerSend(input: ComposerSendInput) {
14921508
});
14931509
}
14941510
}
1511+
let failureToastShown = false;
14951512
if (!isAtomCommandInterrupted(failure)) {
14961513
const error = squashAtomCommandFailure(failure);
14971514
setThreadError(
@@ -1516,10 +1533,27 @@ export function useComposerSend(input: ComposerSendInput) {
15161533
void navigate({ to: "/draft/$draftId", params: { draftId } });
15171534
},
15181535
},
1536+
// The toast is then the only copy of the failed text, so it stays until dismissed.
1537+
...(copyFailedMessage
1538+
? { timeout: 0, data: { secondaryActionProps: copyFailedMessage } }
1539+
: {}),
15191540
}),
15201541
);
1542+
failureToastShown = true;
15211543
}
15221544
}
1545+
// An interrupted send shows no error, but its text still needs a way back.
1546+
if (copyFailedMessage && !failureToastShown) {
1547+
toastManager.add(
1548+
stackedThreadToast({
1549+
type: "error",
1550+
title: "Message not sent",
1551+
description: "Your new draft was kept.",
1552+
timeout: 0,
1553+
actionProps: copyFailedMessage,
1554+
}),
1555+
);
1556+
}
15231557
}
15241558
sendInFlightRef.current = false;
15251559
setSetupQueueSendThreadKey((current) => (current === activeThreadKey ? null : current));

‎apps/web/test/fakeEnvironment.ts‎

Lines changed: 12 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -462,6 +462,18 @@ export function installFakeEnvironment(fixtures: ReadonlyArray<FakeThread>): Dis
462462

463463
type ThreadEvent = Extract<OrchestrationV2ThreadStreamItem, { readonly kind: "event" }>["event"];
464464

465+
/** Answers one RPC method with `handler` until disposed. */
466+
export function answerRpc(method: string, handler: (input: never) => unknown): Disposable {
467+
const previous = handlers[method];
468+
handlers[method] = handler;
469+
return {
470+
[Symbol.dispose]: () => {
471+
if (previous) handlers[method] = previous;
472+
else delete handlers[method];
473+
},
474+
};
475+
}
476+
465477
export async function emitTerminalMetadata(event: TerminalMetadataStreamEvent): Promise<void> {
466478
if (terminalMetadataSubscriber === null) throw new Error("No terminal metadata subscription");
467479
await Effect.runPromise(Queue.offer(terminalMetadataSubscriber, event));

0 commit comments

Comments
 (0)