@cardstack/boxel-cli 0.3.2-unstable.61 → 0.4.0-unstable.1

package/bundled-types/host-app/services/local-persistence-service.ts

@@ -7,6 +7,7 @@ import type { SerializedFileDef } from 'https://cardstack.com/base/file-api';
 
 import {
   AiAssistantMessageDrafts,
+  AiAssistantPendingSends,
   CurrentRoomIdPersistenceKey,
 } from '../utils/local-storage-keys';
 
@@ -30,6 +31,23 @@ type DraftUpdate = {
   attachedFiles?: StoredFileDraft[] | undefined;
 };
 
+export type StoredPendingFile = Pick<
+  SerializedFileDef,
+  'sourceUrl' | 'name' | 'url' | 'contentType' | 'contentHash'
+> & { contentSize?: number };
+
+export type PendingSendStatus = 'sending' | 'not_sent';
+
+export type StoredPendingSend = {
+  clientGeneratedId: string;
+  body: string;
+  attachedCardIds: string[];
+  attachedFiles: StoredPendingFile[];
+  createdAt: number;
+  status: PendingSendStatus;
+  errorMessage?: string;
+};
+
 export default class LocalPersistenceService extends Service {
   // Using sessionStorage for agent id because we want:
   // - to keep the same agent id if user reloads the page (or tab)
@@ -287,6 +305,167 @@ export default class LocalPersistenceService extends Service {
     let hasFiles = draft.attachedFiles && draft.attachedFiles.length > 0;
     return !hasMessage && !hasCards && !hasFiles;
   }
+
+  getPendingSends(roomId: string): StoredPendingSend[] {
+    return this.readPendingSends()[roomId] ?? [];
+  }
+
+  upsertPendingSend(roomId: string, entry: StoredPendingSend) {
+    let all = this.readPendingSends();
+    let list = all[roomId] ? [...all[roomId]] : [];
+    let index = list.findIndex(
+      (e) => e.clientGeneratedId === entry.clientGeneratedId,
+    );
+    if (index >= 0) {
+      list[index] = entry;
+    } else {
+      list.push(entry);
+    }
+    all[roomId] = list;
+    this.writePendingSends(all);
+  }
+
+  updatePendingSendStatus(
+    roomId: string,
+    clientGeneratedId: string,
+    update: { status: PendingSendStatus; errorMessage?: string },
+  ) {
+    let all = this.readPendingSends();
+    let list = all[roomId];
+    if (!list) {
+      return;
+    }
+    let index = list.findIndex(
+      (e) => e.clientGeneratedId === clientGeneratedId,
+    );
+    if (index < 0) {
+      return;
+    }
+    let next = [...list];
+    next[index] = {
+      ...next[index],
+      status: update.status,
+      errorMessage: update.errorMessage,
+    };
+    all[roomId] = next;
+    this.writePendingSends(all);
+  }
+
+  removePendingSend(roomId: string, clientGeneratedId: string) {
+    let all = this.readPendingSends();
+    let list = all[roomId];
+    if (!list) {
+      return;
+    }
+    let next = list.filter((e) => e.clientGeneratedId !== clientGeneratedId);
+    if (next.length === 0) {
+      delete all[roomId];
+    } else {
+      all[roomId] = next;
+    }
+    this.writePendingSends(all);
+  }
+
+  private readPendingSends(): Record<string, StoredPendingSend[]> {
+    let raw = window.localStorage.getItem(AiAssistantPendingSends);
+    if (!raw) {
+      return {};
+    }
+    try {
+      let parsed = JSON.parse(raw);
+      if (!parsed || typeof parsed !== 'object') {
+        return {};
+      }
+      let sanitized: Record<string, StoredPendingSend[]> = {};
+      for (let [roomId, list] of Object.entries(
+        parsed as Record<string, unknown>,
+      )) {
+        if (!Array.isArray(list)) {
+          continue;
+        }
+        let entries = list
+          .map((entry) => this.sanitizePendingSend(entry))
+          .filter((e): e is StoredPendingSend => Boolean(e));
+        if (entries.length > 0) {
+          sanitized[roomId] = entries;
+        }
+      }
+      return sanitized;
+    } catch {
+      window.localStorage.removeItem(AiAssistantPendingSends);
+      return {};
+    }
+  }
+
+  private sanitizePendingSend(value: unknown): StoredPendingSend | undefined {
+    if (!value || typeof value !== 'object') {
+      return;
+    }
+    let cgi = (value as { clientGeneratedId?: unknown }).clientGeneratedId;
+    if (typeof cgi !== 'string' || cgi.length === 0) {
+      return;
+    }
+    let body = (value as { body?: unknown }).body;
+    let attachedCardIds = (value as { attachedCardIds?: unknown })
+      .attachedCardIds;
+    let attachedFiles = (value as { attachedFiles?: unknown }).attachedFiles;
+    let createdAt = Number((value as { createdAt?: unknown }).createdAt);
+    let status = (value as { status?: unknown }).status;
+    let errorMessage = (value as { errorMessage?: unknown }).errorMessage;
+
+    return {
+      clientGeneratedId: cgi,
+      body: typeof body === 'string' ? body : '',
+      attachedCardIds: Array.isArray(attachedCardIds)
+        ? attachedCardIds.filter(
+            (id): id is string => typeof id === 'string' && id.length > 0,
+          )
+        : [],
+      attachedFiles: Array.isArray(attachedFiles)
+        ? (attachedFiles
+            .map((file) => this.sanitizePendingFile(file))
+            .filter(Boolean) as StoredPendingFile[])
+        : [],
+      createdAt: Number.isFinite(createdAt) ? createdAt : 0,
+      status: status === 'not_sent' ? 'not_sent' : 'sending',
+      errorMessage: typeof errorMessage === 'string' ? errorMessage : undefined,
+    };
+  }
+
+  private sanitizePendingFile(file: unknown): StoredPendingFile | undefined {
+    if (!file || typeof file !== 'object') {
+      return;
+    }
+    let sourceUrl = (file as { sourceUrl?: unknown }).sourceUrl;
+    if (typeof sourceUrl !== 'string' || sourceUrl.length === 0) {
+      return;
+    }
+    let name = (file as { name?: unknown }).name;
+    let url = (file as { url?: unknown }).url;
+    let contentType = (file as { contentType?: unknown }).contentType;
+    let contentHash = (file as { contentHash?: unknown }).contentHash;
+    let contentSize = (file as { contentSize?: unknown }).contentSize;
+    return {
+      sourceUrl,
+      ...(typeof name === 'string' ? { name } : {}),
+      ...(typeof url === 'string' ? { url } : {}),
+      ...(typeof contentType === 'string' ? { contentType } : {}),
+      ...(typeof contentHash === 'string' ? { contentHash } : {}),
+      ...(typeof contentSize === 'number' ? { contentSize } : {}),
+    };
+  }
+
+  private writePendingSends(all: Record<string, StoredPendingSend[]>) {
+    let entries = Object.entries(all).filter(([, list]) => list.length > 0);
+    if (entries.length === 0) {
+      window.localStorage.removeItem(AiAssistantPendingSends);
+      return;
+    }
+    window.localStorage.setItem(
+      AiAssistantPendingSends,
+      JSON.stringify(Object.fromEntries(entries)),
+    );
+  }
 }
 
 declare module '@ember/service' {

package/bundled-types/host-app/services/matrix-service.ts

@@ -126,6 +126,10 @@ import type CardService from './card-service';
 import type CommandService from './command-service';
 import type LoaderService from './loader-service';
 import type LocalPersistenceService from './local-persistence-service';
+import type {
+  PendingSendStatus,
+  StoredPendingFile,
+} from './local-persistence-service';
 import type LoggerService from './logger-service';
 import type MatrixSDKLoader from './matrix-sdk-loader';
 import type { ExtendedClient, ExtendedMatrixSDK } from './matrix-sdk-loader';
@@ -208,12 +212,20 @@ export default class MatrixService extends Service {
   private slidingSync: SlidingSync | undefined;
   private aiRoomIds: Set<string> = new Set();
   private restoredDraftRooms = new Set<string>();
+  private hydratedPendingSendRooms = new Set<string>();
   @tracked private _isLoadingMoreAIRooms = false;
   private initialSyncCompleted = false;
   private initialSyncCompletedDeferred = new Deferred<void>();
   private roomsWaitingForSync: Map<string, Deferred<void>> = new Map();
   @tracked private _systemCard: SystemCard | undefined;
   @tracked private _systemCardLoadFailed = false;
+  private _userChoiceId: string | undefined;
+  private _systemCardInvalidationUnsub: (() => void) | undefined;
+  // Sticky "the active SystemCard was deleted in-session" signal. Bridges the
+  // synchronous failure detection in `onSystemCardInvalidated` with the
+  // asynchronous re-entry into `setSystemCard(undefined)` from the matrix
+  // account-data echo. Cleared whenever `setSystemCard` resolves a card.
+  private _systemCardWasLost = false;
   agentId: string | undefined;
 
   constructor(owner: Owner) {
@@ -1251,6 +1263,136 @@ export default class MatrixService extends Service {
     return response;
   }
 
+  // Synthesize a user-message event at click-time and push it into the room's
+  // events list so the pending bubble renders without waiting for the pre-send
+  // pipeline (skill / command / card / file uploads) or for matrix-js-sdk to
+  // emit its native local echo. The synthetic event's id is `local-${cgi}`;
+  // when matrix-js-sdk's real local echo eventually arrives in
+  // processDecryptedEvent, the cgi→oldEventId bridge there replaces the
+  // synthetic in-place so consumers iterating `roomData.events` never see both.
+  async addOptimisticEvent(
+    roomId: string,
+    content: {
+      body: string;
+      clientGeneratedId: string;
+      attachedCardIds: string[];
+      attachedFiles: ReturnType<FileDef['serialize']>[];
+    },
+  ): Promise<number> {
+    let userId = this.userId;
+    if (!userId) {
+      throw new Error('bug: cannot add optimistic event without a userId');
+    }
+    // Sort just after the tail of the existing timeline rather than using
+    // `Date.now()` directly. The matrix-js-sdk and its mocks may use a clock
+    // that's offset from the wall clock (mock-matrix's frozen-2024 clock is
+    // the common case), and `MessageBuilder.updateMessage` early-returns when
+    // the cached message's `created` is later than an incoming event — which
+    // would silently drop the status transition from 'sending' to 'sent'.
+    let originServerTs = this.resolveOptimisticTimestamp(roomId);
+    let event: TempEvent = {
+      event_id: `local-${content.clientGeneratedId}`,
+      room_id: roomId,
+      sender: userId,
+      type: 'm.room.message',
+      origin_server_ts: originServerTs,
+      status: 'sending' as MatrixSDK.EventStatus,
+      content: {
+        msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
+        body: content.body,
+        format: 'org.matrix.custom.html',
+        clientGeneratedId: content.clientGeneratedId,
+        // Deliberately omit isStreamingFinished. Setting it to `false` would
+        // make `generatingResults` (which reads `!lastMessage.isStreamingFinished`)
+        // misclassify the user's own bubble as "AI generating", flashing the
+        // status banner over the user's pending message. Omitting the key is
+        // just as effective at suppressing processDecryptedEvent's
+        // code-patch-processing branch, which gates on a truthy value.
+        data: {
+          attachedCards: content.attachedCardIds.map((id) => ({
+            sourceUrl: id,
+            // MessageBuilder.attachedCardIds only reads sourceUrl; the rest of
+            // SerializedFile is filled in below so attachedCardsAsFiles still
+            // produces a valid FileDef object.
+            name: id.split('/').pop() ?? id,
+            contentType: 'application/json',
+          })),
+          attachedFiles: content.attachedFiles,
+          context: {
+            tools: [],
+            functions: [],
+          },
+        },
+      } as unknown as CardMessageContent,
+    };
+    await this.addRoomEvent(event);
+    return originServerTs;
+  }
+
+  // Resolve a timestamp that won't trip MessageBuilder.updateMessage's
+  // `incoming.created < cached.created` early-return. Prefer the tail of the
+  // existing timeline, then the SDK Room's last-active ts (matches the
+  // SDK/mock clock), then wall-clock as a last resort.
+  private resolveOptimisticTimestamp(roomId: string): number {
+    let existingEvents = this.getRoomData(roomId)?.events ?? [];
+    let maxTs = 0;
+    for (let e of existingEvents) {
+      let ts = (e as any).origin_server_ts;
+      if (typeof ts === 'number' && ts > maxTs) {
+        maxTs = ts;
+      }
+    }
+    if (maxTs > 0) {
+      return maxTs + 1;
+    }
+    let roomLastActive = this.client
+      .getRoom?.(roomId)
+      ?.getLastActiveTimestamp?.();
+    if (typeof roomLastActive === 'number' && roomLastActive > 0) {
+      return roomLastActive + 1;
+    }
+    return Date.now();
+  }
+
+  // Patch an in-flight optimistic event's status (and optional error message)
+  // Flip an in-flight pending send between 'sending' and 'not_sent' from
+  // doSendMessage's catch / retry paths. Updates both the in-memory synthetic
+  // event (so the rendered bubble re-runs through MessageBuilder.updateMessage)
+  // and the persisted localStorage entry as one operation, so the two sources
+  // of truth can't desync.
+  patchPendingSend(
+    roomId: string,
+    clientGeneratedId: string,
+    patch: { status: PendingSendStatus; errorMessage?: string },
+  ) {
+    let syntheticEventId = `local-${clientGeneratedId}`;
+    let roomData = this.getRoomData(roomId);
+    let existing = roomData?.events.find(
+      (e) => e.event_id === syntheticEventId,
+    );
+    if (existing) {
+      let nextContent: Record<string, unknown> = {
+        ...(existing.content ?? {}),
+      };
+      if (patch.status === 'not_sent') {
+        nextContent.errorMessage = patch.errorMessage ?? 'Failed to send';
+      } else {
+        delete nextContent.errorMessage;
+      }
+      let next: TempEvent = {
+        ...existing,
+        status: patch.status as MatrixSDK.EventStatus,
+        content: nextContent as TempEvent['content'],
+      };
+      void this.addRoomEvent(next, syntheticEventId);
+    }
+    this.localPersistenceService.updatePendingSendStatus(
+      roomId,
+      clientGeneratedId,
+      patch,
+    );
+  }
+
   async sendMessage(
     roomId: string,
     body: string | undefined,
@@ -1508,10 +1650,15 @@ export default class MatrixService extends Service {
     this.filesToSend.clear();
     this.currentUserEventReadReceipts.clear();
     this.restoredDraftRooms = new Set();
+    this.hydratedPendingSendRooms = new Set();
     this.aiRoomIds.clear();
     this.initialSyncCompleted = false;
     this.initialSyncCompletedDeferred = new Deferred<void>();
     this.roomsWaitingForSync.clear();
+    this._systemCardInvalidationUnsub?.();
+    this._systemCardInvalidationUnsub = undefined;
+    this._userChoiceId = undefined;
+    this._systemCardWasLost = false;
     this._systemCard = undefined;
     this._systemCardLoadFailed = false;
     this.startedAtTs = -1;
@@ -2198,8 +2345,48 @@ export default class MatrixService extends Service {
       this.processDecryptedEventFromAuthRoom(event);
       return;
     }
+
+    // cgi→oldEventId bridge: if doSendMessage previously injected a synthetic
+    // optimistic event with event_id `local-${cgi}`, hand that id to addEvent
+    // as oldEventId so Room.addEvent replaces the synthetic in-place. Without
+    // this bridge the synthetic and the real echo would both live in
+    // roomData.events and every consumer iterating `this.events` (sortedEvents,
+    // usedLLMs, llmModeEvents, command/code-patch result lookups, MessageBuilder's
+    // `events` argument) would double-count.
+    let cgi = event.content?.clientGeneratedId as string | undefined;
+    if (cgi && !oldEventId) {
+      let existing = this.getRoomData(roomId)?.events.find((e) => {
+        let eContent = (e as any).content;
+        return (
+          eContent?.clientGeneratedId === cgi &&
+          typeof (e as any).event_id === 'string' &&
+          (e as any).event_id.startsWith('local-')
+        );
+      });
+      if (existing) {
+        oldEventId = (existing as any).event_id;
+      }
+    }
+
     await this.addRoomEvent(event, oldEventId);
 
+    // Drop the persisted pending entry only once matrix-js-sdk has finalized
+    // the send. EventStatus is null/undefined for fully-delivered events (the
+    // SDK clears it after the server ack); 'sent' covers the intermediate
+    // "echo accepted, awaiting ack" state. Removing earlier (e.g. on the
+    // initial 'sending' local echo) would defeat a later patchPendingSend(
+    // 'not_sent') because the persisted entry would already be gone, so a
+    // failed send wouldn't survive a reload. 'not_sent' / 'cancelled' flow
+    // through patchPendingSend instead and keep the entry around so the
+    // failed bubble can be restored on reload.
+    let isTerminalSent =
+      event.status === null ||
+      event.status === undefined ||
+      (event.status as string) === 'sent';
+    if (cgi && isTerminalSent && event.sender === this.userId) {
+      this.localPersistenceService.removePendingSend(roomId, cgi);
+    }
+
     if (
       event.type === 'm.room.message' &&
       event.content?.[APP_BOXEL_COMMAND_REQUESTS_KEY]?.length &&
@@ -2347,6 +2534,7 @@ export default class MatrixService extends Service {
   }
 
   private async setSystemCard(userChoiceId: string | undefined) {
+    this._userChoiceId = userChoiceId;
     let envDefaultId = ENV.defaultSystemCardId;
 
     if (userChoiceId && userChoiceId === this._systemCard?.id) {
@@ -2381,18 +2569,57 @@ export default class MatrixService extends Service {
       }
     }
 
+    // Clear the post-loss signal before deriving the banner state so a
+    // successful resolution in this call does not re-trip the third clause.
+    if (loadedCard) {
+      this._systemCardWasLost = false;
+    }
     this._systemCardLoadFailed =
-      envDefaultFailed || (userChoiceFailed && !envDefaultId);
+      envDefaultFailed ||
+      (userChoiceFailed && !envDefaultId) ||
+      (this._systemCardWasLost && !loadedCard);
 
     if (loadedCard?.id !== this._systemCard?.id) {
+      this._systemCardInvalidationUnsub?.();
+      this._systemCardInvalidationUnsub = undefined;
       this.store.dropReference(this._systemCard?.id);
       if (loadedCard) {
         this.store.addReference(loadedCard.id);
+        // Capture the id in the closure — by the time the callback fires, the
+        // store has evicted the card, so we cannot read it off `_systemCard`.
+        let subscribedId = loadedCard.id;
+        this._systemCardInvalidationUnsub =
+          this.store.subscribeToCardInvalidation(subscribedId, () =>
+            this.onSystemCardInvalidated(subscribedId),
+          );
       }
       this._systemCard = loadedCard;
     }
   }
 
+  // Fires when the active SystemCard is deleted in the same session (either
+  // via the in-tab UI or via a matrix-auth-room invalidation originating
+  // elsewhere). Re-evaluate the chain so the fallback banner surfaces or the
+  // env-default silently takes over, and clear the matrix preference when the
+  // dangling id was the user's own pick so it does not keep being rebroadcast.
+  private onSystemCardInvalidated = async (invalidatedId: string) => {
+    let wasUserChoice = this._userChoiceId === invalidatedId;
+    // Drop the doomed reference so setSystemCard does not take its id-match
+    // fast path against the now-evicted instance.
+    this._systemCardInvalidationUnsub?.();
+    this._systemCardInvalidationUnsub = undefined;
+    this.store.dropReference(this._systemCard?.id);
+    this._systemCard = undefined;
+    // Sticky signal that survives the asynchronous matrix account-data echo
+    // below — keeps `_systemCardLoadFailed` true through any re-entry into
+    // `setSystemCard(undefined)` until a replacement card actually resolves.
+    this._systemCardWasLost = true;
+    await this.setSystemCard(this._userChoiceId);
+    if (wasUserChoice) {
+      await this.setUserSystemCard(undefined);
+    }
+  };
+
   async setUserSystemCard(systemCardId: string | undefined) {
     // This sets the users account data for their preferred system card
     // If there is none, we fall back to the default
@@ -2454,6 +2681,132 @@ export default class MatrixService extends Service {
     }
   }
 
+  // Hydrate persisted optimistic sends (from a prior tab/session) into the
+  // room's events list before matrix-js-sdk's /sync delivers any real echo.
+  // Real echoes that match by clientGeneratedId reconcile through the bridge
+  // in processDecryptedEvent; entries left in 'not_sent' surface the retry alert.
+  ensurePendingSendsHydrated(roomId: string) {
+    if (this.hydratedPendingSendRooms.has(roomId)) {
+      return;
+    }
+    let userId = this.userId;
+    if (!userId) {
+      // Don't mark the room hydrated — a later call (once login completes)
+      // must be free to try again.
+      return;
+    }
+    let entries = this.localPersistenceService.getPendingSends(roomId);
+    if (entries.length === 0) {
+      this.hydratedPendingSendRooms.add(roomId);
+      return;
+    }
+    this.hydratedPendingSendRooms.add(roomId);
+    for (let entry of entries) {
+      // Any entry persisted as 'sending' at hydration time is orphaned:
+      // matrix-js-sdk has no live pending event for it (a fresh tab/session
+      // has an empty in-memory queue), so nothing will ever reconcile it.
+      // Flip it to 'not_sent' so the retry alert surfaces and canSend can
+      // unblock once the user dismisses or retries.
+      let effectiveStatus: PendingSendStatus =
+        entry.status === 'sending' ? 'not_sent' : entry.status;
+      let effectiveErrorMessage =
+        effectiveStatus === 'not_sent'
+          ? (entry.errorMessage ?? 'Send interrupted — retry')
+          : entry.errorMessage;
+      if (effectiveStatus !== entry.status) {
+        this.localPersistenceService.updatePendingSendStatus(
+          roomId,
+          entry.clientGeneratedId,
+          { status: effectiveStatus, errorMessage: effectiveErrorMessage },
+        );
+      }
+      let event: TempEvent = {
+        event_id: `local-${entry.clientGeneratedId}`,
+        room_id: roomId,
+        sender: userId,
+        type: 'm.room.message',
+        origin_server_ts: entry.createdAt || Date.now(),
+        status: effectiveStatus as MatrixSDK.EventStatus,
+        content: {
+          msgtype: APP_BOXEL_MESSAGE_MSGTYPE,
+          body: entry.body,
+          format: 'org.matrix.custom.html',
+          clientGeneratedId: entry.clientGeneratedId,
+          ...(effectiveStatus === 'not_sent' && effectiveErrorMessage
+            ? { errorMessage: effectiveErrorMessage }
+            : {}),
+          data: {
+            attachedCards: entry.attachedCardIds.map((id) => ({
+              sourceUrl: id,
+              name: id.split('/').pop() ?? id,
+              contentType: 'application/json',
+            })),
+            attachedFiles: entry.attachedFiles,
+            context: { tools: [], functions: [] },
+          },
+        } as unknown as CardMessageContent,
+      };
+      void this.addRoomEvent(event);
+    }
+  }
+
+  persistOptimisticSend(
+    roomId: string,
+    entry: {
+      clientGeneratedId: string;
+      body: string;
+      attachedCardIds: string[];
+      attachedFiles: ReturnType<FileDef['serialize']>[];
+      createdAt: number;
+    },
+  ) {
+    this.localPersistenceService.upsertPendingSend(roomId, {
+      clientGeneratedId: entry.clientGeneratedId,
+      body: entry.body,
+      attachedCardIds: entry.attachedCardIds,
+      attachedFiles: entry.attachedFiles.map(serializeFileForPersistence),
+      createdAt: entry.createdAt,
+      status: 'sending',
+    });
+  }
+
+  // Look up matrix-js-sdk's view of an outgoing send by clientGeneratedId.
+  // Used by doSendMessage's catch block to detect the inverse delivery race
+  // (sendEvent succeeded server-side but a downstream throw escaped before the
+  // local echo reconciled) — in that case the bubble must stay in 'sending'
+  // and let matrix's reconciliation finish, not flash 'not_sent'.
+  findPendingMatrixEventStatus(
+    roomId: string,
+    clientGeneratedId: string,
+  ): MatrixSDK.EventStatus | null | undefined {
+    let room = this.client.getRoom(roomId);
+    if (!room) {
+      return undefined;
+    }
+    // Optional-chained — the mock Room in tests doesn't implement
+    // getPendingEvents. The real SDK Room always does.
+    let pending = room.getPendingEvents?.() ?? [];
+    let matches = pending.filter((e) => {
+      let c = e.getContent() as { clientGeneratedId?: string };
+      return c?.clientGeneratedId === clientGeneratedId;
+    });
+    if (matches.length > 0) {
+      return matches[matches.length - 1].status ?? null;
+    }
+    // Not in the SDK's pending list — could be already-sent or never-attempted.
+    let live = room
+      .getLiveTimeline()
+      .getEvents()
+      .filter((e) => {
+        let c = e.getContent() as { clientGeneratedId?: string };
+        return c?.clientGeneratedId === clientGeneratedId;
+      });
+    if (live.length > 0) {
+      return live[live.length - 1].status ?? null;
+    }
+    return undefined;
+  }
+
   async getPromptParts(roomId: string) {
     const roomResource = this.roomResourcesCache.get(roomId);
     if (!roomResource) {
@@ -2500,6 +2853,24 @@ async function getStorage() {
   return storage;
 }
 
+function serializeFileForPersistence(
+  f: ReturnType<FileDef['serialize']>,
+): StoredPendingFile {
+  // Conditional spreads avoid emitting `{ name: undefined }` keys, which
+  // matters under exactOptionalPropertyTypes — see sanitizePendingFile in
+  // local-persistence-service.ts for the symmetric reader.
+  return {
+    sourceUrl: f.sourceUrl,
+    ...(f.name ? { name: f.name } : {}),
+    ...(f.url ? { url: f.url } : {}),
+    ...(f.contentType ? { contentType: f.contentType } : {}),
+    ...(f.contentHash ? { contentHash: f.contentHash } : {}),
+    ...(typeof f.contentSize === 'number'
+      ? { contentSize: f.contentSize }
+      : {}),
+  } as StoredPendingFile;
+}
+
 declare module '@ember/service' {
   interface Registry {
     'matrix-service': MatrixService;