WIP Update host types for changes to how command requests are encoded

Author: lukemelia

packages/host/app/components/matrix/room-message-command.gts

@@ -74,7 +74,7 @@ export default class RoomMessageCommand extends Component<Signature> {
   };
 
   private get previewCommandCode() {
-    let { name, payload } = this.args.messageCommand;
+    let { name, arguments: payload } = this.args.messageCommand;
     return JSON.stringify({ name, payload }, null, 2);
   }
 

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

@@ -4,12 +4,10 @@ import { getOwner, setOwner } from '@ember/owner';
 
 import { inject as service } from '@ember/service';
 
-import {
-  LooseSingleCardDocument,
-  sanitizeHtml,
-} from '@cardstack/runtime-common';
+import { LooseSingleCardDocument } from '@cardstack/runtime-common';
 
 import {
+  APP_BOXEL_COMMAND_REQUESTS_KEY,
   APP_BOXEL_COMMAND_RESULT_EVENT_TYPE,
   APP_BOXEL_COMMAND_RESULT_WITH_OUTPUT_MSGTYPE,
   APP_BOXEL_MESSAGE_MSGTYPE,
@@ -40,7 +38,7 @@ const ErrorMessage: Record<string, string> = {
 
 export default class MessageBuilder {
   constructor(
-    private event: MessageEvent | CommandEvent | CardMessageEvent,
+    private event: MessageEvent | CardMessageEvent,
     owner: Owner,
     private builderContext: {
       roomId: string;
@@ -127,28 +125,18 @@ export default class MessageBuilder {
     return errorMessage;
   }
 
-  private get formattedMessageForCommand() {
-    return `<p data-test-command-message class="command-message">${sanitizeHtml(
-      this.event.content.formatted_body,
-    )}</p>`;
-  }
-
   buildMessage(): Message {
     let { event } = this;
     let message = this.coreMessageArgs;
     message.errorMessage = this.errorMessage;
     if (event.content.msgtype === APP_BOXEL_MESSAGE_MSGTYPE) {
       message.clientGeneratedId = this.clientGeneratedId;
       message.attachedCardIds = this.attachedCardIds;
+      if (event.content[APP_BOXEL_COMMAND_REQUESTS_KEY]) {
+        message.command = this.buildMessageCommand(message);
+      }
     } else if (event.content.msgtype === 'm.text') {
       message.isStreamingFinished = !!event.content.isStreamingFinished; // Indicates whether streaming (message updating while AI bot is sending more content into the message) has finished
-    } else if (
-      event.content.msgtype === APP_BOXEL_COMMAND_MSGTYPE &&
-      event.content.data.toolCall
-    ) {
-      message.formattedMessage = this.formattedMessageForCommand;
-      message.command = this.buildMessageCommand(message);
-      message.isStreamingFinished = true;
     }
     return message;
   }
@@ -171,17 +159,15 @@ export default class MessageBuilder {
         : undefined;
     message.updated = new Date();
 
-    if (this.event.content.msgtype === APP_BOXEL_COMMAND_MSGTYPE) {
-      if (!message.command) {
+    let commandRequest = (this.event.content as CardMessageContent)[
+      APP_BOXEL_COMMAND_REQUESTS_KEY
+    ]?.[0]; // TODO: handle multiple commands
+    if (commandRequest) {
+      if (message.command) {
+        message.command.commandRequest = commandRequest;
+      } else {
         message.command = this.buildMessageCommand(message);
       }
-
-      message.isStreamingFinished = true;
-      message.formattedMessage = this.formattedMessageForCommand;
-
-      let command = this.event.content.data.toolCall;
-      message.command.name = command.name;
-      message.command.payload = command.arguments;
     }
   }
 
@@ -192,36 +178,38 @@ export default class MessageBuilder {
 
     if (this.builderContext.commandResultEvent) {
       let event = this.builderContext.commandResultEvent;
-      message.command.commandStatus = event.content['m.relates_to']
+      message.command!.commandStatus = event.content['m.relates_to']
         .key as CommandStatus;
-      message.command.commandResultCardEventId =
+      message.command!.commandResultCardEventId =
         event.content.msgtype === APP_BOXEL_COMMAND_RESULT_WITH_OUTPUT_MSGTYPE
           ? event.content.data.cardEventId
           : undefined;
     }
   }
 
   private buildMessageCommand(message: Message) {
-    let event = this.event as CommandEvent;
+    let eventContent = this.event.content as CardMessageContent;
+    let commandRequests = eventContent[APP_BOXEL_COMMAND_REQUESTS_KEY];
+    if (!commandRequests) {
+      return;
+    }
+    let commandRequest = commandRequests[0]; // TODO: handle multiple commands
     let commandResultEvent =
       this.builderContext.commandResultEvent ??
       (this.builderContext.events.find((e: any) => {
         let r = e.content['m.relates_to'];
         return (
           e.type === APP_BOXEL_COMMAND_RESULT_EVENT_TYPE &&
           r.rel_type === 'm.annotation' &&
-          (r.event_id === event!.content.data.eventId ||
-            r.event_id === event!.event_id ||
-            r.event_id === this.builderContext.effectiveEventId)
+          (r.event_id === this.event.event_id ||
+            r.event_id === this.builderContext.effectiveEventId) &&
+          r.data.commandRequestId === commandRequest.id
         );
       }) as CommandResultEvent | undefined);
 
-    let command = event.content.data.toolCall;
     let messageCommand = new MessageCommand(
       message,
-      command.id,
-      command.name,
-      command.arguments,
+      commandRequest,
       this.builderContext.effectiveEventId,
       (commandResultEvent?.content['m.relates_to']?.key ||
         'ready') as CommandStatus,

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

@@ -4,6 +4,8 @@ import { inject as service } from '@ember/service';
 
 import { tracked } from '@glimmer/tracking';
 
+import { CommandRequestContent } from '@cardstack/runtime-common/helpers/ai';
+
 import type CardService from '@cardstack/host/services/card-service';
 import type CommandService from '@cardstack/host/services/command-service';
 import type MatrixService from '@cardstack/host/services/matrix-service';
@@ -15,25 +17,21 @@ import { Message } from './message';
 type CommandStatus = 'applied' | 'ready' | 'applying';
 
 export default class MessageCommand {
-  @tracked name: string;
-  @tracked payload: any;
+  @tracked commandRequest: Partial<CommandRequestContent>;
   @tracked commandStatus?: CommandStatus;
   @tracked commandResultCardEventId?: string;
 
   constructor(
     public message: Message,
-    public toolCallId: string,
-    name: string,
-    payload: any, //arguments of toolCall. Its not called arguments due to lint
+    commandRequest: Partial<CommandRequestContent>,
     public eventId: string,
     commandStatus: CommandStatus,
     commandResultCardEventId: string | undefined,
     owner: Owner,
   ) {
     setOwner(this, owner);
 
-    this.name = name;
-    this.payload = payload;
+    this.commandRequest = commandRequest;
     this.commandStatus = commandStatus;
     this.commandResultCardEventId = commandResultCardEventId;
   }
@@ -42,6 +40,18 @@ export default class MessageCommand {
   @service declare matrixService: MatrixService;
   @service declare cardService: CardService;
 
+  get id() {
+    return this.commandRequest.id;
+  }
+
+  get name() {
+    return this.commandRequest.name;
+  }
+
+  get arguments() {
+    return this.commandRequest.arguments;
+  }
+
   get status() {
     if (
       this.commandService.currentlyExecutingCommandEventIds.has(this.eventId)

packages/host/app/resources/room.ts

@@ -11,14 +11,13 @@ import { type LooseSingleCardDocument } from '@cardstack/runtime-common';
 
 import {
   APP_BOXEL_CARDFRAGMENT_MSGTYPE,
-  APP_BOXEL_COMMAND_MSGTYPE,
+  APP_BOXEL_COMMAND_REQUESTS_KEY,
   APP_BOXEL_COMMAND_RESULT_EVENT_TYPE,
   DEFAULT_LLM,
 } from '@cardstack/runtime-common/matrix-constants';
 
 import type {
   CardFragmentContent,
-  CommandEvent,
   MatrixEvent as DiscreteMatrixEvent,
   RoomCreateEvent,
   RoomNameEvent,
@@ -294,7 +293,7 @@ export class RoomResource extends Resource<Args> {
     index,
   }: {
     roomId: string;
-    event: MessageEvent | CommandEvent | CardMessageEvent;
+    event: MessageEvent | CardMessageEvent;
     index: number;
   }) {
     if (event.content.msgtype === APP_BOXEL_CARDFRAGMENT_MSGTYPE) {
@@ -311,7 +310,7 @@ export class RoomResource extends Resource<Args> {
     index,
   }: {
     roomId: string;
-    event: MessageEvent | CommandEvent | CardMessageEvent;
+    event: MessageEvent | CardMessageEvent;
     index: number;
   }) {
     let effectiveEventId = this.getEffectiveEventId(event);
@@ -351,35 +350,39 @@ export class RoomResource extends Resource<Args> {
     index: number;
   }) {
     let effectiveEventId = this.getEffectiveEventId(event);
-    let commandEvent = this.events.find(
+    let messageEventWithCommand = this.events.find(
       (e: any) =>
         e.type === 'm.room.message' &&
-        e.content.msgtype === APP_BOXEL_COMMAND_MSGTYPE &&
+        e.content[APP_BOXEL_COMMAND_REQUESTS_KEY]?.length &&
         e.content['m.relates_to']?.event_id === effectiveEventId,
-    )! as CommandEvent | undefined;
+    )! as CardMessageEvent | undefined;
     let message = this._messageCache.get(effectiveEventId);
-    if (!message || !commandEvent) {
+    if (!message || !messageEventWithCommand) {
       return;
     }
 
     let author = this.upsertRoomMember({
       roomId,
       userId: event.sender,
     });
-    let messageBuilder = new MessageBuilder(commandEvent, getOwner(this)!, {
-      roomId,
-      effectiveEventId,
-      author,
-      index,
-      serializedCardFromFragments: this.serializedCardFromFragments,
-      events: this.events,
-      commandResultEvent: event,
-    });
+    let messageBuilder = new MessageBuilder(
+      messageEventWithCommand,
+      getOwner(this)!,
+      {
+        roomId,
+        effectiveEventId,
+        author,
+        index,
+        serializedCardFromFragments: this.serializedCardFromFragments,
+        events: this.events,
+        commandResultEvent: event,
+      },
+    );
     messageBuilder.updateMessageCommandResult(message);
   }
 
   private getEffectiveEventId(
-    event: MessageEvent | CommandEvent | CardMessageEvent | CommandResultEvent,
+    event: MessageEvent | CardMessageEvent | CommandResultEvent,
   ) {
     return event.content['m.relates_to']?.rel_type === 'm.replace' ||
       event.content['m.relates_to']?.rel_type === 'm.annotation'

packages/host/app/services/command-service.ts

@@ -104,6 +104,7 @@ export default class CommandService extends Service {
       await this.matrixService.sendCommandResultEvent(
         event.room_id!,
         eventId,
+        toolCall.id,
         resultCard,
       );
     } finally {
@@ -122,14 +123,14 @@ export default class CommandService extends Service {
 
   //TODO: Convert to non-EC async method after fixing CS-6987
   run = task(async (command: MessageCommand) => {
-    let { payload, eventId } = command;
+    let { arguments: payload, eventId, id: toolCallId } = command;
     let resultCard: CardDef | undefined;
     try {
       this.matrixService.failedCommandState.delete(eventId);
       this.currentlyExecutingCommandEventIds.add(eventId);
 
       // lookup command
-      let { command: commandToRun } = this.commands.get(command.name) ?? {};
+      let { command: commandToRun } = this.commands.get(command.name!) ?? {};
 
       if (commandToRun) {
         // Get the input type and validate/construct the payload
@@ -139,8 +140,8 @@ export default class CommandService extends Service {
         let typedInput;
         if (InputType) {
           typedInput = new InputType({
-            ...payload.attributes,
-            ...payload.relationships,
+            ...payload!.attributes,
+            ...payload!.relationships,
           });
         } else {
           typedInput = undefined;
@@ -183,6 +184,7 @@ export default class CommandService extends Service {
       await this.matrixService.sendCommandResultEvent(
         command.message.roomId,
         eventId,
+        toolCallId!,
         resultCard,
       );
     } catch (e) {