Commands on skill cards

packages/ai-bot/helpers.ts

@@ -12,12 +12,14 @@
   SkillsConfigEvent,
   ActiveLLMEvent,
   CommandResultEvent,
+  CommandDefinitionsEvent,
 } from 'https://cardstack.com/base/matrix-event';
 import { MatrixEvent, type IRoomEvent } from 'matrix-js-sdk';
 import { ChatCompletionMessageToolCall } from 'openai/resources/chat/completions';
 import * as Sentry from '@sentry/node';
 import { logger } from '@cardstack/runtime-common';
 import {
+  APP_BOXEL_COMMAND_DEFINITIONS_MSGTYPE,
   APP_BOXEL_COMMAND_RESULT_EVENT_TYPE,
   APP_BOXEL_COMMAND_RESULT_WITH_OUTPUT_MSGTYPE,
 } from '../runtime-common/matrix-constants';
@@ -29,6 +31,7 @@
   DEFAULT_LLM,
   APP_BOXEL_ACTIVE_LLM,
 } from '@cardstack/runtime-common/matrix-constants';
+import { SkillCard } from '../base/skill-card';
 
 let log = logger('ai-bot');
 
@@ -86,7 +89,7 @@
     cardFragments,
   );
   let skills = getEnabledSkills(eventList, cardFragments);
-  let tools = getTools(history, aiBotUserId);
+  let tools = getTools(history, skills, aiBotUserId);
   let toolChoice = getToolChoice(history, aiBotUserId);
   let messages = getModifyPrompt(history, aiBotUserId, tools, skills);
   let model = getModel(eventList);
@@ -322,10 +325,46 @@
 
 export function getTools(
   history: DiscreteMatrixEvent[],
+  enabledSkills: LooseCardResource[],
   aiBotUserId: string,
 ): Tool[] {
   // Build map directly from messages
+  let enabledCommandNames = new Set<string>();
   let toolMap = new Map<string, Tool>();
+
+  // Get the list of all names from enabled skills
+  for (let skill of enabledSkills) {
+    if (skill.attributes?.commands) {
+      let { commands } = skill.attributes;
+      for (let command of commands) {
+        enabledCommandNames.add(command.functionName);
+      }
+    }
+  }
+
+  // Iterate over the command definitions, and add any tools that are in
+  // enabled skills to the tool map
+  let commandDefinitionEvents: CommandDefinitionsEvent[] = history.filter(
+    (event) =>
+      event.type === 'm.room.message' &&
+      event.content.msgtype === APP_BOXEL_COMMAND_DEFINITIONS_MSGTYPE,
+  ) as CommandDefinitionsEvent[];
+
+  for (let event of commandDefinitionEvents) {
+    let { content } = event;
+    let { commandDefinitions } = content.data;
+    console.log('commands', commandDefinitions);
+    for (let commandDefinition of commandDefinitions) {
+      if (enabledCommandNames.has(commandDefinition.tool.function.name)) {
+        toolMap.set(
+          commandDefinition.tool.function.name,
+          commandDefinition.tool,
+        );
+      }
+    }
+  }
+
+  // Add in tools from the user's messages
   for (let event of history) {
     if (event.type !== 'm.room.message' || event.sender == aiBotUserId) {
       continue;
@@ -608,7 +647,10 @@
 export function eventRequiresResponse(event: MatrixEvent) {
   // If it's a message, we should respond unless it's a card fragment
   if (event.getType() === 'm.room.message') {
-    if (event.getContent().msgtype === APP_BOXEL_CARDFRAGMENT_MSGTYPE) {
+    if (
+      event.getContent().msgtype === APP_BOXEL_CARDFRAGMENT_MSGTYPE ||
+      event.getContent().msgtype === APP_BOXEL_COMMAND_DEFINITIONS_MSGTYPE
+    ) {
       return false;
     }
     return true;

packages/base/matrix-event.gts

@@ -15,6 +15,7 @@ import {
   APP_BOXEL_MESSAGE_MSGTYPE,
   APP_BOXEL_ROOM_SKILLS_EVENT_TYPE,
   APP_BOXEL_ACTIVE_LLM,
+  APP_BOXEL_COMMAND_DEFINITIONS_MSGTYPE,
 } from '@cardstack/runtime-common/matrix-constants';
 
 interface BaseMatrixEvent {
@@ -160,6 +161,17 @@ export interface CardMessageEvent extends BaseMatrixEvent {
   };
 }
 
+export interface CommandDefinitionsEvent extends BaseMatrixEvent {
+  type: 'm.room.message';
+  content: CommandDefinitionsContent;
+  unsigned: {
+    age: number;
+    transaction_id: string;
+    prev_content?: any;
+    prev_sender?: string;
+  };
+}
+
 export interface Tool {
   type: 'function';
   function: {
@@ -246,6 +258,19 @@ export interface CommandResultEvent extends BaseMatrixEvent {
   };
 }
 
+export interface CommandDefinitionsContent {
+  msgtype: typeof APP_BOXEL_COMMAND_DEFINITIONS_MSGTYPE;
+  body: string;
+  data: {
+    commandDefinitions: {
+      codeRef: {
+        module: string;
+        name: string;
+      };
+      tool: Tool;
+    }[];
+  };
+}
 export interface CommandResultWithOutputContent {
   'm.relates_to': {
     rel_type: 'm.annotation';
@@ -276,6 +301,7 @@ export type MatrixEvent =
   | MessageEvent
   | CommandEvent
   | CommandResultEvent
+  | CommandDefinitionsEvent
   | CardMessageEvent
   | RoomNameEvent
   | RoomTopicEvent

packages/base/skill-card.gts

@@ -1,11 +1,56 @@
+import BooleanField from './boolean';
+import CodeRefField from './code-ref';
 import MarkdownField from './markdown';
-import { CardDef, Component, field, contains } from './card-api';
+import StringField from './string';
+import {
+  CardDef,
+  Component,
+  field,
+  FieldDef,
+  contains,
+  containsMany,
+} from './card-api';
 import RobotIcon from '@cardstack/boxel-icons/robot';
 
+export class CommandField extends FieldDef {
+  static displayName = 'CommandField';
+  @field codeRef = contains(CodeRefField, {
+    description: 'An absolute code reference to the command to be executed',
+  });
+  @field requiresApproval = contains(BooleanField, {
+    description:
+      'If true, this command will require human approval before it is executed in the host.',
+  });
+
+  @field functionName = contains(StringField, {
+    description: 'The name of the function to be executed',
+    computeVia: function (this: CommandField) {
+      if (!this.codeRef?.module || !this.codeRef?.name) {
+        return '';
+      }
+
+      // Simple hash function that works in all environments
+      const djb2 = (str: string): string => {
+        let hash = 5381;
+        for (let i = 0; i < str.length; i++) {
+          const char = str.charCodeAt(i);
+          hash = (hash << 5) - hash + char;
+          hash = hash & hash; // Convert to 32-bit integer
+        }
+        return Math.abs(hash).toString(16).slice(0, 4);
+      };
+
+      const input = `${this.codeRef.module}#${this.codeRef.name}`;
+      return `${this.codeRef.name}_${djb2(input)}`;
+    },
+  });
+}
+
 export class SkillCard extends CardDef {
   static displayName = 'Skill';
   static icon = RobotIcon;
   @field instructions = contains(MarkdownField);
+  @field commands = containsMany(CommandField);
   static embedded = class Embedded extends Component<typeof this> {
     <template>
       <@fields.title />

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

@@ -73,6 +73,21 @@ export default class MessageCommand {
     }
   }
 
+  async getCommandCodeRef() {
+    let roomResource = this.matrixService.roomResources.get(
+      this.message.roomId,
+    );
+    if (!roomResource) {
+      return undefined;
+    }
+    // We need to wait for the skills to actually be loaded
+    await roomResource.waitForAllSkills();
+    let commandDefinition = roomResource.commands.find(
+      (command) => command.functionName === this.name,
+    );
+    return commandDefinition?.codeRef;
+  }
+
   async getCommandResultCard(): Promise<CardDef | undefined> {
     let cardDoc = this.commandResultCardDoc;
     if (!cardDoc) {

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';
@@ -28,6 +29,7 @@ import type {
   CardMessageEvent,
   MessageEvent,
   CommandResultEvent,
+  CommandDefinitionsEvent,
 } from 'https://cardstack.com/base/matrix-event';
 
 import { SkillCard } from 'https://cardstack.com/base/skill-card';
@@ -51,6 +53,7 @@ interface SkillId {
   skillCardId: string;
   skillEventId: string;
   isActive: boolean;
+  loadingPromise?: Promise<void>;
 }
 
 interface Args {
@@ -167,8 +170,9 @@ export class RoomResource extends Resource<Args> {
         continue;
       }
       let cardId = cardDoc.data.id;
+      let loadingPromise;
       if (!this._skillCardsCache.has(cardId)) {
-        this.cardService
+        loadingPromise = this.cardService
           .createFromSerialized(cardDoc.data, cardDoc)
           .then((skillsCard) => {
             this._skillCardsCache.set(cardId, skillsCard as SkillCard);
@@ -178,6 +182,7 @@ export class RoomResource extends Resource<Args> {
         skillCardId: cardDoc.data.id,
         skillEventId: eventId,
         isActive: skillsConfig.enabledEventIds.includes(eventId),
+        loadingPromise,
       });
     }
     return result;
@@ -199,6 +204,24 @@ export class RoomResource extends Resource<Args> {
       .filter(Boolean) as Skill[];
   }
 
+  async waitForAllSkills() {
+    let skillCardLoadingPromises = this.skillIds
+      .map(({ loadingPromise }) => loadingPromise)
+      .filter(Boolean);
+    await Promise.all(skillCardLoadingPromises);
+  }
+
+  get commands() {
+    // get all the skills
+    let commands = [];
+    for (let skill of this.skills) {
+      if (skill.isActive) {
+        commands.push(...skill.card.commands);
+      }
+    }
+    return commands;
+  }
+
   get roomId() {
     return this._previousRoomId;
   }
@@ -288,19 +311,37 @@ 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 loadRoomMessage({
     roomId,
     event,
     index,
   }: {
     roomId: string;
-    event: MessageEvent | CommandEvent | CardMessageEvent;
+    event:
+      | MessageEvent
+      | CommandEvent
+      | CardMessageEvent
+      | CommandDefinitionsEvent;
     index: number;
   }) {
     if (event.content.msgtype === APP_BOXEL_CARDFRAGMENT_MSGTYPE) {
       this._fragmentCache.set(event.event_id, event.content);
       return;
     }
+    if (this.isCommandDefinitionsEvent(event)) {
+      // We don't want to show this to the user
+      return;
+    }
 
     this.upsertMessage({ roomId, event, index });
   }

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 = await command.getCommandCodeRef();
+        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