Revert the timeline optimistic and pagination rework (#2596)

* Add npm release track invariant and beta dist-tag procedure

* Revert "Keep older chat history and image previews stable (#2490)"

The timeline optimistic/pagination rework needs more work than main releases can wait for. Reverted together with #2484; both are reapplied on integration/timeline-optimistic-rework.

* Revert "Stop completed turns from appearing stuck (#2484)"

See the #2490 revert. #2490 built on this submission-authority change, so the two revert and reapply as a pair.

packages/app/src/composer/actions.ts

@@ -12,8 +12,13 @@ import {
   splitComposerAttachmentsForSubmit,
   type ComposerAttachmentSubmitFormat,
 } from "@/composer/attachments/submit";
-import { createUserMessage, generateMessageId, type UserMessageItem } from "@/types/stream";
-import type { MessageSubmissionRejectionOutcome } from "@/composer/submission/model";
+import {
+  appendOptimisticUserMessageToStream,
+  buildOptimisticUserMessage,
+  generateMessageId,
+  type StreamItem,
+  type UserMessageItem,
+} from "@/types/stream";
 import type { PickedImageAttachmentInput } from "@/hooks/image-attachment-picker";
 import { i18n } from "@/i18n/i18next";
 
@@ -46,7 +51,7 @@ export interface ComposerSendClient {
       images: Array<{ data: string; mimeType: string }>;
       attachments: ReturnType<typeof splitComposerAttachmentsForSubmit>["attachments"];
     },
-  ) => Promise<void | { outOfBand?: boolean }>;
+  ) => Promise<void>;
   uploadFile: (input: { fileName: string; mimeType: string; bytes: Uint8Array }) => Promise<{
     requestId: string;
     file: {
@@ -65,10 +70,11 @@ export interface ComposerCancelClient {
   cancelAgent: (agentId: string) => Promise<void> | void;
 }
 
-export interface MessageSubmissionWriter {
-  begin: (agentId: string, message: UserMessageItem) => void;
-  accept: (agentId: string, clientMessageId: string, outOfBand: boolean | undefined) => void;
-  reject: (agentId: string, clientMessageId: string) => MessageSubmissionRejectionOutcome;
+export interface AgentStreamWriter {
+  getTail: (agentId: string) => StreamItem[] | undefined;
+  getHead: (agentId: string) => StreamItem[] | undefined;
+  setHead: (updater: (prev: Map<string, StreamItem[]>) => Map<string, StreamItem[]>) => void;
+  setTail: (updater: (prev: Map<string, StreamItem[]>) => Map<string, StreamItem[]>) => void;
 }
 
 export interface QueueWriter {
@@ -163,7 +169,7 @@ export interface DispatchComposerAgentMessageInput {
   encodeImages: (
     images: AttachmentMetadata[],
   ) => Promise<Array<{ data: string; mimeType: string }> | undefined>;
-  submission: MessageSubmissionWriter;
+  stream: AgentStreamWriter;
 }
 
 export async function dispatchComposerAgentMessage(
@@ -172,30 +178,60 @@ export async function dispatchComposerAgentMessage(
   const wirePayload = splitComposerAttachmentsForSubmit(input.attachments, {
     format: input.attachmentSubmitFormat,
   });
-  const clientMessageId = generateMessageId();
-  const userMessage = createUserMessage({
-    clientMessageId,
+  const messageId = generateMessageId();
+  const userMessage = buildOptimisticUserMessage({
+    id: messageId,
     text: input.text,
     timestamp: new Date(),
     images: wirePayload.images,
     attachments: wirePayload.attachments,
   });
-  input.submission.begin(input.agentId, userMessage);
+  const rollbackOptimisticMessage = appendUserMessageToStream(
+    input.agentId,
+    userMessage,
+    input.stream,
+  );
   try {
     const imagesData = await input.encodeImages(wirePayload.images);
-    const result = await input.client.sendAgentMessage(input.agentId, input.text, {
-      messageId: clientMessageId,
+    await input.client.sendAgentMessage(input.agentId, input.text, {
+      messageId,
       images: imagesData ?? [],
       attachments: wirePayload.attachments,
     });
-    input.submission.accept(input.agentId, clientMessageId, result?.outOfBand);
   } catch (error) {
-    const outcome = input.submission.reject(input.agentId, clientMessageId);
-    if (outcome === "accepted") return;
+    rollbackOptimisticMessage();
     throw error;
   }
 }
 
+function appendUserMessageToStream(
+  agentId: string,
+  userMessage: UserMessageItem,
+  stream: AgentStreamWriter,
+): () => void {
+  const result = appendOptimisticUserMessageToStream({
+    tail: stream.getTail(agentId) ?? [],
+    head: stream.getHead(agentId) ?? [],
+    message: userMessage,
+    placement: "active-head",
+  });
+  const write = result.changedHead ? stream.setHead : stream.setTail;
+  const items = result.changedHead ? result.head : result.tail;
+  write((prev) => new Map(prev).set(agentId, items));
+
+  return () => {
+    write((prev) => {
+      const current = prev.get(agentId);
+      if (!current) return prev;
+      const nextItems = current.filter(
+        (item) => item.id !== userMessage.id || item.kind !== "user_message" || !item.optimistic,
+      );
+      if (nextItems.length === current.length) return prev;
+      return new Map(prev).set(agentId, nextItems);
+    });
+  };
+}
+
 export interface QueueComposerMessageInput {
   agentId: string;
   text: string;