@devries-cameron20 / t3code Mirror · read-only / commits / 38b13e977e
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, 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 +}