Enhance RoomResource to manage skill cards and improve message processing

Author: lukemelia

packages/host/app/lib/matrix-classes/message-builder.ts

@@ -16,6 +16,7 @@ import {
   APP_BOXEL_MESSAGE_MSGTYPE,
 } from '@cardstack/runtime-common/matrix-constants';
 
+import { Skill } from '@cardstack/host/components/ai-assistant/skill-menu';
 import type CommandService from '@cardstack/host/services/command-service';
 
 import MatrixService from '@cardstack/host/services/matrix-service';
@@ -50,6 +51,7 @@ export default class MessageBuilder {
       author: RoomMember;
       index: number;
       serializedCardFromFragments: (eventId: string) => LooseSingleCardDocument;
+      skills: Skill[];
       events: DiscreteMatrixEvent[];
       commandResultEvent?: CommandResultEvent;
     },
@@ -156,10 +158,6 @@ export default class MessageBuilder {
   }
 
   updateMessage(message: Message) {
-    if (this.event.content['m.relates_to']?.rel_type !== 'm.replace') {
-      return;
-    }
-
     if (message.created.getTime() > this.event.origin_server_ts) {
       message.created = new Date(this.event.origin_server_ts);
       return;
@@ -173,11 +171,11 @@ export default class MessageBuilder {
         : undefined;
     message.updated = new Date();
 
-    if (this.event.content.msgtype === APP_BOXEL_COMMAND_MSGTYPE) {
-      if (!message.command) {
-        message.command = this.buildMessageCommand(message);
-      }
-
+    if (
+      this.event.content.msgtype === APP_BOXEL_COMMAND_MSGTYPE &&
+      this.event.content.data?.toolCall
+    ) {
+      message.command = this.buildMessageCommand(message);
       message.isStreamingFinished = true;
       message.formattedMessage = this.formattedMessageForCommand;
 

packages/host/app/resources/room.ts

@@ -47,12 +47,6 @@ import type CardService from '../services/card-service';
 import type CommandService from '../services/command-service';
 import type MatrixService from '../services/matrix-service';
 
-interface SkillId {
-  skillCardId: string;
-  skillEventId: string;
-  isActive: boolean;
-}
-
 interface Args {
   named: {
     roomId: string | undefined;
@@ -62,6 +56,8 @@ interface Args {
 
 export class RoomResource extends Resource<Args> {
   private _messageCache: TrackedMap<string, Message> = new TrackedMap();
+  private _skillEventIdToCardIdCache: TrackedMap<string, string> =
+    new TrackedMap();
   private _skillCardsCache: TrackedMap<string, SkillCard> = new TrackedMap();
   private _nameEventsCache: TrackedMap<string, RoomNameEvent> =
     new TrackedMap();
@@ -103,7 +99,33 @@ export class RoomResource extends Resource<Args> {
       if (!memberIds || !memberIds.includes(this.matrixService.aiBotUserId)) {
         return;
       }
-      await this.loadFromEvents(roomId);
+
+      let index = this._messageCache.size;
+      // This is brought up to this level so if the
+      // load task is rerun we can stop processing
+      for (let event of this.sortedEvents) {
+        switch (event.type) {
+          case 'm.room.member':
+            await this.loadRoomMemberEvent(roomId, event);
+            break;
+          case 'm.room.message':
+            if (this.isCardFragmentEvent(event)) {
+              await this.loadCardFragment(event);
+            } else {
+              await this.loadRoomMessage({ roomId, event, index });
+            }
+            break;
+          case APP_BOXEL_COMMAND_RESULT_EVENT_TYPE:
+            this.updateMessageCommandResult({ roomId, event, index });
+            break;
+          case 'm.room.create':
+            await this.loadRoomCreateEvent(event);
+            break;
+          case 'm.room.name':
+            await this.loadRoomNameEvent(event);
+            break;
+        }
+      }
     } catch (e) {
       throw new Error(`Error loading room ${e}`);
     }
@@ -165,61 +187,41 @@ export class RoomResource extends Resource<Args> {
     return this.events.sort((a, b) => a.origin_server_ts - b.origin_server_ts);
   }
 
-  @cached
-  get skillIds(): SkillId[] {
+  get allSkillEventIds(): Set<string> {
     let skillsConfig = this.matrixRoom?.skillsConfig;
     if (!skillsConfig) {
-      return [];
+      return new Set();
     }
-    let result: SkillId[] = [];
-    for (let eventId of [
+    return new Set([
       ...skillsConfig.enabledEventIds,
       ...skillsConfig.disabledEventIds,
-    ]) {
-      let cardDoc;
-      try {
-        cardDoc = this.serializedCardFromFragments(eventId);
-      } catch {
-        // the skill card fragments might not be loaded yet
+    ]);
+  }
+
+  get skills(): Skill[] {
+    let skillsConfig = this.matrixRoom?.skillsConfig;
+    if (!skillsConfig) {
+      return [];
+    }
+    let result: Skill[] = [];
+    for (let skillEventId of this.allSkillEventIds) {
+      let cardId = this._skillEventIdToCardIdCache.get(skillEventId);
+      if (!cardId) {
         continue;
       }
-      if (!cardDoc.data.id) {
+      let skillCard = this._skillCardsCache.get(cardId);
+      if (!skillCard) {
         continue;
       }
-      let cardId = cardDoc.data.id;
-      if (!this._skillCardsCache.has(cardId)) {
-        this.cardService
-          .createFromSerialized(cardDoc.data, cardDoc)
-          .then((skillsCard) => {
-            this._skillCardsCache.set(cardId, skillsCard as SkillCard);
-          });
-      }
       result.push({
-        skillCardId: cardDoc.data.id,
-        skillEventId: eventId,
-        isActive: skillsConfig.enabledEventIds.includes(eventId),
+        card: skillCard,
+        skillEventId,
+        isActive: skillsConfig.enabledEventIds.includes(skillEventId),
       });
     }
     return result;
   }
 
-  @cached
-  get skills(): Skill[] {
-    return this.skillIds
-      .map(({ skillCardId, skillEventId, isActive }) => {
-        let card = this._skillCardsCache.get(skillCardId);
-        if (card) {
-          return {
-            card,
-            skillEventId,
-            isActive,
-          };
-        }
-        return null;
-      })
-      .filter(Boolean) as Skill[];
-  }
-
   @cached
   get created() {
     if (this._createEvent) {
@@ -280,30 +282,6 @@ export class RoomResource extends Resource<Args> {
     }
   });
 
-  private async loadFromEvents(roomId: string) {
-    let index = this._messageCache.size;
-
-    for (let event of this.sortedEvents) {
-      switch (event.type) {
-        case 'm.room.member':
-          await this.loadRoomMemberEvent(roomId, event);
-          break;
-        case 'm.room.message':
-          this.loadRoomMessage({ roomId, event, index });
-          break;
-        case APP_BOXEL_COMMAND_RESULT_EVENT_TYPE:
-          this.updateMessageCommandResult({ roomId, event, index });
-          break;
-        case 'm.room.create':
-          await this.loadRoomCreateEvent(event);
-          break;
-        case 'm.room.name':
-          await this.loadRoomNameEvent(event);
-          break;
-      }
-    }
-  }
-
   private async loadRoomMemberEvent(
     roomId: string,
     event: InviteEvent | JoinEvent | LeaveEvent,
@@ -330,23 +308,6 @@ export class RoomResource extends Resource<Args> {
     roomId: string;
     event: MessageEvent | CommandEvent | CardMessageEvent;
     index: number;
-  }) {
-    if (event.content.msgtype === APP_BOXEL_CARDFRAGMENT_MSGTYPE) {
-      this._fragmentCache.set(event.event_id, event.content);
-      return;
-    }
-
-    this.upsertMessage({ roomId, event, index });
-  }
-
-  private upsertMessage({
-    roomId,
-    event,
-    index,
-  }: {
-    roomId: string;
-    event: MessageEvent | CommandEvent | CardMessageEvent;
-    index: number;
   }) {
     let effectiveEventId = this.getEffectiveEventId(event);
 
@@ -362,6 +323,7 @@ export class RoomResource extends Resource<Args> {
       index,
       serializedCardFromFragments: this.serializedCardFromFragments,
       events: this.events,
+      skills: this.skills,
     });
 
     if (!message) {
@@ -407,6 +369,7 @@ export class RoomResource extends Resource<Args> {
       index,
       serializedCardFromFragments: this.serializedCardFromFragments,
       events: this.events,
+      skills: this.skills,
       commandResultEvent: event,
     });
     messageBuilder.updateMessageCommandResult(message);
@@ -508,6 +471,47 @@ export class RoomResource extends Resource<Args> {
       !this.isDisplayingCode(message),
     );
   }
+
+  private async loadCardFragment(
+    event: CardMessageEvent & {
+      content: { msgtype: typeof APP_BOXEL_CARDFRAGMENT_MSGTYPE };
+    },
+  ) {
+    let eventId = event.event_id;
+    this._fragmentCache.set(eventId, event.content);
+    if (
+      !this.allSkillEventIds.has(eventId) ||
+      this._skillEventIdToCardIdCache.has(eventId)
+    ) {
+      return;
+    }
+    await this.loadSkillCardIntoCache(eventId);
+  }
+
+  private async loadSkillCardIntoCache(eventId: string) {
+    let cardDoc = this.serializedCardFromFragments(eventId);
+    if (!cardDoc.data.id) {
+      console.warn(
+        `No card id found for skill event id ${eventId}, this should not happen, this can happen if you add a skill card to a room without saving it, and without giving it an ID`,
+      );
+      return;
+    }
+    let cardId = cardDoc.data.id;
+    let skillCard = (await this.cardService.createFromSerialized(
+      cardDoc.data,
+      cardDoc,
+    )) as SkillCard;
+    this._skillCardsCache.set(cardId, skillCard);
+    this._skillEventIdToCardIdCache.set(eventId, cardId);
+  }
+
+  private isCardFragmentEvent(
+    event: MessageEvent | CommandEvent | CardMessageEvent,
+  ): event is CardMessageEvent & {
+    content: { msgtype: typeof APP_BOXEL_CARDFRAGMENT_MSGTYPE };
+  } {
+    return event.content.msgtype === APP_BOXEL_CARDFRAGMENT_MSGTYPE;
+  }
 }
 
 export function getRoom(