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, 20:45 UTC
refactor(web): ChatView's send preparation is pure functions in ChatView.logic (#22734)
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
Julius Marminge committed
Oct 21, 2026 at 01:36 UTC
38b13e977efe65dee331b15f950b9164b4159489
4 files changed
+478
-199
apps/web/src/components/ChatView.logic.test.ts
+135
-1
@@ -1,7 +1,16 @@
1
-import { findRecordedWorktreeSetup, mergeDirectPreviewAnnotation } from "./ChatView.logic";
1
+import {
2
+ boundAttachmentIds,
3
+ findRecordedWorktreeSetup,
4
+ mergeDirectPreviewAnnotation,
5
+ planComposerTurn,
6
+ snapshotComposerSend,
7
+ withMessageContext,
8
+} from "./ChatView.logic";
9
import { recallCheckoutIsRepo, rememberCheckoutIsRepo } from "./ChatView.logic";
10
import { ProviderDriverKind, type ServerProvider } from "@t3tools/contracts";
11
import { deriveProviderInstanceEntries } from "../providerInstances";
12
+import { ensureInlineContextReferences } from "../lib/composerContextReferences";
13
+import { terminalContextReference } from "../lib/composerContextRecords";
14
import {
15
CommandId,
16
EnvironmentId,
@@ -1024,3 +1033,128 @@ describe("mergeDirectPreviewAnnotation", () => {
1033
expect(result.previewAnnotations[0]?.screenshot).toBeNull();
1034
});
1035
});
1036
+
1037
+describe("snapshotComposerSend", () => {
1038
+ const expired = {
1039
+ id: "ctx-expired",
1040
+ threadId,
1041
+ terminalId: "default",
1042
+ terminalLabel: "Terminal 1",
1043
+ lineStart: 4,
1044
+ lineEnd: 4,
1045
+ text: "",
1046
+ createdAt: now,
1047
+ };
1048
+ const live = { ...expired, id: "ctx-live", text: "pnpm test", lineStart: 9, lineEnd: 9 };
1049
+
1050
+ it("drops expired terminal contexts from the contexts and from the prompt", () => {
1051
+ const snapshot = snapshotComposerSend({
1052
+ prompt: ensureInlineContextReferences("run", [
1053
+ terminalContextReference(expired),
1054
+ terminalContextReference(live),
1055
+ ]),
1056
+ images: [],
1057
+ files: [],
1058
+ terminalContexts: [expired, live],
1059
+ sendableTerminalContexts: [live],
1060
+ previewAnnotations: [],
1061
+ reviewComments: [],
1062
+ threadContexts: [],
1063
+ });
1064
+
1065
+ expect(snapshot.terminalContexts).toEqual([live]);
1066
+ expect(snapshot.messageText).toBe(
1067
+ ensureInlineContextReferences("run", [terminalContextReference(live)]).trim(),
1068
+ );
1069
+ });
1070
+});
1071
+
1072
+describe("planComposerTurn", () => {
1073
+ const base = {
1074
+ messageText: "hello",
1075
+ sendQueuesBehindSetup: false,
1076
+ isServerThread: false,
1077
+ activeMessageCount: 0,
1078
+ sendEnvMode: "worktree" as const,
1079
+ worktreePath: null,
1080
+ activeThreadBranch: "main",
1081
+ resumeCompactionTokens: null,
1082
+ keepFullHistory: false,
1083
+ phase: "ready" as const,
1084
+ dispatchMode: "auto" as const,
1085
+ };
1086
+
1087
+ it("prepares a worktree from the selected branch on a new thread", () => {
1088
+ expect(planComposerTurn(base)).toMatchObject({
1089
+ missingWorktreeBaseBranch: false,
1090
+ baseBranchForWorktree: "main",
1091
+ shouldQueueBehindActiveRun: false,
1092
+ });
1093
+ });
1094
+
1095
+ it("refuses a new worktree without a base branch", () => {
1096
+ expect(planComposerTurn({ ...base, activeThreadBranch: null })).toMatchObject({
1097
+ missingWorktreeBaseBranch: true,
1098
+ baseBranchForWorktree: null,
1099
+ });
1100
+ });
1101
+
1102
+ it("queues behind a compaction of a stale session, except for /compact itself", () => {
1103
+ expect(planComposerTurn({ ...base, resumeCompactionTokens: 120_000 })).toMatchObject({
1104
+ compactBeforeSend: true,
1105
+ turnDispatchMode: "queue",
1106
+ shouldQueueBehindActiveRun: true,
1107
+ });
1108
+ expect(
1109
+ planComposerTurn({ ...base, resumeCompactionTokens: 120_000, messageText: "/COMPACT" }),
1110
+ ).toMatchObject({ compactBeforeSend: false, turnDispatchMode: "auto" });
1111
+ });
1112
+
1113
+ it("queues behind a running turn only when asked to", () => {
1114
+ const running = {
1115
+ ...base,
1116
+ isServerThread: true,
1117
+ activeMessageCount: 3,
1118
+ phase: "running" as const,
1119
+ };
1120
+ expect(planComposerTurn({ ...running, dispatchMode: "queue" }).shouldQueueBehindActiveRun).toBe(
1121
+ true,
1122
+ );
1123
+ expect(planComposerTurn({ ...running, dispatchMode: "steer" })).toMatchObject({
1124
+ shouldQueueBehindActiveRun: false,
1125
+ baseBranchForWorktree: null,
1126
+ });
1127
+ });
1128
+});
1129
+
1130
+describe("withMessageContext", () => {
1131
+ const context = { records: [] } as unknown as NonNullable<
1132
+ Parameters<typeof withMessageContext>[0]["context"]
1133
+ >;
1134
+
1135
+ it("sends the context inline when the server supports it", () => {
1136
+ expect(withMessageContext({ text: "hi", context, supportsInlineMessageContext: true })).toEqual(
1137
+ { text: "hi", context },
1138
+ );
1139
+ });
1140
+
1141
+ it("folds the context into the text for older servers", () => {
1142
+ const result = withMessageContext({ text: "hi", context, supportsInlineMessageContext: false });
1143
+ expect(result.context).toBeUndefined();
1144
+ expect(result.text).toContain("hi");
1145
+ });
1146
+
1147
+ it("sends the text alone without context", () => {
1148
+ expect(
1149
+ withMessageContext({ text: "hi", context: undefined, supportsInlineMessageContext: false }),
1150
+ ).toEqual({ text: "hi" });
1151
+ });
1152
+});
1153
+
1154
+describe("boundAttachmentIds", () => {
1155
+ it("prefers the uploaded id and falls back to the local one", () => {
1156
+ expect(
1157
+ boundAttachmentIds([{ id: "upload-1" }, {}], [{ id: "local-1" }, { id: "local-2" }]),
1158
+ ).toEqual(["upload-1", "local-2"]);
1159
+ });
1160
+});
apps/web/src/components/ChatView.logic.ts
+170
-2
@@ -16,6 +16,7 @@ import {
16
ProjectId,
17
type MessageId,
18
type ModelSelection,
19
+ type OrchestrationMessageContext,
20
type OrchestrationV2ProjectedTurnItem,
21
type PreviewAnnotationPayload,
22
type ProviderInteractionMode,
@@ -53,6 +54,7 @@ import {
54
type TurnDiffSummary,
55
} from "../types";
56
import {
57
+ type ComposerFileAttachment,
58
type ComposerImageAttachment,
59
type DraftId,
60
type DraftThreadState,
@@ -61,8 +63,22 @@ import * as Schema from "effect/Schema";
63
import { appAtomRegistry } from "../rpc/atomRegistry";
64
import { environmentThreadShells, environmentThreadDetails } from "../state/threads";
65
import { waitForAtomValue } from "../state/waitForAtomValue";
64
-import { filterTerminalContextsWithText, type TerminalContextDraft } from "../lib/terminalContext";
65
-import { stripInlineContextReferences } from "~/lib/composerContextReferences";
66
+import {
67
+ filterTerminalContextsWithText,
68
+ formatTerminalContextLabel,
69
+ type TerminalContextDraft,
70
+} from "../lib/terminalContext";
71
+import {
72
+ removeInlineContextReference,
73
+ stripInlineContextReferences,
74
+} from "~/lib/composerContextReferences";
75
+import {
76
+ previewAnnotationContextLabel,
77
+ reviewCommentContextLabel,
78
+ terminalContextReference,
79
+} from "../lib/composerContextRecords";
80
+import { serializeLegacyContextMessage } from "@t3tools/shared/composerContextLegacySend";
81
+import type { ComposerDispatchMode } from "@t3tools/client-runtime/state/composer-dispatch";
82
import type { DraftThreadEnvMode } from "../composerDraftStore";
83
import { collapseExpandedComposerCursor, type ComposerSubmissionIntent } from "../composer-logic";
84
import type { ReviewCommentContext } from "../reviewCommentContext";
@@ -1442,3 +1458,155 @@ export function makeModelDisabledReason(
1458
return reason ? `${reason.description} Start a new thread to use this model.` : null;
1459
};
1460
}
1461
+
1462
+/** What the composer held when the user pressed send, after a direct annotation merged in. */
1463
+export interface ComposerSendContents {
1464
+ readonly prompt: string;
1465
+ readonly images: ReadonlyArray<ComposerImageAttachment>;
1466
+ readonly files: ReadonlyArray<ComposerFileAttachment>;
1467
+ readonly terminalContexts: ReadonlyArray<TerminalContextDraft>;
1468
+ readonly sendableTerminalContexts: ReadonlyArray<TerminalContextDraft>;
1469
+ readonly previewAnnotations: ReadonlyArray<PreviewAnnotationPayload>;
1470
+ readonly reviewComments: ReadonlyArray<ReviewCommentContext>;
1471
+ readonly threadContexts: ReadonlyArray<ThreadContextRecord>;
1472
+}
1473
+
1474
+/**
1475
+ * Copies the composer contents a send dispatches, so a failed send can put the
1476
+ * same draft back. Terminal contexts that lost their text are dropped from both
1477
+ * the contexts and the prompt's inline references.
1478
+ */
1479
+export function snapshotComposerSend(contents: ComposerSendContents) {
1480
+ const images = [...contents.images];
1481
+ const files = [...contents.files];
1482
+ const terminalContexts = [...contents.sendableTerminalContexts];
1483
+ return {
1484
+ images,
1485
+ files,
1486
+ attachments: [...images, ...files],
1487
+ terminalContexts,
1488
+ previewAnnotations: [...contents.previewAnnotations],
1489
+ reviewComments: [...contents.reviewComments],
1490
+ threadContexts: [...contents.threadContexts],
1491
+ messageText: contents.terminalContexts
1492
+ .filter((context) => !terminalContexts.includes(context))
1493
+ .reduce(
1494
+ (text, context) =>
1495
+ removeInlineContextReference(text, terminalContextReference(context).contextId).prompt,
1496
+ contents.prompt,
1497
+ )
1498
+ .trim(),
1499
+ };
1500
+}
1501
+
1502
+export type ComposerSendSnapshot = ReturnType<typeof snapshotComposerSend>;
1503
+
1504
+/** How a composer send dispatches: where it runs and whether it waits behind other work. */
1505
+export function planComposerTurn(input: {
1506
+ readonly messageText: string;
1507
+ readonly sendQueuesBehindSetup: boolean;
1508
+ readonly isServerThread: boolean;
1509
+ readonly activeMessageCount: number;
1510
+ readonly sendEnvMode: DraftThreadEnvMode;
1511
+ readonly worktreePath: string | null;
1512
+ readonly activeThreadBranch: string | null;
1513
+ readonly resumeCompactionTokens: number | null;
1514
+ readonly keepFullHistory: boolean;
1515
+ readonly phase: SessionPhase;
1516
+ readonly dispatchMode: ComposerDispatchMode;
1517
+}) {
1518
+ const isFirstMessage =
1519
+ !input.sendQueuesBehindSetup && (!input.isServerThread || input.activeMessageCount === 0);
1520
+ const shouldCreateWorktree =
1521
+ isFirstMessage && input.sendEnvMode === "worktree" && !input.worktreePath;
1522
+ // A stale Claude session compacts before this message so the turn does not re-read the
1523
+ // old history. The message queues behind the /compact run, since steering into it is
1524
+ // rejected.
1525
+ const compactBeforeSend =
1526
+ input.resumeCompactionTokens !== null &&
1527
+ !input.keepFullHistory &&
1528
+ input.messageText.toLowerCase() !== "/compact";
1529
+ return {
1530
+ // In worktree mode, require an explicit base branch so we don't silently
1531
+ // fall back to local execution when branch selection is missing.
1532
+ missingWorktreeBaseBranch: shouldCreateWorktree && !input.activeThreadBranch,
1533
+ baseBranchForWorktree: shouldCreateWorktree ? input.activeThreadBranch : null,
1534
+ compactBeforeSend,
1535
+ turnDispatchMode:
1536
+ compactBeforeSend || input.sendQueuesBehindSetup ? ("queue" as const) : input.dispatchMode,
1537
+ shouldQueueBehindActiveRun:
1538
+ compactBeforeSend ||
1539
+ input.sendQueuesBehindSetup ||
1540
+ (input.phase === "running" && input.dispatchMode === "queue"),
1541
+ };
1542
+}
1543
+
1544
+/**
1545
+ * The attachment ids a message's context records bind to: the upload id the
1546
+ * server returned, or the local id on the data-URL path.
1547
+ */
1548
+export function boundAttachmentIds(
1549
+ turnAttachments: ReadonlyArray<{ readonly id?: string | undefined }>,
1550
+ attachments: ReadonlyArray<{ readonly id: string }>,
1551
+): string[] {
1552
+ return turnAttachments.map((attachment, index) =>
1553
+ "id" in attachment && attachment.id !== undefined ? attachment.id : attachments[index]!.id,
1554
+ );
1555
+}
1556
+
1557
+/**
1558
+ * The message text and context a turn sends. Servers from before inline
1559
+ * context drop the records and forward the links as literal text, so their
1560
+ * turns carry the payload the legacy way.
1561
+ */
1562
+export function withMessageContext(input: {
1563
+ readonly text: string;
1564
+ readonly context: OrchestrationMessageContext | undefined;
1565
+ readonly supportsInlineMessageContext: boolean;
1566
+}): { readonly text: string; readonly context?: OrchestrationMessageContext } {
1567
+ const { text, context } = input;
1568
+ if (context === undefined) return { text };
1569
+ if (!input.supportsInlineMessageContext) {
1570
+ return { text: serializeLegacyContextMessage({ text, records: context.records }) };
1571
+ }
1572
+ return { text, context };
1573
+}
1574
+
1575
+/** The attachments the optimistic user row shows before the server echoes the message. */
1576
+export function optimisticMessageAttachments(
1577
+ attachments: ReadonlyArray<ComposerImageAttachment | ComposerFileAttachment>,
1578
+) {
1579
+ return attachments.map((attachment) =>
1580
+ attachment.type === "image"
1581
+ ? {
1582
+ type: "image" as const,
1583
+ id: attachment.id,
1584
+ name: attachment.name,
1585
+ mimeType: attachment.mimeType,
1586
+ sizeBytes: attachment.sizeBytes,
1587
+ previewUrl: attachment.previewUrl,
1588
+ ...(attachment.source ? { source: attachment.source } : {}),
1589
+ }
1590
+ : {
1591
+ type: "file" as const,
1592
+ id: attachment.id,
1593
+ name: attachment.name,
1594
+ mimeType: attachment.mimeType,
1595
+ sizeBytes: attachment.sizeBytes,
1596
+ downloadable: false,
1597
+ ...(attachment.source ? { source: attachment.source } : {}),
1598
+ },
1599
+ );
1600
+}
1601
+
1602
+/** Fallback title sources for a message with no text of its own. */
1603
+export function sendTitleFallbackLabels(snapshot: ComposerSendSnapshot) {
1604
+ const terminalContext = snapshot.terminalContexts[0];
1605
+ const reviewComment = snapshot.reviewComments[0];
1606
+ const previewAnnotation = snapshot.previewAnnotations[0];
1607
+ return [
1608
+ terminalContext ? formatTerminalContextLabel(terminalContext) : undefined,
1609
+ reviewComment ? `Review: ${reviewCommentContextLabel(reviewComment)}` : undefined,
1610
+ previewAnnotation ? previewAnnotationContextLabel(previewAnnotation) : undefined,
1611
+ ];
1612
+}
apps/web/src/components/ChatView.tsx
+81
-195
@@ -256,10 +256,6 @@ import { useNewThreadHandler } from "../hooks/useHandleNewThread";
256
import { useRemoveClonedProject } from "../hooks/useRemoveClonedProject";
257
import { useOpenPanelPullRequestUrl } from "../hooks/useOpenPanelPullRequestUrl";
258
import { resolveAppModelSelectionForInstance } from "../modelSelection";
259
-import {
260
- getComposerPromptInjectionState,
261
- getComposerProviderState,
262
-} from "./chat/composerProviderState";
259
import { confirmTerminalClose } from "../lib/terminalCloseConfirm";
260
import { isPreviewFocused } from "../lib/previewFocus";
261
import { getTerminalFocusOwner } from "../lib/terminalFocus";
@@ -287,25 +283,15 @@ import {
283
useComposerDraftStore,
284
DraftId,
285
} from "../composerDraftStore";
290
-import {
291
- formatTerminalContextLabel,
292
- type TerminalContextDraft,
293
- type TerminalContextSelection,
294
-} from "../lib/terminalContext";
286
+import { type TerminalContextDraft, type TerminalContextSelection } from "../lib/terminalContext";
287
import {
288
collectInlineContextIds,
289
ensureInlineContextReferences,
298
- removeInlineContextReference,
290
} from "../lib/composerContextReferences";
300
-import { serializeLegacyContextMessage } from "@t3tools/shared/composerContextLegacySend";
291
import {
292
buildMessageContext,
303
- previewAnnotationContextLabel,
293
previewAnnotationContextReference,
305
- reviewCommentContextLabel,
306
- terminalContextReference,
294
} from "../lib/composerContextRecords";
308
-import { type ReviewCommentContext } from "../reviewCommentContext";
295
import { selectThreadTerminalUiState, useTerminalUiStateStore } from "../terminalUiStateStore";
296
import { useKnownTerminalSessions, useThreadRunningTerminalIds } from "../state/terminalSessions";
297
import { useEnvironmentQuery } from "../state/query";
@@ -437,13 +423,11 @@ import {
423
getStartedThreadModelChangeBlockReason,
424
LAST_INVOKED_SCRIPT_BY_PROJECT_KEY,
425
LastInvokedScriptByProjectSchema,
440
- cloneComposerImageForRetry,
426
deriveLockedProvider,
427
readFileAsDataUrl,
428
resolveFileAttachmentUrl,
429
resolveComposerInteractionMode,
430
resolveComposerProviderSelection,
446
- getAntigravitySendBlockReason,
431
resolveThreadMetadataUpdateForNextTurn,
432
resolveSendEnvMode,
433
revokeBlobPreviewUrl,
@@ -499,12 +483,21 @@ import { useLocalDispatchState } from "./chat/useLocalDispatchState";
483
import {
484
draftFanoutSelectionsAtom,
485
draftSendState,
486
+ type MultipleModelTarget,
487
+ resolveMultipleModelTargets,
488
+ restoreComposerDraft,
489
rewindToMessage,
490
startFanoutThread,
491
} from "./chat/chatViewSend";
492
import {
493
+ boundAttachmentIds,
494
chatActionErrorMessage,
495
formatOutgoingPrompt,
496
+ optimisticMessageAttachments,
497
+ planComposerTurn,
498
+ sendTitleFallbackLabels,
499
+ snapshotComposerSend,
500
+ withMessageContext,
501
isCompactCommandMessage,
502
type LocalThreadErrorEntry,
503
makeModelDisabledReason,
@@ -806,8 +799,6 @@ export default function ChatView(props: ChatViewProps) {
799
return draft ? composerDraftHasUserContent({ ...draft, prompt: "" }) : false;
800
});
801
const setComposerDraftPrompt = useComposerDraftStore((store) => store.setPrompt);
809
- const addComposerDraftImages = useComposerDraftStore((store) => store.addImages);
810
- const addComposerDraftFiles = useComposerDraftStore((store) => store.addFiles);
802
const setComposerDraftTerminalContexts = useComposerDraftStore(
803
(store) => store.setTerminalContexts,
804
);
@@ -5003,36 +4994,48 @@ export default function ChatView(props: ChatViewProps) {
4994
return;
4995
}
4996
const threadIdForSend = activeThread.id;
5006
- const isFirstMessage = !sendQueuesBehindSetup && (!isServerThread || activeMessageCount === 0);
5007
- const baseBranchForWorktree =
5008
- isFirstMessage && sendEnvMode === "worktree" && !activeThread.worktreePath
5009
- ? activeThreadBranch
5010
- : null;
5011
-
5012
- // In worktree mode, require an explicit base branch so we don't silently
5013
- // fall back to local execution when branch selection is missing.
5014
- const shouldCreateWorktree =
5015
- isFirstMessage && sendEnvMode === "worktree" && !activeThread.worktreePath;
5016
- if (shouldCreateWorktree && !activeThreadBranch) {
4997
+ const sendSnapshot = snapshotComposerSend({
4998
+ prompt: promptForSend,
4999
+ images: composerImages,
5000
+ files: composerFiles,
5001
+ terminalContexts: composerTerminalContexts,
5002
+ sendableTerminalContexts: sendableComposerTerminalContexts,
5003
+ previewAnnotations: composerPreviewAnnotations,
5004
+ reviewComments: composerReviewComments,
5005
+ threadContexts: composerThreadContexts,
5006
+ });
5007
+ const {
5008
+ files: composerFilesSnapshot,
5009
+ attachments: composerAttachmentsSnapshot,
5010
+ terminalContexts: composerTerminalContextsSnapshot,
5011
+ previewAnnotations: composerPreviewAnnotationsSnapshot,
5012
+ reviewComments: composerReviewCommentsSnapshot,
5013
+ threadContexts: composerThreadContextsSnapshot,
5014
+ messageText: messageTextForSend,
5015
+ } = sendSnapshot;
5016
+ const {
5017
+ missingWorktreeBaseBranch,
5018
+ baseBranchForWorktree,
5019
+ compactBeforeSend,
5020
+ turnDispatchMode,
5021
+ shouldQueueBehindActiveRun,
5022
+ } = planComposerTurn({
5023
+ messageText: messageTextForSend,
5024
+ sendQueuesBehindSetup,
5025
+ isServerThread,
5026
+ activeMessageCount,
5027
+ sendEnvMode,
5028
+ worktreePath: activeThread.worktreePath,
5029
+ activeThreadBranch,
5030
+ resumeCompactionTokens,
5031
+ keepFullHistory,
5032
+ phase,
5033
+ dispatchMode,
5034
+ });
5035
+ if (missingWorktreeBaseBranch) {
5036
setThreadError(threadIdForSend, "Select a base branch before sending in New worktree mode.");
5037
return;
5038
}
5020
-
5021
- const composerImagesSnapshot = [...composerImages];
5022
- const composerFilesSnapshot = [...composerFiles];
5023
- const composerAttachmentsSnapshot = [...composerImagesSnapshot, ...composerFilesSnapshot];
5024
- const composerTerminalContextsSnapshot = [...sendableComposerTerminalContexts];
5025
- const composerPreviewAnnotationsSnapshot = [...composerPreviewAnnotations];
5026
- const composerReviewCommentsSnapshot: ReviewCommentContext[] = [...composerReviewComments];
5027
- const composerThreadContextsSnapshot = [...composerThreadContexts];
5028
- const messageTextForSend = composerTerminalContexts
5029
- .filter((context) => !composerTerminalContextsSnapshot.includes(context))
5030
- .reduce(
5031
- (text, context) =>
5032
- removeInlineContextReference(text, terminalContextReference(context).contextId).prompt,
5033
- promptForSend,
5034
- )
5035
- .trim();
5039
// Records bind attachments by the id each side knows: the local id for the optimistic
5040
// row, the upload id (or local id on the data-URL path) on the wire; the server
5041
// rebinds them to the persisted id.
@@ -5052,18 +5055,6 @@ export default function ChatView(props: ChatViewProps) {
5055
);
5056
const messageIdForSend = newMessageId();
5057
const messageCreatedAt = new Date().toISOString();
5055
- // A stale Claude session compacts before this message so the turn does not re-read the
5056
- // old history. The message queues behind the /compact run, since steering into it is
5057
- // rejected.
5058
- const compactBeforeSend =
5059
- resumeCompactionTokens !== null &&
5060
- !keepFullHistory &&
5061
- messageTextForSend.toLowerCase() !== "/compact";
5062
- const turnDispatchMode = compactBeforeSend || sendQueuesBehindSetup ? "queue" : dispatchMode;
5063
- const shouldQueueBehindActiveRun =
5064
- compactBeforeSend ||
5065
- sendQueuesBehindSetup ||
5066
- (phase === "running" && dispatchMode === "queue");
5058
const outgoingMessageText = formatOutgoingPrompt({
5059
provider: ctxSelectedProvider,
5060
model: ctxSelectedModel,
@@ -5091,53 +5082,20 @@ export default function ChatView(props: ChatViewProps) {
5082
};
5083
};
5084
5094
- const multipleTargets: Array<{
5095
- readonly selection: ModelSelection;
5096
- readonly text: string;
5097
- readonly interactionMode: ProviderInteractionMode;
5098
- }> = [];
5099
- for (const selection of multipleModelSelections ?? []) {
5100
- const provider = providerInstanceEntries.find(
5101
- (entry) => entry.instanceId === selection.instanceId,
5102
- );
5103
- if (!provider?.enabled || !provider.isAvailable || provider.status !== "ready") {
5104
- setThreadError(threadIdForSend, `Provider for ${selection.model} is unavailable.`);
5105
- return;
5106
- }
5107
- const providerBlockReason = getAntigravitySendBlockReason(provider.snapshot, selection.model);
5108
- if (providerBlockReason) {
5109
- setThreadError(threadIdForSend, providerBlockReason);
5085
+ const multipleTargets: MultipleModelTarget[] = [];
5086
+ for (const resolved of resolveMultipleModelTargets({
5087
+ selections: multipleModelSelections ?? [],
5088
+ providerInstanceEntries,
5089
+ messageText: messageTextForSend,
5090
+ planModeEnabled: settings.planModeEnabled,
5091
+ interactionMode: sendInteractionMode,
5092
+ })) {
5093
+ if ("error" in resolved) {
5094
+ setThreadError(threadIdForSend, resolved.error);
5095
return;
5096
}
5112
- const providerState = getComposerProviderState({
5113
- provider: provider.driverKind,
5114
- model: selection.model,
5115
- models: provider.models,
5116
- modelOptions: selection.options,
5117
- promptInjectionState: getComposerPromptInjectionState(messageTextForSend),
5118
- planModeEnabled: settings.planModeEnabled,
5119
- });
5120
- const text = formatOutgoingPrompt({
5121
- provider: provider.driverKind,
5122
- model: selection.model,
5123
- models: provider.models,
5124
- effort: providerState.promptEffort,
5125
- text: messageTextForSend || ATTACHMENT_ONLY_BOOTSTRAP_PROMPT,
5126
- });
5127
- if (composerRef.current?.validateProviderInput(text) === false) return;
5128
- multipleTargets.push({
5129
- selection: createModelSelection(
5130
- selection.instanceId,
5131
- selection.model,
5132
- providerState.modelOptionsForDispatch,
5133
- ),
5134
- text,
5135
- interactionMode: resolveComposerInteractionMode({
5136
- planModeEnabled: settings.planModeEnabled,
5137
- provider: provider.snapshot,
5138
- interactionMode: sendInteractionMode,
5139
- }).interactionMode,
5140
- });
5097
+ if (composerRef.current?.validateProviderInput(resolved.text) === false) return;
5098
+ multipleTargets.push(resolved);
5099
}
5100
5101
sendInFlightRef.current = true;
@@ -5361,11 +5319,7 @@ export default function ChatView(props: ChatViewProps) {
5319
const fileBlockReason = readLiveAttachmentCapabilities().fileBlockReason;
5320
if (fileBlockReason !== null) throw new Error(fileBlockReason);
5321
const context = buildOutgoingMessageContext(
5364
- attachments.map((attachment, index) =>
5365
- "id" in attachment && attachment.id !== undefined
5366
- ? attachment.id
5367
- : composerAttachmentsSnapshot[index]!.id,
5368
- ),
5322
+ boundAttachmentIds(attachments, composerAttachmentsSnapshot),
5323
);
5324
const title = deriveThreadTitleSeed({
5325
text: messageTextForSend,
@@ -5407,15 +5361,12 @@ export default function ChatView(props: ChatViewProps) {
5361
message: {
5362
messageId: newMessageId(),
5363
role: "user",
5410
- text:
5411
- context && !supportsInlineMessageContext
5412
- ? serializeLegacyContextMessage({
5413
- text: target.text,
5414
- records: context.records,
5415
- })
5416
- : target.text,
5364
attachments,
5418
- ...(context && supportsInlineMessageContext ? { context } : {}),
5365
+ ...withMessageContext({
5366
+ text: target.text,
5367
+ context,
5368
+ supportsInlineMessageContext,
5369
+ }),
5370
},
5371
modelSelection: target.selection,
5372
titleSeed: title,
@@ -5481,19 +5432,7 @@ export default function ChatView(props: ChatViewProps) {
5432
const restoreFailedDraft = () => {
5433
setMultipleModelSelections(failedSelections);
5434
if (clearedDraft) {
5484
- setComposerDraftPrompt(composerDraftTarget, messageTextForSend);
5485
- addComposerDraftImages(
5486
- composerDraftTarget,
5487
- composerImagesSnapshot.map(cloneComposerImageForRetry),
5488
- );
5489
- addComposerDraftFiles(composerDraftTarget, composerFilesSnapshot);
5490
- setComposerDraftTerminalContexts(composerDraftTarget, composerTerminalContextsSnapshot);
5491
- setComposerDraftPreviewAnnotations(
5492
- composerDraftTarget,
5493
- composerPreviewAnnotationsSnapshot,
5494
- );
5495
- setComposerDraftReviewComments(composerDraftTarget, composerReviewCommentsSnapshot);
5496
- setComposerDraftThreadContexts(composerDraftTarget, composerThreadContextsSnapshot);
5435
+ restoreComposerDraft(composerDraftTarget, sendSnapshot);
5436
if (composerRef.current && currentRouteThreadKeyRef.current === routeThreadKey) {
5437
promptRef.current = messageTextForSend;
5438
composerRef.current.resetCursorState({
@@ -5547,27 +5486,7 @@ export default function ChatView(props: ChatViewProps) {
5486
}
5487
return;
5488
}
5550
- const optimisticAttachments = composerAttachmentsSnapshot.map((attachment) =>
5551
- attachment.type === "image"
5552
- ? {
5553
- type: "image" as const,
5554
- id: attachment.id,
5555
- name: attachment.name,
5556
- mimeType: attachment.mimeType,
5557
- sizeBytes: attachment.sizeBytes,
5558
- previewUrl: attachment.previewUrl,
5559
- ...(attachment.source ? { source: attachment.source } : {}),
5560
- }
5561
- : {
5562
- type: "file" as const,
5563
- id: attachment.id,
5564
- name: attachment.name,
5565
- mimeType: attachment.mimeType,
5566
- sizeBytes: attachment.sizeBytes,
5567
- downloadable: false,
5568
- ...(attachment.source ? { source: attachment.source } : {}),
5569
- },
5570
- );
5489
+ const optimisticAttachments = optimisticMessageAttachments(composerAttachmentsSnapshot);
5490
if (!shouldQueueBehindActiveRun) {
5491
anchorNewTurn(
5492
scopedThreadKey(scopeThreadRef(activeThread.environmentId, threadIdForSend)),
@@ -5619,17 +5538,7 @@ export default function ChatView(props: ChatViewProps) {
5538
const title = deriveThreadTitleSeed({
5539
text: messageTextForSend,
5540
attachments: composerAttachmentsSnapshot,
5622
- fallbackLabels: [
5623
- composerTerminalContextsSnapshot[0]
5624
- ? formatTerminalContextLabel(composerTerminalContextsSnapshot[0])
5625
- : undefined,
5626
- composerReviewCommentsSnapshot[0]
5627
- ? `Review: ${reviewCommentContextLabel(composerReviewCommentsSnapshot[0])}`
5628
- : undefined,
5629
- composerPreviewAnnotationsSnapshot[0]
5630
- ? previewAnnotationContextLabel(composerPreviewAnnotationsSnapshot[0])
5631
- : undefined,
5632
- ],
5541
+ fallbackLabels: sendTitleFallbackLabels(sendSnapshot),
5542
});
5543
const threadCreateModelSelection = createModelSelection(
5544
ctxSelectedModelSelection.instanceId,
@@ -5726,34 +5635,18 @@ export default function ChatView(props: ChatViewProps) {
5635
message: {
5636
messageId: messageIdForSend,
5637
role: "user",
5729
- text: outgoingMessageText,
5638
attachments: turnAttachmentsResult.value,
5731
- ...(() => {
5732
- const context = buildOutgoingMessageContext(
5733
- turnAttachmentsResult.value.map((attachment, index) =>
5734
- "id" in attachment && attachment.id !== undefined
5735
- ? attachment.id
5736
- : composerAttachmentsSnapshot[index]!.id,
5737
- ),
5738
- );
5739
- if (context === undefined) return {};
5740
- // Read the capability at dispatch time: the upload and persistence
5741
- // awaits above can span a server reconnect that changes it. Servers
5742
- // from before inline context drop the records and forward the links
5743
- // as literal text, so their turns carry the payload the legacy way.
5744
- const supportsInlineMessageContext =
5639
+ ...withMessageContext({
5640
+ text: outgoingMessageText,
5641
+ context: buildOutgoingMessageContext(
5642
+ boundAttachmentIds(turnAttachmentsResult.value, composerAttachmentsSnapshot),
5643
+ ),
5644
+ // Read at dispatch time: the upload and persistence awaits above can
5645
+ // span a server reconnect that changes it.
5646
+ supportsInlineMessageContext:
5647
appAtomRegistry.get(environmentServerConfigsAtom).get(environmentId)?.environment
5746
- .capabilities.inlineMessageContext === true;
5747
- if (!supportsInlineMessageContext) {
5748
- return {
5749
- text: serializeLegacyContextMessage({
5750
- text: outgoingMessageText,
5751
- records: context.records,
5752
- }),
5753
- };
5754
- }
5755
- return { context };
5756
- })(),
5648
+ .capabilities.inlineMessageContext === true,
5649
+ }),
5650
},
5651
modelSelection: ctxSelectedModelSelection,
5652
titleSeed: title,
@@ -5858,14 +5751,7 @@ export default function ChatView(props: ChatViewProps) {
5751
const next = existing.filter((message) => message.id !== messageIdForSend);
5752
return next.length === existing.length ? existing : next;
5753
});
5861
- const retryComposerImages = composerImagesSnapshot.map(cloneComposerImageForRetry);
5862
- setComposerDraftPrompt(composerDraftTarget, messageTextForSend);
5863
- addComposerDraftImages(composerDraftTarget, retryComposerImages);
5864
- addComposerDraftFiles(composerDraftTarget, composerFilesSnapshot);
5865
- setComposerDraftTerminalContexts(composerDraftTarget, composerTerminalContextsSnapshot);
5866
- setComposerDraftPreviewAnnotations(composerDraftTarget, composerPreviewAnnotationsSnapshot);
5867
- setComposerDraftReviewComments(composerDraftTarget, composerReviewCommentsSnapshot);
5868
- setComposerDraftThreadContexts(composerDraftTarget, composerThreadContextsSnapshot);
5754
+ const retryComposerImages = restoreComposerDraft(composerDraftTarget, sendSnapshot);
5755
if (currentRouteThreadKeyRef.current === routeThreadKey) {
5756
promptRef.current = messageTextForSend;
5757
composerImagesRef.current = retryComposerImages;
apps/web/src/components/chat/chatViewSend.ts
+92
-1
@@ -2,6 +2,7 @@ import {
2
CommandId,
3
type EnvironmentId,
4
type ModelSelection,
5
+ type ProviderInteractionMode,
6
type ScopedThreadRef,
7
type ThreadId,
8
PROVIDER_SEND_TURN_MAX_ATTACHMENTS,
@@ -27,7 +28,19 @@ import {
28
useComposerDraftStore,
29
DraftId,
30
} from "../../composerDraftStore";
30
-import { prepareRevertedMessageAttachments, waitForRevertedMessage } from "../ChatView.logic";
31
+import { ATTACHMENT_ONLY_BOOTSTRAP_PROMPT } from "@t3tools/shared/composerContextReferences";
32
+import { createModelSelection } from "@t3tools/shared/model";
33
+import type { ProviderInstanceEntry } from "../../providerInstances";
34
+import { getComposerPromptInjectionState, getComposerProviderState } from "./composerProviderState";
35
+import {
36
+ formatOutgoingPrompt,
37
+ getAntigravitySendBlockReason,
38
+ resolveComposerInteractionMode,
39
+ cloneComposerImageForRetry,
40
+ type ComposerSendSnapshot,
41
+ prepareRevertedMessageAttachments,
42
+ waitForRevertedMessage,
43
+} from "../ChatView.logic";
44
import { readPreparedConnection } from "../../state/session";
45
import { recallableComposerPrompt } from "./composerPromptHistory";
46
@@ -235,3 +248,81 @@ export async function rewindToMessage(input: {
248
return { error: error instanceof Error ? error.message : "Failed to revert thread state." };
249
}
250
}
251
+
252
+/**
253
+ * Writes a failed send's composer contents back into its draft. Returns the
254
+ * restored images, which are fresh copies so their preview URLs outlive the
255
+ * optimistic row that held the originals.
256
+ */
257
+export function restoreComposerDraft(
258
+ draftTarget: ScopedThreadRef | DraftId,
259
+ snapshot: ComposerSendSnapshot,
260
+): ComposerImageAttachment[] {
261
+ const store = useComposerDraftStore.getState();
262
+ const images = snapshot.images.map(cloneComposerImageForRetry);
263
+ store.setPrompt(draftTarget, snapshot.messageText);
264
+ store.addImages(draftTarget, images);
265
+ store.addFiles(draftTarget, snapshot.files);
266
+ store.setTerminalContexts(draftTarget, snapshot.terminalContexts);
267
+ store.setPreviewAnnotations(draftTarget, snapshot.previewAnnotations);
268
+ store.setReviewComments(draftTarget, snapshot.reviewComments);
269
+ store.setThreadContexts(draftTarget, snapshot.threadContexts);
270
+ return images;
271
+}
272
+
273
+export interface MultipleModelTarget {
274
+ readonly selection: ModelSelection;
275
+ readonly text: string;
276
+ readonly interactionMode: ProviderInteractionMode;
277
+}
278
+
279
+/**
280
+ * The thread each selected model starts for a multiple-model send, in
281
+ * selection order, or why that model cannot take the message.
282
+ */
283
+export function resolveMultipleModelTargets(input: {
284
+ readonly selections: ReadonlyArray<ModelSelection>;
285
+ readonly providerInstanceEntries: ReadonlyArray<ProviderInstanceEntry>;
286
+ readonly messageText: string;
287
+ readonly planModeEnabled: boolean;
288
+ readonly interactionMode: ProviderInteractionMode;
289
+}): Array<MultipleModelTarget | { readonly error: string }> {
290
+ const { messageText, planModeEnabled } = input;
291
+ return input.selections.map((selection) => {
292
+ const provider = input.providerInstanceEntries.find(
293
+ (entry) => entry.instanceId === selection.instanceId,
294
+ );
295
+ if (!provider?.enabled || !provider.isAvailable || provider.status !== "ready") {
296
+ return { error: `Provider for ${selection.model} is unavailable.` };
297
+ }
298
+ const providerBlockReason = getAntigravitySendBlockReason(provider.snapshot, selection.model);
299
+ if (providerBlockReason) return { error: providerBlockReason };
300
+ const providerState = getComposerProviderState({
301
+ provider: provider.driverKind,
302
+ model: selection.model,
303
+ models: provider.models,
304
+ modelOptions: selection.options,
305
+ promptInjectionState: getComposerPromptInjectionState(messageText),
306
+ planModeEnabled,
307
+ });
308
+ return {
309
+ selection: createModelSelection(
310
+ selection.instanceId,
311
+ selection.model,
312
+ providerState.modelOptionsForDispatch,
313
+ ),
314
+ text: formatOutgoingPrompt({
315
+ provider: provider.driverKind,
316
+ model: selection.model,
317
+ models: provider.models,
318
+ effort: providerState.promptEffort,
319
+ text: messageText || ATTACHMENT_ONLY_BOOTSTRAP_PROMPT,
320
+ }),
321
+ interactionMode: resolveComposerInteractionMode({
322
+ planModeEnabled,
323
+ provider: provider.snapshot,
324
+ interactionMode: input.interactionMode,
325
+ }).interactionMode,
326
+ };
327
+ });
328
+}