Open History to see the last commit
1import { sourceControlClients } from "@t3tools/client-runtime/source-control-clients";
2import * as Dialog from "../components/ui/Dialog";
3import {
4 type EnvironmentProject,
5 type EnvironmentThreadShell,
6} from "@t3tools/client-runtime/state/shell";
7import {
8 type AtomCommand,
9 type AtomCommandResult,
10 runAtomCommand,
11} from "@t3tools/client-runtime/state/runtime";
12import { threadFamilyRead, type ThreadFamilyRead } from "@t3tools/client-runtime/state/threads";
13import { deriveThreadTitleSeed } from "@t3tools/client-runtime/operations";
14import {
15 AuthOrchestrationOperateScope,
16 CommandId,
17 DEFAULT_PROVIDER_INTERACTION_MODE,
18 DEFAULT_RUNTIME_MODE,
19 MessageId,
20 managedRuntimeModeDenial,
21 PROVIDER_SEND_TURN_MAX_ATTACHMENTS,
22 type EnvironmentId,
23} from "@t3tools/contracts";
24import { buildTemporaryWorktreeBranchName } from "@t3tools/shared/git";
25import * as Cause from "effect/Cause";
26import { AsyncResult, Atom } from "effect/reactivity";
27
28import { createDebugLogger } from "../lib/debugLog";
29import { scopedThreadKey } from "../lib/scopedEntities";
30import { buildProjectThreadStartTurnInput } from "../lib/projectThreadStartTurn";
31import { serializeComposerMessageForServer, uploadedComposerContext } from "../lib/composerContext";
32import { prepareTurnAttachments, type PreparedTurnAttachments } from "../lib/attachmentUpload";
33import { randomHex } from "../lib/uuid";
34import {
35 describeUnavailableModelSelection,
36 isModelSelectionUnavailable,
37} from "../lib/modelOptions";
38import {
39 retainAcknowledgedThreadMessage,
40 forgetAcknowledgedThreadMessage,
41} from "./acknowledged-thread-messages";
42import { appAtomRegistry } from "./atom-registry";
43import { restoredNewTaskDraftKey } from "./new-task-draft-key";
44import {
45 clearPendingThreadCreationOutcome,
46 pendingThreadCreationOutcomesAtom,
47 recordPendingThreadCreationOutcome,
48} from "./pending-thread-creation";
49import { environmentProjects } from "./projects";
50import { environmentServerConfigsAtom, serverEnvironment } from "./server";
51import { gitEnvironment } from "./git";
52import { environmentSession, readEnvironmentScope, sessionHasScope } from "./session";
53import {
54 confirmThreadOutboxMessageQueued,
55 threadOutboxManager,
56 threadOutboxRevision,
57 updateThreadOutboxMessage,
58} from "./thread-outbox";
59import { removeThreadOutboxMessage } from "./thread-outbox-removal";
60import {
61 isQueuedThreadCreationSendable,
62 resolveThreadOutboxDeliveryAction,
63 resolveThreadOutboxDispatchStep,
64 resolveThreadOutboxFailureAction,
65 resolveQueuedThreadSettings,
66 shouldRetryThreadOutboxDelivery,
67 threadOutboxRetryDelayMs,
68 type QueuedThreadCreation,
69 type QueuedThreadMessage,
70 type ThreadOutboxCommandStage,
71 type ThreadOutboxFailureAction,
72} from "./thread-outbox-model";
73import { environmentThreadShells, threadEnvironment, threadFamilies } from "./threads";
74import {
75 appendComposerDraftAttachments,
76 composerDraftsAtom,
77 flushComposerDrafts,
78 type ComposerDraft,
79 getComposerDraftSnapshot,
80 mergeComposerDraftContent,
81 replaceComposerDraftAttachments,
82 removeDeliveredCloudQueuedMessage,
83 undoComposerDraftMerge,
84 updateComposerDraftSettings,
85 waitForComposerDraftsLoaded,
86} from "./use-composer-drafts";
87import {
88 dispatchingQueuedMessageIdAtom,
89 editingQueuedMessageIdsAtom,
90 retryingQueuedMessageIdsAtom,
91 threadOutboxShellStatusesAtom,
92} from "./use-thread-outbox";
93import { clearThreadComposerError, setThreadComposerError } from "./thread-composer-error";
94import { workspaceConnections } from "./workspace";
95
96const threadOutboxDebug = createDebugLogger("thread-outbox");
97
98function isRpcClientDecodeDefect(error: unknown): boolean {
99 if (
100 typeof error !== "object" ||
101 error === null ||
102 !("_tag" in error) ||
103 error._tag !== "RpcClientError"
104 ) {
105 return false;
106 }
107 const reason: unknown = (error as { readonly reason?: unknown }).reason;
108 return (
109 typeof reason === "object" &&
110 reason !== null &&
111 "_tag" in reason &&
112 reason._tag === "RpcClientDefect"
113 );
114}
115
116function isOrdinaryThreadOutboxTransportFailure(error: unknown): boolean {
117 return shouldRetryThreadOutboxDelivery(error) && !isRpcClientDecodeDefect(error);
118}
119
120function logThreadOutboxDeliveryFailure(input: {
121 readonly stage: ThreadOutboxCommandStage;
122 readonly error: unknown;
123 readonly interrupted: boolean;
124 readonly context: Record<string, unknown>;
125}): ThreadOutboxFailureAction {
126 const action = resolveThreadOutboxFailureAction({
127 stage: input.stage,
128 error: input.error,
129 interrupted: input.interrupted,
130 });
131 const details = { ...input.context, stage: input.stage, action };
132 const ordinaryTransportRetry =
133 action === "retry" &&
134 !isRpcClientDecodeDefect(input.error) &&
135 (input.interrupted ||
136 input.stage !== "settings-sync" ||
137 shouldRetryThreadOutboxDelivery(input.error));
138 if (ordinaryTransportRetry) {
139 threadOutboxDebug.log("queued message delivery failed", details);
140 } else {
141 console.warn("[thread-outbox] queued message delivery failed", details);
142 }
143 return action;
144}
145
146function logThreadOutboxUploadFailure(queuedMessage: QueuedThreadMessage, error: unknown): void {
147 const context = {
148 environmentId: queuedMessage.environmentId,
149 threadId: queuedMessage.threadId,
150 messageId: queuedMessage.messageId,
151 };
152 if (isOrdinaryThreadOutboxTransportFailure(error)) {
153 threadOutboxDebug.log("attachment upload failed; retrying", { ...context, error });
154 } else {
155 console.warn("[thread-outbox] failed to upload attachments", { ...context, error });
156 }
157}
158
159function setQueuedMessageRetrying(queuedMessageId: MessageId, retrying: boolean): void {
160 const { [queuedMessageId]: current, ...others } = appAtomRegistry.get(
161 retryingQueuedMessageIdsAtom,
162 );
163 if ((current === true) === retrying) return;
164 appAtomRegistry.set(
165 retryingQueuedMessageIdsAtom,
166 retrying ? { ...others, [queuedMessageId]: true } : others,
167 );
168}
169
170function beginDispatchingQueuedMessage(queuedMessageId: MessageId): void {
171 // An attempt in flight is sending, even while its retry count is kept.
172 setQueuedMessageRetrying(queuedMessageId, false);
173 appAtomRegistry.set(dispatchingQueuedMessageIdAtom, queuedMessageId);
174}
175
176function finishDispatchingQueuedMessage(queuedMessageId: MessageId): void {
177 const current = appAtomRegistry.get(dispatchingQueuedMessageIdAtom);
178 appAtomRegistry.set(dispatchingQueuedMessageIdAtom, current === queuedMessageId ? null : current);
179}
180
181function findThread(
182 threads: ReadonlyArray<EnvironmentThreadShell>,
183 message: QueuedThreadMessage,
184): EnvironmentThreadShell | undefined {
185 return threads.find(
186 (candidate) =>
187 candidate.environmentId === message.environmentId && candidate.id === message.threadId,
188 );
189}
190
191function findCreationProject(
192 projects: ReadonlyArray<EnvironmentProject>,
193 message: QueuedThreadMessage,
194): EnvironmentProject | undefined {
195 return projects.find(
196 (candidate) =>
197 candidate.environmentId === message.environmentId &&
198 candidate.id === message.creation?.projectId,
199 );
200}
201
202function settingsCommandId(message: QueuedThreadMessage, setting: string): CommandId {
203 return CommandId.make(`${message.commandId}:${setting}`);
204}
205
206export async function prepareQueuedMessageAttachments(queuedMessage: QueuedThreadMessage): Promise<
207 | {
208 readonly status: "ready";
209 readonly prepared: PreparedTurnAttachments;
210 readonly persistedMessage: QueuedThreadMessage;
211 readonly deliveryRevision: number;
212 }
213 | { readonly status: "abandoned" }
214> {
215 if (!(await confirmThreadOutboxMessageQueued(queuedMessage))) {
216 return { status: "abandoned" };
217 }
218 if (!readEnvironmentScope(queuedMessage.environmentId, AuthOrchestrationOperateScope)) {
219 return { status: "abandoned" };
220 }
221 const revision = threadOutboxRevision(queuedMessage.messageId);
222 if (!isQueuedMessagePayloadCurrent(queuedMessage, revision)) {
223 return { status: "abandoned" };
224 }
225 let persistedMessage = queuedMessage;
226 let deliveryRevision = revision;
227 const result = await prepareTurnAttachments({
228 environmentId: queuedMessage.environmentId,
229 attachments: queuedMessage.attachments,
230 supportsImageUploads: true,
231 persistUploadedReferences: async (draftAttachments) => {
232 if (appAtomRegistry.get(editingQueuedMessageIdsAtom)[queuedMessage.messageId]) {
233 return "abandon";
234 }
235 const updatedMessage = { ...queuedMessage, attachments: draftAttachments };
236 if (!(await updateThreadOutboxMessage(updatedMessage, revision))) {
237 return "abandon";
238 }
239 persistedMessage = updatedMessage;
240 deliveryRevision = revision + 1;
241 return "persisted";
242 },
243 });
244 if (
245 result.status === "abandoned" ||
246 !isQueuedMessagePayloadCurrent(persistedMessage, deliveryRevision)
247 ) {
248 return { status: "abandoned" };
249 }
250 return { status: "ready", prepared: result, persistedMessage, deliveryRevision };
251}
252
253function isQueuedMessagePayloadCurrent(
254 message: QueuedThreadMessage,
255 expectedRevision: number,
256): boolean {
257 return (
258 threadOutboxRevision(message.messageId) === expectedRevision &&
259 Object.values(appAtomRegistry.get(threadOutboxManager.queuedMessagesByThreadKeyAtom))
260 .flat()
261 .some((candidate) => candidate === message)
262 );
263}
264
265export async function completeQueuedMessageDelivery(
266 queuedMessage: QueuedThreadMessage,
267 deliveryRevision: number,
268 sequence: number | undefined,
269): Promise<"removed" | "edited" | "failed"> {
270 clearThreadComposerError(
271 scopedThreadKey(queuedMessage.environmentId, queuedMessage.threadId),
272 queuedMessage.messageId,
273 );
274 try {
275 await removeDeliveredCloudQueuedMessage(queuedMessage).catch((error) => {
276 console.warn("[thread-outbox] could not update sign-out snapshot after delivery", {
277 messageId: queuedMessage.messageId,
278 error,
279 });
280 });
281 // Editors can acquire entries during startTurn without bumping revisions; CAS alone would lose unsaved edits.
282 if (appAtomRegistry.get(editingQueuedMessageIdsAtom)[queuedMessage.messageId]) {
283 return "edited";
284 }
285 retainAcknowledgedThreadMessage(
286 sequence === undefined ? queuedMessage : { ...queuedMessage, sequence },
287 );
288 const removed = await removeThreadOutboxMessage(
289 queuedMessage,
290 deliveryRevision,
291 () => !appAtomRegistry.get(editingQueuedMessageIdsAtom)[queuedMessage.messageId],
292 );
293 if (!removed) {
294 forgetAcknowledgedThreadMessage(queuedMessage);
295 threadOutboxDebug.log("delivered message was edited before cleanup", {
296 environmentId: queuedMessage.environmentId,
297 threadId: queuedMessage.threadId,
298 messageId: queuedMessage.messageId,
299 });
300 return "edited";
301 }
302 return "removed";
303 } catch (error) {
304 forgetAcknowledgedThreadMessage(queuedMessage);
305 console.warn("[thread-outbox] failed to remove delivered queued message", {
306 environmentId: queuedMessage.environmentId,
307 threadId: queuedMessage.threadId,
308 messageId: queuedMessage.messageId,
309 error,
310 });
311 return "failed";
312 }
313}
314
315export async function removeAcknowledgedExistingThreadMessage(
316 queuedMessage: QueuedThreadMessage,
317 acknowledgedMessageIds: Set<MessageId>,
318): Promise<boolean> {
319 try {
320 await removeDeliveredCloudQueuedMessage(queuedMessage).catch((error) => {
321 console.warn("[thread-outbox] could not update sign-out snapshot after delivery", {
322 messageId: queuedMessage.messageId,
323 error,
324 });
325 });
326 const removed = await removeThreadOutboxMessage(queuedMessage);
327 if (removed) {
328 acknowledgedMessageIds.delete(queuedMessage.messageId);
329 }
330 return removed;
331 } catch (error) {
332 console.warn("[thread-outbox] failed to remove acknowledged queued message", {
333 environmentId: queuedMessage.environmentId,
334 threadId: queuedMessage.threadId,
335 messageId: queuedMessage.messageId,
336 error,
337 });
338 return false;
339 }
340}
341
342export async function recoverEditedCreationAfterDelivery(
343 queuedMessage: QueuedThreadMessage,
344): Promise<boolean> {
345 const kept = Object.values(appAtomRegistry.get(threadOutboxManager.queuedMessagesByThreadKeyAtom))
346 .flat()
347 .find((candidate) => candidate.messageId === queuedMessage.messageId);
348 if (!kept) {
349 return true;
350 }
351 const keptRevision = threadOutboxRevision(kept.messageId);
352 if (appAtomRegistry.get(editingQueuedMessageIdsAtom)[kept.messageId]) {
353 return true;
354 }
355 const draftKey = scopedThreadKey(kept.environmentId, kept.threadId);
356 try {
357 // Merge before removal to retain file ownership; allow overflow and let send guards require trimming.
358 await mergeComposerDraftContent(draftKey, {
359 text: kept.text,
360 context: kept.context,
361 attachments: [],
362 });
363 if (appAtomRegistry.get(editingQueuedMessageIdsAtom)[kept.messageId]) {
364 return true;
365 }
366 if (threadOutboxRevision(kept.messageId) !== keptRevision) {
367 return false;
368 }
369 const existingAttachmentIds = new Set(
370 getComposerDraftSnapshot(draftKey).attachments.map((attachment) => attachment.id),
371 );
372 appendComposerDraftAttachments(
373 draftKey,
374 kept.attachments.filter((attachment) => !existingAttachmentIds.has(attachment.id)),
375 { allowOverflow: true },
376 );
377 updateComposerDraftSettings(draftKey, {
378 ...(kept.modelSelection !== undefined ? { modelSelection: kept.modelSelection } : {}),
379 ...(kept.runtimeMode !== undefined ? { runtimeMode: kept.runtimeMode } : {}),
380 ...(kept.interactionMode !== undefined ? { interactionMode: kept.interactionMode } : {}),
381 });
382 // Flush before removal: append only schedules persistence, leaving the queue as the sole durable copy.
383 await flushComposerDrafts();
384 } catch (error) {
385 console.warn("[thread-outbox] could not hand an edited pending task to the composer", error);
386 return false;
387 }
388 if (appAtomRegistry.get(editingQueuedMessageIdsAtom)[kept.messageId]) {
389 return true;
390 }
391 try {
392 return await removeThreadOutboxMessage(
393 kept,
394 keptRevision,
395 () => !appAtomRegistry.get(editingQueuedMessageIdsAtom)[kept.messageId],
396 );
397 } catch (error) {
398 console.warn("[thread-outbox] could not remove recovered pending task", error);
399 return false;
400 }
401}
402
403export async function restoreRejectedQueuedMessage(
404 queuedMessage: QueuedThreadMessage,
405 message: string,
406): Promise<"restored" | "deferred" | "blocked" | "retry"> {
407 const draftKey = recoveryDraftKey(queuedMessage);
408 const threadKey = scopedThreadKey(queuedMessage.environmentId, queuedMessage.threadId);
409 let rollback: { readonly snapshot: ComposerDraft; readonly merged: ComposerDraft } | null = null;
410 try {
411 if (
412 appAtomRegistry.get(editingQueuedMessageIdsAtom)[queuedMessage.messageId] ||
413 !(await confirmThreadOutboxMessageQueued(queuedMessage)) ||
414 appAtomRegistry.get(editingQueuedMessageIdsAtom)[queuedMessage.messageId]
415 ) {
416 return "deferred";
417 }
418 const revision = threadOutboxRevision(queuedMessage.messageId);
419
420 await waitForComposerDraftsLoaded();
421 if (appAtomRegistry.get(editingQueuedMessageIdsAtom)[queuedMessage.messageId]) {
422 return "deferred";
423 }
424 const originalDraft = getComposerDraftSnapshot(draftKey);
425 const existingAttachmentIds = new Set(
426 originalDraft.attachments.map((attachment) => attachment.id),
427 );
428 const addedAttachmentCount = queuedMessage.attachments.filter(
429 (attachment) => !existingAttachmentIds.has(attachment.id),
430 ).length;
431 if (existingAttachmentIds.size + addedAttachmentCount > PROVIDER_SEND_TURN_MAX_ATTACHMENTS) {
432 setThreadComposerError(
433 threadKey,
434 `Remove attachments from the draft before restoring this message. Messages can contain at most ${PROVIDER_SEND_TURN_MAX_ATTACHMENTS} attachments.`,
435 queuedMessage.messageId,
436 );
437 return "blocked";
438 }
439
440 const withdrawError = () => clearThreadComposerError(threadKey, queuedMessage.messageId);
441 if (!queuedMessage.creation) {
442 setThreadComposerError(threadKey, message, queuedMessage.messageId);
443 }
444 let mergedDraft: ComposerDraft;
445 try {
446 stampRecoveryDraftProject(queuedMessage, draftKey);
447 await mergeComposerDraftContent(draftKey, {
448 text: queuedMessage.text,
449 context: queuedMessage.context,
450 attachments: queuedMessage.attachments,
451 });
452 } finally {
453 // Capture rollback in finally because merge publishes even on persistence failure; undo must preserve concurrent edits.
454 mergedDraft = getComposerDraftSnapshot(draftKey);
455 rollback = { snapshot: originalDraft, merged: mergedDraft };
456 }
457 if (appAtomRegistry.get(editingQueuedMessageIdsAtom)[queuedMessage.messageId]) {
458 withdrawError();
459 await undoComposerDraftMerge(draftKey, originalDraft, mergedDraft);
460 return "deferred";
461 }
462 updateComposerDraftSettings(draftKey, {
463 ...(queuedMessage.modelSelection ? { modelSelection: queuedMessage.modelSelection } : {}),
464 ...(queuedMessage.runtimeMode ? { runtimeMode: queuedMessage.runtimeMode } : {}),
465 ...(queuedMessage.interactionMode ? { interactionMode: queuedMessage.interactionMode } : {}),
466 ...(queuedMessage.freshContext ? { freshContext: true } : {}),
467 ...(queuedMessage.creation
468 ? {
469 workspaceSelection: {
470 mode: queuedMessage.creation.workspaceMode,
471 branch: queuedMessage.creation.branch,
472 worktreePath: queuedMessage.creation.worktreePath,
473 pullRequestReference: queuedMessage.creation.pullRequestReference,
474 ...(queuedMessage.creation.startFromOrigin !== undefined
475 ? { startFromOrigin: queuedMessage.creation.startFromOrigin }
476 : {}),
477 },
478 }
479 : {}),
480 });
481 const restoredDraft = getComposerDraftSnapshot(draftKey);
482 rollback = { snapshot: originalDraft, merged: restoredDraft };
483 await flushComposerDrafts();
484 if (
485 appAtomRegistry.get(editingQueuedMessageIdsAtom)[queuedMessage.messageId] ||
486 !(await confirmThreadOutboxMessageQueued(queuedMessage)) ||
487 appAtomRegistry.get(editingQueuedMessageIdsAtom)[queuedMessage.messageId]
488 ) {
489 withdrawError();
490 await undoComposerDraftMerge(draftKey, originalDraft, restoredDraft);
491 return "deferred";
492 }
493 if (
494 !(await removeThreadOutboxMessage(
495 queuedMessage,
496 revision,
497 () => !appAtomRegistry.get(editingQueuedMessageIdsAtom)[queuedMessage.messageId],
498 ))
499 ) {
500 withdrawError();
501 await undoComposerDraftMerge(draftKey, originalDraft, restoredDraft);
502 return "deferred";
503 }
504 // After queue removal, the draft owns content and must never roll back.
505 rollback = null;
506 if (queuedMessage.creation) {
507 withdrawError();
508 recordPendingThreadCreationOutcome({
509 kind: "failed",
510 message: queuedMessage,
511 reason: message,
512 });
513 }
514 return "restored";
515 } catch (error) {
516 if (rollback !== null) {
517 await undoComposerDraftMerge(draftKey, rollback.snapshot, rollback.merged).catch(
518 (undoError) => {
519 console.warn("[thread-outbox] failed to persist a recovery rollback", undoError);
520 },
521 );
522 }
523 console.warn("[thread-outbox] failed to restore an undeliverable message", error);
524 setThreadComposerError(
525 threadKey,
526 error instanceof Error ? error.message : "The unsent message could not be restored.",
527 queuedMessage.messageId,
528 );
529 return "retry";
530 }
531}
532
533/** Derive keys from message ids so failed recovery retries reuse the same draft. */
534function recoveryDraftKey(queuedMessage: QueuedThreadMessage): string {
535 return queuedMessage.creation
536 ? restoredNewTaskDraftKey(queuedMessage.messageId)
537 : scopedThreadKey(queuedMessage.environmentId, queuedMessage.threadId);
538}
539
540function stampRecoveryDraftProject(queuedMessage: QueuedThreadMessage, draftKey: string): void {
541 if (!queuedMessage.creation) {
542 return;
543 }
544 updateComposerDraftSettings(draftKey, {
545 project: {
546 environmentId: queuedMessage.environmentId,
547 projectId: queuedMessage.creation.projectId,
548 createdAt: queuedMessage.createdAt,
549 },
550 });
551}
552
553async function preserveUploadedAttachmentsForEditor(
554 originalMessage: QueuedThreadMessage,
555 uploadedMessage: QueuedThreadMessage,
556): Promise<void> {
557 if (!originalMessage.creation) {
558 return;
559 }
560
561 const draftKey = `pending-task:${originalMessage.messageId}`;
562 const draft = getComposerDraftSnapshot(draftKey);
563 const uploadedById = new Map(
564 uploadedMessage.attachments.map((attachment) => [attachment.id, attachment] as const),
565 );
566 let changed = false;
567 const nextAttachments = draft.attachments.map((attachment) => {
568 const uploaded = uploadedById.get(attachment.id);
569 if (
570 !uploaded?.uploadedAttachmentId ||
571 uploaded.uploadEnvironmentId !== originalMessage.environmentId ||
572 (attachment.uploadedAttachmentId === uploaded.uploadedAttachmentId &&
573 attachment.uploadEnvironmentId === uploaded.uploadEnvironmentId)
574 ) {
575 return attachment;
576 }
577 changed = true;
578 return {
579 ...attachment,
580 uploadedAttachmentId: uploaded.uploadedAttachmentId,
581 uploadEnvironmentId: uploaded.uploadEnvironmentId,
582 };
583 });
584 if (changed) {
585 replaceComposerDraftAttachments(draftKey, nextAttachments);
586 await flushComposerDrafts();
587 }
588}
589
590// Everything a drain pass decides from. Each queued environment's session is
591// read here so a granted or revoked operate scope re-runs the drain.
592const deliveryInputsAtom = Atom.make((get) => {
593 const connectedEnvironments = get(workspaceConnections.environmentsAtom);
594 const operableEnvironments = new Set<EnvironmentId>();
595 for (const { environmentId } of connectedEnvironments) {
596 if (
597 sessionHasScope(
598 get(environmentSession.sessionStateAtom(environmentId)),
599 AuthOrchestrationOperateScope,
600 )
601 ) {
602 operableEnvironments.add(environmentId);
603 }
604 }
605 return {
606 dispatchingQueuedMessageId: get(dispatchingQueuedMessageIdAtom),
607 editingQueuedMessageIds: get(editingQueuedMessageIdsAtom),
608 queuedMessagesByThreadKey: get(threadOutboxManager.queuedMessagesByThreadKeyAtom),
609 shellStatuses: get(threadOutboxShellStatusesAtom),
610 threads: get(environmentThreadShells.threadShellsAtom),
611 projects: get(environmentProjects.projectsAtom),
612 serverConfigs: get(environmentServerConfigsAtom),
613 connectedEnvironments,
614 operableEnvironments,
615 };
616}).pipe(Atom.withLabel("mobile:thread-outbox:delivery-inputs"));
617
618// Read through the shell atom, not once: the shell often lands before the
619// outcome is recorded, and that entry must still be collected when it does.
620const settledCreationOutcomeKeysAtom = Atom.make((get): ReadonlyArray<string> => {
621 const outcomes = get(pendingThreadCreationOutcomesAtom);
622 const threads = get(environmentThreadShells.threadShellsAtom);
623 return Object.entries(outcomes).flatMap(([threadKey, outcome]) =>
624 outcome.kind === "delivered" &&
625 threads.some(
626 (thread) =>
627 scopedThreadKey(thread.environmentId, thread.id) === threadKey &&
628 (thread.latestRun !== null ||
629 thread.runtime?.status === "failed" ||
630 thread.runtime?.status === "cancelled" ||
631 thread.runtime?.status === "interrupted"),
632 )
633 ? [threadKey]
634 : [],
635 );
636}).pipe(Atom.withLabel("mobile:thread-outbox:settled-creation-outcomes"));
637
638function deliveredSequence(
639 result: AtomCommandResult<{ readonly sequence?: number }, unknown>,
640): number | undefined {
641 return AsyncResult.isSuccess(result) ? result.value.sequence : undefined;
642}
643
644const runDeliveryCommand = <W, A, E>(
645 command: AtomCommand<W, A, E>,
646 input: W,
647): Promise<AtomCommandResult<A, E>> =>
648 runAtomCommand(appAtomRegistry, command, input, { reportFailure: false });
649
650function reportCommandFailure(
651 queuedMessage: QueuedThreadMessage,
652 commandResult: AtomCommandResult<unknown, unknown>,
653 stage: ThreadOutboxCommandStage,
654): { readonly action: "retry" | "restore"; readonly message: string } | null {
655 if (!AsyncResult.isFailure(commandResult)) {
656 return null;
657 }
658 const error = Cause.squash(commandResult.cause);
659 const action = logThreadOutboxDeliveryFailure({
660 stage,
661 error,
662 interrupted: Cause.hasInterruptsOnly(commandResult.cause),
663 context: {
664 environmentId: queuedMessage.environmentId,
665 threadId: queuedMessage.threadId,
666 messageId: queuedMessage.messageId,
667 cause: commandResult.cause,
668 },
669 });
670 return {
671 action,
672 message: error instanceof Error ? error.message : "The message could not be sent.",
673 };
674}
675
676interface ThreadOutboxRetry {
677 readonly attempt: number;
678 readonly notBefore: number;
679 readonly timer: ReturnType<typeof setTimeout>;
680}
681
682/**
683 * Delivers queued thread messages one at a time. A drain pass runs whenever its inputs
684 * change (outbox, locks, shells, projects, configs, connections, scopes) and when a retry
685 * backoff expires. `dispatchingQueuedMessageIdAtom` is the single in-flight slot; clearing
686 * it re-runs the drain for the next message.
687 */
688export function createThreadOutboxDelivery(): {
689 readonly drain: () => void;
690 readonly dispose: () => void;
691} {
692 let disposed = false;
693 const retries = new Map<MessageId, ThreadOutboxRetry>();
694 // Existing-thread turns the server accepted but whose outbox removal has
695 // not landed; the next pass retries only the removal, never the send.
696 const acknowledgedExistingThreadMessageIds = new Set<MessageId>();
697 // Targets the shell may have left out hold their thread family until they leave the queue, so
698 // the row stays readable through dispatch.
699 const familyMounts = new Map<MessageId, () => void>();
700 const blockedRecoveries = new Map<
701 MessageId,
702 { readonly message: QueuedThreadMessage; readonly unsubscribe: () => void }
703 >();
704
705 const retryNotBefore = (messageId: MessageId): number => retries.get(messageId)?.notBefore ?? 0;
706
707 const scheduleRetry = (messageId: MessageId): void => {
708 if (disposed) return;
709 const previous = retries.get(messageId);
710 if (previous !== undefined) clearTimeout(previous.timer);
711 const attempt = (previous?.attempt ?? 0) + 1;
712 const delayMs = threadOutboxRetryDelayMs(attempt);
713 retries.set(messageId, {
714 attempt,
715 notBefore: Date.now() + delayMs,
716 timer: setTimeout(drain, delayMs),
717 });
718 setQueuedMessageRetrying(messageId, true);
719 };
720
721 const clearRetry = (messageId: MessageId): void => {
722 const retry = retries.get(messageId);
723 if (retry === undefined) return;
724 clearTimeout(retry.timer);
725 retries.delete(messageId);
726 setQueuedMessageRetrying(messageId, false);
727 };
728
729 // A delivery that throws backs off like any failure. Releasing the slot
730 // without a retry would re-run the drain straight into the same message.
731 const settle = (messageId: MessageId, delivery: Promise<boolean>): void => {
732 void delivery
733 .then(
734 (sent) => (sent ? clearRetry(messageId) : scheduleRetry(messageId)),
735 (error: unknown) => {
736 console.warn("[thread-outbox] queued message delivery threw", { messageId, error });
737 scheduleRetry(messageId);
738 },
739 )
740 .finally(() => finishDispatchingQueuedMessage(messageId));
741 };
742
743 // An over-cap draft blocks recovery until the user changes its attachments;
744 // parking on the draft avoids hammering the restore with backoff retries.
745 const restoreQueuedMessage = async (
746 queuedMessage: QueuedThreadMessage,
747 message: string,
748 ): Promise<boolean> => {
749 const result = await restoreRejectedQueuedMessage(queuedMessage, message);
750 if (result !== "blocked") {
751 return result !== "retry";
752 }
753 if (disposed || blockedRecoveries.has(queuedMessage.messageId)) {
754 return true;
755 }
756 const draftKey = recoveryDraftKey(queuedMessage);
757 const editorDraftKey = queuedMessage.creation
758 ? `pending-task:${queuedMessage.messageId}`
759 : null;
760 const currentDrafts = appAtomRegistry.get(composerDraftsAtom);
761 const blockedAttachments = currentDrafts[draftKey]?.attachments;
762 const editorAttachments =
763 editorDraftKey === null ? undefined : currentDrafts[editorDraftKey]?.attachments;
764 const unsubscribe = appAtomRegistry.subscribe(composerDraftsAtom, (drafts) => {
765 if (
766 drafts[draftKey]?.attachments === blockedAttachments &&
767 (editorDraftKey === null || drafts[editorDraftKey]?.attachments === editorAttachments)
768 ) {
769 return;
770 }
771 const active = blockedRecoveries.get(queuedMessage.messageId);
772 if (!active) {
773 return;
774 }
775 blockedRecoveries.delete(queuedMessage.messageId);
776 active.unsubscribe();
777 drain();
778 });
779 blockedRecoveries.set(queuedMessage.messageId, { message: queuedMessage, unsubscribe });
780 return true;
781 };
782
783 const sendQueuedMessage = async (
784 queuedMessage: QueuedThreadMessage,
785 thread: EnvironmentThreadShell,
786 ): Promise<boolean> => {
787 const hasAccess = () =>
788 readEnvironmentScope(queuedMessage.environmentId, AuthOrchestrationOperateScope);
789 if (!hasAccess()) return true;
790 const serverConfig = appAtomRegistry.get(
791 serverEnvironment.configValueAtom(queuedMessage.environmentId),
792 );
793 if (!serverConfig) return false;
794 const settings = resolveQueuedThreadSettings(queuedMessage, thread, serverConfig.providers);
795 if (isModelSelectionUnavailable(serverConfig, settings.modelSelection, thread.projectId)) {
796 const { title, detail } = describeUnavailableModelSelection(
797 serverConfig,
798 settings.modelSelection,
799 thread.projectId,
800 );
801 return restoreQueuedMessage(queuedMessage, `${title}. ${detail}`);
802 }
803 // The server would refuse this mode in settings sync, which retries forever; stop first.
804 const runtimeModeDenial = managedRuntimeModeDenial(
805 serverConfig.managedPolicy,
806 settings.runtimeMode,
807 );
808 if (runtimeModeDenial !== undefined) {
809 return restoreQueuedMessage(queuedMessage, runtimeModeDenial);
810 }
811
812 if (settings.runtimeMode !== thread.runtimeMode) {
813 if (!hasAccess()) return true;
814 const runtimeResult = await runDeliveryCommand(threadEnvironment.setRuntimeMode, {
815 environmentId: queuedMessage.environmentId,
816 input: {
817 commandId: settingsCommandId(queuedMessage, "runtime-mode"),
818 threadId: queuedMessage.threadId,
819 runtimeMode: settings.runtimeMode,
820 createdAt: queuedMessage.createdAt,
821 },
822 });
823 if (AsyncResult.isFailure(runtimeResult)) {
824 reportCommandFailure(queuedMessage, runtimeResult, "settings-sync");
825 return false;
826 }
827 }
828
829 if (settings.interactionMode !== thread.interactionMode) {
830 if (!hasAccess()) return true;
831 const interactionResult = await runDeliveryCommand(threadEnvironment.setInteractionMode, {
832 environmentId: queuedMessage.environmentId,
833 input: {
834 commandId: settingsCommandId(queuedMessage, "interaction-mode"),
835 threadId: queuedMessage.threadId,
836 interactionMode: settings.interactionMode,
837 createdAt: queuedMessage.createdAt,
838 },
839 });
840 if (AsyncResult.isFailure(interactionResult)) {
841 reportCommandFailure(queuedMessage, interactionResult, "settings-sync");
842 return false;
843 }
844 }
845
846 let prepared: PreparedTurnAttachments;
847 let persistedMessage: QueuedThreadMessage;
848 let deliveryRevision: number;
849 if (!hasAccess()) return true;
850 try {
851 const preparedResult = await prepareQueuedMessageAttachments(queuedMessage);
852 if (preparedResult.status === "abandoned") {
853 return true;
854 }
855 prepared = preparedResult.prepared;
856 persistedMessage = preparedResult.persistedMessage;
857 deliveryRevision = preparedResult.deliveryRevision;
858 if (appAtomRegistry.get(editingQueuedMessageIdsAtom)[queuedMessage.messageId]) {
859 await preserveUploadedAttachmentsForEditor(queuedMessage, preparedResult.persistedMessage);
860 return true;
861 }
862 } catch (error) {
863 if (!hasAccess()) return true;
864 logThreadOutboxUploadFailure(queuedMessage, error);
865 if (!shouldRetryThreadOutboxDelivery(error)) {
866 return restoreQueuedMessage(
867 queuedMessage,
868 error instanceof Error ? error.message : "An attachment could not upload.",
869 );
870 }
871 return false;
872 }
873 if (!isQueuedMessagePayloadCurrent(persistedMessage, deliveryRevision)) {
874 return true;
875 }
876 const currentConfig = appAtomRegistry.get(
877 serverEnvironment.configValueAtom(queuedMessage.environmentId),
878 );
879 if (!currentConfig) return false;
880 if (isModelSelectionUnavailable(currentConfig, settings.modelSelection, thread.projectId)) {
881 const { title, detail } = describeUnavailableModelSelection(
882 currentConfig,
883 settings.modelSelection,
884 thread.projectId,
885 );
886 return restoreQueuedMessage(persistedMessage, `${title}. ${detail}`);
887 }
888 const sendSettings = resolveQueuedThreadSettings(
889 queuedMessage,
890 settings,
891 currentConfig.providers,
892 );
893 if (queuedMessage.compactBeforeSend === true) {
894 if (!hasAccess()) return true;
895 // Queued, since steering a running turn with a compaction is rejected.
896 const compactionResult = await runDeliveryCommand(threadEnvironment.startTurn, {
897 environmentId: queuedMessage.environmentId,
898 input: {
899 commandId: settingsCommandId(queuedMessage, "compact"),
900 creationSource: "mobile",
901 threadId: queuedMessage.threadId,
902 message: {
903 messageId: MessageId.make(`${queuedMessage.messageId}:compact`),
904 role: "user",
905 text: "/compact",
906 attachments: [],
907 idleCompaction: "onReturn",
908 },
909 modelSelection: sendSettings.modelSelection,
910 runtimeMode: sendSettings.runtimeMode,
911 interactionMode: sendSettings.interactionMode,
912 createdAt: queuedMessage.createdAt,
913 dispatchMode: "queue",
914 resendAfterSocketLoss: false,
915 },
916 });
917 if (AsyncResult.isFailure(compactionResult) && !hasAccess()) return true;
918 const compactionFailure = reportCommandFailure(queuedMessage, compactionResult, "start-turn");
919 if (compactionFailure?.action === "retry") return false;
920 if (compactionFailure?.action === "restore") {
921 return restoreQueuedMessage(persistedMessage, compactionFailure.message);
922 }
923 if (!isQueuedMessagePayloadCurrent(persistedMessage, deliveryRevision)) return true;
924 }
925 if (!hasAccess()) return true;
926 const deliveryResult = await runDeliveryCommand(threadEnvironment.startTurn, {
927 environmentId: queuedMessage.environmentId,
928 input: {
929 commandId: queuedMessage.commandId,
930 creationSource: "mobile",
931 threadId: queuedMessage.threadId,
932 message: {
933 messageId: queuedMessage.messageId,
934 role: "user",
935 ...serializeComposerMessageForServer(
936 queuedMessage.text,
937 uploadedComposerContext(
938 queuedMessage.context,
939 queuedMessage.attachments,
940 prepared.attachments,
941 ),
942 ),
943 attachments: prepared.attachments,
944 },
945 modelSelection: sendSettings.modelSelection,
946 titleSeed: deriveThreadTitleSeed({
947 text: queuedMessage.text,
948 attachments: queuedMessage.attachments,
949 }),
950 runtimeMode: sendSettings.runtimeMode,
951 interactionMode: sendSettings.interactionMode,
952 createdAt: queuedMessage.createdAt,
953 dispatchMode: queuedMessage.dispatchMode ?? "start",
954 ...(queuedMessage.freshContext ? { freshContext: true } : {}),
955 resendAfterSocketLoss: false,
956 },
957 });
958 if (AsyncResult.isFailure(deliveryResult) && !hasAccess()) return true;
959 const failure = reportCommandFailure(queuedMessage, deliveryResult, "start-turn");
960 if (failure?.action === "retry") {
961 return false;
962 }
963 if (failure?.action === "restore") {
964 return restoreQueuedMessage(persistedMessage, failure.message);
965 }
966 acknowledgedExistingThreadMessageIds.add(persistedMessage.messageId);
967 const delivered =
968 (await completeQueuedMessageDelivery(
969 persistedMessage,
970 deliveryRevision,
971 deliveredSequence(deliveryResult),
972 )) === "removed";
973 if (delivered) {
974 acknowledgedExistingThreadMessageIds.delete(persistedMessage.messageId);
975 }
976 return delivered;
977 };
978
979 const sendQueuedCreation = async (
980 queuedMessage: QueuedThreadMessage,
981 creation: QueuedThreadCreation,
982 projectCwd: string,
983 ): Promise<boolean> => {
984 const hasAccess = () =>
985 readEnvironmentScope(queuedMessage.environmentId, AuthOrchestrationOperateScope);
986 if (!hasAccess()) return true;
987 const modelSelection = queuedMessage.modelSelection;
988 if (modelSelection === undefined) {
989 return false;
990 }
991 const serverConfig = appAtomRegistry.get(
992 serverEnvironment.configValueAtom(queuedMessage.environmentId),
993 );
994 if (!serverConfig) return false;
995 const settings = resolveQueuedThreadSettings(
996 queuedMessage,
997 {
998 modelSelection,
999 runtimeMode: DEFAULT_RUNTIME_MODE,
1000 interactionMode: DEFAULT_PROVIDER_INTERACTION_MODE,
1001 },
1002 serverConfig.providers,
1003 );
1004 if (isModelSelectionUnavailable(serverConfig, settings.modelSelection, creation.projectId)) {
1005 const { title, detail } = describeUnavailableModelSelection(
1006 serverConfig,
1007 settings.modelSelection,
1008 creation.projectId,
1009 );
1010 return restoreQueuedMessage(queuedMessage, `${title}. ${detail}`);
1011 }
1012 const runtimeModeDenial = managedRuntimeModeDenial(
1013 serverConfig.managedPolicy,
1014 settings.runtimeMode,
1015 );
1016 if (runtimeModeDenial !== undefined) {
1017 return restoreQueuedMessage(queuedMessage, runtimeModeDenial);
1018 }
1019 let prepared: PreparedTurnAttachments;
1020 let persistedMessage: QueuedThreadMessage;
1021 let deliveryRevision: number;
1022 try {
1023 const preparedResult = await prepareQueuedMessageAttachments(queuedMessage);
1024 if (preparedResult.status === "abandoned") {
1025 return true;
1026 }
1027 prepared = preparedResult.prepared;
1028 persistedMessage = preparedResult.persistedMessage;
1029 deliveryRevision = preparedResult.deliveryRevision;
1030 if (appAtomRegistry.get(editingQueuedMessageIdsAtom)[queuedMessage.messageId]) {
1031 await preserveUploadedAttachmentsForEditor(queuedMessage, preparedResult.persistedMessage);
1032 return true;
1033 }
1034 } catch (error) {
1035 if (!hasAccess()) return true;
1036 logThreadOutboxUploadFailure(queuedMessage, error);
1037 if (!shouldRetryThreadOutboxDelivery(error)) {
1038 return restoreQueuedMessage(
1039 queuedMessage,
1040 error instanceof Error ? error.message : "An attachment could not upload.",
1041 );
1042 }
1043 return false;
1044 }
1045 if (!isQueuedMessagePayloadCurrent(persistedMessage, deliveryRevision)) {
1046 return true;
1047 }
1048 const currentConfig = appAtomRegistry.get(
1049 serverEnvironment.configValueAtom(queuedMessage.environmentId),
1050 );
1051 if (!currentConfig) return false;
1052 if (isModelSelectionUnavailable(currentConfig, settings.modelSelection, creation.projectId)) {
1053 const { title, detail } = describeUnavailableModelSelection(
1054 currentConfig,
1055 settings.modelSelection,
1056 creation.projectId,
1057 );
1058 return restoreQueuedMessage(persistedMessage, `${title}. ${detail}`);
1059 }
1060 const sendSettings = resolveQueuedThreadSettings(
1061 queuedMessage,
1062 settings,
1063 currentConfig.providers,
1064 );
1065 if (!hasAccess()) return true;
1066 let workspace = creation;
1067 if (creation.pullRequestReference) {
1068 const checkout = await runDeliveryCommand(gitEnvironment.preparePullRequestThread, {
1069 environmentId: queuedMessage.environmentId,
1070 input: { cwd: projectCwd, reference: creation.pullRequestReference, mode: "worktree" },
1071 });
1072 if (!isQueuedMessagePayloadCurrent(persistedMessage, deliveryRevision) || !hasAccess())
1073 return true;
1074 const failure = reportCommandFailure(queuedMessage, checkout, "start-turn");
1075 if (failure?.action === "retry") return false;
1076 if (failure?.action === "restore")
1077 return restoreQueuedMessage(persistedMessage, failure.message);
1078 if (!AsyncResult.isSuccess(checkout)) return false;
1079 if (!checkout.value.worktreePath || !checkout.value.isOnPullRequestHead) {
1080 const { shortLabel } = (
1081 sourceControlClients.findByChangeRequestUrl(creation.pullRequestReference) ??
1082 sourceControlClients.get(undefined)
1083 ).changeRequest;
1084 return restoreQueuedMessage(
1085 persistedMessage,
1086 `The ${shortLabel} worktree has local changes and could not update to the ${shortLabel} head. Resolve them before trying again.`,
1087 );
1088 }
1089 workspace = {
1090 ...creation,
1091 workspaceMode: "local",
1092 branch: checkout.value.branch,
1093 worktreePath: checkout.value.worktreePath,
1094 startFromOrigin: false,
1095 };
1096 }
1097 const deliveryResult = await runDeliveryCommand(threadEnvironment.startTurn, {
1098 environmentId: queuedMessage.environmentId,
1099 input: buildProjectThreadStartTurnInput({
1100 projectId: creation.projectId,
1101 projectCwd,
1102 threadId: queuedMessage.threadId,
1103 commandId: queuedMessage.commandId,
1104 messageId: queuedMessage.messageId,
1105 createdAt: queuedMessage.createdAt,
1106 titleText: queuedMessage.text,
1107 ...serializeComposerMessageForServer(
1108 queuedMessage.text.trim(),
1109 uploadedComposerContext(
1110 queuedMessage.context,
1111 queuedMessage.attachments,
1112 prepared.attachments,
1113 ),
1114 ),
1115 uploadedAttachments: prepared.attachments,
1116 modelSelection: sendSettings.modelSelection,
1117 runtimeMode: sendSettings.runtimeMode,
1118 interactionMode: sendSettings.interactionMode,
1119 workspaceMode: workspace.workspaceMode,
1120 branch: workspace.branch,
1121 worktreePath: workspace.worktreePath,
1122 startFromOrigin: workspace.startFromOrigin ?? false,
1123 worktreeBranchName: buildTemporaryWorktreeBranchName(randomHex),
1124 }),
1125 });
1126 if (AsyncResult.isFailure(deliveryResult) && !hasAccess()) return true;
1127 const failure = reportCommandFailure(queuedMessage, deliveryResult, "start-turn");
1128 if (failure?.action === "retry") {
1129 return false;
1130 }
1131 if (failure?.action === "restore") {
1132 return restoreQueuedMessage(persistedMessage, failure.message);
1133 }
1134 recordPendingThreadCreationOutcome({ kind: "delivered", message: persistedMessage });
1135 const outcome = await completeQueuedMessageDelivery(
1136 persistedMessage,
1137 deliveryRevision,
1138 deliveredSequence(deliveryResult),
1139 );
1140 if (outcome === "edited") {
1141 if (appAtomRegistry.get(editingQueuedMessageIdsAtom)[queuedMessage.messageId]) {
1142 return true;
1143 }
1144 return recoverEditedCreationAfterDelivery(persistedMessage);
1145 }
1146 return outcome === "removed";
1147 };
1148
1149 // A pass writes atoms the pass reads (family mounts, the dispatch slot), and the registry
1150 // notifies subscribers synchronously, so drain() can be called from inside a pass. That call
1151 // only asks for another pass; a nested pass would decide from inputs the outer one is still
1152 // acting on and could start a second delivery.
1153 let draining = false;
1154 let drainRequested = false;
1155 function drain(): void {
1156 if (disposed) return;
1157 if (draining) {
1158 drainRequested = true;
1159 return;
1160 }
1161 draining = true;
1162 try {
1163 do {
1164 if (disposed) return;
1165 drainRequested = false;
1166 drainPass();
1167 } while (drainRequested);
1168 } finally {
1169 draining = false;
1170 }
1171 }
1172
1173 function drainPass(): void {
1174 const {
1175 dispatchingQueuedMessageId,
1176 editingQueuedMessageIds,
1177 queuedMessagesByThreadKey,
1178 shellStatuses,
1179 threads,
1180 projects,
1181 serverConfigs,
1182 connectedEnvironments,
1183 operableEnvironments,
1184 } = appAtomRegistry.get(deliveryInputsAtom);
1185 if (dispatchingQueuedMessageId !== null) {
1186 return;
1187 }
1188
1189 const queuedMessageIds = new Set(
1190 Object.values(queuedMessagesByThreadKey)
1191 .flat()
1192 .map((message) => message.messageId),
1193 );
1194 for (const messageId of acknowledgedExistingThreadMessageIds) {
1195 if (!queuedMessageIds.has(messageId)) {
1196 acknowledgedExistingThreadMessageIds.delete(messageId);
1197 }
1198 }
1199 for (const [messageId, release] of familyMounts) {
1200 if (!queuedMessageIds.has(messageId)) {
1201 release();
1202 familyMounts.delete(messageId);
1203 }
1204 }
1205
1206 for (const [threadKey, queuedMessages] of Object.entries(queuedMessagesByThreadKey)) {
1207 const nextQueuedMessage = queuedMessages[0];
1208 if (!nextQueuedMessage) {
1209 continue;
1210 }
1211 const messageId = nextQueuedMessage.messageId;
1212 if (
1213 nextQueuedMessage.creation === undefined &&
1214 acknowledgedExistingThreadMessageIds.has(messageId)
1215 ) {
1216 if (retryNotBefore(messageId) > Date.now()) {
1217 continue;
1218 }
1219 beginDispatchingQueuedMessage(messageId);
1220 settle(
1221 messageId,
1222 removeAcknowledgedExistingThreadMessage(
1223 nextQueuedMessage,
1224 acknowledgedExistingThreadMessageIds,
1225 ),
1226 );
1227 return;
1228 }
1229 if (editingQueuedMessageIds[messageId]) {
1230 continue;
1231 }
1232 const blockedRecovery = blockedRecoveries.get(messageId);
1233 if (blockedRecovery) {
1234 if (blockedRecovery.message === nextQueuedMessage) {
1235 continue;
1236 }
1237 blockedRecoveries.delete(messageId);
1238 blockedRecovery.unsubscribe();
1239 }
1240 if (retryNotBefore(messageId) > Date.now()) {
1241 continue;
1242 }
1243
1244 let thread = findThread(threads, nextQueuedMessage);
1245 if (thread && scopedThreadKey(thread.environmentId, thread.id) !== threadKey) {
1246 continue;
1247 }
1248
1249 const creation = nextQueuedMessage.creation;
1250 const environment = connectedEnvironments.find(
1251 (candidate) => candidate.environmentId === nextQueuedMessage.environmentId,
1252 );
1253 const shellStatus = shellStatuses.get(nextQueuedMessage.environmentId) ?? "empty";
1254 const serverConfig = serverConfigs.get(nextQueuedMessage.environmentId);
1255 let familyRead: ThreadFamilyRead | undefined;
1256 if (
1257 thread === undefined &&
1258 creation === undefined &&
1259 serverConfig?.shellThreadFamilies === true
1260 ) {
1261 // The family keeps the row readable through dispatch once it loads; the current shell
1262 // generation's read decides whether the thread is gone.
1263 if (!familyMounts.has(nextQueuedMessage.messageId)) {
1264 familyMounts.set(
1265 nextQueuedMessage.messageId,
1266 threadFamilies.mount(
1267 appAtomRegistry,
1268 nextQueuedMessage.environmentId,
1269 nextQueuedMessage.threadId,
1270 ),
1271 );
1272 }
1273 familyRead = threadFamilyRead(
1274 appAtomRegistry.get(
1275 threadFamilies.familyAtom(nextQueuedMessage.environmentId, nextQueuedMessage.threadId),
1276 ),
1277 );
1278 if (familyRead === "settled") {
1279 // The rows read at the start of this pass can lag the family that just settled;
1280 // decide from the merged rows as they are now.
1281 thread = findThread(
1282 appAtomRegistry.get(environmentThreadShells.threadShellsAtom),
1283 nextQueuedMessage,
1284 );
1285 } else if (familyRead === "failed") {
1286 threadFamilies.refresh(
1287 appAtomRegistry,
1288 nextQueuedMessage.environmentId,
1289 nextQueuedMessage.threadId,
1290 );
1291 }
1292 }
1293 const deliveryAction = resolveThreadOutboxDeliveryAction({
1294 isCreation: creation !== undefined,
1295 threadExists: thread !== undefined,
1296 shellStatus,
1297 environmentConnected: environment?.connectionState === "connected",
1298 ...(familyRead === undefined ? {} : { familyRead }),
1299 });
1300 if (
1301 deliveryAction === "wait" &&
1302 shellStatus === "live" &&
1303 familyRead !== undefined &&
1304 familyRead !== "settled"
1305 ) {
1306 // An empty family read changes no merged row, so nothing else would wake the drain.
1307 scheduleRetry(messageId);
1308 continue;
1309 }
1310 if (deliveryAction === "send" && !operableEnvironments.has(nextQueuedMessage.environmentId)) {
1311 continue;
1312 }
1313 const dispatchStep = resolveThreadOutboxDispatchStep({
1314 deliveryAction,
1315 fileAttachments: nextQueuedMessage.attachments.filter(
1316 (attachment) => attachment.type === "file",
1317 ),
1318 serverConfig: serverConfig
1319 ? {
1320 maxFileUploadBytes:
1321 serverConfig.environment.capabilities.fileAttachments?.maxUploadBytes,
1322 }
1323 : null,
1324 });
1325 if (dispatchStep.step === "wait") {
1326 continue;
1327 }
1328 if (dispatchStep.step === "retry") {
1329 scheduleRetry(messageId);
1330 continue;
1331 }
1332 if (dispatchStep.step === "restore") {
1333 const attachmentError = dispatchStep.reason;
1334 beginDispatchingQueuedMessage(messageId);
1335 settle(
1336 messageId,
1337 confirmThreadOutboxMessageQueued(nextQueuedMessage).then((queued) =>
1338 !queued || appAtomRegistry.get(editingQueuedMessageIdsAtom)[messageId]
1339 ? true
1340 : restoreQueuedMessage(nextQueuedMessage, attachmentError),
1341 ),
1342 );
1343 return;
1344 }
1345 const creationProjectCwd =
1346 creation !== undefined
1347 ? (findCreationProject(projects, nextQueuedMessage)?.workspaceRoot ??
1348 creation.projectCwd ??
1349 null)
1350 : null;
1351 if (deliveryAction === "send" && creation !== undefined) {
1352 if (!isQueuedThreadCreationSendable(nextQueuedMessage)) {
1353 continue;
1354 }
1355 if (creationProjectCwd === null && shellStatus !== "live") {
1356 continue;
1357 }
1358 }
1359
1360 beginDispatchingQueuedMessage(messageId);
1361 const removeQueuedMessage = (warning: string) =>
1362 removeThreadOutboxMessage(nextQueuedMessage).then(
1363 () => true,
1364 (error) => {
1365 console.warn(warning, {
1366 environmentId: nextQueuedMessage.environmentId,
1367 threadId: nextQueuedMessage.threadId,
1368 messageId,
1369 error,
1370 });
1371 return false;
1372 },
1373 );
1374 // Confirm durability before sending; optimistic enqueue can still roll back on write failure.
1375 const delivery = confirmThreadOutboxMessageQueued(nextQueuedMessage).then((queued) => {
1376 if (!queued) {
1377 return true;
1378 }
1379 // Re-check editor ownership after confirmation; return true to defer without failure backoff.
1380 if (appAtomRegistry.get(editingQueuedMessageIdsAtom)[messageId]) {
1381 return true;
1382 }
1383 if (deliveryAction === "send") {
1384 const liveThread = findThread(
1385 appAtomRegistry.get(environmentThreadShells.threadShellsAtom),
1386 nextQueuedMessage,
1387 );
1388 const liveDeliveryAction = resolveThreadOutboxDeliveryAction({
1389 isCreation: creation !== undefined,
1390 threadExists: liveThread !== undefined,
1391 shellStatus,
1392 environmentConnected: environment?.connectionState === "connected",
1393 });
1394 if (liveDeliveryAction !== "send") {
1395 return true;
1396 }
1397 }
1398 return deliveryAction === "remove"
1399 ? creation !== undefined
1400 ? // After restart, always recover delivered creations; lost in-memory state cannot distinguish edits from duplicate payloads.
1401 recoverEditedCreationAfterDelivery(nextQueuedMessage)
1402 : removeQueuedMessage("[thread-outbox] failed to remove message for a missing thread")
1403 : creation !== undefined
1404 ? creationProjectCwd !== null
1405 ? sendQueuedCreation(nextQueuedMessage, creation, creationProjectCwd)
1406 : removeQueuedMessage("[thread-outbox] dropped pending task for a missing project")
1407 : thread !== undefined
1408 ? sendQueuedMessage(nextQueuedMessage, thread)
1409 : Promise.resolve(false);
1410 });
1411 settle(messageId, delivery);
1412 return;
1413 }
1414 }
1415
1416 const stopDraining = appAtomRegistry.subscribe(deliveryInputsAtom, drain, { immediate: true });
1417 const stopCollectingOutcomes = appAtomRegistry.subscribe(
1418 settledCreationOutcomeKeysAtom,
1419 (threadKeys) => {
1420 for (const threadKey of threadKeys) clearPendingThreadCreationOutcome(threadKey);
1421 },
1422 { immediate: true },
1423 );
1424
1425 return {
1426 drain,
1427 dispose: () => {
1428 disposed = true;
1429 stopDraining();
1430 stopCollectingOutcomes();
1431 for (const retry of retries.values()) clearTimeout(retry.timer);
1432 retries.clear();
1433 appAtomRegistry.set(retryingQueuedMessageIdsAtom, {});
1434 for (const blocked of blockedRecoveries.values()) blocked.unsubscribe();
1435 blockedRecoveries.clear();
1436 for (const release of familyMounts.values()) release();
1437 familyMounts.clear();
1438 },
1439 };
1440}
1441
1442function loadThreadOutbox(isActive: () => boolean): void {
1443 void threadOutboxManager.load().then((loaded) => {
1444 if (loaded || !isActive()) return;
1445 Dialog.alert(
1446 "Some queued messages could not be loaded",
1447 "Unreadable records and attachment files are still saved. Other messages can still be sent.",
1448 [
1449 { text: "Dismiss", style: "cancel" },
1450 { text: "Retry", onPress: () => loadThreadOutbox(isActive) },
1451 ],
1452 );
1453 });
1454}
1455
1456/** App-lifetime: loads the persisted outbox and delivers queued messages. */
1457export function installThreadOutboxDelivery(): () => void {
1458 let active = true;
1459 loadThreadOutbox(() => active);
1460 const delivery = createThreadOutboxDelivery();
1461 return () => {
1462 active = false;
1463 delivery.dispose();
1464 };
1465}