diff --git a/apps/mobile/src/lib/composerAttachmentUploadQueue.ts b/apps/mobile/src/lib/composerAttachmentUploadQueue.ts index f52b6fcdbe36b..92434c56b391d 100644 --- a/apps/mobile/src/lib/composerAttachmentUploadQueue.ts +++ b/apps/mobile/src/lib/composerAttachmentUploadQueue.ts @@ -114,30 +114,6 @@ export function composerAttachmentsStillUploading(input: { }); } -/** Changes when an upload starts or settles, not on its progress ticks. */ -export function uploadingComposerAttachmentKeys( - states: Readonly>, -): string { - return Object.keys(states) - .filter((key) => states[key]?.status === "uploading") - .sort() - .join("\n"); -} - -/** A queued message waits for the worker's upload instead of starting a second one. */ -export function queuedAttachmentsStillUploading(input: { - readonly environmentId: EnvironmentId; - readonly attachments: ReadonlyArray; - readonly states: Readonly>; -}): boolean { - return input.attachments.some( - (attachment) => - attachment.uploadedAttachmentId === undefined && - input.states[composerAttachmentUploadKey(input.environmentId, attachment.id)]?.status === - "uploading", - ); -} - /** Equal by environment and attachment id; the request rides along for the upload. */ class UploadKey implements Equal.Equal { constructor( diff --git a/apps/mobile/src/state/composer-attachment-upload-states.ts b/apps/mobile/src/state/composer-attachment-upload-states.ts deleted file mode 100644 index 2dafe12ef678a..0000000000000 --- a/apps/mobile/src/state/composer-attachment-upload-states.ts +++ /dev/null @@ -1,8 +0,0 @@ -import { Atom } from "effect/reactivity"; - -import type { ComposerAttachmentUploadState } from "../lib/composerAttachmentUploadQueue"; - -/** The upload worker's per-attachment states, apart from the worker so the outbox can read them. */ -export const composerAttachmentUploadsAtom = Atom.make< - Readonly> ->({}).pipe(Atom.keepAlive); diff --git a/apps/mobile/src/state/composer-attachment-uploads.test.ts b/apps/mobile/src/state/composer-attachment-uploads.test.ts index ac8bed2a42a75..c931dd1a87aaa 100644 --- a/apps/mobile/src/state/composer-attachment-uploads.test.ts +++ b/apps/mobile/src/state/composer-attachment-uploads.test.ts @@ -1,5 +1,7 @@ import { CommandId, EnvironmentId, MessageId, ThreadId } from "@t3tools/contracts"; -import { afterEach, beforeEach, expect, it, vi } from "vite-plus/test"; +import { expect, it } from "@effect/vitest"; +import * as Effect from "effect/Effect"; +import { afterEach, beforeEach, vi } from "vite-plus/test"; type UploadOptions = { signal: AbortSignal; @@ -167,7 +169,7 @@ vi.mock("./use-thread-outbox", async () => { const { Atom } = await import("effect/reactivity"); return { editingQueuedMessageIdsAtom: Atom.make>({}).pipe(Atom.keepAlive), - dispatchingQueuedMessageIdAtom: Atom.make>({}).pipe(Atom.keepAlive), + dispatchingQueuedMessageIdsAtom: Atom.make>({}).pipe(Atom.keepAlive), useThreadOutboxMessages: () => appAtomRegistry.get(threadOutboxManager.queuedMessagesByThreadKeyAtom), retryingQueuedMessageIdsAtom: Atom.make({}).pipe(Atom.keepAlive), @@ -296,29 +298,30 @@ function uploadState() { ]; } -it.each(["decode", "write"] as const)( +it.effect.each(["decode", "write"] as const)( "keeps an accepted upload ready when the draft %s fails", - async (fault) => { - native.fault = fault; - if (fault === "decode") - native.files.set(draftsUri, Buffer.from('{"schemaVersion":1,"drafts":')); - drafts.resetComposerDraftsLoadState(); - const queue = worker(); - await queue.settled(); - expect(uploadState()).toEqual({ status: "ready" }); - expect(native.deleted).toEqual([]); - expect(composerAttachmentUploadBlockReason(sendInput())).toBeNull(); - expect(composerAttachmentsStillUploading(sendInput())).toBe(false); + (fault) => + Effect.gen(function* () { + native.fault = fault; + if (fault === "decode") + native.files.set(draftsUri, Buffer.from('{"schemaVersion":1,"drafts":')); + drafts.resetComposerDraftsLoadState(); + const queue = worker(); + yield* Effect.promise(() => queue.settled()); + expect(uploadState()).toEqual({ status: "ready" }); + expect(native.deleted).toEqual([]); + expect(composerAttachmentUploadBlockReason(sendInput())).toBeNull(); + expect(composerAttachmentsStillUploading(sendInput())).toBe(false); - const message = queuedMessage(); - expect(message.attachments[0]?.uploadedAttachmentId).toBe("pending-1"); - await enqueueThreadOutboxMessage(message); - const prepared = await prepareQueuedMessageAttachments(message); - expect(prepared.status).toBe("ready"); - if (prepared.status !== "ready") throw new Error("Outbox preparation abandoned"); - expect(prepared.prepared.pendingAttachmentIds).toEqual(["pending-1"]); - expect(native.transfer).toHaveBeenCalledTimes(1); - }, + const message = queuedMessage(); + expect(message.attachments[0]?.uploadedAttachmentId).toBe("pending-1"); + yield* Effect.promise(() => enqueueThreadOutboxMessage(message)); + const prepared = yield* prepareQueuedMessageAttachments(message); + expect(prepared.status).toBe("ready"); + if (prepared.status !== "ready") throw new Error("Outbox preparation abandoned"); + expect(prepared.prepared.pendingAttachmentIds).toEqual(["pending-1"]); + expect(native.transfer).toHaveBeenCalledTimes(1); + }), ); it("keeps an upload running when its message is sent mid-upload and records it on the message", async () => { diff --git a/apps/mobile/src/state/composer-attachment-uploads.ts b/apps/mobile/src/state/composer-attachment-uploads.ts index 71812bb70aa72..acc7576a8d1d8 100644 --- a/apps/mobile/src/state/composer-attachment-uploads.ts +++ b/apps/mobile/src/state/composer-attachment-uploads.ts @@ -16,9 +16,9 @@ import { composerDraftEnvironmentId, canUploadComposerAttachment, createComposerAttachmentUploadQueue, + type ComposerAttachmentUploadState, } from "../lib/composerAttachmentUploadQueue"; import { appAtomRegistry } from "./atom-registry"; -import { composerAttachmentUploadsAtom } from "./composer-attachment-upload-states"; import { environmentServerConfigsAtom } from "./server"; import { flattenQueuedThreadMessages, @@ -46,7 +46,9 @@ export { composerAttachmentsStillUploading, } from "../lib/composerAttachmentUploadQueue"; -export { composerAttachmentUploadsAtom }; +export const composerAttachmentUploadsAtom = Atom.make< + Readonly> +>({}).pipe(Atom.keepAlive); const uploadStateAtom = Atom.family((key: string) => Atom.map(composerAttachmentUploadsAtom, (states) => states[key]), ); diff --git a/apps/mobile/src/state/edit-pending-thread-message.test.ts b/apps/mobile/src/state/edit-pending-thread-message.test.ts index c9c8b4f6a47f8..c9efb7c934e5c 100644 --- a/apps/mobile/src/state/edit-pending-thread-message.test.ts +++ b/apps/mobile/src/state/edit-pending-thread-message.test.ts @@ -3,7 +3,7 @@ import { CommandId, EnvironmentId, MessageId, ThreadId } from "@t3tools/contract import type { QueuedThreadMessage } from "./thread-outbox-model"; const state = vi.hoisted(() => ({ - dispatching: null as string | null, + dispatching: {} as Record, held: {} as Record, draft: { text: "Existing draft", attachments: [] as { id: string }[] }, confirm: vi.fn(async () => true), @@ -16,7 +16,7 @@ vi.mock("./atom-registry", () => ({ }, })); vi.mock("./use-thread-outbox", () => ({ - dispatchingQueuedMessageIdAtom: "dispatching", + dispatchingQueuedMessageIdsAtom: "dispatching", editingQueuedMessageIdsAtom: "editing", holdEditingQueuedMessage: (id: string) => { state.held[id] = true; @@ -67,7 +67,7 @@ const message: QueuedThreadMessage = { }; beforeEach(() => { vi.clearAllMocks(); - state.dispatching = null; + state.dispatching = {}; state.held = {}; state.draft = { text: "Existing draft", attachments: [] }; state.confirm.mockResolvedValue(true); @@ -90,7 +90,7 @@ describe("editing a pending message", () => { expect(state.held).toEqual({}); }); it("does not reclaim a message already being dispatched", async () => { - state.dispatching = message.messageId; + state.dispatching = { [message.messageId]: true }; expect(await editPendingThreadMessage(message)).toBe(false); expect(state.confirm).not.toHaveBeenCalled(); expect(state.draft.text).toBe("Existing draft"); diff --git a/apps/mobile/src/state/edit-pending-thread-message.ts b/apps/mobile/src/state/edit-pending-thread-message.ts index e2f3a2bfcb5d5..6e599abf6823d 100644 --- a/apps/mobile/src/state/edit-pending-thread-message.ts +++ b/apps/mobile/src/state/edit-pending-thread-message.ts @@ -16,7 +16,7 @@ import { waitForComposerDraftsLoaded, } from "./use-composer-drafts"; import { - dispatchingQueuedMessageIdAtom, + dispatchingQueuedMessageIdsAtom, editingQueuedMessageIdsAtom, holdEditingQueuedMessage, releaseEditingQueuedMessage, @@ -26,7 +26,7 @@ import { export async function editPendingThreadMessage(message: QueuedThreadMessage): Promise { if ( message.creation || - appAtomRegistry.get(dispatchingQueuedMessageIdAtom) === message.messageId || + appAtomRegistry.get(dispatchingQueuedMessageIdsAtom)[message.messageId] || appAtomRegistry.get(editingQueuedMessageIdsAtom)[message.messageId] ) { return false; diff --git a/apps/mobile/src/state/thread-task-permissions.test.ts b/apps/mobile/src/state/thread-task-permissions.test.ts index d037ac106a025..7051193be1175 100644 --- a/apps/mobile/src/state/thread-task-permissions.test.ts +++ b/apps/mobile/src/state/thread-task-permissions.test.ts @@ -141,7 +141,7 @@ vi.mock("./threads", async () => { }); vi.mock("./use-thread-outbox", async () => { const { Atom } = await import("effect/reactivity"); - return { dispatchingQueuedMessageIdAtom: Atom.make(null), useThreadOutboxMessages: () => ({}) }; + return { dispatchingQueuedMessageIdsAtom: Atom.make({}), useThreadOutboxMessages: () => ({}) }; }); vi.mock("./thread-outbox", () => ({ enqueueThreadOutboxMessage: state.enqueue })); vi.mock("./composer-attachment-uploads", async () => { diff --git a/apps/mobile/src/state/threadOutboxDelivery.permissions.test.ts b/apps/mobile/src/state/threadOutboxDelivery.permissions.test.ts index b9ad37a6d7d0d..700b58499d691 100644 --- a/apps/mobile/src/state/threadOutboxDelivery.permissions.test.ts +++ b/apps/mobile/src/state/threadOutboxDelivery.permissions.test.ts @@ -138,7 +138,9 @@ vi.mock("./use-thread-outbox", async () => { const { Atom } = await import("effect/reactivity"); return { editingQueuedMessageIdsAtom: Atom.make({}).pipe(Atom.keepAlive), - dispatchingQueuedMessageIdAtom: Atom.make(null).pipe(Atom.keepAlive), + dispatchingQueuedMessageIdsAtom: Atom.make>>({}).pipe( + Atom.keepAlive, + ), retryingQueuedMessageIdsAtom: Atom.make({}).pipe(Atom.keepAlive), threadOutboxShellStatusesAtom: Atom.make(new Map([["secondary", "live"]])), }; @@ -149,7 +151,7 @@ vi.mock("./use-composer-drafts", async () => { composerDraftsAtom: Atom.make({}), removeDeliveredCloudQueuedMessage: async () => {}, appendComposerDraftAttachments: vi.fn(), - flushComposerDrafts: vi.fn(), + flushComposerDrafts: vi.fn(async () => {}), getComposerDraftSnapshot: vi.fn(() => ({ text: state.draftText, attachments: [] })), mergeComposerDraftContent: vi.fn(async (_key: string, input: { text: string }) => { state.draftText += `\n${input.text}`; @@ -164,9 +166,10 @@ vi.mock("./use-composer-drafts", async () => { import { appAtomRegistry } from "./atom-registry"; import { environmentSession } from "./session"; -import { dispatchingQueuedMessageIdAtom, editingQueuedMessageIdsAtom } from "./use-thread-outbox"; +import { dispatchingQueuedMessageIdsAtom, editingQueuedMessageIdsAtom } from "./use-thread-outbox"; + +const sendingMessageIds = () => Object.keys(appAtomRegistry.get(dispatchingQueuedMessageIdsAtom)); import { createThreadOutboxDelivery } from "./threadOutboxDelivery"; -import { composerAttachmentUploadsAtom } from "./composer-attachment-upload-states"; import { workspaceConnections } from "./workspace"; const message = (overrides: Partial = {}): QueuedThreadMessage => ({ @@ -190,8 +193,8 @@ function setOperateGrant(environmentId: string, granted: boolean): void { function runDrain() { const settled = Promise.withResolvers(); - const release = appAtomRegistry.subscribe(dispatchingQueuedMessageIdAtom, (id) => { - if (id === null) settled.resolve(); + const release = appAtomRegistry.subscribe(dispatchingQueuedMessageIdsAtom, (ids) => { + if (Object.keys(ids).length === 0) settled.resolve(); }); startDelivery(); return settled.promise.finally(release); @@ -220,7 +223,7 @@ beforeEach(() => { state.familyMount.mockReset().mockReturnValue(() => {}); appAtomRegistry.set(state.threadShells, [state.thread]); appAtomRegistry.set(state.manager.queuedMessagesByThreadKeyAtom, {}); - appAtomRegistry.set(dispatchingQueuedMessageIdAtom, null); + appAtomRegistry.set(dispatchingQueuedMessageIdsAtom, {}); appAtomRegistry.set(editingQueuedMessageIdsAtom, {}); for (const command of [ state.start, @@ -361,7 +364,7 @@ describe("queued task operation access", () => { expect(state.modelUnavailable).toHaveBeenCalledOnce(); expect(state.prepare).not.toHaveBeenCalled(); expect(state.start).not.toHaveBeenCalled(); - expect(appAtomRegistry.get(dispatchingQueuedMessageIdAtom)).toBeNull(); + expect(sendingMessageIds()).toEqual([]); expect(remaining()).toEqual([queued]); }); @@ -378,17 +381,17 @@ describe("queued task operation access", () => { startDelivery(); appAtomRegistry.set(editingQueuedMessageIdsAtom, { [queued.messageId]: true }); await state.manager.enqueue(queued); - using confirm = vi.spyOn(state.manager, "confirmQueued"); const delivered = Promise.withResolvers(); - const release = appAtomRegistry.subscribe(dispatchingQueuedMessageIdAtom, (id) => { - if (id === null) delivered.resolve(); + const release = appAtomRegistry.subscribe(dispatchingQueuedMessageIdsAtom, (ids) => { + if (Object.keys(ids).length === 0) delivered.resolve(); }); - // Ending the edit wakes the drain through a registry notification, the path on which the - // mount's synchronous row change notifies the drain again mid-pass. + // Ending the edit wakes the thread through a registry notification, the path on which the + // mount's synchronous row change wakes it again while it is deciding. appAtomRegistry.set(editingQueuedMessageIdsAtom, {}); - expect(state.familyMount).toHaveBeenCalledOnce(); - expect(confirm).toHaveBeenCalledOnce(); await delivered.promise.finally(release); + expect(state.familyMount).toHaveBeenCalledOnce(); + // One fiber took the message: a second would have prepared it again. + expect(state.prepare).toHaveBeenCalledOnce(); expect(state.start).toHaveBeenCalledOnce(); expect(remaining()).toEqual([]); }); @@ -544,8 +547,8 @@ describe("queued task whose launch reply is lost", () => { async function fireRetry(): Promise { const settled = Promise.withResolvers(); - const release = appAtomRegistry.subscribe(dispatchingQueuedMessageIdAtom, (id) => { - if (id === null) settled.resolve(); + const release = appAtomRegistry.subscribe(dispatchingQueuedMessageIdsAtom, (ids) => { + if (Object.keys(ids).length === 0) settled.resolve(); }); vi.advanceTimersByTime(threadOutboxRetryDelayMs(1)); await settled.promise.finally(release); @@ -577,7 +580,7 @@ describe("queued task whose launch reply is lost", () => { await loseLaunchReply(queuedTask()); setOperateGrant("secondary", false); vi.advanceTimersByTime(threadOutboxRetryDelayMs(1)); - expect(appAtomRegistry.get(dispatchingQueuedMessageIdAtom)).toBeNull(); + expect(sendingMessageIds()).toEqual([]); expect(state.start).toHaveBeenCalledOnce(); expect(remaining()).toHaveLength(1); @@ -665,42 +668,87 @@ describe("compaction before a queued send", () => { describe("queued delivery timing", () => { /** Runs `change`, then resolves once the delivery it starts has settled. */ async function deliveryAfter(change: () => void): Promise { + const started = Promise.withResolvers(); const settled = Promise.withResolvers(); - const release = appAtomRegistry.subscribe(dispatchingQueuedMessageIdAtom, (id) => { - if (id === null) settled.resolve(); + const release = appAtomRegistry.subscribe(dispatchingQueuedMessageIdsAtom, (ids) => { + if (Object.keys(ids).length > 0) started.resolve(); + else settled.resolve(); }); change(); - expect(appAtomRegistry.get(dispatchingQueuedMessageIdAtom)).not.toBeNull(); + await started.promise; await settled.promise.finally(release); } - it("waits for the composer's upload of a sent attachment instead of uploading it again", async () => { + it("starts a thread's next message only after its interrupted send has finished", async () => { setOperateGrant("secondary", true); - const photo = { - id: "photo-1", - type: "image" as const, - name: "photo.png", - mimeType: "image/png", - sizeBytes: 3, - previewUri: "file:///photo.png", - fileUri: "file:///photo.png", - }; - appAtomRegistry.set(composerAttachmentUploadsAtom, { - "secondary:photo-1": { status: "uploading", progress: 0.5 }, + const firstStarted = Promise.withResolvers(); + const finishFirst = Promise.withResolvers>(); + state.start.mockImplementationOnce(async () => { + firstStarted.resolve(); + return finishFirst.promise; }); - state.cleanups.push(() => appAtomRegistry.set(composerAttachmentUploadsAtom, {})); - await state.manager.enqueue(message({ attachments: [photo] })); + const first = message(); + await state.manager.enqueue(first); startDelivery(); - expect(appAtomRegistry.get(dispatchingQueuedMessageIdAtom)).toBeNull(); + await firstStarted.promise; + // The queue empties under the running send, then the thread gets its next message. + await state.manager.remove(first); + const allDelivered = Promise.withResolvers(); + const release = appAtomRegistry.subscribe(state.manager.queuedMessagesByThreadKeyAtom, () => { + if (remaining().length === 0) allDelivered.resolve(); + }); + await state.manager.enqueue( + message({ messageId: MessageId.make("next"), commandId: CommandId.make("next-command") }), + ); + // The next message waits; only the interrupted send is still marked as sending. + expect(sendingMessageIds()).toEqual(["message"]); + expect(state.start).toHaveBeenCalledOnce(); + finishFirst.resolve(AsyncResult.success({})); + await allDelivered.promise.finally(release); + expect(state.start).toHaveBeenCalledTimes(2); + }); - await deliveryAfter(() => - appAtomRegistry.set(composerAttachmentUploadsAtom, { - "secondary:photo-1": { status: "ready" }, + it("sends another thread's message while one thread's send is still running", async () => { + setOperateGrant("secondary", true); + const other = { ...state.thread, id: "other" }; + appAtomRegistry.set(state.threadShells, [state.thread, other]); + const slowStarted = Promise.withResolvers(); + const finishSlow = Promise.withResolvers>(); + state.start.mockImplementation(async ({ input }: { input: { threadId: string } }) => { + if (input.threadId !== "thread") return AsyncResult.success({}); + slowStarted.resolve(); + return finishSlow.promise; + }); + /** Resolves once only these message ids are still queued. */ + const queuedBecomes = (ids: ReadonlyArray) => { + const reached = Promise.withResolvers(); + const release = appAtomRegistry.subscribe(state.manager.queuedMessagesByThreadKeyAtom, () => { + if ( + remaining() + .map((queued) => queued.messageId) + .join() === ids.join() + ) { + reached.resolve(); + } + }); + return reached.promise.finally(release); + }; + await state.manager.enqueue(message()); + startDelivery(); + await slowStarted.promise; + const otherDelivered = queuedBecomes(["message"]); + await state.manager.enqueue( + message({ + threadId: ThreadId.make("other"), + messageId: MessageId.make("other-message"), + commandId: CommandId.make("other-command"), }), ); - expect(state.prepare).toHaveBeenCalledOnce(); - expect(state.start).toHaveBeenCalledOnce(); - expect(remaining()).toEqual([]); + await otherDelivered; + const allDelivered = queuedBecomes([]); + finishSlow.resolve(AsyncResult.success({})); + await allDelivered; + expect(state.start).toHaveBeenCalledTimes(2); }); it("sends at once when its environment reconnects instead of waiting out the backoff", async () => { diff --git a/apps/mobile/src/state/threadOutboxDelivery.test.ts b/apps/mobile/src/state/threadOutboxDelivery.test.ts index b85ed8e4bf4cd..aa6e04c1867c8 100644 --- a/apps/mobile/src/state/threadOutboxDelivery.test.ts +++ b/apps/mobile/src/state/threadOutboxDelivery.test.ts @@ -3,6 +3,7 @@ import { pruneCaughtUpAcknowledgedThreadMessages, } from "./acknowledged-thread-messages"; import * as Effect from "effect/Effect"; +import * as Fiber from "effect/Fiber"; import { CommandId, EnvironmentId, @@ -11,7 +12,8 @@ import { ProviderInstanceId, ThreadId, } from "@t3tools/contracts"; -import { afterEach, beforeEach, describe, expect, it, vi } from "vite-plus/test"; +import { describe, expect, it } from "@effect/vitest"; +import { afterEach, beforeEach, vi } from "vite-plus/test"; import type { PreparedTurnAttachments } from "../lib/attachmentUpload"; @@ -121,7 +123,7 @@ vi.mock("./use-thread-outbox", async () => { const { Atom } = await import("effect/reactivity"); return { editingQueuedMessageIdsAtom: Atom.make>({}).pipe(Atom.keepAlive), - dispatchingQueuedMessageIdAtom: Atom.make(null).pipe(Atom.keepAlive), + dispatchingQueuedMessageIdsAtom: Atom.make({}).pipe(Atom.keepAlive), retryingQueuedMessageIdsAtom: Atom.make({}).pipe(Atom.keepAlive), threadOutboxShellStatusesAtom: Atom.make(new Map()), }; @@ -160,6 +162,7 @@ import { recoverFailedThreadDraft } from "./recover-failed-thread-draft"; import { editingQueuedMessageIdsAtom } from "./use-thread-outbox"; import { completeQueuedMessageDelivery, + type DeliveryRetry, prepareQueuedMessageAttachments, recoverEditedCreationAfterDelivery, removeAcknowledgedExistingThreadMessage, @@ -235,447 +238,522 @@ afterEach(() => { harness.prepareTurnAttachments.mockReset(); }); +/** True once a delivery step handled its message, false when it asks to retry. */ +const handled = (step: Effect.Effect) => + step.pipe(Effect.as(true), Effect.catchTags({ DeliveryRetry: () => Effect.succeed(false) })); + describe("thread outbox attachment preparation", () => { - it("keeps a denied message queued without starting its attachment upload", async () => { - const message = queuedMessage({ - messageId: "denied-queued-message", - text: "Keep this queued", - fileUri: "file:///documents/keep.pdf", - }); - await harness.manager.enqueue(message); - harness.prepareTurnAttachments.mockReturnValueOnce( - Effect.succeed({ + it.effect("keeps a denied message queued without starting its attachment upload", () => + Effect.gen(function* () { + const message = queuedMessage({ + messageId: "denied-queued-message", + text: "Keep this queued", + fileUri: "file:///documents/keep.pdf", + }); + yield* Effect.promise(() => harness.manager.enqueue(message)); + harness.prepareTurnAttachments.mockReturnValueOnce( + Effect.succeed({ + status: "ready", + attachments: [], + draftAttachments: message.attachments, + pendingAttachmentIds: [], + }), + ); + harness.canOperate = false; + expect(yield* prepareQueuedMessageAttachments(message)).toEqual({ + status: "abandoned", + }); + expect(harness.prepareTurnAttachments).not.toHaveBeenCalled(); + expect(remainingMessages()).toEqual([message]); + }), + ); + + it.effect("abandons reused uploads when an editor saves changed text during verification", () => + Effect.gen(function* () { + const message = withReusedFileUpload( + queuedMessage({ + messageId: "message-reused-upload-race", + text: "original text", + fileUri: "file:///documents/t3-composer-attachments/reused.pdf", + }), + "pending-reused-upload", + ); + const preparationStarted = Promise.withResolvers(); + const preparationBarrier = Promise.withResolvers(); + harness.prepareTurnAttachments.mockImplementationOnce(() => + Effect.promise(() => { + preparationStarted.resolve(); + return preparationBarrier.promise; + }), + ); + yield* Effect.promise(() => harness.manager.enqueue(message)); + appAtomRegistry.set(editingQueuedMessageIdsAtom, { [message.messageId]: true }); + + const preparation = yield* Effect.forkChild(prepareQueuedMessageAttachments(message), { + startImmediately: true, + }); + yield* Effect.promise(() => preparationStarted.promise); + const edited = { ...message, text: "saved editor text" }; + yield* Effect.promise(() => harness.manager.update(edited)); + appAtomRegistry.set(editingQueuedMessageIdsAtom, {}); + preparationBarrier.resolve({ status: "ready", attachments: [], draftAttachments: message.attachments, - pendingAttachmentIds: [], - }), - ); - harness.canOperate = false; - await expect(prepareQueuedMessageAttachments(message)).resolves.toEqual({ - status: "abandoned", - }); - expect(harness.prepareTurnAttachments).not.toHaveBeenCalled(); - expect(remainingMessages()).toEqual([message]); - }); - - it("abandons reused uploads when an editor saves changed text during verification", async () => { - const message = withReusedFileUpload( - queuedMessage({ - messageId: "message-reused-upload-race", - text: "original text", - fileUri: "file:///documents/t3-composer-attachments/reused.pdf", - }), - "pending-reused-upload", - ); - const preparationStarted = Promise.withResolvers(); - const preparationBarrier = Promise.withResolvers(); - harness.prepareTurnAttachments.mockImplementationOnce(() => - Effect.promise(() => { - preparationStarted.resolve(); - return preparationBarrier.promise; - }), - ); - await harness.manager.enqueue(message); - appAtomRegistry.set(editingQueuedMessageIdsAtom, { [message.messageId]: true }); - - const preparation = prepareQueuedMessageAttachments(message); - await preparationStarted.promise; - const edited = { ...message, text: "saved editor text" }; - await harness.manager.update(edited); - appAtomRegistry.set(editingQueuedMessageIdsAtom, {}); - preparationBarrier.resolve({ - status: "ready", - attachments: [], - draftAttachments: message.attachments, - pendingAttachmentIds: ["pending-reused-upload"], - }); + pendingAttachmentIds: ["pending-reused-upload"], + }); - await expect(preparation).resolves.toEqual({ status: "abandoned" }); - expect(remainingMessages()).toEqual([edited]); - }); + expect(yield* Fiber.join(preparation)).toEqual({ status: "abandoned" }); + expect(remainingMessages()).toEqual([edited]); + }), + ); - it("uses the known next revision after persisting uploaded references", async () => { - const message = queuedMessage({ - messageId: "message-new-upload-revision", - text: "upload this file", - fileUri: "file:///documents/t3-composer-attachments/new.pdf", - }); - const uploadedAttachments = message.attachments.map((attachment) => - attachment.type === "file" - ? { - ...attachment, - uploadedAttachmentId: "pending-new-upload", - uploadEnvironmentId: message.environmentId, - } - : attachment, - ); - harness.prepareTurnAttachments.mockImplementationOnce((input) => - Effect.gen(function* () { - expect(yield* input.persistUploadedReferences!(uploadedAttachments)).toBe("persisted"); - return { - status: "ready", - attachments: [], - draftAttachments: uploadedAttachments, - pendingAttachmentIds: ["pending-new-upload"], - } as const; - }), - ); - await harness.manager.enqueue(message); - const revision = harness.manager.revisionOf(message.messageId); + it.effect("uses the known next revision after persisting uploaded references", () => + Effect.gen(function* () { + const message = queuedMessage({ + messageId: "message-new-upload-revision", + text: "upload this file", + fileUri: "file:///documents/t3-composer-attachments/new.pdf", + }); + const uploadedAttachments = message.attachments.map((attachment) => + attachment.type === "file" + ? { + ...attachment, + uploadedAttachmentId: "pending-new-upload", + uploadEnvironmentId: message.environmentId, + } + : attachment, + ); + harness.prepareTurnAttachments.mockImplementationOnce((input) => + Effect.gen(function* () { + expect(yield* input.persistUploadedReferences!(uploadedAttachments)).toBe("persisted"); + return { + status: "ready", + attachments: [], + draftAttachments: uploadedAttachments, + pendingAttachmentIds: ["pending-new-upload"], + } as const; + }), + ); + yield* Effect.promise(() => harness.manager.enqueue(message)); + const revision = harness.manager.revisionOf(message.messageId); - const result = await prepareQueuedMessageAttachments(message); + const result = yield* prepareQueuedMessageAttachments(message); - expect(result).toMatchObject({ - status: "ready", - persistedMessage: { attachments: uploadedAttachments }, - deliveryRevision: revision + 1, - }); - expect(harness.manager.revisionOf(message.messageId)).toBe(revision + 1); - }); + expect(result).toMatchObject({ + status: "ready", + persistedMessage: { attachments: uploadedAttachments }, + deliveryRevision: revision + 1, + }); + expect(harness.manager.revisionOf(message.messageId)).toBe(revision + 1); + }), + ); - it("does not prepare a payload that was already replaced", async () => { - const message = queuedMessage({ messageId: "message-stale-before-upload", text: "old" }); - await harness.manager.enqueue(message); - const edited = { ...message, text: "new" }; - await harness.manager.update(edited); + it.effect("does not prepare a payload that was already replaced", () => + Effect.gen(function* () { + const message = queuedMessage({ messageId: "message-stale-before-upload", text: "old" }); + yield* Effect.promise(() => harness.manager.enqueue(message)); + const edited = { ...message, text: "new" }; + yield* Effect.promise(() => harness.manager.update(edited)); - await expect(prepareQueuedMessageAttachments(message)).resolves.toEqual({ - status: "abandoned", - }); - expect(harness.prepareTurnAttachments).not.toHaveBeenCalled(); - expect(remainingMessages()).toEqual([edited]); - }); + expect(yield* prepareQueuedMessageAttachments(message)).toEqual({ + status: "abandoned", + }); + expect(harness.prepareTurnAttachments).not.toHaveBeenCalled(); + expect(remainingMessages()).toEqual([edited]); + }), + ); }); describe("thread outbox drain delivery cleanup", () => { - it("drops caught-up acknowledged rows at the next delivery without subscribing to the thread", async () => { - const first = queuedMessage({ messageId: "awaiting-echo", text: "Delivered" }); - const second = queuedMessage({ messageId: "next-delivery", text: "Also delivered" }); - await harness.manager.enqueue(first); - await harness.manager.enqueue(second); - - await expect( - completeQueuedMessageDelivery(first, harness.manager.revisionOf(first.messageId), 7), - ).resolves.toBe("removed"); - expect(appAtomRegistry.get(acknowledgedThreadMessagesAtom)).toEqual([ - { ...first, sequence: 7 }, - ]); - - // The thread applied the message, but its bounded window does not hold it. - appAtomRegistry.set(harness.threadState, { - data: Option.some({ messages: [{ id: "unrelated" }] }), - sequence: 7, - }); - expect(appAtomRegistry.get(acknowledgedThreadMessagesAtom)).toHaveLength(1); - - await expect( - completeQueuedMessageDelivery(second, harness.manager.revisionOf(second.messageId), 9), - ).resolves.toBe("removed"); - expect(appAtomRegistry.get(acknowledgedThreadMessagesAtom)).toEqual([ - { ...second, sequence: 9 }, - ]); - }); - - it("drops an acknowledged row once the open thread catches up, so a reload cannot resurrect it", async () => { - const message = queuedMessage({ messageId: "paged-out-later", text: "Delivered" }); - await harness.manager.enqueue(message); - await completeQueuedMessageDelivery(message, harness.manager.revisionOf(message.messageId), 7); - - pruneCaughtUpAcknowledgedThreadMessages( - scopedThreadKey(message.environmentId, message.threadId), - { - sequence: 6, - messages: [], - }, - ); - expect(appAtomRegistry.get(acknowledgedThreadMessagesAtom)).toEqual([ - { ...message, sequence: 7 }, - ]); - - pruneCaughtUpAcknowledgedThreadMessages( - scopedThreadKey(message.environmentId, message.threadId), - { - sequence: 7, - messages: [], - }, - ); - expect(appAtomRegistry.get(acknowledgedThreadMessagesAtom)).toEqual([]); - }); + it.effect( + "drops caught-up acknowledged rows at the next delivery without subscribing to the thread", + () => + Effect.gen(function* () { + const first = queuedMessage({ messageId: "awaiting-echo", text: "Delivered" }); + const second = queuedMessage({ messageId: "next-delivery", text: "Also delivered" }); + yield* Effect.promise(() => harness.manager.enqueue(first)); + yield* Effect.promise(() => harness.manager.enqueue(second)); + + expect( + yield* completeQueuedMessageDelivery( + first, + harness.manager.revisionOf(first.messageId), + 7, + ), + ).toBe("removed"); + expect(appAtomRegistry.get(acknowledgedThreadMessagesAtom)).toEqual([ + { ...first, sequence: 7 }, + ]); + + // The thread applied the message, but its bounded window does not hold it. + appAtomRegistry.set(harness.threadState, { + data: Option.some({ messages: [{ id: "unrelated" }] }), + sequence: 7, + }); + expect(appAtomRegistry.get(acknowledgedThreadMessagesAtom)).toHaveLength(1); + + expect( + yield* completeQueuedMessageDelivery( + second, + harness.manager.revisionOf(second.messageId), + 9, + ), + ).toBe("removed"); + expect(appAtomRegistry.get(acknowledgedThreadMessagesAtom)).toEqual([ + { ...second, sequence: 9 }, + ]); + }), + ); - it("removes an acknowledged outbox item even when the sign-out archive write fails", async () => { - const message = queuedMessage({ messageId: "archive-write-failure", text: "Delivered" }); - await harness.manager.enqueue(message); - await composerDrafts.archiveCloudComposerDrafts("account-a", new Set([message.environmentId]), [ - message.environmentId, - ]); - harness.draftFile.setWriteError(new Error("Draft storage unavailable")); - - await expect( - completeQueuedMessageDelivery( - message, - harness.manager.revisionOf(message.messageId), - undefined, - ), - ).resolves.toBe("removed"); - expect(remainingMessages()).toEqual([]); + it.effect( + "drops an acknowledged row once the open thread catches up, so a reload cannot resurrect it", + () => + Effect.gen(function* () { + const message = queuedMessage({ messageId: "paged-out-later", text: "Delivered" }); + yield* Effect.promise(() => harness.manager.enqueue(message)); + yield* completeQueuedMessageDelivery( + message, + harness.manager.revisionOf(message.messageId), + 7, + ); + + pruneCaughtUpAcknowledgedThreadMessages( + scopedThreadKey(message.environmentId, message.threadId), + { + sequence: 6, + messages: [], + }, + ); + expect(appAtomRegistry.get(acknowledgedThreadMessagesAtom)).toEqual([ + { ...message, sequence: 7 }, + ]); - harness.draftFile.setWriteError(null); - await composerDrafts.flushComposerDrafts(); - appAtomRegistry.set(composerDrafts.composerCloudDraftsAtom, { accountId: null, signedOut: {} }); - composerDrafts.resetComposerDraftsLoadState(); - await composerDrafts.restoreCloudComposerDrafts("account-a"); - expect(remainingMessages()).toEqual([]); - }); + pruneCaughtUpAcknowledgedThreadMessages( + scopedThreadKey(message.environmentId, message.threadId), + { + sequence: 7, + messages: [], + }, + ); + expect(appAtomRegistry.get(acknowledgedThreadMessagesAtom)).toEqual([]); + }), + ); - it.each([false, true])( - "does not restore a message delivered after the sign-out snapshot (outbox already cleared: %s)", - async (cleared) => { - const message = queuedMessage({ - messageId: "delivered-during-sign-out", - text: "Already delivered", - }); - await harness.manager.enqueue(message); - const deliveryRevision = harness.manager.revisionOf(message.messageId); - await composerDrafts.archiveCloudComposerDrafts( - "account-a", - new Set([message.environmentId]), - [message.environmentId], + it.effect("removes an acknowledged outbox item even when the sign-out archive write fails", () => + Effect.gen(function* () { + const message = queuedMessage({ messageId: "archive-write-failure", text: "Delivered" }); + yield* Effect.promise(() => harness.manager.enqueue(message)); + yield* Effect.promise(() => + composerDrafts.archiveCloudComposerDrafts("account-a", new Set([message.environmentId]), [ + message.environmentId, + ]), ); - expect( - appAtomRegistry.get(composerDrafts.composerCloudDraftsAtom).signedOut["account-a"] - ?.queuedMessages, - ).toEqual([message]); + harness.draftFile.setWriteError(new Error("Draft storage unavailable")); - if (cleared) await harness.manager.clearEnvironment(message.environmentId); - await expect( - completeQueuedMessageDelivery(message, deliveryRevision, undefined), - ).resolves.toBe(cleared ? "edited" : "removed"); + expect( + yield* completeQueuedMessageDelivery( + message, + harness.manager.revisionOf(message.messageId), + undefined, + ), + ).toBe("removed"); + expect(remainingMessages()).toEqual([]); + harness.draftFile.setWriteError(null); + yield* Effect.promise(() => composerDrafts.flushComposerDrafts()); appAtomRegistry.set(composerDrafts.composerCloudDraftsAtom, { accountId: null, signedOut: {}, }); composerDrafts.resetComposerDraftsLoadState(); - await composerDrafts.restoreCloudComposerDrafts("account-a"); + yield* Effect.promise(() => composerDrafts.restoreCloudComposerDrafts("account-a")); expect(remainingMessages()).toEqual([]); - }, + }), ); - it("preserves an archived edit when an older payload finishes delivery", async () => { - const message = queuedMessage({ messageId: "edited-during-sign-out", text: "Original" }); - await harness.manager.enqueue(message); - const deliveryRevision = harness.manager.revisionOf(message.messageId); - const edited = { ...message, text: "Keep this edit" }; - await harness.manager.update(edited); - await composerDrafts.archiveCloudComposerDrafts("account-a", new Set([message.environmentId]), [ - message.environmentId, - ]); - await harness.manager.clearEnvironment(message.environmentId); - await expect(completeQueuedMessageDelivery(message, deliveryRevision, undefined)).resolves.toBe( - "edited", - ); - await composerDrafts.restoreCloudComposerDrafts("account-a"); - expect(remainingMessages()).toEqual([edited]); - }); - - it("retries only cleanup after an acknowledged send removal fails", async () => { - const message = queuedMessage({ messageId: "message-acknowledged", text: "delivered" }); - const acknowledged = new Set([message.messageId]); - harness.removeOutboxMessage.mockRejectedValueOnce(new Error("storage unavailable")); - await harness.manager.enqueue(message); - - await expect(removeAcknowledgedExistingThreadMessage(message, acknowledged)).resolves.toBe( - false, - ); - expect(remainingMessages()).toEqual([message]); - expect(acknowledged).toEqual(new Set([message.messageId])); - - await expect(removeAcknowledgedExistingThreadMessage(message, acknowledged)).resolves.toBe( - true, - ); - expect(remainingMessages()).toEqual([]); - expect(acknowledged).toEqual(new Set()); - }); + it.effect.each([false, true])( + "does not restore a message delivered after the sign-out snapshot (outbox already cleared: %s)", + (cleared) => + Effect.gen(function* () { + const message = queuedMessage({ + messageId: "delivered-during-sign-out", + text: "Already delivered", + }); + yield* Effect.promise(() => harness.manager.enqueue(message)); + const deliveryRevision = harness.manager.revisionOf(message.messageId); + yield* Effect.promise(() => + composerDrafts.archiveCloudComposerDrafts("account-a", new Set([message.environmentId]), [ + message.environmentId, + ]), + ); + expect( + appAtomRegistry.get(composerDrafts.composerCloudDraftsAtom).signedOut["account-a"] + ?.queuedMessages, + ).toEqual([message]); + + if (cleared) { + yield* Effect.promise(() => harness.manager.clearEnvironment(message.environmentId)); + } + expect(yield* completeQueuedMessageDelivery(message, deliveryRevision, undefined)).toBe( + cleared ? "edited" : "removed", + ); + + appAtomRegistry.set(composerDrafts.composerCloudDraftsAtom, { + accountId: null, + signedOut: {}, + }); + composerDrafts.resetComposerDraftsLoadState(); + yield* Effect.promise(() => composerDrafts.restoreCloudComposerDrafts("account-a")); + expect(remainingMessages()).toEqual([]); + }), + ); - it("keeps an edited message and its files when delivery cleanup loses the revision race", async () => { - const message = queuedMessage({ - messageId: "message-edited", - text: "original", - fileUri: "file:///documents/t3-composer-attachments/report.pdf", - }); - await harness.manager.enqueue(message); - const deliveryRevision = harness.manager.revisionOf(message.messageId); - const edited = { ...message, text: "edited while the turn delivered" }; - await harness.manager.update(edited); + it.effect("preserves an archived edit when an older payload finishes delivery", () => + Effect.gen(function* () { + const message = queuedMessage({ messageId: "edited-during-sign-out", text: "Original" }); + yield* Effect.promise(() => harness.manager.enqueue(message)); + const deliveryRevision = harness.manager.revisionOf(message.messageId); + const edited = { ...message, text: "Keep this edit" }; + yield* Effect.promise(() => harness.manager.update(edited)); + yield* Effect.promise(() => + composerDrafts.archiveCloudComposerDrafts("account-a", new Set([message.environmentId]), [ + message.environmentId, + ]), + ); + yield* Effect.promise(() => harness.manager.clearEnvironment(message.environmentId)); + expect(yield* completeQueuedMessageDelivery(message, deliveryRevision, undefined)).toBe( + "edited", + ); + yield* Effect.promise(() => composerDrafts.restoreCloudComposerDrafts("account-a")); + expect(remainingMessages()).toEqual([edited]); + }), + ); - await expect(completeQueuedMessageDelivery(message, deliveryRevision, undefined)).resolves.toBe( - "edited", - ); + it.effect("retries only cleanup after an acknowledged send removal fails", () => + Effect.gen(function* () { + const message = queuedMessage({ messageId: "message-acknowledged", text: "delivered" }); + const acknowledged = new Set([message.messageId]); + harness.removeOutboxMessage.mockRejectedValueOnce(new Error("storage unavailable")); + yield* Effect.promise(() => harness.manager.enqueue(message)); - expect(remainingMessages()).toEqual([edited]); - expect(harness.removePersistedFile).not.toHaveBeenCalled(); - }); - - it("removes the delivered message when no edit was accepted", async () => { - const message = queuedMessage({ messageId: "message-clean", text: "hello" }); - await harness.manager.enqueue(message); - const deliveryRevision = harness.manager.revisionOf(message.messageId); + expect(yield* handled(removeAcknowledgedExistingThreadMessage(message, acknowledged))).toBe( + false, + ); + expect(remainingMessages()).toEqual([message]); + expect(acknowledged).toEqual(new Set([message.messageId])); - await expect(completeQueuedMessageDelivery(message, deliveryRevision, undefined)).resolves.toBe( - "removed", - ); + expect(yield* handled(removeAcknowledgedExistingThreadMessage(message, acknowledged))).toBe( + true, + ); + expect(remainingMessages()).toEqual([]); + expect(acknowledged).toEqual(new Set()); + }), + ); - expect(remainingMessages()).toEqual([]); - expect(appAtomRegistry.get(acknowledgedThreadMessagesAtom)).toEqual([message]); - }); + it.effect( + "keeps an edited message and its files when delivery cleanup loses the revision race", + () => + Effect.gen(function* () { + const message = queuedMessage({ + messageId: "message-edited", + text: "original", + fileUri: "file:///documents/t3-composer-attachments/report.pdf", + }); + yield* Effect.promise(() => harness.manager.enqueue(message)); + const deliveryRevision = harness.manager.revisionOf(message.messageId); + const edited = { ...message, text: "edited while the turn delivered" }; + yield* Effect.promise(() => harness.manager.update(edited)); + + expect(yield* completeQueuedMessageDelivery(message, deliveryRevision, undefined)).toBe( + "edited", + ); + + expect(remainingMessages()).toEqual([edited]); + expect(harness.removePersistedFile).not.toHaveBeenCalled(); + }), + ); - it("keeps a delivered message when its editor opens during storage removal", async () => { - const message = queuedMessage({ - messageId: "message-editor-removal-race", - text: "keep editor changes", - fileUri: "file:///documents/t3-composer-attachments/editor-race.pdf", - }); - const removeStarted = Promise.withResolvers(); - const removeBarrier = Promise.withResolvers(); - harness.removeOutboxMessage.mockImplementationOnce(async () => { - removeStarted.resolve(); - await removeBarrier.promise; - }); - await harness.manager.enqueue(message); - const deliveryRevision = harness.manager.revisionOf(message.messageId); + it.effect("removes the delivered message when no edit was accepted", () => + Effect.gen(function* () { + const message = queuedMessage({ messageId: "message-clean", text: "hello" }); + yield* Effect.promise(() => harness.manager.enqueue(message)); + const deliveryRevision = harness.manager.revisionOf(message.messageId); - const cleanup = completeQueuedMessageDelivery(message, deliveryRevision, undefined); - await removeStarted.promise; - appAtomRegistry.set(editingQueuedMessageIdsAtom, { [message.messageId]: true }); - removeBarrier.resolve(); + expect(yield* completeQueuedMessageDelivery(message, deliveryRevision, undefined)).toBe( + "removed", + ); - await expect(cleanup).resolves.toBe("edited"); - expect(remainingMessages()).toEqual([message]); - expect(harness.removePersistedFile).not.toHaveBeenCalled(); - }); -}); + expect(remainingMessages()).toEqual([]); + expect(appAtomRegistry.get(acknowledgedThreadMessagesAtom)).toEqual([message]); + }), + ); -describe("thread outbox delivered creation recovery", () => { - it("keeps an edit accepted while the older payload is persisted to the draft", async () => { - const message = queuedMessage({ - messageId: "message-recovery-race", - text: "original queued text", - fileUri: "file:///documents/t3-composer-attachments/report.pdf", - }); - const originalMergeComposerDraftContent = composerDrafts.mergeComposerDraftContent; - const mergeCompleted = Promise.withResolvers(); - const releaseRecovery = Promise.withResolvers(); - const mergeSpy = vi - .spyOn(composerDrafts, "mergeComposerDraftContent") - .mockImplementation(async (draftKey, content) => { - const result = await originalMergeComposerDraftContent(draftKey, content); - mergeCompleted.resolve(); - await releaseRecovery.promise; - return result; + it.effect("keeps a delivered message when its editor opens during storage removal", () => + Effect.gen(function* () { + const message = queuedMessage({ + messageId: "message-editor-removal-race", + text: "keep editor changes", + fileUri: "file:///documents/t3-composer-attachments/editor-race.pdf", }); - - try { - await harness.manager.enqueue(message); - const recovery = recoverEditedCreationAfterDelivery(message); - await mergeCompleted.promise; - - const newer = { ...message, text: "edited while recovery persisted the draft" }; - await harness.manager.update(newer); - - releaseRecovery.resolve(); - await expect(recovery).resolves.toBe(false); - - expect(remainingMessages()).toEqual([newer]); - expect( - composerDrafts.getComposerDraftSnapshot(`${message.environmentId}:${message.threadId}`), - ).toMatchObject({ text: message.text, attachments: [] }); - expect(harness.removePersistedFile).not.toHaveBeenCalled(); - } finally { - releaseRecovery.resolve(); - mergeSpy.mockRestore(); - } - }); - - it("leaves recovery to an editor that opens while the draft persists", async () => { - const message = queuedMessage({ - messageId: "message-recovery-editor", - text: "recover this text", - fileUri: "file:///documents/t3-composer-attachments/editor.pdf", - }); - const originalMergeComposerDraftContent = composerDrafts.mergeComposerDraftContent; - const mergeCompleted = Promise.withResolvers(); - const releaseRecovery = Promise.withResolvers(); - const mergeSpy = vi - .spyOn(composerDrafts, "mergeComposerDraftContent") - .mockImplementation(async (draftKey, content) => { - const result = await originalMergeComposerDraftContent(draftKey, content); - mergeCompleted.resolve(); - await releaseRecovery.promise; - return result; + const removeStarted = Promise.withResolvers(); + const removeBarrier = Promise.withResolvers(); + harness.removeOutboxMessage.mockImplementationOnce(async () => { + removeStarted.resolve(); + await removeBarrier.promise; }); + yield* Effect.promise(() => harness.manager.enqueue(message)); + const deliveryRevision = harness.manager.revisionOf(message.messageId); - try { - await harness.manager.enqueue(message); - const recovery = recoverEditedCreationAfterDelivery(message); - await mergeCompleted.promise; + const cleanup = yield* Effect.forkChild( + completeQueuedMessageDelivery(message, deliveryRevision, undefined), + { startImmediately: true }, + ); + yield* Effect.promise(() => removeStarted.promise); appAtomRegistry.set(editingQueuedMessageIdsAtom, { [message.messageId]: true }); + removeBarrier.resolve(); - releaseRecovery.resolve(); - await expect(recovery).resolves.toBe(true); - + expect(yield* Fiber.join(cleanup)).toBe("edited"); expect(remainingMessages()).toEqual([message]); - expect( - composerDrafts.getComposerDraftSnapshot(`${message.environmentId}:${message.threadId}`), - ).toMatchObject({ text: message.text, attachments: [] }); expect(harness.removePersistedFile).not.toHaveBeenCalled(); - } finally { - releaseRecovery.resolve(); - mergeSpy.mockRestore(); - } - }); - - it("retries a failed removal without duplicating recovered draft content", async () => { - const message = queuedMessage({ - messageId: "message-recovery-removal", - text: "recover once", - fileUri: "file:///documents/t3-composer-attachments/retry.pdf", - }); - const draftKey = `${message.environmentId}:${message.threadId}`; - const removeSpy = vi - .spyOn(harness.manager, "remove") - .mockRejectedValueOnce(new Error("storage unavailable")); + }), + ); +}); - try { - await harness.manager.enqueue(message); +describe("thread outbox delivered creation recovery", () => { + it.effect("keeps an edit accepted while the older payload is persisted to the draft", () => + Effect.gen(function* () { + const message = queuedMessage({ + messageId: "message-recovery-race", + text: "original queued text", + fileUri: "file:///documents/t3-composer-attachments/report.pdf", + }); + const originalMergeComposerDraftContent = composerDrafts.mergeComposerDraftContent; + const mergeCompleted = Promise.withResolvers(); + const releaseRecovery = Promise.withResolvers(); + const mergeSpy = vi + .spyOn(composerDrafts, "mergeComposerDraftContent") + .mockImplementation(async (draftKey, content) => { + const result = await originalMergeComposerDraftContent(draftKey, content); + mergeCompleted.resolve(); + await releaseRecovery.promise; + return result; + }); + + try { + yield* Effect.promise(() => harness.manager.enqueue(message)); + const recovery = yield* Effect.forkChild( + handled(recoverEditedCreationAfterDelivery(message)), + { startImmediately: true }, + ); + yield* Effect.promise(() => mergeCompleted.promise); + + const newer = { ...message, text: "edited while recovery persisted the draft" }; + yield* Effect.promise(() => harness.manager.update(newer)); + + releaseRecovery.resolve(); + expect(yield* Fiber.join(recovery)).toBe(false); + + expect(remainingMessages()).toEqual([newer]); + expect( + composerDrafts.getComposerDraftSnapshot(`${message.environmentId}:${message.threadId}`), + ).toMatchObject({ text: message.text, attachments: [] }); + expect(harness.removePersistedFile).not.toHaveBeenCalled(); + } finally { + releaseRecovery.resolve(); + mergeSpy.mockRestore(); + } + }), + ); - await expect(recoverEditedCreationAfterDelivery(message)).resolves.toBe(false); - expect(remainingMessages()).toEqual([message]); + it.effect("leaves recovery to an editor that opens while the draft persists", () => + Effect.gen(function* () { + const message = queuedMessage({ + messageId: "message-recovery-editor", + text: "recover this text", + fileUri: "file:///documents/t3-composer-attachments/editor.pdf", + }); + const originalMergeComposerDraftContent = composerDrafts.mergeComposerDraftContent; + const mergeCompleted = Promise.withResolvers(); + const releaseRecovery = Promise.withResolvers(); + const mergeSpy = vi + .spyOn(composerDrafts, "mergeComposerDraftContent") + .mockImplementation(async (draftKey, content) => { + const result = await originalMergeComposerDraftContent(draftKey, content); + mergeCompleted.resolve(); + await releaseRecovery.promise; + return result; + }); + + try { + yield* Effect.promise(() => harness.manager.enqueue(message)); + const recovery = yield* Effect.forkChild( + handled(recoverEditedCreationAfterDelivery(message)), + { startImmediately: true }, + ); + yield* Effect.promise(() => mergeCompleted.promise); + appAtomRegistry.set(editingQueuedMessageIdsAtom, { [message.messageId]: true }); - await expect(recoverEditedCreationAfterDelivery(message)).resolves.toBe(true); + releaseRecovery.resolve(); + expect(yield* Fiber.join(recovery)).toBe(true); + + expect(remainingMessages()).toEqual([message]); + expect( + composerDrafts.getComposerDraftSnapshot(`${message.environmentId}:${message.threadId}`), + ).toMatchObject({ text: message.text, attachments: [] }); + expect(harness.removePersistedFile).not.toHaveBeenCalled(); + } finally { + releaseRecovery.resolve(); + mergeSpy.mockRestore(); + } + }), + ); - const draft = composerDrafts.getComposerDraftSnapshot(draftKey); - expect(draft.text).toBe(message.text); - expect(draft.attachments).toEqual(message.attachments); - expect(remainingMessages()).toEqual([]); - expect(harness.removePersistedFile).not.toHaveBeenCalled(); - } finally { - removeSpy.mockRestore(); - } - }); + it.effect("retries a failed removal without duplicating recovered draft content", () => + Effect.gen(function* () { + const message = queuedMessage({ + messageId: "message-recovery-removal", + text: "recover once", + fileUri: "file:///documents/t3-composer-attachments/retry.pdf", + }); + const draftKey = `${message.environmentId}:${message.threadId}`; + const removeSpy = vi + .spyOn(harness.manager, "remove") + .mockRejectedValueOnce(new Error("storage unavailable")); + + try { + yield* Effect.promise(() => harness.manager.enqueue(message)); + + expect(yield* handled(recoverEditedCreationAfterDelivery(message))).toBe(false); + expect(remainingMessages()).toEqual([message]); + + expect(yield* handled(recoverEditedCreationAfterDelivery(message))).toBe(true); + + const draft = composerDrafts.getComposerDraftSnapshot(draftKey); + expect(draft.text).toBe(message.text); + expect(draft.attachments).toEqual(message.attachments); + expect(remainingMessages()).toEqual([]); + expect(harness.removePersistedFile).not.toHaveBeenCalled(); + } finally { + removeSpy.mockRestore(); + } + }), + ); - it("keeps the queue entry when the recovered draft cannot persist", async () => { - const message = queuedMessage({ - messageId: "message-recovery-persistence", - text: "recover after persistence returns", - }); - await harness.manager.enqueue(message); - harness.draftFile.setWriteError(new Error("disk full")); + it.effect("keeps the queue entry when the recovered draft cannot persist", () => + Effect.gen(function* () { + const message = queuedMessage({ + messageId: "message-recovery-persistence", + text: "recover after persistence returns", + }); + yield* Effect.promise(() => harness.manager.enqueue(message)); + harness.draftFile.setWriteError(new Error("disk full")); - await expect(recoverEditedCreationAfterDelivery(message)).resolves.toBe(false); + expect(yield* handled(recoverEditedCreationAfterDelivery(message))).toBe(false); - expect(remainingMessages()).toEqual([message]); - }); + expect(remainingMessages()).toEqual([message]); + }), + ); }); describe("thread outbox recovery rollback", () => { @@ -728,111 +806,121 @@ describe("thread outbox recovery rollback", () => { ); }); - it("restores a rejected new task as its own draft for the project", async () => { - const message: QueuedThreadMessage = { - ...queuedMessage({ messageId: "message-creation-restore", text: "new task text" }), - modelSelection: { instanceId: ProviderInstanceId.make("codex"), model: "gpt-5.6-sol" }, - creation: { - projectId: ProjectId.make("project-1"), - workspaceMode: "local", - branch: null, - worktreePath: null, - }, - }; - await harness.manager.enqueue(message); - - await expect(restoreRejectedQueuedMessage(message, "rejected by server")).resolves.toBe( - "restored", - ); + it.effect("restores a rejected new task as its own draft for the project", () => + Effect.gen(function* () { + const message: QueuedThreadMessage = { + ...queuedMessage({ messageId: "message-creation-restore", text: "new task text" }), + modelSelection: { instanceId: ProviderInstanceId.make("codex"), model: "gpt-5.6-sol" }, + creation: { + projectId: ProjectId.make("project-1"), + workspaceMode: "local", + branch: null, + worktreePath: null, + }, + }; + yield* Effect.promise(() => harness.manager.enqueue(message)); + + expect(yield* restoreRejectedQueuedMessage(message, "rejected by server")).toBe("restored"); - expect( - composerDrafts.getComposerDraftSnapshot(`new-task:restored-${message.messageId}`), - ).toMatchObject({ - text: message.text, - attachments: message.attachments, - modelSelection: message.modelSelection, - project: { - environmentId: message.environmentId, - projectId: message.creation!.projectId, - createdAt: message.createdAt, - }, - }); - expect(remainingMessages()).toEqual([]); - expect(appAtomRegistry.get(threadComposerErrorsAtom)).toEqual({}); - expect( - appAtomRegistry.get(pendingThreadCreationOutcomesAtom)[ - `${message.environmentId}:${message.threadId}` - ], - ).toEqual({ kind: "failed", message, reason: "rejected by server" }); - }); + expect( + composerDrafts.getComposerDraftSnapshot(`new-task:restored-${message.messageId}`), + ).toMatchObject({ + text: message.text, + attachments: message.attachments, + modelSelection: message.modelSelection, + project: { + environmentId: message.environmentId, + projectId: message.creation!.projectId, + createdAt: message.createdAt, + }, + }); + expect(remainingMessages()).toEqual([]); + expect(appAtomRegistry.get(threadComposerErrorsAtom)).toEqual({}); + expect( + appAtomRegistry.get(pendingThreadCreationOutcomesAtom)[ + `${message.environmentId}:${message.threadId}` + ], + ).toEqual({ kind: "failed", message, reason: "rejected by server" }); + }), + ); - it("does not record a creation outcome for a rejected follow-up message", async () => { - const message = queuedMessage({ messageId: "message-followup-restore", text: "follow up" }); - await harness.manager.enqueue(message); + it.effect("does not record a creation outcome for a rejected follow-up message", () => + Effect.gen(function* () { + const message = queuedMessage({ messageId: "message-followup-restore", text: "follow up" }); + yield* Effect.promise(() => harness.manager.enqueue(message)); - await expect(restoreRejectedQueuedMessage(message, "rejected")).resolves.toBe("restored"); + expect(yield* restoreRejectedQueuedMessage(message, "rejected")).toBe("restored"); - expect(appAtomRegistry.get(pendingThreadCreationOutcomesAtom)).toEqual({}); - expect( - appAtomRegistry.get(threadComposerErrorsAtom)[`${message.environmentId}:${message.threadId}`], - ).toEqual({ message: "rejected", messageId: message.messageId }); - }); + expect(appAtomRegistry.get(pendingThreadCreationOutcomesAtom)).toEqual({}); + expect( + appAtomRegistry.get(threadComposerErrorsAtom)[ + `${message.environmentId}:${message.threadId}` + ], + ).toEqual({ message: "rejected", messageId: message.messageId }); + }), + ); - it("leaves no error when the restored text is resent before recovery finishes", async () => { - const message = queuedMessage({ messageId: "message-resent", text: "resend me" }); - const threadKey = `${message.environmentId}:${message.threadId}`; - await harness.manager.enqueue(message); - const unsubscribe = appAtomRegistry.subscribe(composerDrafts.composerDraftsAtom, (drafts) => { - if (drafts[threadKey]?.text === "resend me") { - unsubscribe(); - clearThreadComposerError(threadKey); - void composerDrafts.clearComposerDraftContent(threadKey); - } - }); + it.effect("leaves no error when the restored text is resent before recovery finishes", () => + Effect.gen(function* () { + const message = queuedMessage({ messageId: "message-resent", text: "resend me" }); + const threadKey = `${message.environmentId}:${message.threadId}`; + yield* Effect.promise(() => harness.manager.enqueue(message)); + const unsubscribe = appAtomRegistry.subscribe(composerDrafts.composerDraftsAtom, (drafts) => { + if (drafts[threadKey]?.text === "resend me") { + unsubscribe(); + clearThreadComposerError(threadKey); + void composerDrafts.clearComposerDraftContent(threadKey); + } + }); - await expect(restoreRejectedQueuedMessage(message, "rejected")).resolves.toBe("restored"); + expect(yield* restoreRejectedQueuedMessage(message, "rejected")).toBe("restored"); - expect(appAtomRegistry.get(threadComposerErrorsAtom)).toEqual({}); - }); + expect(appAtomRegistry.get(threadComposerErrorsAtom)).toEqual({}); + }), + ); - it("withdraws the error when an edit makes the recovery back out", async () => { - const message = queuedMessage({ messageId: "message-edited-mid-recovery", text: "edit me" }); - const threadKey = `${message.environmentId}:${message.threadId}`; - await harness.manager.enqueue(message); - const unsubscribe = appAtomRegistry.subscribe(composerDrafts.composerDraftsAtom, (drafts) => { - if (drafts[threadKey]?.text === "edit me") { - unsubscribe(); - appAtomRegistry.set(editingQueuedMessageIdsAtom, { [message.messageId]: true }); - } - }); + it.effect("withdraws the error when an edit makes the recovery back out", () => + Effect.gen(function* () { + const message = queuedMessage({ messageId: "message-edited-mid-recovery", text: "edit me" }); + const threadKey = `${message.environmentId}:${message.threadId}`; + yield* Effect.promise(() => harness.manager.enqueue(message)); + const unsubscribe = appAtomRegistry.subscribe(composerDrafts.composerDraftsAtom, (drafts) => { + if (drafts[threadKey]?.text === "edit me") { + unsubscribe(); + appAtomRegistry.set(editingQueuedMessageIdsAtom, { [message.messageId]: true }); + } + }); - await expect(restoreRejectedQueuedMessage(message, "rejected")).resolves.toBe("deferred"); + expect(yield* restoreRejectedQueuedMessage(message, "rejected")).toBe("deferred"); - expect(appAtomRegistry.get(threadComposerErrorsAtom)).toEqual({}); - expect(remainingMessages()).toEqual([message]); - }); + expect(appAtomRegistry.get(threadComposerErrorsAtom)).toEqual({}); + expect(remainingMessages()).toEqual([message]); + }), + ); - it("rolls a failed recovery merge back so the retry cannot duplicate the text", async () => { - const message = queuedMessage({ messageId: "message-restore", text: "queued text" }); - const draftKey = `${message.environmentId}:${message.threadId}`; - appAtomRegistry.set(composerDrafts.composerDraftsAtom, { - [draftKey]: { text: "typed offline", attachments: [] }, - }); - await harness.manager.enqueue(message); + it.effect("rolls a failed recovery merge back so the retry cannot duplicate the text", () => + Effect.gen(function* () { + const message = queuedMessage({ messageId: "message-restore", text: "queued text" }); + const draftKey = `${message.environmentId}:${message.threadId}`; + appAtomRegistry.set(composerDrafts.composerDraftsAtom, { + [draftKey]: { text: "typed offline", attachments: [] }, + }); + yield* Effect.promise(() => harness.manager.enqueue(message)); - harness.draftFile.setWriteError(new Error("disk full")); - await expect(restoreRejectedQueuedMessage(message, "too large")).resolves.toBe("retry"); + harness.draftFile.setWriteError(new Error("disk full")); + expect(yield* restoreRejectedQueuedMessage(message, "too large")).toBe("retry"); - expect(composerDrafts.getComposerDraftSnapshot(draftKey).text).toBe("typed offline"); - expect(remainingMessages()).toEqual([message]); + expect(composerDrafts.getComposerDraftSnapshot(draftKey).text).toBe("typed offline"); + expect(remainingMessages()).toEqual([message]); - harness.draftFile.setWriteError(null); - await expect(restoreRejectedQueuedMessage(message, "too large")).resolves.toBe("restored"); + harness.draftFile.setWriteError(null); + expect(yield* restoreRejectedQueuedMessage(message, "too large")).toBe("restored"); - expect(composerDrafts.getComposerDraftSnapshot(draftKey).text).toBe( - "typed offline\n\nqueued text", - ); - expect(remainingMessages()).toEqual([]); - expect(appAtomRegistry.get(threadComposerErrorsAtom)[draftKey]?.message).toBe("too large"); - }); + expect(composerDrafts.getComposerDraftSnapshot(draftKey).text).toBe( + "typed offline\n\nqueued text", + ); + expect(remainingMessages()).toEqual([]); + expect(appAtomRegistry.get(threadComposerErrorsAtom)[draftKey]?.message).toBe("too large"); + }), + ); }); diff --git a/apps/mobile/src/state/threadOutboxDelivery.ts b/apps/mobile/src/state/threadOutboxDelivery.ts index 3a3802d425897..5eb87964571db 100644 --- a/apps/mobile/src/state/threadOutboxDelivery.ts +++ b/apps/mobile/src/state/threadOutboxDelivery.ts @@ -23,14 +23,20 @@ import { } from "@t3tools/contracts"; import { buildTemporaryWorktreeBranchName } from "@t3tools/shared/git"; import * as Cause from "effect/Cause"; +import * as Clock from "effect/Clock"; import * as Effect from "effect/Effect"; +import * as Exit from "effect/Exit"; +import * as Fiber from "effect/Fiber"; +import * as Latch from "effect/Latch"; +import * as Schema from "effect/Schema"; import { AsyncResult, Atom } from "effect/reactivity"; import { createDebugLogger } from "../lib/debugLog"; +import type { DraftComposerAttachment } from "../lib/composerImages"; import { scopedThreadKey } from "../lib/scopedEntities"; import { buildProjectThreadStartTurnInput } from "../lib/projectThreadStartTurn"; import { serializeComposerMessageForServer, uploadedComposerContext } from "../lib/composerContext"; -import { prepareTurnAttachments, type PreparedTurnAttachments } from "../lib/attachmentUpload"; +import { prepareTurnAttachments } from "../lib/attachmentUpload"; import { randomHex } from "../lib/uuid"; import { describeUnavailableModelSelection, @@ -49,12 +55,7 @@ import { } from "./pending-thread-creation"; import { environmentProjects } from "./projects"; import { environmentServerConfigsAtom, serverEnvironment } from "./server"; -import { composerAttachmentUploadsAtom } from "./composer-attachment-upload-states"; import { uploadComposerAttachmentShared } from "./composer-attachment-uploads"; -import { - queuedAttachmentsStillUploading, - uploadingComposerAttachmentKeys, -} from "../lib/composerAttachmentUploadQueue"; import { gitEnvironment } from "./git"; import { environmentSession, readEnvironmentScope, sessionHasScope } from "./session"; import { @@ -92,7 +93,7 @@ import { waitForComposerDraftsLoaded, } from "./use-composer-drafts"; import { - dispatchingQueuedMessageIdAtom, + dispatchingQueuedMessageIdsAtom, editingQueuedMessageIdsAtom, retryingQueuedMessageIdsAtom, threadOutboxShellStatusesAtom, @@ -177,12 +178,17 @@ function setQueuedMessageRetrying(queuedMessageId: MessageId, retrying: boolean) function beginDispatchingQueuedMessage(queuedMessageId: MessageId): void { // An attempt in flight is sending, even while its retry count is kept. setQueuedMessageRetrying(queuedMessageId, false); - appAtomRegistry.set(dispatchingQueuedMessageIdAtom, queuedMessageId); + appAtomRegistry.set(dispatchingQueuedMessageIdsAtom, { + ...appAtomRegistry.get(dispatchingQueuedMessageIdsAtom), + [queuedMessageId]: true, + }); } function finishDispatchingQueuedMessage(queuedMessageId: MessageId): void { - const current = appAtomRegistry.get(dispatchingQueuedMessageIdAtom); - appAtomRegistry.set(dispatchingQueuedMessageIdAtom, current === queuedMessageId ? null : current); + const { [queuedMessageId]: _finished, ...others } = appAtomRegistry.get( + dispatchingQueuedMessageIdsAtom, + ); + appAtomRegistry.set(dispatchingQueuedMessageIdsAtom, others); } function findThread( @@ -210,57 +216,93 @@ function settingsCommandId(message: QueuedThreadMessage, setting: string): Comma return CommandId.make(`${message.commandId}:${setting}`); } -export async function prepareQueuedMessageAttachments(queuedMessage: QueuedThreadMessage): Promise< - | { - readonly status: "ready"; - readonly prepared: PreparedTurnAttachments; - readonly persistedMessage: QueuedThreadMessage; - readonly deliveryRevision: number; - } - | { readonly status: "abandoned" } -> { - if (!(await confirmThreadOutboxMessageQueued(queuedMessage))) { - return { status: "abandoned" }; - } - if (!readEnvironmentScope(queuedMessage.environmentId, AuthOrchestrationOperateScope)) { - return { status: "abandoned" }; +/** Outbox or draft storage refused a step; the step decides what that means for the message. */ +class ThreadOutboxStorageError extends Schema.TaggedError()( + "ThreadOutboxStorageError", + { + operation: Schema.Literals([ + "forget-sign-out-snapshot", + "remove-delivered", + "remove-acknowledged", + "remove-unsendable", + "hand-back-to-draft", + "restore-to-draft", + "undo-draft-merge", + "load-drafts", + "flush-drafts", + "remove-recovered", + "remove-restored", + ]), + messageId: Schema.String, + cause: Schema.Defect(), + }, +) { + override get message(): string { + return `Queued message ${this.messageId} could not ${this.operation.replaceAll("-", " ")}.`; } - const revision = threadOutboxRevision(queuedMessage.messageId); - if (!isQueuedMessagePayloadCurrent(queuedMessage, revision)) { - return { status: "abandoned" }; - } - let persistedMessage = queuedMessage; - let deliveryRevision = revision; - const result = await Effect.runPromise( - prepareTurnAttachments({ +} + +const storage = ( + operation: ThreadOutboxStorageError["operation"], + messageId: MessageId, + write: () => Promise, +) => + Effect.tryPromise({ + try: write, + catch: (cause) => new ThreadOutboxStorageError({ operation, messageId, cause }), + }); + +/** The head was not handled; back off and try it again. */ +export class DeliveryRetry extends Schema.TaggedError()("DeliveryRetry", {}) {} + +const retryDelivery = Effect.fail(new DeliveryRetry()); + +const isEditingQueuedMessage = (messageId: MessageId): boolean => + appAtomRegistry.get(editingQueuedMessageIdsAtom)[messageId] === true; + +const confirmQueued = (message: QueuedThreadMessage) => + Effect.promise(() => confirmThreadOutboxMessageQueued(message)); + +const abandoned = { status: "abandoned" } as const; + +export const prepareQueuedMessageAttachments = Effect.fn("ThreadOutbox.prepareAttachments")( + function* (queuedMessage: QueuedThreadMessage) { + if (!(yield* confirmQueued(queuedMessage))) return abandoned; + if (!readEnvironmentScope(queuedMessage.environmentId, AuthOrchestrationOperateScope)) { + return abandoned; + } + const revision = threadOutboxRevision(queuedMessage.messageId); + if (!isQueuedMessagePayloadCurrent(queuedMessage, revision)) return abandoned; + let persistedMessage = queuedMessage; + let deliveryRevision = revision; + const result = yield* prepareTurnAttachments({ environmentId: queuedMessage.environmentId, attachments: queuedMessage.attachments, supportsImageUploads: true, uploadAttachment: (attachment) => uploadComposerAttachmentShared(queuedMessage.environmentId, attachment), - persistUploadedReferences: (draftAttachments) => - Effect.promise(async () => { - if (appAtomRegistry.get(editingQueuedMessageIdsAtom)[queuedMessage.messageId]) { - return "abandon" as const; - } - const updatedMessage = { ...queuedMessage, attachments: draftAttachments }; - if (!(await updateThreadOutboxMessage(updatedMessage, revision))) { - return "abandon" as const; - } - persistedMessage = updatedMessage; - deliveryRevision = revision + 1; - return "persisted" as const; - }), - }), - ); - if ( - result.status === "abandoned" || - !isQueuedMessagePayloadCurrent(persistedMessage, deliveryRevision) - ) { - return { status: "abandoned" }; - } - return { status: "ready", prepared: result, persistedMessage, deliveryRevision }; -} + persistUploadedReferences: Effect.fn("ThreadOutbox.persistUploadedReferences")(function* ( + draftAttachments: ReadonlyArray, + ) { + if (isEditingQueuedMessage(queuedMessage.messageId)) return "abandon" as const; + const updatedMessage = { ...queuedMessage, attachments: draftAttachments }; + if (!(yield* Effect.promise(() => updateThreadOutboxMessage(updatedMessage, revision)))) { + return "abandon" as const; + } + persistedMessage = updatedMessage; + deliveryRevision = revision + 1; + return "persisted" as const; + }), + }); + if ( + result.status === "abandoned" || + !isQueuedMessagePayloadCurrent(persistedMessage, deliveryRevision) + ) { + return abandoned; + } + return { status: "ready", prepared: result, persistedMessage, deliveryRevision } as const; + }, +); function isQueuedMessagePayloadCurrent( message: QueuedThreadMessage, @@ -274,273 +316,279 @@ function isQueuedMessagePayloadCurrent( ); } -export async function completeQueuedMessageDelivery( +const forgetCloudQueuedMessage = (queuedMessage: QueuedThreadMessage) => + storage("forget-sign-out-snapshot", queuedMessage.messageId, () => + removeDeliveredCloudQueuedMessage(queuedMessage), + ).pipe( + Effect.catch((error) => + Effect.logWarning("[thread-outbox] could not update sign-out snapshot after delivery", { + messageId: queuedMessage.messageId, + error: error.cause, + }), + ), + ); + +export const completeQueuedMessageDelivery = Effect.fn("ThreadOutbox.completeDelivery")(function* ( queuedMessage: QueuedThreadMessage, deliveryRevision: number, - sequence: number | undefined, -): Promise<"removed" | "edited" | "failed"> { + sequence?: number, +) { clearThreadComposerError( scopedThreadKey(queuedMessage.environmentId, queuedMessage.threadId), queuedMessage.messageId, ); - try { - await removeDeliveredCloudQueuedMessage(queuedMessage).catch((error) => { - console.warn("[thread-outbox] could not update sign-out snapshot after delivery", { - messageId: queuedMessage.messageId, - error, - }); - }); - // Editors can acquire entries during startTurn without bumping revisions; CAS alone would lose unsaved edits. - if (appAtomRegistry.get(editingQueuedMessageIdsAtom)[queuedMessage.messageId]) { - return "edited"; - } - retainAcknowledgedThreadMessage( - sequence === undefined ? queuedMessage : { ...queuedMessage, sequence }, - ); - const removed = await removeThreadOutboxMessage( + yield* forgetCloudQueuedMessage(queuedMessage); + // Editors can acquire entries during startTurn without bumping revisions; CAS alone would lose unsaved edits. + if (isEditingQueuedMessage(queuedMessage.messageId)) return "edited" as const; + retainAcknowledgedThreadMessage( + sequence === undefined ? queuedMessage : { ...queuedMessage, sequence }, + ); + const removed = yield* storage("remove-delivered", queuedMessage.messageId, () => + removeThreadOutboxMessage( queuedMessage, deliveryRevision, - () => !appAtomRegistry.get(editingQueuedMessageIdsAtom)[queuedMessage.messageId], - ); - if (!removed) { - forgetAcknowledgedThreadMessage(queuedMessage); - threadOutboxDebug.log("delivered message was edited before cleanup", { + () => !isEditingQueuedMessage(queuedMessage.messageId), + ), + ).pipe( + Effect.catch((error) => + Effect.logWarning("[thread-outbox] failed to remove delivered queued message", { environmentId: queuedMessage.environmentId, threadId: queuedMessage.threadId, messageId: queuedMessage.messageId, - }); - return "edited"; - } - return "removed"; - } catch (error) { - forgetAcknowledgedThreadMessage(queuedMessage); - console.warn("[thread-outbox] failed to remove delivered queued message", { - environmentId: queuedMessage.environmentId, - threadId: queuedMessage.threadId, - messageId: queuedMessage.messageId, - error, - }); - return "failed"; - } -} + error: error.cause, + }).pipe(Effect.as(null)), + ), + ); + if (removed === true) return "removed" as const; + forgetAcknowledgedThreadMessage(queuedMessage); + if (removed === null) return "failed" as const; + threadOutboxDebug.log("delivered message was edited before cleanup", { + environmentId: queuedMessage.environmentId, + threadId: queuedMessage.threadId, + messageId: queuedMessage.messageId, + }); + return "edited" as const; +}); -export async function removeAcknowledgedExistingThreadMessage( - queuedMessage: QueuedThreadMessage, - acknowledgedMessageIds: Set, -): Promise { - try { - await removeDeliveredCloudQueuedMessage(queuedMessage).catch((error) => { - console.warn("[thread-outbox] could not update sign-out snapshot after delivery", { +export const removeAcknowledgedExistingThreadMessage = Effect.fn( + "ThreadOutbox.removeAcknowledgedMessage", +)(function* (queuedMessage: QueuedThreadMessage, acknowledgedMessageIds: Set) { + yield* forgetCloudQueuedMessage(queuedMessage); + const removed = yield* storage("remove-acknowledged", queuedMessage.messageId, () => + removeThreadOutboxMessage(queuedMessage), + ).pipe( + Effect.catch((error) => + Effect.logWarning("[thread-outbox] failed to remove acknowledged queued message", { + environmentId: queuedMessage.environmentId, + threadId: queuedMessage.threadId, messageId: queuedMessage.messageId, - error, - }); - }); - const removed = await removeThreadOutboxMessage(queuedMessage); - if (removed) { - acknowledgedMessageIds.delete(queuedMessage.messageId); - } - return removed; - } catch (error) { - console.warn("[thread-outbox] failed to remove acknowledged queued message", { - environmentId: queuedMessage.environmentId, - threadId: queuedMessage.threadId, - messageId: queuedMessage.messageId, - error, - }); - return false; - } -} + error: error.cause, + }).pipe(Effect.as(false)), + ), + ); + if (!removed) return yield* retryDelivery; + acknowledgedMessageIds.delete(queuedMessage.messageId); +}); -export async function recoverEditedCreationAfterDelivery( - queuedMessage: QueuedThreadMessage, -): Promise { - const kept = Object.values(appAtomRegistry.get(threadOutboxManager.queuedMessagesByThreadKeyAtom)) - .flat() - .find((candidate) => candidate.messageId === queuedMessage.messageId); - if (!kept) { - return true; - } - const keptRevision = threadOutboxRevision(kept.messageId); - if (appAtomRegistry.get(editingQueuedMessageIdsAtom)[kept.messageId]) { - return true; - } - const draftKey = scopedThreadKey(kept.environmentId, kept.threadId); - try { - // Merge before removal to retain file ownership; allow overflow and let send guards require trimming. - await mergeComposerDraftContent(draftKey, { - text: kept.text, - context: kept.context, - attachments: [], - }); - if (appAtomRegistry.get(editingQueuedMessageIdsAtom)[kept.messageId]) { - return true; - } - if (threadOutboxRevision(kept.messageId) !== keptRevision) { - return false; - } - const existingAttachmentIds = new Set( - getComposerDraftSnapshot(draftKey).attachments.map((attachment) => attachment.id), - ); - appendComposerDraftAttachments( - draftKey, - kept.attachments.filter((attachment) => !existingAttachmentIds.has(attachment.id)), - { restore: true }, +/** Hands a new task edited after its launch back to the composer, then drops it from the queue. */ +export const recoverEditedCreationAfterDelivery = Effect.fn("ThreadOutbox.recoverEditedCreation")( + function* (queuedMessage: QueuedThreadMessage) { + const kept = Object.values( + appAtomRegistry.get(threadOutboxManager.queuedMessagesByThreadKeyAtom), + ) + .flat() + .find((candidate) => candidate.messageId === queuedMessage.messageId); + if (!kept || isEditingQueuedMessage(kept.messageId)) return; + const keptRevision = threadOutboxRevision(kept.messageId); + const draftKey = scopedThreadKey(kept.environmentId, kept.threadId); + const handedBack = yield* Effect.gen(function* () { + // Merge before removal to retain file ownership; allow overflow and let send guards require trimming. + yield* storage("hand-back-to-draft", kept.messageId, () => + mergeComposerDraftContent(draftKey, { + text: kept.text, + context: kept.context, + attachments: [], + }), + ); + if (isEditingQueuedMessage(kept.messageId)) return "edited" as const; + if (threadOutboxRevision(kept.messageId) !== keptRevision) return "changed" as const; + const existingAttachmentIds = new Set( + getComposerDraftSnapshot(draftKey).attachments.map((attachment) => attachment.id), + ); + appendComposerDraftAttachments( + draftKey, + kept.attachments.filter((attachment) => !existingAttachmentIds.has(attachment.id)), + { restore: true }, + ); + updateComposerDraftSettings(draftKey, { + ...(kept.modelSelection !== undefined ? { modelSelection: kept.modelSelection } : {}), + ...(kept.runtimeMode !== undefined ? { runtimeMode: kept.runtimeMode } : {}), + ...(kept.interactionMode !== undefined ? { interactionMode: kept.interactionMode } : {}), + }); + // Flush before removal: append only schedules persistence, leaving the queue as the sole durable copy. + yield* storage("flush-drafts", kept.messageId, () => flushComposerDrafts()); + return "handed-back" as const; + }).pipe( + Effect.catch((error) => + Effect.logWarning( + "[thread-outbox] could not hand an edited pending task to the composer", + error.cause, + ).pipe(Effect.as("failed" as const)), + ), ); - updateComposerDraftSettings(draftKey, { - ...(kept.modelSelection !== undefined ? { modelSelection: kept.modelSelection } : {}), - ...(kept.runtimeMode !== undefined ? { runtimeMode: kept.runtimeMode } : {}), - ...(kept.interactionMode !== undefined ? { interactionMode: kept.interactionMode } : {}), - }); - // Flush before removal: append only schedules persistence, leaving the queue as the sole durable copy. - await flushComposerDrafts(); - } catch (error) { - console.warn("[thread-outbox] could not hand an edited pending task to the composer", error); - return false; - } - if (appAtomRegistry.get(editingQueuedMessageIdsAtom)[kept.messageId]) { - return true; - } - try { - return await removeThreadOutboxMessage( - kept, - keptRevision, - () => !appAtomRegistry.get(editingQueuedMessageIdsAtom)[kept.messageId], + if (handedBack === "edited") return; + if (handedBack !== "handed-back") return yield* retryDelivery; + if (isEditingQueuedMessage(kept.messageId)) return; + const removed = yield* storage("remove-recovered", kept.messageId, () => + removeThreadOutboxMessage(kept, keptRevision, () => !isEditingQueuedMessage(kept.messageId)), + ).pipe( + Effect.catch((error) => + Effect.logWarning( + "[thread-outbox] could not remove recovered pending task", + error.cause, + ).pipe(Effect.as(false)), + ), ); - } catch (error) { - console.warn("[thread-outbox] could not remove recovered pending task", error); - return false; - } -} - -export async function restoreRejectedQueuedMessage( - queuedMessage: QueuedThreadMessage, - message: string, -): Promise<"restored" | "deferred" | "blocked" | "retry"> { - const draftKey = recoveryDraftKey(queuedMessage); - const threadKey = scopedThreadKey(queuedMessage.environmentId, queuedMessage.threadId); - let rollback: { readonly snapshot: ComposerDraft; readonly merged: ComposerDraft } | null = null; - try { - if ( - appAtomRegistry.get(editingQueuedMessageIdsAtom)[queuedMessage.messageId] || - !(await confirmThreadOutboxMessageQueued(queuedMessage)) || - appAtomRegistry.get(editingQueuedMessageIdsAtom)[queuedMessage.messageId] - ) { - return "deferred"; - } - const revision = threadOutboxRevision(queuedMessage.messageId); + if (!removed) return yield* retryDelivery; + }, +); - await waitForComposerDraftsLoaded(); - if (appAtomRegistry.get(editingQueuedMessageIdsAtom)[queuedMessage.messageId]) { - return "deferred"; - } - const originalDraft = getComposerDraftSnapshot(draftKey); - const existingAttachmentIds = new Set( - originalDraft.attachments.map((attachment) => attachment.id), - ); - const addedAttachmentCount = queuedMessage.attachments.filter( - (attachment) => !existingAttachmentIds.has(attachment.id), - ).length; - if (existingAttachmentIds.size + addedAttachmentCount > PROVIDER_SEND_TURN_MAX_ATTACHMENTS) { - setThreadComposerError( - threadKey, - `Remove attachments from the draft before restoring this message. Messages can contain at most ${PROVIDER_SEND_TURN_MAX_ATTACHMENTS} attachments.`, - queuedMessage.messageId, +/** + * Hands an undeliverable message back to its draft with the reason. "blocked" means the draft + * cannot take it yet (attachment cap); "deferred" means an editor or newer write owns it. + */ +export const restoreRejectedQueuedMessage = Effect.fn("ThreadOutbox.restoreRejectedMessage")( + function* (queuedMessage: QueuedThreadMessage, message: string) { + const draftKey = recoveryDraftKey(queuedMessage); + const threadKey = scopedThreadKey(queuedMessage.environmentId, queuedMessage.threadId); + const editing = () => isEditingQueuedMessage(queuedMessage.messageId); + // Until the queue drops the message, a failure undoes the merge, keeping concurrent edits. + let rollback: { readonly snapshot: ComposerDraft; readonly merged: ComposerDraft } | null = + null; + const undo = (snapshot: ComposerDraft, merged: ComposerDraft) => + storage("undo-draft-merge", queuedMessage.messageId, () => + undoComposerDraftMerge(draftKey, snapshot, merged), ); - return "blocked"; - } + return yield* Effect.gen(function* () { + if (editing() || !(yield* confirmQueued(queuedMessage)) || editing()) { + return "deferred" as const; + } + const revision = threadOutboxRevision(queuedMessage.messageId); + yield* storage("load-drafts", queuedMessage.messageId, () => waitForComposerDraftsLoaded()); + if (editing()) return "deferred" as const; + const originalDraft = getComposerDraftSnapshot(draftKey); + const existingAttachmentIds = new Set( + originalDraft.attachments.map((attachment) => attachment.id), + ); + const addedAttachmentCount = queuedMessage.attachments.filter( + (attachment) => !existingAttachmentIds.has(attachment.id), + ).length; + if (existingAttachmentIds.size + addedAttachmentCount > PROVIDER_SEND_TURN_MAX_ATTACHMENTS) { + setThreadComposerError( + threadKey, + `Remove attachments from the draft before restoring this message. Messages can contain at most ${PROVIDER_SEND_TURN_MAX_ATTACHMENTS} attachments.`, + queuedMessage.messageId, + ); + return "blocked" as const; + } - const withdrawError = () => clearThreadComposerError(threadKey, queuedMessage.messageId); - if (!queuedMessage.creation) { - setThreadComposerError(threadKey, message, queuedMessage.messageId); - } - let mergedDraft: ComposerDraft; - try { + const withdraw = (merged: ComposerDraft) => + Effect.sync(() => clearThreadComposerError(threadKey, queuedMessage.messageId)).pipe( + Effect.andThen(undo(originalDraft, merged)), + Effect.as("deferred" as const), + ); + if (!queuedMessage.creation) { + setThreadComposerError(threadKey, message, queuedMessage.messageId); + } stampRecoveryDraftProject(queuedMessage, draftKey); - await mergeComposerDraftContent(draftKey, { - text: queuedMessage.text, - context: queuedMessage.context, - attachments: queuedMessage.attachments, - }); - } finally { - // Capture rollback in finally because merge publishes even on persistence failure; undo must preserve concurrent edits. - mergedDraft = getComposerDraftSnapshot(draftKey); - rollback = { snapshot: originalDraft, merged: mergedDraft }; - } - if (appAtomRegistry.get(editingQueuedMessageIdsAtom)[queuedMessage.messageId]) { - withdrawError(); - await undoComposerDraftMerge(draftKey, originalDraft, mergedDraft); - return "deferred"; - } - updateComposerDraftSettings(draftKey, { - ...(queuedMessage.modelSelection ? { modelSelection: queuedMessage.modelSelection } : {}), - ...(queuedMessage.runtimeMode ? { runtimeMode: queuedMessage.runtimeMode } : {}), - ...(queuedMessage.interactionMode ? { interactionMode: queuedMessage.interactionMode } : {}), - ...(queuedMessage.freshContext ? { freshContext: true } : {}), - ...(queuedMessage.creation - ? { - workspaceSelection: { - mode: queuedMessage.creation.workspaceMode, - branch: queuedMessage.creation.branch, - worktreePath: queuedMessage.creation.worktreePath, - pullRequestReference: queuedMessage.creation.pullRequestReference, - ...(queuedMessage.creation.startFromOrigin !== undefined - ? { startFromOrigin: queuedMessage.creation.startFromOrigin } - : {}), - }, - } - : {}), - }); - const restoredDraft = getComposerDraftSnapshot(draftKey); - rollback = { snapshot: originalDraft, merged: restoredDraft }; - await flushComposerDrafts(); - if ( - appAtomRegistry.get(editingQueuedMessageIdsAtom)[queuedMessage.messageId] || - !(await confirmThreadOutboxMessageQueued(queuedMessage)) || - appAtomRegistry.get(editingQueuedMessageIdsAtom)[queuedMessage.messageId] - ) { - withdrawError(); - await undoComposerDraftMerge(draftKey, originalDraft, restoredDraft); - return "deferred"; - } - if ( - !(await removeThreadOutboxMessage( - queuedMessage, - revision, - () => !appAtomRegistry.get(editingQueuedMessageIdsAtom)[queuedMessage.messageId], - )) - ) { - withdrawError(); - await undoComposerDraftMerge(draftKey, originalDraft, restoredDraft); - return "deferred"; - } - // After queue removal, the draft owns content and must never roll back. - rollback = null; - if (queuedMessage.creation) { - withdrawError(); - recordPendingThreadCreationOutcome({ - kind: "failed", - message: queuedMessage, - reason: message, + // The merge publishes even when persisting it fails, so the rollback is captured either way. + yield* storage("restore-to-draft", queuedMessage.messageId, () => + mergeComposerDraftContent(draftKey, { + text: queuedMessage.text, + context: queuedMessage.context, + attachments: queuedMessage.attachments, + }), + ).pipe( + Effect.ensuring( + Effect.sync(() => { + rollback = { snapshot: originalDraft, merged: getComposerDraftSnapshot(draftKey) }; + }), + ), + ); + if (editing()) return yield* withdraw(getComposerDraftSnapshot(draftKey)); + updateComposerDraftSettings(draftKey, { + ...(queuedMessage.modelSelection ? { modelSelection: queuedMessage.modelSelection } : {}), + ...(queuedMessage.runtimeMode ? { runtimeMode: queuedMessage.runtimeMode } : {}), + ...(queuedMessage.interactionMode + ? { interactionMode: queuedMessage.interactionMode } + : {}), + ...(queuedMessage.freshContext ? { freshContext: true } : {}), + ...(queuedMessage.creation + ? { + workspaceSelection: { + mode: queuedMessage.creation.workspaceMode, + branch: queuedMessage.creation.branch, + worktreePath: queuedMessage.creation.worktreePath, + pullRequestReference: queuedMessage.creation.pullRequestReference, + ...(queuedMessage.creation.startFromOrigin !== undefined + ? { startFromOrigin: queuedMessage.creation.startFromOrigin } + : {}), + }, + } + : {}), }); - } - return "restored"; - } catch (error) { - if (rollback !== null) { - await undoComposerDraftMerge(draftKey, rollback.snapshot, rollback.merged).catch( - (undoError) => { - console.warn("[thread-outbox] failed to persist a recovery rollback", undoError); - }, + const restoredDraft = getComposerDraftSnapshot(draftKey); + rollback = { snapshot: originalDraft, merged: restoredDraft }; + yield* storage("flush-drafts", queuedMessage.messageId, () => flushComposerDrafts()); + if (editing() || !(yield* confirmQueued(queuedMessage)) || editing()) { + return yield* withdraw(restoredDraft); + } + const removed = yield* storage("remove-restored", queuedMessage.messageId, () => + removeThreadOutboxMessage(queuedMessage, revision, () => !editing()), ); - } - console.warn("[thread-outbox] failed to restore an undeliverable message", error); - setThreadComposerError( - threadKey, - error instanceof Error ? error.message : "The unsent message could not be restored.", - queuedMessage.messageId, + if (!removed) return yield* withdraw(restoredDraft); + // After queue removal, the draft owns content and must never roll back. + rollback = null; + if (queuedMessage.creation) { + clearThreadComposerError(threadKey, queuedMessage.messageId); + recordPendingThreadCreationOutcome({ + kind: "failed", + message: queuedMessage, + reason: message, + }); + } + return "restored" as const; + }).pipe( + Effect.catch((error) => + Effect.gen(function* () { + const pending: typeof rollback = rollback; + if (pending !== null) { + yield* undo(pending.snapshot, pending.merged).pipe( + Effect.catch((undoError) => + Effect.logWarning( + "[thread-outbox] failed to persist a recovery rollback", + undoError.cause, + ), + ), + ); + } + yield* Effect.logWarning( + "[thread-outbox] failed to restore an undeliverable message", + error.cause, + ); + setThreadComposerError( + threadKey, + error.cause instanceof Error + ? error.cause.message + : "The unsent message could not be restored.", + queuedMessage.messageId, + ); + return "retry" as const; + }), + ), ); - return "retry"; - } -} + }, +); /** Derive keys from message ids so failed recovery retries reuse the same draft. */ function recoveryDraftKey(queuedMessage: QueuedThreadMessage): string { @@ -562,14 +610,10 @@ function stampRecoveryDraftProject(queuedMessage: QueuedThreadMessage, draftKey: }); } -async function preserveUploadedAttachmentsForEditor( - originalMessage: QueuedThreadMessage, - uploadedMessage: QueuedThreadMessage, -): Promise { - if (!originalMessage.creation) { - return; - } - +const preserveUploadedAttachmentsForEditor = Effect.fn( + "ThreadOutbox.preserveUploadedAttachmentsForEditor", +)(function* (originalMessage: QueuedThreadMessage, uploadedMessage: QueuedThreadMessage) { + if (!originalMessage.creation) return; const draftKey = `pending-task:${originalMessage.messageId}`; const draft = getComposerDraftSnapshot(draftKey); const uploadedById = new Map( @@ -593,18 +637,13 @@ async function preserveUploadedAttachmentsForEditor( uploadEnvironmentId: uploaded.uploadEnvironmentId, }; }); - if (changed) { - replaceComposerDraftAttachments(draftKey, nextAttachments); - await flushComposerDrafts(); - } -} + if (!changed) return; + replaceComposerDraftAttachments(draftKey, nextAttachments); + yield* Effect.promise(() => flushComposerDrafts()); +}); -// Everything a drain pass decides from. Each queued environment's session is -// read here so a granted or revoked operate scope re-runs the drain. -const uploadingComposerAttachmentKeysAtom = Atom.map( - composerAttachmentUploadsAtom, - uploadingComposerAttachmentKeys, -); +// Everything delivery decides from. Each queued environment's session is read +// here so a granted or revoked operate scope wakes delivery. const deliveryInputsAtom = Atom.make((get) => { const connectedEnvironments = get(workspaceConnections.environmentsAtom); @@ -620,7 +659,6 @@ const deliveryInputsAtom = Atom.make((get) => { } } return { - dispatchingQueuedMessageId: get(dispatchingQueuedMessageIdAtom), editingQueuedMessageIds: get(editingQueuedMessageIdsAtom), queuedMessagesByThreadKey: get(threadOutboxManager.queuedMessagesByThreadKeyAtom), shellStatuses: get(threadOutboxShellStatusesAtom), @@ -629,8 +667,6 @@ const deliveryInputsAtom = Atom.make((get) => { serverConfigs: get(environmentServerConfigsAtom), connectedEnvironments, operableEnvironments, - // Wakes a message waiting on the upload worker when that upload settles. - uploadingAttachmentKeys: get(uploadingComposerAttachmentKeysAtom), }; }).pipe(Atom.withLabel("mobile:thread-outbox:delivery-inputs")); @@ -660,11 +696,11 @@ function deliveredSequence( return AsyncResult.isSuccess(result) ? result.value.sequence : undefined; } -const runDeliveryCommand = ( +const deliveryCommand = ( command: AtomCommand, input: W, -): Promise> => - runAtomCommand(appAtomRegistry, command, input, { reportFailure: false }); +): Effect.Effect> => + Effect.promise(() => runAtomCommand(appAtomRegistry, command, input, { reportFailure: false })); function reportCommandFailure( queuedMessage: QueuedThreadMessage, @@ -695,14 +731,33 @@ function reportCommandFailure( interface ThreadOutboxRetry { readonly attempt: number; readonly notBefore: number; - readonly timer: ReturnType; } +/** A thread's delivery fiber; `retiring` once interrupted, until the fiber has exited. */ +interface ThreadFiber { + readonly wake: Latch.Latch; + fiber: Fiber.Fiber | undefined; + retiring: boolean; +} + +/** What a thread's delivery fiber does next with the head of its queue. */ +type ThreadDeliveryStep = + /** Nothing to send until an input changes, or until `until` when a backoff is running. */ + | { readonly _tag: "Wait"; readonly until?: number } + /** The head failed without a send; back off before trying it again. */ + | { readonly _tag: "Backoff"; readonly messageId: MessageId } + | { + readonly _tag: "Dispatch"; + readonly messageId: MessageId; + /** Succeeds once the message is handled (sent, removed or handed back). */ + readonly run: Effect.Effect; + }; + /** - * Delivers queued thread messages one at a time. A drain pass runs whenever its inputs - * change (outbox, locks, shells, projects, configs, connections, scopes) and when a retry - * backoff expires. `dispatchingQueuedMessageIdAtom` is the single in-flight slot; clearing - * it re-runs the drain for the next message. + * Delivers queued thread messages, one fiber per thread so a slow send in one thread never + * holds another. Each fiber sends its thread's head message in order, backs off after a + * failure, and otherwise waits until an input changes (outbox, locks, shells, projects, + * configs, connections, scopes). */ export function createThreadOutboxDelivery(): { readonly drain: () => void; @@ -732,52 +787,29 @@ export function createThreadOutboxDelivery(): { const scheduleRetry = (messageId: MessageId): void => { if (disposed) return; - const previous = retries.get(messageId); - if (previous !== undefined) clearTimeout(previous.timer); - const attempt = (previous?.attempt ?? 0) + 1; - const delayMs = threadOutboxRetryDelayMs(attempt); + const attempt = (retries.get(messageId)?.attempt ?? 0) + 1; retries.set(messageId, { attempt, - notBefore: Date.now() + delayMs, - timer: setTimeout(drain, delayMs), + notBefore: Date.now() + threadOutboxRetryDelayMs(attempt), }); setQueuedMessageRetrying(messageId, true); }; const clearRetry = (messageId: MessageId): void => { - const retry = retries.get(messageId); - if (retry === undefined) return; - clearTimeout(retry.timer); - retries.delete(messageId); + if (!retries.delete(messageId)) return; setQueuedMessageRetrying(messageId, false); }; - // A delivery that throws backs off like any failure. Releasing the slot - // without a retry would re-run the drain straight into the same message. - const settle = (messageId: MessageId, delivery: Promise): void => { - void delivery - .then( - (sent) => (sent ? clearRetry(messageId) : scheduleRetry(messageId)), - (error: unknown) => { - console.warn("[thread-outbox] queued message delivery threw", { messageId, error }); - scheduleRetry(messageId); - }, - ) - .finally(() => finishDispatchingQueuedMessage(messageId)); - }; - // An over-cap draft blocks recovery until the user changes its attachments; // parking on the draft avoids hammering the restore with backoff retries. - const restoreQueuedMessage = async ( + const restoreQueuedMessage = Effect.fn("ThreadOutbox.restoreQueuedMessage")(function* ( queuedMessage: QueuedThreadMessage, message: string, - ): Promise => { - const result = await restoreRejectedQueuedMessage(queuedMessage, message); - if (result !== "blocked") { - return result !== "retry"; - } - if (disposed || blockedRecoveries.has(queuedMessage.messageId)) { - return true; + ) { + const result = yield* restoreRejectedQueuedMessage(queuedMessage, message); + if (result === "retry") return yield* retryDelivery; + if (result !== "blocked" || disposed || blockedRecoveries.has(queuedMessage.messageId)) { + return; } const draftKey = recoveryDraftKey(queuedMessage); const editorDraftKey = queuedMessage.creation @@ -800,23 +832,22 @@ export function createThreadOutboxDelivery(): { } blockedRecoveries.delete(queuedMessage.messageId); active.unsubscribe(); - drain(); + wakeThreads(); }); blockedRecoveries.set(queuedMessage.messageId, { message: queuedMessage, unsubscribe }); - return true; - }; + }); - const sendQueuedMessage = async ( + const sendQueuedMessage = Effect.fn("ThreadOutbox.sendQueuedMessage")(function* ( queuedMessage: QueuedThreadMessage, thread: EnvironmentThreadShell, - ): Promise => { + ) { const hasAccess = () => readEnvironmentScope(queuedMessage.environmentId, AuthOrchestrationOperateScope); - if (!hasAccess()) return true; + if (!hasAccess()) return; const serverConfig = appAtomRegistry.get( serverEnvironment.configValueAtom(queuedMessage.environmentId), ); - if (!serverConfig) return false; + if (!serverConfig) return yield* retryDelivery; const settings = resolveQueuedThreadSettings(queuedMessage, thread, serverConfig.providers); if (isModelSelectionUnavailable(serverConfig, settings.modelSelection, thread.projectId)) { const { title, detail } = describeUnavailableModelSelection( @@ -824,7 +855,7 @@ export function createThreadOutboxDelivery(): { settings.modelSelection, thread.projectId, ); - return restoreQueuedMessage(queuedMessage, `${title}. ${detail}`); + return yield* restoreQueuedMessage(queuedMessage, `${title}. ${detail}`); } // The server would refuse this mode in settings sync, which retries forever; stop first. const runtimeModeDenial = managedRuntimeModeDenial( @@ -832,12 +863,12 @@ export function createThreadOutboxDelivery(): { settings.runtimeMode, ); if (runtimeModeDenial !== undefined) { - return restoreQueuedMessage(queuedMessage, runtimeModeDenial); + return yield* restoreQueuedMessage(queuedMessage, runtimeModeDenial); } if (settings.runtimeMode !== thread.runtimeMode) { - if (!hasAccess()) return true; - const runtimeResult = await runDeliveryCommand(threadEnvironment.setRuntimeMode, { + if (!hasAccess()) return; + const runtimeResult = yield* deliveryCommand(threadEnvironment.setRuntimeMode, { environmentId: queuedMessage.environmentId, input: { commandId: settingsCommandId(queuedMessage, "runtime-mode"), @@ -848,13 +879,13 @@ export function createThreadOutboxDelivery(): { }); if (AsyncResult.isFailure(runtimeResult)) { reportCommandFailure(queuedMessage, runtimeResult, "settings-sync"); - return false; + return yield* retryDelivery; } } if (settings.interactionMode !== thread.interactionMode) { - if (!hasAccess()) return true; - const interactionResult = await runDeliveryCommand(threadEnvironment.setInteractionMode, { + if (!hasAccess()) return; + const interactionResult = yield* deliveryCommand(threadEnvironment.setInteractionMode, { environmentId: queuedMessage.environmentId, input: { commandId: settingsCommandId(queuedMessage, "interaction-mode"), @@ -865,51 +896,48 @@ export function createThreadOutboxDelivery(): { }); if (AsyncResult.isFailure(interactionResult)) { reportCommandFailure(queuedMessage, interactionResult, "settings-sync"); - return false; + return yield* retryDelivery; } } - let prepared: PreparedTurnAttachments; - let persistedMessage: QueuedThreadMessage; - let deliveryRevision: number; - if (!hasAccess()) return true; - try { - const preparedResult = await prepareQueuedMessageAttachments(queuedMessage); - if (preparedResult.status === "abandoned") { - return true; - } - prepared = preparedResult.prepared; - persistedMessage = preparedResult.persistedMessage; - deliveryRevision = preparedResult.deliveryRevision; - if (appAtomRegistry.get(editingQueuedMessageIdsAtom)[queuedMessage.messageId]) { - await preserveUploadedAttachmentsForEditor(queuedMessage, preparedResult.persistedMessage); - return true; - } - } catch (error) { - if (!hasAccess()) return true; + if (!hasAccess()) return; + // Waiting on the shared upload is the one part of a send that may be cut short. + const preparedExit = yield* Effect.exit( + Effect.interruptible(prepareQueuedMessageAttachments(queuedMessage)), + ); + if (Exit.isFailure(preparedExit)) { + if (Cause.hasInterruptsOnly(preparedExit.cause)) return yield* Effect.interrupt; + const error = Cause.squash(preparedExit.cause); + if (!hasAccess()) return; logThreadOutboxUploadFailure(queuedMessage, error); if (!shouldRetryThreadOutboxDelivery(error)) { - return restoreQueuedMessage( + return yield* restoreQueuedMessage( queuedMessage, error instanceof Error ? error.message : "An attachment could not upload.", ); } - return false; + return yield* retryDelivery; + } + if (preparedExit.value.status === "abandoned") return; + const { prepared, persistedMessage, deliveryRevision } = preparedExit.value; + if (isEditingQueuedMessage(queuedMessage.messageId)) { + yield* preserveUploadedAttachmentsForEditor(queuedMessage, persistedMessage); + return; } if (!isQueuedMessagePayloadCurrent(persistedMessage, deliveryRevision)) { - return true; + return; } const currentConfig = appAtomRegistry.get( serverEnvironment.configValueAtom(queuedMessage.environmentId), ); - if (!currentConfig) return false; + if (!currentConfig) return yield* retryDelivery; if (isModelSelectionUnavailable(currentConfig, settings.modelSelection, thread.projectId)) { const { title, detail } = describeUnavailableModelSelection( currentConfig, settings.modelSelection, thread.projectId, ); - return restoreQueuedMessage(persistedMessage, `${title}. ${detail}`); + return yield* restoreQueuedMessage(persistedMessage, `${title}. ${detail}`); } const sendSettings = resolveQueuedThreadSettings( queuedMessage, @@ -917,9 +945,9 @@ export function createThreadOutboxDelivery(): { currentConfig.providers, ); if (queuedMessage.compactBeforeSend === true) { - if (!hasAccess()) return true; + if (!hasAccess()) return; // Queued, since steering a running turn with a compaction is rejected. - const compactionResult = await runDeliveryCommand(threadEnvironment.startTurn, { + const compactionResult = yield* deliveryCommand(threadEnvironment.startTurn, { environmentId: queuedMessage.environmentId, input: { commandId: settingsCommandId(queuedMessage, "compact"), @@ -940,16 +968,16 @@ export function createThreadOutboxDelivery(): { resendAfterSocketLoss: false, }, }); - if (AsyncResult.isFailure(compactionResult) && !hasAccess()) return true; + if (AsyncResult.isFailure(compactionResult) && !hasAccess()) return; const compactionFailure = reportCommandFailure(queuedMessage, compactionResult, "start-turn"); - if (compactionFailure?.action === "retry") return false; + if (compactionFailure?.action === "retry") return yield* retryDelivery; if (compactionFailure?.action === "restore") { - return restoreQueuedMessage(persistedMessage, compactionFailure.message); + return yield* restoreQueuedMessage(persistedMessage, compactionFailure.message); } - if (!isQueuedMessagePayloadCurrent(persistedMessage, deliveryRevision)) return true; + if (!isQueuedMessagePayloadCurrent(persistedMessage, deliveryRevision)) return; } - if (!hasAccess()) return true; - const deliveryResult = await runDeliveryCommand(threadEnvironment.startTurn, { + if (!hasAccess()) return; + const deliveryResult = yield* deliveryCommand(threadEnvironment.startTurn, { environmentId: queuedMessage.environmentId, input: { commandId: queuedMessage.commandId, @@ -981,43 +1009,40 @@ export function createThreadOutboxDelivery(): { resendAfterSocketLoss: false, }, }); - if (AsyncResult.isFailure(deliveryResult) && !hasAccess()) return true; + if (AsyncResult.isFailure(deliveryResult) && !hasAccess()) return; const failure = reportCommandFailure(queuedMessage, deliveryResult, "start-turn"); if (failure?.action === "retry") { - return false; + return yield* retryDelivery; } if (failure?.action === "restore") { - return restoreQueuedMessage(persistedMessage, failure.message); + return yield* restoreQueuedMessage(persistedMessage, failure.message); } acknowledgedExistingThreadMessageIds.add(persistedMessage.messageId); - const delivered = - (await completeQueuedMessageDelivery( - persistedMessage, - deliveryRevision, - deliveredSequence(deliveryResult), - )) === "removed"; - if (delivered) { - acknowledgedExistingThreadMessageIds.delete(persistedMessage.messageId); - } - return delivered; - }; + const outcome = yield* completeQueuedMessageDelivery( + persistedMessage, + deliveryRevision, + deliveredSequence(deliveryResult), + ); + if (outcome !== "removed") return yield* retryDelivery; + acknowledgedExistingThreadMessageIds.delete(persistedMessage.messageId); + }); - const sendQueuedCreation = async ( + const sendQueuedCreation = Effect.fn("ThreadOutbox.sendQueuedCreation")(function* ( queuedMessage: QueuedThreadMessage, creation: QueuedThreadCreation, projectCwd: string, - ): Promise => { + ) { const hasAccess = () => readEnvironmentScope(queuedMessage.environmentId, AuthOrchestrationOperateScope); - if (!hasAccess()) return true; + if (!hasAccess()) return; const modelSelection = queuedMessage.modelSelection; if (modelSelection === undefined) { - return false; + return yield* retryDelivery; } const serverConfig = appAtomRegistry.get( serverEnvironment.configValueAtom(queuedMessage.environmentId), ); - if (!serverConfig) return false; + if (!serverConfig) return yield* retryDelivery; const settings = resolveQueuedThreadSettings( queuedMessage, { @@ -1033,84 +1058,81 @@ export function createThreadOutboxDelivery(): { settings.modelSelection, creation.projectId, ); - return restoreQueuedMessage(queuedMessage, `${title}. ${detail}`); + return yield* restoreQueuedMessage(queuedMessage, `${title}. ${detail}`); } const runtimeModeDenial = managedRuntimeModeDenial( serverConfig.managedPolicy, settings.runtimeMode, ); if (runtimeModeDenial !== undefined) { - return restoreQueuedMessage(queuedMessage, runtimeModeDenial); + return yield* restoreQueuedMessage(queuedMessage, runtimeModeDenial); } - let prepared: PreparedTurnAttachments; - let persistedMessage: QueuedThreadMessage; - let deliveryRevision: number; - try { - const preparedResult = await prepareQueuedMessageAttachments(queuedMessage); - if (preparedResult.status === "abandoned") { - return true; - } - prepared = preparedResult.prepared; - persistedMessage = preparedResult.persistedMessage; - deliveryRevision = preparedResult.deliveryRevision; - if (appAtomRegistry.get(editingQueuedMessageIdsAtom)[queuedMessage.messageId]) { - await preserveUploadedAttachmentsForEditor(queuedMessage, preparedResult.persistedMessage); - return true; - } - } catch (error) { - if (!hasAccess()) return true; + // Waiting on the shared upload is the one part of a send that may be cut short. + const preparedExit = yield* Effect.exit( + Effect.interruptible(prepareQueuedMessageAttachments(queuedMessage)), + ); + if (Exit.isFailure(preparedExit)) { + if (Cause.hasInterruptsOnly(preparedExit.cause)) return yield* Effect.interrupt; + const error = Cause.squash(preparedExit.cause); + if (!hasAccess()) return; logThreadOutboxUploadFailure(queuedMessage, error); if (!shouldRetryThreadOutboxDelivery(error)) { - return restoreQueuedMessage( + return yield* restoreQueuedMessage( queuedMessage, error instanceof Error ? error.message : "An attachment could not upload.", ); } - return false; + return yield* retryDelivery; + } + if (preparedExit.value.status === "abandoned") return; + const { prepared, persistedMessage, deliveryRevision } = preparedExit.value; + if (isEditingQueuedMessage(queuedMessage.messageId)) { + yield* preserveUploadedAttachmentsForEditor(queuedMessage, persistedMessage); + return; } if (!isQueuedMessagePayloadCurrent(persistedMessage, deliveryRevision)) { - return true; + return; } const currentConfig = appAtomRegistry.get( serverEnvironment.configValueAtom(queuedMessage.environmentId), ); - if (!currentConfig) return false; + if (!currentConfig) return yield* retryDelivery; if (isModelSelectionUnavailable(currentConfig, settings.modelSelection, creation.projectId)) { const { title, detail } = describeUnavailableModelSelection( currentConfig, settings.modelSelection, creation.projectId, ); - return restoreQueuedMessage(persistedMessage, `${title}. ${detail}`); + return yield* restoreQueuedMessage(persistedMessage, `${title}. ${detail}`); } const sendSettings = resolveQueuedThreadSettings( queuedMessage, settings, currentConfig.providers, ); - if (!hasAccess()) return true; + if (!hasAccess()) return; let workspace = creation; const launched = launchedCreations.get(persistedMessage.messageId); if (launched?.revision === deliveryRevision) { workspace = launched.workspace; } else if (creation.pullRequestReference) { - const checkout = await runDeliveryCommand(gitEnvironment.preparePullRequestThread, { + const checkout = yield* deliveryCommand(gitEnvironment.preparePullRequestThread, { environmentId: queuedMessage.environmentId, input: { cwd: projectCwd, reference: creation.pullRequestReference, mode: "worktree" }, }); if (!isQueuedMessagePayloadCurrent(persistedMessage, deliveryRevision) || !hasAccess()) - return true; + return; const failure = reportCommandFailure(queuedMessage, checkout, "start-turn"); - if (failure?.action === "retry") return false; + if (failure?.action === "retry") return yield* retryDelivery; if (failure?.action === "restore") - return restoreQueuedMessage(persistedMessage, failure.message); - if (!AsyncResult.isSuccess(checkout)) return false; + return yield* restoreQueuedMessage(persistedMessage, failure.message); + if (!AsyncResult.isSuccess(checkout)) return yield* retryDelivery; if (!checkout.value.worktreePath || !checkout.value.isOnPullRequestHead) { const { shortLabel } = ( sourceControlClients.findByChangeRequestUrl(creation.pullRequestReference) ?? sourceControlClients.get(undefined) ).changeRequest; - return restoreQueuedMessage( + return yield* restoreQueuedMessage( persistedMessage, `The ${shortLabel} worktree has local changes and could not update to the ${shortLabel} head. Resolve them before trying again.`, ); @@ -1124,7 +1146,7 @@ export function createThreadOutboxDelivery(): { }; } launchedCreations.set(persistedMessage.messageId, { revision: deliveryRevision, workspace }); - const deliveryResult = await runDeliveryCommand(threadEnvironment.startTurn, { + const deliveryResult = yield* deliveryCommand(threadEnvironment.startTurn, { environmentId: queuedMessage.environmentId, input: buildProjectThreadStartTurnInput({ projectId: creation.projectId, @@ -1153,65 +1175,305 @@ export function createThreadOutboxDelivery(): { worktreeBranchName: buildTemporaryWorktreeBranchName(randomHex), }), }); - if (AsyncResult.isFailure(deliveryResult) && !hasAccess()) return true; + if (AsyncResult.isFailure(deliveryResult) && !hasAccess()) return; const failure = reportCommandFailure(queuedMessage, deliveryResult, "start-turn"); if (failure?.action === "retry") { - return false; + return yield* retryDelivery; } if (failure?.action === "restore") { - return restoreQueuedMessage(persistedMessage, failure.message); + return yield* restoreQueuedMessage(persistedMessage, failure.message); } recordPendingThreadCreationOutcome({ kind: "delivered", message: persistedMessage }); - const outcome = await completeQueuedMessageDelivery( + const outcome = yield* completeQueuedMessageDelivery( persistedMessage, deliveryRevision, deliveredSequence(deliveryResult), ); if (outcome === "edited") { - if (appAtomRegistry.get(editingQueuedMessageIdsAtom)[queuedMessage.messageId]) { - return true; - } - return recoverEditedCreationAfterDelivery(persistedMessage); + if (isEditingQueuedMessage(queuedMessage.messageId)) return; + return yield* recoverEditedCreationAfterDelivery(persistedMessage); } - return outcome === "removed"; - }; - - // A pass writes atoms the pass reads (family mounts, the dispatch slot), and the registry - // notifies subscribers synchronously, so drain() can be called from inside a pass. That call - // only asks for another pass; a nested pass would decide from inputs the outer one is still - // acting on and could start a second delivery. - let draining = false; - let drainRequested = false; - function drain(): void { - if (disposed) return; - if (draining) { - drainRequested = true; - return; - } - draining = true; - try { - do { - if (disposed) return; - drainRequested = false; - drainPass(); - } while (drainRequested); - } finally { - draining = false; - } - } + if (outcome !== "removed") return yield* retryDelivery; + }); - function drainPass(): void { + /** The head of one thread's queue, as the inputs stand now. */ + function nextStep( + threadKey: string, + queuedMessages: ReadonlyArray, + inputs: Atom.Type, + ): ThreadDeliveryStep { const { - dispatchingQueuedMessageId, editingQueuedMessageIds, - queuedMessagesByThreadKey, shellStatuses, threads, projects, serverConfigs, connectedEnvironments, operableEnvironments, - } = appAtomRegistry.get(deliveryInputsAtom); + } = inputs; + const nextQueuedMessage = queuedMessages[0]; + if (!nextQueuedMessage) { + return { _tag: "Wait" }; + } + const messageId = nextQueuedMessage.messageId; + if ( + nextQueuedMessage.creation === undefined && + acknowledgedExistingThreadMessageIds.has(messageId) + ) { + if (retryNotBefore(messageId) > Date.now()) { + return { _tag: "Wait", until: retryNotBefore(messageId) }; + } + return { + _tag: "Dispatch", + messageId, + run: removeAcknowledgedExistingThreadMessage( + nextQueuedMessage, + acknowledgedExistingThreadMessageIds, + ), + }; + } + if (editingQueuedMessageIds[messageId]) { + return { _tag: "Wait" }; + } + const blockedRecovery = blockedRecoveries.get(messageId); + if (blockedRecovery) { + if (blockedRecovery.message === nextQueuedMessage) { + return { _tag: "Wait" }; + } + blockedRecoveries.delete(messageId); + blockedRecovery.unsubscribe(); + } + if (retryNotBefore(messageId) > Date.now()) { + return { _tag: "Wait", until: retryNotBefore(messageId) }; + } + let thread = findThread(threads, nextQueuedMessage); + if (thread && scopedThreadKey(thread.environmentId, thread.id) !== threadKey) { + return { _tag: "Wait" }; + } + + const creation = nextQueuedMessage.creation; + const environment = connectedEnvironments.find( + (candidate) => candidate.environmentId === nextQueuedMessage.environmentId, + ); + const shellStatus = shellStatuses.get(nextQueuedMessage.environmentId) ?? "empty"; + const serverConfig = serverConfigs.get(nextQueuedMessage.environmentId); + let familyRead: ThreadFamilyRead | undefined; + if ( + thread === undefined && + creation === undefined && + serverConfig?.shellThreadFamilies === true + ) { + // The family keeps the row readable through dispatch once it loads; the current shell + // generation's read decides whether the thread is gone. + if (!familyMounts.has(nextQueuedMessage.messageId)) { + familyMounts.set( + nextQueuedMessage.messageId, + threadFamilies.mount( + appAtomRegistry, + nextQueuedMessage.environmentId, + nextQueuedMessage.threadId, + ), + ); + } + familyRead = threadFamilyRead( + appAtomRegistry.get( + threadFamilies.familyAtom(nextQueuedMessage.environmentId, nextQueuedMessage.threadId), + ), + ); + if (familyRead === "settled") { + // The rows read at the start of this pass can lag the family that just settled; + // decide from the merged rows as they are now. + thread = findThread( + appAtomRegistry.get(environmentThreadShells.threadShellsAtom), + nextQueuedMessage, + ); + } else if (familyRead === "failed") { + threadFamilies.refresh( + appAtomRegistry, + nextQueuedMessage.environmentId, + nextQueuedMessage.threadId, + ); + } + } + const resendLaunch = + creation !== undefined && + launchedCreations.get(messageId)?.revision === threadOutboxRevision(messageId); + const deliveryAction = resolveThreadOutboxDeliveryAction({ + isCreation: creation !== undefined, + // A resend goes through the same gates as the first launch. + threadExists: thread !== undefined && !resendLaunch, + shellStatus, + environmentConnected: environment?.connectionState === "connected", + ...(familyRead === undefined ? {} : { familyRead }), + }); + if ( + deliveryAction === "wait" && + shellStatus === "live" && + familyRead !== undefined && + familyRead !== "settled" + ) { + // An empty family read changes no merged row, so nothing else would wake the thread. + return { _tag: "Backoff", messageId }; + } + if (deliveryAction === "send" && !operableEnvironments.has(nextQueuedMessage.environmentId)) { + return { _tag: "Wait" }; + } + const dispatchStep = resolveThreadOutboxDispatchStep({ + deliveryAction, + fileAttachments: nextQueuedMessage.attachments.filter( + (attachment) => attachment.type === "file", + ), + serverConfig: serverConfig + ? { + maxFileUploadBytes: + serverConfig.environment.capabilities.fileAttachments?.maxUploadBytes, + } + : null, + }); + if (dispatchStep.step === "wait") { + return { _tag: "Wait" }; + } + if (dispatchStep.step === "retry") { + return { _tag: "Backoff", messageId }; + } + if (dispatchStep.step === "restore") { + const attachmentError = dispatchStep.reason; + return { + _tag: "Dispatch", + messageId, + run: Effect.gen(function* () { + if (!(yield* confirmQueued(nextQueuedMessage)) || isEditingQueuedMessage(messageId)) { + return; + } + yield* restoreQueuedMessage(nextQueuedMessage, attachmentError); + }), + }; + } + const creationProjectCwd = + creation !== undefined + ? (findCreationProject(projects, nextQueuedMessage)?.workspaceRoot ?? + creation.projectCwd ?? + null) + : null; + if (deliveryAction === "send" && creation !== undefined) { + if (!isQueuedThreadCreationSendable(nextQueuedMessage)) { + return { _tag: "Wait" }; + } + if (creationProjectCwd === null && shellStatus !== "live") { + return { _tag: "Wait" }; + } + } + + const removeQueuedMessage = (warning: string) => + storage("remove-unsendable", messageId, () => + removeThreadOutboxMessage(nextQueuedMessage), + ).pipe( + Effect.catch((error) => + Effect.logWarning(warning, { + environmentId: nextQueuedMessage.environmentId, + threadId: nextQueuedMessage.threadId, + messageId, + error: error.cause, + }).pipe(Effect.andThen(retryDelivery)), + ), + Effect.asVoid, + ); + // Confirm durability before sending; optimistic enqueue can still roll back on write failure. + const run = Effect.gen(function* () { + if (!(yield* confirmQueued(nextQueuedMessage))) return; + // An editor that took the message after confirmation owns it; that is not a failure. + if (isEditingQueuedMessage(messageId)) return; + if (deliveryAction === "send") { + const liveThread = findThread( + appAtomRegistry.get(environmentThreadShells.threadShellsAtom), + nextQueuedMessage, + ); + const liveDeliveryAction = resolveThreadOutboxDeliveryAction({ + isCreation: creation !== undefined, + threadExists: liveThread !== undefined && !resendLaunch, + shellStatus, + environmentConnected: environment?.connectionState === "connected", + }); + if (liveDeliveryAction !== "send") return; + } + if (deliveryAction === "remove") { + // Edited since launch, or launched before a restart that lost the revision: hand it back. + return yield* creation !== undefined + ? recoverEditedCreationAfterDelivery(nextQueuedMessage) + : removeQueuedMessage("[thread-outbox] failed to remove message for a missing thread"); + } + if (creation !== undefined) { + return yield* creationProjectCwd !== null + ? sendQueuedCreation(nextQueuedMessage, creation, creationProjectCwd) + : removeQueuedMessage("[thread-outbox] dropped pending task for a missing project"); + } + return yield* thread !== undefined + ? sendQueuedMessage(nextQueuedMessage, thread) + : retryDelivery; + }); + return { _tag: "Dispatch", messageId, run }; + } + + // One fiber per thread with queued messages. Opening a thread's latch wakes its fiber to + // reconsider its head; the fiber closes it before reading the inputs, so no wake is lost. + // An entry outlives its interrupted fiber until that fiber exits, so a thread never has two. + const threadFibers = new Map(); + + const deliverThread = (threadKey: string, wake: Latch.Latch) => + Effect.forever( + Effect.gen(function* () { + yield* wake.close; + const inputs = appAtomRegistry.get(deliveryInputsAtom); + const step = nextStep(threadKey, inputs.queuedMessagesByThreadKey[threadKey] ?? [], inputs); + if (step._tag === "Backoff") { + scheduleRetry(step.messageId); + return; + } + if (step._tag === "Wait") { + if (step.until === undefined) { + yield* wake.await; + return; + } + const now = yield* Clock.currentTimeMillis; + yield* wake.await.pipe( + Effect.timeoutOrElse({ + duration: Math.max(0, step.until - now), + orElse: () => Effect.void, + }), + ); + return; + } + // A send that started finishes, even when its thread leaves the queue meanwhile; only + // its wait on a shared upload stops early. + beginDispatchingQueuedMessage(step.messageId); + const sent = yield* step.run.pipe( + Effect.as(true), + Effect.catchTags({ DeliveryRetry: () => Effect.succeed(false) }), + // A send that throws backs off like any failure, not straight back into the send. + Effect.catchDefect((error) => + Effect.logWarning("[thread-outbox] queued message delivery threw", { + messageId: step.messageId, + error, + }).pipe(Effect.as(false)), + ), + Effect.ensuring(Effect.sync(() => finishDispatchingQueuedMessage(step.messageId))), + Effect.uninterruptible, + ); + if (sent) clearRetry(step.messageId); + else scheduleRetry(step.messageId); + }), + ); + + function wakeThreads(): void { + for (const { wake } of threadFibers.values()) wake.openUnsafe(); + } + + /** Starts a fiber for each thread with queued messages, stops the rest, and wakes them all. */ + function onInputs(): void { + if (disposed) return; + const { queuedMessagesByThreadKey, serverConfigs, connectedEnvironments } = + appAtomRegistry.get(deliveryInputsAtom); + const queued = Object.values(queuedMessagesByThreadKey).flat(); // Failures while an environment was unreachable say nothing about it now; a backoff // started then would hold a message for up to its full delay after reconnecting. const ready = new Set( @@ -1223,30 +1485,19 @@ export function createThreadOutboxDelivery(): { ) .map((environment) => environment.environmentId), ); - for (const message of Object.values(queuedMessagesByThreadKey).flat()) { + for (const message of queued) { if (ready.has(message.environmentId) && !readyEnvironmentIds.has(message.environmentId)) { clearRetry(message.messageId); } } readyEnvironmentIds = ready; - if (dispatchingQueuedMessageId !== null) { - return; - } - const queuedMessageIds = new Set( - Object.values(queuedMessagesByThreadKey) - .flat() - .map((message) => message.messageId), - ); + const queuedMessageIds = new Set(queued.map((message) => message.messageId)); for (const messageId of acknowledgedExistingThreadMessageIds) { - if (!queuedMessageIds.has(messageId)) { - acknowledgedExistingThreadMessageIds.delete(messageId); - } + if (!queuedMessageIds.has(messageId)) acknowledgedExistingThreadMessageIds.delete(messageId); } for (const messageId of launchedCreations.keys()) { - if (!queuedMessageIds.has(messageId)) { - launchedCreations.delete(messageId); - } + if (!queuedMessageIds.has(messageId)) launchedCreations.delete(messageId); } for (const [messageId, release] of familyMounts) { if (!queuedMessageIds.has(messageId)) { @@ -1255,230 +1506,36 @@ export function createThreadOutboxDelivery(): { } } - for (const [threadKey, queuedMessages] of Object.entries(queuedMessagesByThreadKey)) { - const nextQueuedMessage = queuedMessages[0]; - if (!nextQueuedMessage) { - continue; - } - const messageId = nextQueuedMessage.messageId; - if ( - nextQueuedMessage.creation === undefined && - acknowledgedExistingThreadMessageIds.has(messageId) - ) { - if (retryNotBefore(messageId) > Date.now()) { - continue; - } - beginDispatchingQueuedMessage(messageId); - settle( - messageId, - removeAcknowledgedExistingThreadMessage( - nextQueuedMessage, - acknowledgedExistingThreadMessageIds, - ), - ); - return; - } - if (editingQueuedMessageIds[messageId]) { - continue; - } - const blockedRecovery = blockedRecoveries.get(messageId); - if (blockedRecovery) { - if (blockedRecovery.message === nextQueuedMessage) { - continue; - } - blockedRecoveries.delete(messageId); - blockedRecovery.unsubscribe(); - } - if (retryNotBefore(messageId) > Date.now()) { - continue; - } - if ( - queuedAttachmentsStillUploading({ - environmentId: nextQueuedMessage.environmentId, - attachments: nextQueuedMessage.attachments, - states: appAtomRegistry.get(composerAttachmentUploadsAtom), - }) - ) { - continue; - } - - let thread = findThread(threads, nextQueuedMessage); - if (thread && scopedThreadKey(thread.environmentId, thread.id) !== threadKey) { - continue; - } - - const creation = nextQueuedMessage.creation; - const environment = connectedEnvironments.find( - (candidate) => candidate.environmentId === nextQueuedMessage.environmentId, - ); - const shellStatus = shellStatuses.get(nextQueuedMessage.environmentId) ?? "empty"; - const serverConfig = serverConfigs.get(nextQueuedMessage.environmentId); - let familyRead: ThreadFamilyRead | undefined; - if ( - thread === undefined && - creation === undefined && - serverConfig?.shellThreadFamilies === true - ) { - // The family keeps the row readable through dispatch once it loads; the current shell - // generation's read decides whether the thread is gone. - if (!familyMounts.has(nextQueuedMessage.messageId)) { - familyMounts.set( - nextQueuedMessage.messageId, - threadFamilies.mount( - appAtomRegistry, - nextQueuedMessage.environmentId, - nextQueuedMessage.threadId, - ), - ); - } - familyRead = threadFamilyRead( - appAtomRegistry.get( - threadFamilies.familyAtom(nextQueuedMessage.environmentId, nextQueuedMessage.threadId), - ), - ); - if (familyRead === "settled") { - // The rows read at the start of this pass can lag the family that just settled; - // decide from the merged rows as they are now. - thread = findThread( - appAtomRegistry.get(environmentThreadShells.threadShellsAtom), - nextQueuedMessage, - ); - } else if (familyRead === "failed") { - threadFamilies.refresh( - appAtomRegistry, - nextQueuedMessage.environmentId, - nextQueuedMessage.threadId, - ); - } - } - const resendLaunch = - creation !== undefined && - launchedCreations.get(messageId)?.revision === threadOutboxRevision(messageId); - const deliveryAction = resolveThreadOutboxDeliveryAction({ - isCreation: creation !== undefined, - // A resend goes through the same gates as the first launch. - threadExists: thread !== undefined && !resendLaunch, - shellStatus, - environmentConnected: environment?.connectionState === "connected", - ...(familyRead === undefined ? {} : { familyRead }), - }); - if ( - deliveryAction === "wait" && - shellStatus === "live" && - familyRead !== undefined && - familyRead !== "settled" - ) { - // An empty family read changes no merged row, so nothing else would wake the drain. - scheduleRetry(messageId); - continue; - } - if (deliveryAction === "send" && !operableEnvironments.has(nextQueuedMessage.environmentId)) { - continue; - } - const dispatchStep = resolveThreadOutboxDispatchStep({ - deliveryAction, - fileAttachments: nextQueuedMessage.attachments.filter( - (attachment) => attachment.type === "file", - ), - serverConfig: serverConfig - ? { - maxFileUploadBytes: - serverConfig.environment.capabilities.fileAttachments?.maxUploadBytes, - } - : null, - }); - if (dispatchStep.step === "wait") { - continue; - } - if (dispatchStep.step === "retry") { - scheduleRetry(messageId); - continue; - } - if (dispatchStep.step === "restore") { - const attachmentError = dispatchStep.reason; - beginDispatchingQueuedMessage(messageId); - settle( - messageId, - confirmThreadOutboxMessageQueued(nextQueuedMessage).then((queued) => - !queued || appAtomRegistry.get(editingQueuedMessageIdsAtom)[messageId] - ? true - : restoreQueuedMessage(nextQueuedMessage, attachmentError), - ), - ); - return; - } - const creationProjectCwd = - creation !== undefined - ? (findCreationProject(projects, nextQueuedMessage)?.workspaceRoot ?? - creation.projectCwd ?? - null) - : null; - if (deliveryAction === "send" && creation !== undefined) { - if (!isQueuedThreadCreationSendable(nextQueuedMessage)) { - continue; - } - if (creationProjectCwd === null && shellStatus !== "live") { - continue; - } - } - - beginDispatchingQueuedMessage(messageId); - const removeQueuedMessage = (warning: string) => - removeThreadOutboxMessage(nextQueuedMessage).then( - () => true, - (error) => { - console.warn(warning, { - environmentId: nextQueuedMessage.environmentId, - threadId: nextQueuedMessage.threadId, - messageId, - error, - }); - return false; - }, - ); - // Confirm durability before sending; optimistic enqueue can still roll back on write failure. - const delivery = confirmThreadOutboxMessageQueued(nextQueuedMessage).then((queued) => { - if (!queued) { - return true; - } - // Re-check editor ownership after confirmation; return true to defer without failure backoff. - if (appAtomRegistry.get(editingQueuedMessageIdsAtom)[messageId]) { - return true; - } - if (deliveryAction === "send") { - const liveThread = findThread( - appAtomRegistry.get(environmentThreadShells.threadShellsAtom), - nextQueuedMessage, - ); - const liveDeliveryAction = resolveThreadOutboxDeliveryAction({ - isCreation: creation !== undefined, - threadExists: liveThread !== undefined && !resendLaunch, - shellStatus, - environmentConnected: environment?.connectionState === "connected", - }); - if (liveDeliveryAction !== "send") { - return true; - } - } - return deliveryAction === "remove" - ? creation !== undefined - ? // Edited since launch, or launched before a restart that lost the revision: hand it back. - recoverEditedCreationAfterDelivery(nextQueuedMessage) - : removeQueuedMessage("[thread-outbox] failed to remove message for a missing thread") - : creation !== undefined - ? creationProjectCwd !== null - ? sendQueuedCreation(nextQueuedMessage, creation, creationProjectCwd) - : removeQueuedMessage("[thread-outbox] dropped pending task for a missing project") - : thread !== undefined - ? sendQueuedMessage(nextQueuedMessage, thread) - : Promise.resolve(false); + for (const [threadKey, entry] of threadFibers) { + if ((queuedMessagesByThreadKey[threadKey]?.length ?? 0) > 0 || entry.retiring) continue; + entry.retiring = true; + if (entry.fiber !== undefined) Effect.runFork(Fiber.interrupt(entry.fiber)); + } + for (const [threadKey, messages] of Object.entries(queuedMessagesByThreadKey)) { + if (messages.length === 0 || threadFibers.has(threadKey)) continue; + // Registered before the fiber starts: its first step runs synchronously and can re-enter here. + const entry: ThreadFiber = { + wake: Latch.makeUnsafe(true), + fiber: undefined, + retiring: false, + }; + threadFibers.set(threadKey, entry); + const fiber = Effect.runFork(deliverThread(threadKey, entry.wake)); + entry.fiber = fiber; + fiber.addObserver(() => { + if (threadFibers.get(threadKey) !== entry) return; + threadFibers.delete(threadKey); + // A message queued while this fiber finished its send starts the next fiber now. + if (!disposed) onInputs(); }); - settle(messageId, delivery); - return; + if (entry.retiring) Effect.runFork(Fiber.interrupt(fiber)); } + wakeThreads(); } - const stopDraining = appAtomRegistry.subscribe(deliveryInputsAtom, drain, { immediate: true }); + const stopDelivering = appAtomRegistry.subscribe(deliveryInputsAtom, onInputs, { + immediate: true, + }); const stopCollectingOutcomes = appAtomRegistry.subscribe( settledCreationOutcomeKeysAtom, (threadKeys) => { @@ -1488,12 +1545,15 @@ export function createThreadOutboxDelivery(): { ); return { - drain, + drain: wakeThreads, dispose: () => { disposed = true; - stopDraining(); + stopDelivering(); stopCollectingOutcomes(); - for (const retry of retries.values()) clearTimeout(retry.timer); + for (const { fiber } of threadFibers.values()) { + if (fiber !== undefined) Effect.runFork(Fiber.interrupt(fiber)); + } + threadFibers.clear(); retries.clear(); appAtomRegistry.set(retryingQueuedMessageIdsAtom, {}); for (const blocked of blockedRecoveries.values()) blocked.unsubscribe(); diff --git a/apps/mobile/src/state/use-thread-composer-state.ts b/apps/mobile/src/state/use-thread-composer-state.ts index f8f836dd77e9b..58f2da087ea41 100644 --- a/apps/mobile/src/state/use-thread-composer-state.ts +++ b/apps/mobile/src/state/use-thread-composer-state.ts @@ -122,7 +122,7 @@ import { } from "./use-thread-detail"; import { useThreadSelection } from "./use-thread-selection"; import { enqueueThreadOutboxMessage } from "./thread-outbox"; -import { dispatchingQueuedMessageIdAtom, useThreadOutboxMessages } from "./use-thread-outbox"; +import { dispatchingQueuedMessageIdsAtom, useThreadOutboxMessages } from "./use-thread-outbox"; import { threadEnvironment } from "./threads"; import { useAtomCommand } from "./use-atom-command"; @@ -217,7 +217,7 @@ export function useThreadComposerState(input: { const selectedThreadVisibleTurnItems = useSelectedThreadVisibleTurnItems(); const acknowledgedMessages = useAtomValue(acknowledgedThreadMessagesAtom); const queuedMessagesByThreadKey = useThreadOutboxMessages(); - const dispatchingQueuedMessageId = useAtomValue(dispatchingQueuedMessageIdAtom); + const dispatchingQueuedMessageIds = useAtomValue(dispatchingQueuedMessageIdsAtom); const [feedbackSubmissionsByThreadKey, setFeedbackSubmissionsByThreadKey] = useState< Record> >({}); @@ -240,6 +240,10 @@ export function useThreadComposerState(input: { (message) => message.creation === undefined, ) : []; + // The thread sends one message at a time, the head of its queue. + const dispatchingQueuedMessageId = + selectedThreadQueuedMessages.find((message) => dispatchingQueuedMessageIds[message.messageId]) + ?.messageId ?? null; const feedbackSubmissions = selectedThreadKey ? (feedbackSubmissionsByThreadKey[selectedThreadKey] ?? []) : []; diff --git a/apps/mobile/src/state/use-thread-outbox.ts b/apps/mobile/src/state/use-thread-outbox.ts index bc1f3ea149e1b..8edb8e033b361 100644 --- a/apps/mobile/src/state/use-thread-outbox.ts +++ b/apps/mobile/src/state/use-thread-outbox.ts @@ -26,10 +26,10 @@ export const editingQueuedMessageIdsAtom = Atom.make(null).pipe( - Atom.keepAlive, - Atom.withLabel("mobile:thread-outbox:dispatching-message-id"), -); +/** Messages being sent now: at most one per thread, the head of its queue. */ +export const dispatchingQueuedMessageIdsAtom = Atom.make< + Readonly>> +>({}).pipe(Atom.keepAlive, Atom.withLabel("mobile:thread-outbox:dispatching-message-ids")); /** Messages waiting out a retry backoff, which can repeat for as long as the failure lasts. */ export const retryingQueuedMessageIdsAtom = Atom.make>>>(