Merge pull request #2132 from cardstack/return-of-the-skill-commands

Commands on skill cards

Author: lukemelia

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

@@ -6,6 +6,7 @@ import { inject as service } from '@ember/service';
 
 import {
   LooseSingleCardDocument,
+  ResolvedCodeRef,
   sanitizeHtml,
 } from '@cardstack/runtime-common';
 
@@ -16,12 +17,12 @@ 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';
 
 import type { CommandStatus } from 'https://cardstack.com/base/command';
-
 import { SerializedFile } from 'https://cardstack.com/base/file-api';
 import type {
   CardMessageContent,
@@ -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;
 
@@ -219,11 +217,22 @@ export default class MessageBuilder {
       }) as CommandResultEvent | undefined);
 
     let command = event.content.data.toolCall;
+    // Find command in skills
+    let codeRef: ResolvedCodeRef | undefined;
+    findCommand: for (let skill of this.builderContext.skills) {
+      for (let skillCommand of skill.card.commands) {
+        if (command.name === skillCommand.functionName) {
+          codeRef = skillCommand.codeRef;
+          break findCommand;
+        }
+      }
+    }
     let messageCommand = new MessageCommand(
       message,
       command.id,
       command.name,
       command.arguments,
+      codeRef,
       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 { ResolvedCodeRef } from '@cardstack/runtime-common';
+
 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';
@@ -25,6 +27,7 @@ export default class MessageCommand {
     public toolCallId: string,
     name: string,
     payload: any, //arguments of toolCall. Its not called arguments due to lint
+    public codeRef: ResolvedCodeRef | undefined,
     public eventId: string,
     commandStatus: CommandStatus,
     commandResultCardEventId: string | undefined,

packages/host/app/resources/room.ts

@@ -12,6 +12,7 @@ import { type LooseSingleCardDocument } from '@cardstack/runtime-common';
 import {
   APP_BOXEL_CARDFRAGMENT_MSGTYPE,
   APP_BOXEL_COMMAND_MSGTYPE,
+  APP_BOXEL_COMMAND_DEFINITIONS_MSGTYPE,
   APP_BOXEL_COMMAND_RESULT_EVENT_TYPE,
   DEFAULT_LLM,
 } from '@cardstack/runtime-common/matrix-constants';
@@ -31,9 +32,8 @@ import type {
   CommandResultEvent,
 } from 'https://cardstack.com/base/matrix-event';
 
-import { SkillCard } from 'https://cardstack.com/base/skill-card';
+import type { SkillCard } from 'https://cardstack.com/base/skill-card';
 
-import { Skill } from '../components/ai-assistant/skill-menu';
 import {
   RoomMember,
   type RoomMemberInterface,
@@ -42,6 +42,8 @@ import { Message } from '../lib/matrix-classes/message';
 
 import MessageBuilder from '../lib/matrix-classes/message-builder';
 
+import type { Skill } from '../components/ai-assistant/skill-menu';
+
 import type Room from '../lib/matrix-classes/room';
 
 import type CardService from '../services/card-service';
@@ -57,9 +59,9 @@ interface Args {
 
 export class RoomResource extends Resource<Args> {
   private _messageCache: TrackedMap<string, Message> = new TrackedMap();
-  private _skillCardsCache: TrackedMap<string, SkillCard> = new TrackedMap();
   private _skillEventIdToCardIdCache: TrackedMap<string, string> =
     new TrackedMap();
+  private _skillCardsCache: TrackedMap<string, SkillCard> = new TrackedMap();
   private _nameEventsCache: TrackedMap<string, RoomNameEvent> =
     new TrackedMap();
   @tracked private _createEvent: RoomCreateEvent | undefined;
@@ -112,6 +114,8 @@ export class RoomResource extends Resource<Args> {
           case 'm.room.message':
             if (this.isCardFragmentEvent(event)) {
               await this.loadCardFragment(event);
+            } else if (this.isCommandDefinitionsEvent(event)) {
+              break;
             } else {
               await this.loadRoomMessage({
                 roomId,
@@ -224,6 +228,17 @@ export class RoomResource extends Resource<Args> {
     return result;
   }
 
+  get commands() {
+    // Usable commands are all commands on *active* skills
+    let commands = [];
+    for (let skill of this.skills) {
+      if (skill.isActive) {
+        commands.push(...skill.card.commands);
+      }
+    }
+    return commands;
+  }
+
   @cached
   get created() {
     if (this._createEvent) {
@@ -302,6 +317,16 @@ export class RoomResource extends Resource<Args> {
     });
   }
 
+  private isCommandDefinitionsEvent(
+    event:
+      | MessageEvent
+      | CommandEvent
+      | CardMessageEvent
+      | CommandDefinitionsEvent,
+  ): event is CommandDefinitionsEvent {
+    return event.content.msgtype === APP_BOXEL_COMMAND_DEFINITIONS_MSGTYPE;
+  }
+
   private isCardFragmentEvent(
     event:
       | MessageEvent
@@ -374,6 +399,7 @@ export class RoomResource extends Resource<Args> {
       index,
       serializedCardFromFragments: this.serializedCardFromFragments,
       events: this.events,
+      skills: this.skills,
     });
 
     if (!message) {
@@ -420,6 +446,7 @@ export class RoomResource extends Resource<Args> {
       index,
       serializedCardFromFragments: this.serializedCardFromFragments,
       events: this.events,
+      skills: this.skills,
       commandResultEvent: event,
     });
     messageBuilder.updateMessageCommandResult(message);

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

@@ -16,6 +16,7 @@ import {
   CommandContextStamp,
   ResolvedCodeRef,
   isResolvedCodeRef,
+  getClass,
 } from '@cardstack/runtime-common';
 
 import type MatrixService from '@cardstack/host/services/matrix-service';
@@ -130,6 +131,19 @@ export default class CommandService extends Service {
 
       // lookup command
       let { command: commandToRun } = this.commands.get(command.name) ?? {};
+      // If we don't find it in the one-offs, start searching for
+      // one in the skills we can construct
+      if (!commandToRun) {
+        // here we can get the coderef from the messagecommand
+        let commandCodeRef = command.codeRef;
+        if (commandCodeRef) {
+          let CommandConstructor = (await getClass(
+            commandCodeRef,
+            this.loaderService.loader,
+          )) as { new (context: CommandContext): Command<any, any> };
+          commandToRun = new CommandConstructor(this.commandContext);
+        }
+      }
 
       if (commandToRun) {
         // Get the input type and validate/construct the payload

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

@@ -27,6 +27,7 @@ import {
   LooseCardResource,
   ResolvedCodeRef,
   aiBotUsername,
+  getClass,
 } from '@cardstack/runtime-common';
 
 import {
@@ -42,6 +43,7 @@ import {
   APP_BOXEL_CARD_FORMAT,
   APP_BOXEL_CARDFRAGMENT_MSGTYPE,
   APP_BOXEL_COMMAND_MSGTYPE,
+  APP_BOXEL_COMMAND_DEFINITIONS_MSGTYPE,
   APP_BOXEL_COMMAND_RESULT_EVENT_TYPE,
   APP_BOXEL_COMMAND_RESULT_WITH_NO_OUTPUT_MSGTYPE,
   APP_BOXEL_COMMAND_RESULT_WITH_OUTPUT_MSGTYPE,
@@ -73,10 +75,11 @@ import type {
   MatrixEvent as DiscreteMatrixEvent,
   CommandResultWithNoOutputContent,
   CommandResultWithOutputContent,
+  CommandDefinitionsContent,
 } from 'https://cardstack.com/base/matrix-event';
 
 import type { Tool } from 'https://cardstack.com/base/matrix-event';
-import { SkillCard } from 'https://cardstack.com/base/skill-card';
+import { CommandField, SkillCard } from 'https://cardstack.com/base/skill-card';
 
 import AddSkillsToRoomCommand from '../commands/add-skills-to-room';
 import { importResource } from '../resources/import';
@@ -513,7 +516,8 @@ export default class MatrixService extends Service {
       | CardMessageContent
       | CardFragmentContent
       | CommandResultWithNoOutputContent
-      | CommandResultWithOutputContent,
+      | CommandResultWithOutputContent
+      | CommandDefinitionsContent,
   ) {
     let roomData = await this.ensureRoomData(roomId);
     return roomData.mutex.dispatch(async () => {
@@ -578,11 +582,61 @@ export default class MatrixService extends Service {
     }
   }
 
+  async addCommandDefinitionsToRoomHistory(
+    commandDefinitions: CommandField[],
+    roomId: string,
+  ) {
+    // Create the command defs so getting the json schema
+    // and send it to the matrix room.
+    let commandDefinitionSchemas: {
+      codeRef: ResolvedCodeRef;
+      tool: Tool;
+    }[] = [];
+    const mappings = await basicMappings(this.loaderService.loader);
+    for (let commandDef of commandDefinitions) {
+      const Command = await getClass(
+        commandDef.codeRef,
+        this.loaderService.loader,
+      );
+      const command = new Command(this.commandService.commandContext);
+      const name = commandDef.functionName;
+      commandDefinitionSchemas.push({
+        codeRef: commandDef.codeRef,
+        tool: {
+          type: 'function',
+          function: {
+            name,
+            description: command.description,
+            parameters: {
+              type: 'object',
+              properties: {
+                description: {
+                  type: 'string',
+                },
+                ...(await command.getInputJsonSchema(this.cardAPI, mappings)),
+              },
+              required: ['attributes', 'description'],
+            },
+          },
+        },
+      });
+    }
+    await this.sendEvent(roomId, 'm.room.message', {
+      msgtype: APP_BOXEL_COMMAND_DEFINITIONS_MSGTYPE,
+      body: 'Command Definitions',
+      data: {
+        commandDefinitions: commandDefinitionSchemas,
+      },
+    });
+  }
+
   async addSkillCardsToRoomHistory(
     skills: SkillCard[],
     roomId: string,
     opts?: CardAPI.SerializeOpts,
   ): Promise<string[]> {
+    const commandDefinitions = skills.flatMap((skill) => skill.commands);
+    await this.addCommandDefinitionsToRoomHistory(commandDefinitions, roomId);
     return this.addCardsToRoom(skills, roomId, this.skillCardHashes, opts);
   }