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

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;

package/bundled-types/host-app/services/store.ts

@@ -224,6 +224,7 @@ export default class StoreService extends Service implements StoreInterface {
   @service declare private operatorModeStateService: OperatorModeStateService;
   @service declare private realmServer: RealmServerService;
   private subscriptions: Map<string, { unsubscribe: () => void }> = new Map();
+  private cardInvalidationSubscribers: Map<string, Set<() => void>> = new Map();
   private referenceCount: ReferenceCount = new Map();
   private newReferencePromises: Promise<void>[] = [];
   private autoSaveStates: TrackedMap<string, AutoSaveState> = new TrackedMap();
@@ -323,6 +324,7 @@ export default class StoreService extends Service implements StoreInterface {
   resetState() {
     clearInterval(this.gcInterval);
     this.subscriptions = new Map();
+    this.cardInvalidationSubscribers = new Map();
     this.onSaveSubscriber = undefined;
     this.referenceCount = new Map();
     this.newReferencePromises = [];
@@ -396,6 +398,65 @@ export default class StoreService extends Service implements StoreInterface {
     this.reestablishReferences.perform();
   }
 
+  // Notify-on-delete for callers that hold a card by direct JS reference rather
+  // than by linksTo. `consumersOf` only walks linksTo refs, so a direct holder
+  // (e.g. MatrixService's `_systemCard`) would otherwise stay pinned to a
+  // now-evicted instance until the next reload. Subscribers fire from both
+  // delete paths — `delete()` (in-tab UI) and the `reloadTask` 404 branch
+  // (matrix-auth-room invalidation for cross-tab / cross-machine deletes).
+  subscribeToCardInvalidation(id: string, cb: () => void): () => void {
+    let normalizedId = asURL(id, this.network.virtualNetwork);
+    let subscribers = this.cardInvalidationSubscribers.get(normalizedId);
+    if (!subscribers) {
+      subscribers = new Set();
+      this.cardInvalidationSubscribers.set(normalizedId, subscribers);
+    }
+    subscribers.add(cb);
+    return () => {
+      let current = this.cardInvalidationSubscribers.get(normalizedId);
+      if (!current) {
+        return;
+      }
+      current.delete(cb);
+      if (current.size === 0) {
+        this.cardInvalidationSubscribers.delete(normalizedId);
+      }
+    };
+  }
+
+  private notifyCardInvalidationSubscribers(id: string) {
+    let normalizedId = asURL(id, this.network.virtualNetwork);
+    let subscribers = this.cardInvalidationSubscribers.get(normalizedId);
+    if (!subscribers) {
+      return;
+    }
+    // Snapshot to tolerate unsubscribe-from-callback without skipping siblings.
+    // Subscribers may be async — catch rejections that escape the synchronous
+    // try/catch so a failure in one handler does not become an unhandled
+    // promise rejection or starve sibling handlers.
+    for (let cb of [...subscribers]) {
+      try {
+        let maybePromise = cb() as unknown;
+        if (
+          maybePromise &&
+          typeof (maybePromise as PromiseLike<unknown>).then === 'function'
+        ) {
+          (maybePromise as Promise<unknown>).catch((err) =>
+            console.error(
+              `card invalidation subscriber for ${normalizedId} rejected`,
+              err,
+            ),
+          );
+        }
+      } catch (err) {
+        console.error(
+          `card invalidation subscriber for ${normalizedId} threw`,
+          err,
+        );
+      }
+    }
+  }
+
   dropReference(id: string | undefined) {
     if (!id) {
       return;
@@ -809,6 +870,11 @@ export default class StoreService extends Service implements StoreInterface {
       }
     }
     await this.cardService.fetchJSON(id, { method: 'DELETE' });
+    // Notify direct-reference holders (e.g. MatrixService's `_systemCard`)
+    // only AFTER the server DELETE completes — these subscribers typically
+    // re-evaluate by calling `store.get(id)`, which is cache-first and would
+    // otherwise refetch the still-extant file and miss the deletion.
+    this.notifyCardInvalidationSubscribers(id);
   }
 
   async patch<T extends CardDef = CardDef>(
@@ -1660,6 +1726,10 @@ export default class StoreService extends Service implements StoreInterface {
         for (let consumer of consumers) {
           api.notifyLinksToTargetDeleted(consumer, instance.id);
         }
+        // Notify direct-reference holders after the local eviction so their
+        // re-evaluation does not return the cached pre-delete instance.
+        // (The server is already gone — we got here from a 404 reload.)
+        this.notifyCardInvalidationSubscribers(instance.id);
       }
     } finally {
       this.finishTrackingCardLoad(instance.id, reloadTracker);

package/bundled-types/host-app/utils/local-storage-keys.ts

@@ -7,6 +7,7 @@ export const CodeModePanelHeights = 'code-mode-panel-heights';
 export const ModuleInspectorSelections = 'code-mode-panel-selections';
 export const SessionLocalStorageKey = 'boxel-session';
 export const AiAssistantMessageDrafts = 'ai-assistant-message-drafts';
+export const AiAssistantPendingSends = 'ai-assistant-pending-sends';
 export const PlaygroundSelections = 'playground-selections';
 export const SpecSelection = 'spec-selection';
 export const RecentCards = 'recent-cards';
@@ -25,4 +26,5 @@ export function clearLocalStorage(storage: Storage | undefined) {
   storage?.removeItem(RecentFiles);
   storage?.removeItem(ScrollPositions);
   storage?.removeItem(AiAssistantMessageDrafts);
+  storage?.removeItem(AiAssistantPendingSends);
 }

package/bundled-types/host-tests/helpers/mock-matrix/_client.ts

@@ -498,6 +498,9 @@ export class MockClient implements ExtendedClient {
     let localEvent = new MatrixEvent(localEventData);
     localEvent.setStatus('sending' as MatrixSDK.EventStatus.SENDING);
     this.emitEvent(localEvent);
+    if (this.sdkOpts.sendEventInterceptor) {
+      await this.sdkOpts.sendEventInterceptor();
+    }
     if (content.body?.match(/SENDING_DELAY_THEN_/)) {
       await new Promise((resolve) => setTimeout(resolve, 1000));
     }

package/bundled-types/host-tests/helpers/mock-matrix/_utils.ts

@@ -131,6 +131,9 @@ export class MockUtils {
   setUploadContentInterceptor = (fn: (() => Promise<void>) | undefined) => {
     this.testState.opts!.uploadContentInterceptor = fn;
   };
+  setSendEventInterceptor = (fn: (() => Promise<void>) | undefined) => {
+    this.testState.opts!.sendEventInterceptor = fn;
+  };
 
   setRoomState = (
     roomId: string,

package/bundled-types/host-tests/helpers/mock-matrix.ts

@@ -31,6 +31,7 @@ export interface Config {
   directRooms?: string[];
   systemCardAccountData?: { id?: string };
   uploadContentInterceptor?: () => Promise<void>;
+  sendEventInterceptor?: () => Promise<void>;
   workspaceFavorites?: string[];
 }