Move command requests to card message matrix events and add support for multiple commands per message

packages/ai-bot/.eslintrc.js

@@ -0,0 +1,33 @@
+'use strict';
+
+module.exports = {
+  root: true,
+  parser: '@typescript-eslint/parser',
+  parserOptions: {
+    ecmaVersion: 2020,
+    sourceType: 'module',
+    ecmaFeatures: {
+      legacyDecorators: true,
+    },
+  },
+  plugins: ['ember'],
+  extends: [
+    'eslint:recommended',
+    'plugin:@typescript-eslint/recommended',
+    'plugin:prettier/recommended',
+  ],
+  rules: {
+    // this doesn't work well with the monorepo. Typescript already complains if you try to import something that's not found
+    'import/no-unresolved': 'off',
+    'prefer-const': 'off',
+    '@typescript-eslint/ban-ts-comment': 'off',
+    '@typescript-eslint/ban-types': 'off',
+    '@typescript-eslint/prefer-as-const': 'off',
+    '@typescript-eslint/no-explicit-any': 'off',
+    '@typescript-eslint/no-non-null-assertion': 'off',
+    '@typescript-eslint/no-unused-vars': [
+      'error',
+      { argsIgnorePattern: '^_', varsIgnorePattern: '^_' },
+    ],
+  },
+};

packages/ai-bot/helpers.ts

@@ -3,14 +3,17 @@ import {
   type LooseSingleCardDocument,
   type CardResource,
 } from '@cardstack/runtime-common';
-import { ToolChoice } from '@cardstack/runtime-common/helpers/ai';
+import {
+  CommandRequestContent,
+  ToolChoice,
+} from '@cardstack/runtime-common/helpers/ai';
 import type {
   MatrixEvent as DiscreteMatrixEvent,
   CardFragmentContent,
-  CommandEvent,
   Tool,
   SkillsConfigEvent,
   ActiveLLMEvent,
+  CardMessageEvent,
   CommandResultEvent,
   CommandDefinitionsEvent,
 } from 'https://cardstack.com/base/matrix-event';
@@ -19,14 +22,14 @@ import { ChatCompletionMessageToolCall } from 'openai/resources/chat/completions
 import * as Sentry from '@sentry/node';
 import { logger } from '@cardstack/runtime-common';
 import {
+  APP_BOXEL_COMMAND_REQUESTS_KEY,
   APP_BOXEL_COMMAND_DEFINITIONS_MSGTYPE,
   APP_BOXEL_COMMAND_RESULT_EVENT_TYPE,
   APP_BOXEL_COMMAND_RESULT_WITH_OUTPUT_MSGTYPE,
 } from '../runtime-common/matrix-constants';
 import {
   APP_BOXEL_CARDFRAGMENT_MSGTYPE,
   APP_BOXEL_MESSAGE_MSGTYPE,
-  APP_BOXEL_COMMAND_MSGTYPE,
   APP_BOXEL_ROOM_SKILLS_EVENT_TYPE,
   DEFAULT_LLM,
   APP_BOXEL_ACTIVE_LLM,
@@ -61,13 +64,23 @@ type TextMessage = {
   complete: boolean;
 };
 
-export interface PromptParts {
-  tools: Tool[];
-  messages: OpenAIPromptMessage[];
-  model: string;
-  history: DiscreteMatrixEvent[];
-  toolChoice: ToolChoice;
-}
+export type PromptParts =
+  | {
+      shouldRespond: true;
+      tools: Tool[];
+      messages: OpenAIPromptMessage[];
+      model: string;
+      history: DiscreteMatrixEvent[];
+      toolChoice: ToolChoice;
+    }
+  | {
+      shouldRespond: false;
+      tools: undefined;
+      messages: undefined;
+      model: undefined;
+      history: undefined;
+      toolChoice: undefined;
+    };
 
 export type Message = CommandMessage | TextMessage;
 
@@ -88,12 +101,24 @@ export async function getPromptParts(
     eventList,
     cardFragments,
   );
+  let shouldRespond = getShouldRespond(history);
+  if (!shouldRespond) {
+    return {
+      shouldRespond: false,
+      tools: undefined,
+      messages: undefined,
+      model: undefined,
+      history: undefined,
+      toolChoice: undefined,
+    };
+  }
   let skills = getEnabledSkills(eventList, cardFragments);
   let tools = getTools(history, skills, aiBotUserId);
   let toolChoice = getToolChoice(history, aiBotUserId);
   let messages = await getModifyPrompt(history, aiBotUserId, tools, skills);
   let model = getModel(eventList);
   return {
+    shouldRespond,
     tools,
     messages,
     model,
@@ -172,8 +197,8 @@ export function constructHistory(
     if (event.content.msgtype === APP_BOXEL_MESSAGE_MSGTYPE) {
       let { attachedCardsEventIds } = event.content.data;
       if (attachedCardsEventIds && attachedCardsEventIds.length > 0) {
-        event.content.data.attachedCards = attachedCardsEventIds.map((id) =>
-          serializedCardFromFragments(id, cardFragments),
+        event.content.data.attachedCards = attachedCardsEventIds.map(
+          (id: string) => serializedCardFromFragments(id, cardFragments),
         );
       }
     }
@@ -199,6 +224,30 @@ export function constructHistory(
   return latestEvents;
 }
 
+function getShouldRespond(history: DiscreteMatrixEvent[]): boolean {
+  // If the aibot is awaiting command results, it should not respond yet.
+  let lastEventExcludingCommandResults = history.findLast(
+    (event) => event.type !== APP_BOXEL_COMMAND_RESULT_EVENT_TYPE,
+  );
+  let commandRequests =
+    lastEventExcludingCommandResults.content[APP_BOXEL_COMMAND_REQUESTS_KEY];
+  if (!commandRequests || commandRequests.length === 0) {
+    return true;
+  }
+  let lastEventIndex = history.indexOf(lastEventExcludingCommandResults);
+  let allCommandsHaveResults = commandRequests.every(
+    (commandRequest: CommandRequestContent) => {
+      return history.slice(lastEventIndex).some((event) => {
+        return (
+          event.type === APP_BOXEL_COMMAND_RESULT_EVENT_TYPE &&
+          event.content.data.commandRequestId === commandRequest.id
+        );
+      });
+    },
+  );
+  return allCommandsHaveResults;
+}
+
 function getEnabledSkills(
   eventlist: DiscreteMatrixEvent[],
   cardFragments: Map<string, CardFragmentContent>,
@@ -522,57 +571,69 @@ export function getToolChoice(
   return 'auto';
 }
 
-function getCommandResult(
-  commandEvent: CommandEvent,
+function getCommandResults(
+  cardMessageEvent: CardMessageEvent,
   history: DiscreteMatrixEvent[],
 ) {
-  let commandResultEvent = history.find((e) => {
+  let commandResultEvents = history.filter((e) => {
     if (
       isCommandResultEvent(e) &&
-      e.content['m.relates_to']?.event_id === commandEvent.event_id
+      e.content['m.relates_to']?.event_id === cardMessageEvent.event_id
     ) {
       return true;
     }
     return false;
-  }) as CommandResultEvent | undefined;
-  return commandResultEvent;
+  }) as CommandResultEvent[];
+  return commandResultEvents;
 }
 
-function toToolCall(event: CommandEvent): ChatCompletionMessageToolCall {
-  return {
-    id: event.content.data.toolCall.id,
-    function: {
-      name: event.content.data.toolCall.name,
-      arguments: JSON.stringify(event.content.data.toolCall.arguments),
+function toToolCalls(event: CardMessageEvent): ChatCompletionMessageToolCall[] {
+  return (event.content[APP_BOXEL_COMMAND_REQUESTS_KEY] ?? []).map(
+    (commandRequest: CommandRequestContent) => {
+      return {
+        id: commandRequest.id,
+        function: {
+          name: commandRequest.name,
+          arguments: JSON.stringify(commandRequest.arguments),
+        },
+        type: 'function',
+      };
     },
-    type: 'function',
-  };
+  );
 }
 
-function toPromptMessageWithToolResult(
-  event: CommandEvent,
+function toPromptMessageWithToolResults(
+  event: CardMessageEvent,
   history: DiscreteMatrixEvent[],
-): OpenAIPromptMessage {
-  let commandResult = getCommandResult(event, history);
-  let content = 'pending';
-  if (commandResult) {
-    let status = commandResult.content['m.relates_to']?.key;
-    if (
-      commandResult.content.msgtype ===
-      APP_BOXEL_COMMAND_RESULT_WITH_OUTPUT_MSGTYPE
-    ) {
-      content = `Command ${status}, with result card: ${JSON.stringify(
-        commandResult.content.data.card,
-      )}.\n`;
-    } else {
-      content = `Command ${status}.\n`;
-    }
-  }
-  return {
-    role: 'tool',
-    content,
-    tool_call_id: event.content.data.toolCall.id,
-  };
+): OpenAIPromptMessage[] {
+  let commandResults = getCommandResults(event, history);
+  return (event.content[APP_BOXEL_COMMAND_REQUESTS_KEY] ?? []).map(
+    (commandRequest: CommandRequestContent) => {
+      let content = 'pending';
+      let commandResult = commandResults.find(
+        (commandResult) =>
+          commandResult.content.data.commandRequestId === commandRequest.id,
+      );
+      if (commandResult) {
+        let status = commandResult.content['m.relates_to']?.key;
+        if (
+          commandResult.content.msgtype ===
+          APP_BOXEL_COMMAND_RESULT_WITH_OUTPUT_MSGTYPE
+        ) {
+          content = `Command ${status}, with result card: ${JSON.stringify(
+            commandResult.content.data.card,
+          )}.\n`;
+        } else {
+          content = `Command ${status}.\n`;
+        }
+      }
+      return {
+        role: 'tool',
+        tool_call_id: commandRequest.id,
+        content,
+      };
+    },
+  );
 }
 
 export async function getModifyPrompt(
@@ -605,20 +666,19 @@ export async function getModifyPrompt(
     let body = event.content.body;
     if (body) {
       if (event.sender === aiBotUserId) {
-        if (isCommandEvent(event)) {
-          historicalMessages.push({
-            role: 'assistant',
-            content: body,
-            tool_calls: [toToolCall(event)],
-          });
-          historicalMessages.push(
-            toPromptMessageWithToolResult(event, history),
+        let toolCalls = toToolCalls(event);
+        let historicalMessage: OpenAIPromptMessage = {
+          role: 'assistant',
+          content: body,
+        };
+        if (toolCalls.length) {
+          historicalMessage.tool_calls = toolCalls;
+        }
+        historicalMessages.push(historicalMessage);
+        if (toolCalls.length) {
+          toPromptMessageWithToolResults(event, history).forEach((message) =>
+            historicalMessages.push(message),
           );
-        } else {
-          historicalMessages.push({
-            role: 'assistant',
-            content: body,
-          });
         }
       } else {
         if (
@@ -718,19 +778,6 @@ export const isCommandResultStatusApplied = (event?: MatrixEvent) => {
   );
 };
 
-export function isCommandEvent(
-  event: DiscreteMatrixEvent,
-): event is CommandEvent {
-  return (
-    event.type === 'm.room.message' &&
-    typeof event.content === 'object' &&
-    event.content.msgtype === APP_BOXEL_COMMAND_MSGTYPE &&
-    event.content.format === 'org.matrix.custom.html' &&
-    typeof event.content.data === 'object' &&
-    typeof event.content.data.toolCall === 'object'
-  );
-}
-
 function getModel(eventlist: DiscreteMatrixEvent[]): string {
   let activeLLMEvent = eventlist.findLast(
     (event) => event.type === APP_BOXEL_ACTIVE_LLM,

packages/ai-bot/lib/debug.ts

@@ -1,10 +1,5 @@
 import { setTitle } from './set-title';
-import {
-  sendErrorEvent,
-  sendCommandEvent,
-  sendMessageEvent,
-  MatrixClient,
-} from './matrix';
+import { sendErrorEvent, sendMessageEvent, MatrixClient } from './matrix';
 import OpenAI from 'openai';
 
 import * as Sentry from '@sentry/node';
@@ -62,19 +57,16 @@ export async function handleDebugCommands(
         roomId,
         `Error parsing your debug patch, ${error} ${patchMessage}`,
         undefined,
+        {},
+        [
+          {
+            id: 'patchCard-debug',
+            name: 'patchCard',
+            arguments: toolArguments,
+          },
+        ],
       );
     }
-    return await sendCommandEvent(
-      client,
-      roomId,
-      {
-        id: 'patchCard-debug',
-        name: 'patchCard',
-        type: 'function',
-        arguments: toolArguments,
-      },
-      undefined,
-    );
   }
   return;
 }