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 21, 04:45 UTC
| 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 | } |