The best way to control Claude Code, Codex and more from any computer or phone

main
ts 250 lines 8.96 KB
Raw
1 import {
2 isCompactionCommandMessage,
3 type ThreadGuestMessage,
4 type ThreadGuestShare,
5 } from "@t3tools/contracts";
6 import { LIVE_ACTIVITY_ROW_ID, type ThreadFeedEntry } from "../../lib/threadActivity";
7 import { scopedThreadKey } from "../../lib/scopedEntities";
8 import { threadHasCaughtUpTo } from "@t3tools/client-runtime/state/threads";
9 import { resolveUserMessageGrouping } from "@t3tools/client-runtime/user-message";
10 import { msg } from "gt-react-native";
11
12 import { m, type MessageResolver } from "../../i18n/messages";
13 import type {
14 AcknowledgedThreadMessage,
15 QueuedThreadMessage,
16 } from "../../state/thread-outbox-model";
17
18 /**
19 * A guest's message waiting for the owner's Send or Dismiss. It is a feed row, not the list
20 * footer, so the feed follows it arriving and leaving the way it follows any row.
21 */
22 export interface GuestPendingFeedEntry {
23 readonly type: "guest-pending";
24 readonly id: string;
25 readonly createdAt: string;
26 readonly guestName: string;
27 readonly message: ThreadGuestMessage;
28 }
29
30 export type PendingThreadFeedEntry = ThreadFeedEntry & {
31 readonly pendingMessage?: QueuedThreadMessage;
32 readonly acknowledged?: boolean;
33 };
34
35 // An acknowledged row stops being pending once the thread catches up to it,
36 // even when the feed hides that message (a rolled-back or cancelled run).
37 export function selectPendingAcknowledgedMessages(
38 acknowledged: ReadonlyArray<AcknowledgedThreadMessage>,
39 thread: {
40 readonly threadKey: string | null;
41 readonly queuedMessages: ReadonlyArray<QueuedThreadMessage>;
42 readonly sequence: number;
43 readonly projectedMessages: ReadonlyArray<{ readonly id: string }> | undefined;
44 },
45 ): ReadonlyArray<AcknowledgedThreadMessage> {
46 return acknowledged.filter(
47 (message) =>
48 scopedThreadKey(message.environmentId, message.threadId) === thread.threadKey &&
49 !thread.queuedMessages.some((queued) => queued.messageId === message.messageId) &&
50 !threadHasCaughtUpTo(message, {
51 sequence: thread.sequence,
52 messages: thread.projectedMessages,
53 }),
54 );
55 }
56
57 /**
58 * Holds the turn's fold slot while a sent message waits for its run, so the live "Working for"
59 * row replaces it in place instead of being inserted.
60 */
61 export interface PendingFoldFeedEntry {
62 readonly type: "pending-fold";
63 readonly id: string;
64 readonly createdAt: string;
65 readonly messageId: string;
66 }
67
68 /** A row of the thread feed's list. */
69 export type ThreadFeedRow = PendingThreadFeedEntry | GuestPendingFeedEntry | PendingFoldFeedEntry;
70
71 export type GroupedThreadFeedRow = ThreadFeedRow & {
72 readonly userMessageGrouping: ReturnType<typeof resolveUserMessageGrouping>;
73 };
74
75 export function createThreadFeedGrouping() {
76 const rows = new WeakMap<ThreadFeedRow, GroupedThreadFeedRow>();
77 const ungrouped = resolveUserMessageGrouping(undefined, undefined, undefined);
78 return (
79 feed: ReadonlyArray<ThreadFeedRow>,
80 options: { readonly workflowOpeningMessageId?: string; readonly setupAnchorIndex?: number },
81 ): ReadonlyArray<GroupedThreadFeedRow> => {
82 const groupingMessage = (index: number) => {
83 const entry = feed[index];
84 return entry?.type === "message" &&
85 entry.message.role === "user" &&
86 !isCompactionCommandFeedEntry(entry) &&
87 entry.message.id !== options.workflowOpeningMessageId
88 ? entry.message
89 : undefined;
90 };
91 return feed.map((entry, index) => {
92 const message = groupingMessage(index);
93 const grouping =
94 message === undefined
95 ? ungrouped
96 : resolveUserMessageGrouping(
97 message,
98 index - 1 === options.setupAnchorIndex ? undefined : groupingMessage(index - 1),
99 index === options.setupAnchorIndex ? undefined : groupingMessage(index + 1),
100 );
101 const previous = rows.get(entry);
102 if (
103 previous?.userMessageGrouping.groupedWithPrevious === grouping.groupedWithPrevious &&
104 previous.userMessageGrouping.groupedWithNext === grouping.groupedWithNext &&
105 previous.userMessageGrouping.continuesSteer === grouping.continuesSteer
106 )
107 return previous;
108 const row = { ...entry, userMessageGrouping: grouping };
109 rows.set(entry, row);
110 return row;
111 });
112 };
113 }
114
115 /** Waiting guest messages go after the transcript, oldest first. */
116 export function appendGuestPendingMessages(
117 presentedFeed: ReadonlyArray<PendingThreadFeedEntry | PendingFoldFeedEntry>,
118 share: ThreadGuestShare | null,
119 resolve: MessageResolver = m,
120 ): ReadonlyArray<ThreadFeedRow> {
121 const pending = share?.messages.filter((message) => message.status === "pending") ?? [];
122 if (share === null || pending.length === 0) return presentedFeed;
123 const guestName = share.guestName ?? resolve(msg("Guest"));
124 return [
125 ...presentedFeed,
126 ...pending.map((message): GuestPendingFeedEntry => ({
127 type: "guest-pending",
128 id: `guest-pending:${message.id}`,
129 createdAt: message.submittedAt,
130 guestName,
131 message,
132 })),
133 ];
134 }
135
136 export function appendPendingThreadMessages(
137 presentedFeed: ReadonlyArray<ThreadFeedEntry>,
138 feed: ReadonlyArray<ThreadFeedEntry>,
139 queuedMessages: ReadonlyArray<QueuedThreadMessage>,
140 ): ReadonlyArray<PendingThreadFeedEntry> {
141 if (queuedMessages.length === 0) return presentedFeed;
142 const deliveredIds = new Set(
143 feed.flatMap((entry) => (entry.type === "message" ? [entry.message.id] : [])),
144 );
145 return [
146 ...presentedFeed.map((entry): PendingThreadFeedEntry => {
147 const pendingMessage = queuedMessages.find(
148 (message) => message.creation !== undefined && message.messageId === entry.id,
149 );
150 return pendingMessage ? { ...entry, pendingMessage, acknowledged: false } : entry;
151 }),
152 ...queuedMessages
153 .filter((message) => !deliveredIds.has(message.messageId))
154 .map((pendingMessage): PendingThreadFeedEntry => ({
155 type: "message",
156 id: pendingMessage.messageId,
157 createdAt: pendingMessage.createdAt,
158 pendingMessage,
159 message: {
160 id: pendingMessage.messageId,
161 role: "user",
162 text: pendingMessage.text,
163 attachments: [],
164 context: pendingMessage.context,
165 createdAt: pendingMessage.createdAt,
166 updatedAt: pendingMessage.createdAt,
167 runId: null,
168 streaming: false,
169 visibility: "local",
170 sourceThreadId: pendingMessage.threadId,
171 },
172 })),
173 ];
174 }
175
176 /**
177 * Messages the server accepted but has not projected yet. A new thread's first message stays
178 * anchored until the server's copy loads, and keeps its local attachments so its media does
179 * not drop out of the feed in between.
180 */
181 export function appendAcceptedThreadMessages(
182 feed: ReadonlyArray<ThreadFeedEntry>,
183 acknowledged: ReadonlyArray<QueuedThreadMessage>,
184 creation: QueuedThreadMessage | null,
185 ): ReadonlyArray<PendingThreadFeedEntry> {
186 const accepted = creation === null ? acknowledged : [...acknowledged, creation];
187 if (accepted.length === 0) return feed;
188 return appendPendingThreadMessages(feed, feed, accepted).map((entry) =>
189 entry.pendingMessage ? { ...entry, acknowledged: true } : entry,
190 );
191 }
192
193 /**
194 * Ends the feed with the rows a starting run will fill, while its last row is a sent message no
195 * run has picked up: the fold slot and the live activity row, under the activity row's own key.
196 * The run's rows then replace them in place instead of being inserted.
197 */
198 export function createPendingTurnAppender() {
199 let fold: PendingFoldFeedEntry | null = null;
200 let activity: Extract<ThreadFeedEntry, { readonly type: "thinking" }> | null = null;
201 return (
202 feed: ReadonlyArray<PendingThreadFeedEntry>,
203 options: { readonly zen: boolean },
204 resolve: MessageResolver = m,
205 ): ReadonlyArray<PendingThreadFeedEntry | PendingFoldFeedEntry> => {
206 const last = feed.at(-1);
207 if (
208 last?.type !== "message" ||
209 last.message.role !== "user" ||
210 last.pendingMessage === undefined ||
211 last.pendingMessage.creation !== undefined ||
212 isCompactionCommandMessage(last.message) ||
213 feed.some(
214 (entry) =>
215 (entry.type === "run-fold" && entry.workingSince !== undefined) ||
216 entry.type === "thinking",
217 )
218 ) {
219 return feed;
220 }
221 const label = last.acknowledged ? resolve(msg("Starting…")) : resolve(msg("Sending…"));
222 if (activity?.createdAt !== last.createdAt || activity.label !== label) {
223 activity = {
224 type: "thinking",
225 id: LIVE_ACTIVITY_ROW_ID,
226 createdAt: last.createdAt,
227 runId: null,
228 label,
229 };
230 }
231 if (options.zen) return [...feed, activity];
232 if (fold?.messageId !== last.id) {
233 fold = {
234 type: "pending-fold",
235 id: `pending-fold:${last.id}`,
236 createdAt: last.createdAt,
237 messageId: last.id,
238 };
239 }
240 return [...feed, fold, activity];
241 };
242 }
243
244 export function isCompactionCommandFeedEntry(entry: PendingThreadFeedEntry): boolean {
245 return (
246 entry.type === "message" &&
247 entry.pendingMessage === undefined &&
248 isCompactionCommandMessage(entry.message)
249 );
250 }