@statelyai/agent 0.0.1 → 0.0.3

package/examples/joke.ts

@@ -1,185 +1,214 @@
 import OpenAI from 'openai';
-import { assign, fromPromise, createActor, waitFor, setup } from 'xstate';
-import { fromEventChoice } from '../src/index';
+import {
+  assign,
+  createActor,
+  fromCallback,
+  fromPromise,
+  log,
+  setup,
+} from 'xstate';
+import { createAgent } from '../src';
+import { loadingAnimation } from './helpers/loader';
 
 const openai = new OpenAI({
   apiKey: process.env.OPENAI_API_KEY,
 });
 
-async function start() {
-  const promptTemplate = (topic: string) => `Tell me a joke about ${topic}.`;
-
-  const getJokeCompletion = fromPromise(
-    async ({ input }: { input: { topic: string } }) => {
-      const res = await openai.chat.completions.create({
-        messages: [
-          {
-            role: 'user',
-            content: promptTemplate(input.topic),
-          },
-        ],
-        model: 'gpt-3.5-turbo',
-        n: 1,
-      });
+const agent = createAgent(openai, {
+  model: 'gpt-3.5-turbo-1106',
+  context: {
+    topic: { type: 'string' },
+    jokes: {
+      type: 'array',
+      items: {
+        type: 'string',
+      },
+      desire: { type: ['string', 'null'] },
+      lastRating: { type: ['string', 'null'] },
+    },
+  },
+  events: {},
+});
 
-      return res.choices[0]?.message.content;
-    }
-  );
+const getJokeCompletion = agent.fromChatCompletion(
+  (topic: string) => `Tell me a joke about ${topic}.`
+);
+
+const rateJoke = agent.fromChatCompletion(
+  (joke: string) => `Rate this joke on a scale of 1 to 10: ${joke}`
+);
+
+const getTopic = fromPromise(async () => {
+  const topic = await new Promise<string>((res) => {
+    console.log('Give me a joke topic:');
+    const listener = (data: Buffer) => {
+      const result = data.toString().trim();
+      process.stdin.off('data', listener);
+      res(result);
+    };
+    process.stdin.on('data', listener);
+  });
 
-  const rateJoke = fromPromise(
-    async ({ input }: { input: { joke: string } }) => {
-      const res = await openai.chat.completions.create({
-        messages: [
-          {
-            role: 'user',
-            content: `Rate this joke on a scale of 1 to 10: ${input.joke}`,
-          },
-        ],
-        model: 'gpt-3.5-turbo',
-        n: 1,
-      });
+  return topic;
+});
 
-      return res.choices[0]?.message.content;
-    }
-  );
+const decide = agent.fromEvent(
+  (lastRating: string) =>
+    `Choose what to do next, given the previous rating of the joke: ${lastRating}`
+);
+export function getRandomFunnyPhrase() {
+  const funnyPhrases = [
+    'Concocting chuckles...',
+    'Brewing belly laughs...',
+    'Fabricating funnies...',
+    'Assembling amusement...',
+    'Molding merriment...',
+    'Whipping up wisecracks...',
+    'Generating guffaws...',
+    'Inventing hilarity...',
+    'Cultivating chortles...',
+    'Hatching howlers...',
+  ];
+  return funnyPhrases[Math.floor(Math.random() * funnyPhrases.length)]!;
+}
 
-  const getTopic = fromPromise(async () => {
-    const topic = await new Promise<string>((res) => {
-      console.log('Give me a topic: \n\n');
-      process.stdin.on('data', (data) => {
-        const eventType = data.toString().trim();
-        res(eventType);
-      });
-    });
+export function getRandomRatingPhrase() {
+  const ratingPhrases = [
+    'Assessing amusement...',
+    'Evaluating hilarity...',
+    'Ranking chuckles...',
+    'Classifying cackles...',
+    'Scoring snickers...',
+    'Rating roars...',
+    'Judging jollity...',
+    'Measuring merriment...',
+    'Rating rib-ticklers...',
+  ];
+  return ratingPhrases[Math.floor(Math.random() * ratingPhrases.length)]!;
+}
 
-    return topic;
-  });
+const loader = fromCallback(({ input }: { input: string }) => {
+  const anim = loadingAnimation(input);
 
-  const chain = setup({
-    types: {
-      context: {} as {
-        topic: string;
-        jokes: string[];
-        desire: string | null;
-        lastRating: string | null;
-      },
-      input: {} as { topic: string },
-    },
-    actors: {
-      getJokeCompletion,
-      getTopic,
-      rateJoke,
-      decide: fromEventChoice(openai, (desire: string) => ({
-        model: 'gpt-4-1106-preview',
-        messages: [
-          {
-            role: 'user',
-            content: `Execute the function that best satisfies this desire:
+  return () => {
+    anim.stop();
+  };
+});
 
-${desire}
-`,
-          },
-        ],
-      })),
+const jokeMachine = setup({
+  types: {
+    context: {} as {
+      topic: string;
+      jokes: string[];
+      desire: string | null;
+      lastRating: string | null;
     },
-  }).createMachine({
-    context: ({ input }) => ({
-      topic: input.topic,
-      jokes: [],
-      desire: null,
-      lastRating: null,
-    }),
-    initial: 'waitingForTopic',
-    states: {
-      waitingForTopic: {
-        invoke: {
-          src: 'getTopic',
-          onDone: {
-            actions: assign({
-              topic: ({ event }) => event.output,
-            }),
-            target: 'tellingJoke',
-          },
+    input: {} as { topic: string },
+  },
+  actors: {
+    getJokeCompletion,
+    getTopic,
+    rateJoke,
+    decide,
+    loader,
+  },
+}).createMachine({
+  context: () => ({
+    topic: '',
+    jokes: [],
+    desire: null,
+    lastRating: null,
+    loader: null,
+  }),
+  initial: 'waitingForTopic',
+  states: {
+    waitingForTopic: {
+      invoke: {
+        src: 'getTopic',
+        onDone: {
+          actions: assign({
+            topic: ({ event }) => event.output,
+          }),
+          target: 'tellingJoke',
         },
       },
-      tellingJoke: {
-        invoke: {
+    },
+    tellingJoke: {
+      invoke: [
+        {
           src: 'getJokeCompletion',
-          input: ({ context }) => ({ topic: context.topic }),
+          input: ({ context }) => context.topic,
           onDone: {
-            actions: assign({
-              jokes: ({ context, event }) =>
-                context.jokes.concat(event.output as string),
-            }),
+            actions: [
+              assign({
+                jokes: ({ context, event }) =>
+                  context.jokes.concat(
+                    event.output.choices[0]!.message.content!
+                  ),
+              }),
+              log((x) => x.context.jokes.at(-1)),
+            ],
             target: 'rateJoke',
           },
         },
-      },
-      rateJoke: {
-        invoke: {
-          src: 'rateJoke',
-          input: ({ context }) => ({
-            joke: context.jokes[context.jokes.length - 1]!,
-          }),
-          onDone: {
-            actions: assign({
-              lastRating: ({ event }) => event.output as string,
-            }),
-            target: 'joked',
-          },
+        {
+          src: 'loader',
+          input: getRandomFunnyPhrase,
         },
-      },
-      joked: {
-        invoke: {
-          src: 'getTopic',
+      ],
+    },
+    rateJoke: {
+      invoke: [
+        {
+          src: 'rateJoke',
+          input: ({ context }) => context.jokes[context.jokes.length - 1]!,
           onDone: {
-            actions: assign({
-              desire: ({ event }) => event.output,
-            }),
+            actions: [
+              assign({
+                lastRating: ({ event }) =>
+                  event.output.choices[0]!.message.content!,
+              }),
+              log(({ context }) => context.lastRating),
+            ],
             target: 'decide',
           },
         },
+        {
+          src: 'loader',
+          input: getRandomRatingPhrase,
+        },
+      ],
+    },
+    decide: {
+      invoke: {
+        src: 'decide',
+        input: ({ context }) => context.lastRating!,
+        onDone: {
+          actions: log(({ event }) => event),
+        },
       },
-      decide: {
-        invoke: {
-          src: 'decide',
-          input: ({ context }) => context.desire!,
+      on: {
+        askForTopic: {
+          target: 'waitingForTopic',
+          actions: log("That joke wasn't good enough. Let's try again."),
+          description:
+            'Ask for a new topic, because the last joke rated 6 or lower',
         },
-        on: {
-          askForTopic: {
-            target: 'waitingForTopic',
-            description:
-              'Ask for a new topic, because the last joke was almost perfect',
-          },
-          endJokes: {
-            target: 'end',
-            description: 'End the jokes, since the last joke was not too good',
-          },
+        endJokes: {
+          target: 'end',
+          actions: log('That joke was good enough. Goodbye!'),
+          description: 'End the jokes, since the last joke rated 7 or higher',
         },
       },
-      end: {},
     },
-  });
-
-  const actor = createActor(chain, {
-    input: {
-      topic: 'donuts',
+    end: {
+      type: 'final',
     },
-  });
-
-  actor.subscribe((st) => {
-    console.log('State: ', st.value);
-
-    if (st.context.jokes) {
-      console.log('Joke: ', st.context.jokes[st.context.jokes.length - 1]);
-    }
-  });
-
-  actor.start();
-
-  await waitFor(actor, (snap) => snap.status === 'done', {
-    timeout: Infinity,
-  });
-}
+  },
+  exit: () => {
+    process.exit();
+  },
+});
 
-start();
+const actor = createActor(jokeMachine);
+actor.start();

package/examples/ticTacToe.ts

@@ -1,6 +1,6 @@
-import { assign, setup, assertEvent, createActor, raise } from 'xstate';
-import { fromChatCompletionStream, fromEventChoice } from '../src/openai';
+import { assign, setup, assertEvent, createActor } from 'xstate';
 import OpenAI from 'openai';
+import { createAgent } from '../src/openai';
 
 const openai = new OpenAI({
   apiKey: process.env.OPENAI_API_KEY,
@@ -8,64 +8,126 @@ const openai = new OpenAI({
 
 type Player = 'x' | 'o';
 
+const agent = createAgent(openai, {
+  model: 'gpt-4-1106-preview',
+  context: {
+    board: {
+      type: 'array',
+      items: {
+        type: ['null', 'string'],
+        enum: [null, 'x', 'o'],
+      },
+      minItems: 9,
+      maxItems: 9,
+      description: 'The board of the tic-tac-toe game',
+    },
+    moves: {
+      type: 'number',
+      description: 'The number of moves that have been played',
+    },
+    player: {
+      type: 'string',
+      enum: ['x', 'o'],
+      description: 'The player whose turn it is',
+    },
+    gameReport: {
+      type: 'string',
+      description: 'The game report',
+    },
+    events: {
+      type: 'array',
+      items: {
+        type: 'string',
+      },
+    },
+  } as const,
+  events: {
+    'x.play': {
+      properties: {
+        index: {
+          description: 'The index of the cell to play on',
+          type: 'number',
+
+          minimum: 0,
+          maximum: 8,
+        },
+      },
+    },
+    'o.play': {
+      properties: {
+        index: {
+          description: 'The index of the cell to play on',
+          type: 'number',
+          minimum: 0,
+          maximum: 8,
+        },
+      },
+    },
+    reset: {
+      properties: {},
+    },
+  },
+});
+
 const initialContext = {
   board: Array(9).fill(null) as Array<Player | null>,
   moves: 0,
   player: 'x' as Player,
-  winner: undefined as Player | undefined,
   gameReport: '',
-};
+  events: [],
+} satisfies typeof agent.types.context;
+
+const bot = agent.fromEvent(
+  ({ context }: { context: typeof agent.types.context }) => `
+You are playing a game of tic tac toe. This is the current game state. The 3x3 board is represented by a 9-element array. The first element is the top-left cell, the second element is the top-middle cell, the third element is the top-right cell, the fourth element is the middle-left cell, and so on. The value of each cell is either null, x, or o. The value of null means that the cell is empty. The value of x means that the cell is occupied by an x. The value of o means that the cell is occupied by an o.
+
+${JSON.stringify(context, null, 2)}
+
+Execute the single best next move to try to win the game. Do not play on an existing cell.`
+);
+
+const gameReporter = agent.fromChatCompletionStream(
+  ({
+    context,
+  }: {
+    context: typeof agent.types.context;
+  }) => `Here is the game board:
 
-export const ticTacToeMachine = setup({
-  types: {} as {
-    context: typeof initialContext;
-    events:
-      | { type: 'x.play'; index: number }
-      | {
-          type: 'o.play';
-          index: number;
-        }
-      | { type: 'RESET' };
-  },
-  actors: {
-    bot: fromEventChoice(
-      openai,
-      ({ context }: { context: typeof initialContext }) => ({
-        model: 'gpt-4-1106-preview',
-        messages: [
-          {
-            role: 'system',
-            content: `You are playing a game of tic tac toe. This is the current game state. The 3x3 board is represented by a 9-element array. The first element is the top-left cell, the second element is the top-middle cell, the third element is the top-right cell, the fourth element is the middle-left cell, and so on. The value of each cell is either null, x, or o. The value of null means that the cell is empty. The value of x means that the cell is occupied by an x. The value of o means that the cell is occupied by an o.
-
-${JSON.stringify(context, null, 2)}`,
-          },
-          {
-            role: 'user',
-            content:
-              'Execute the single best next move to try to win the game. Do not play on an existing cell.',
-          },
-        ],
-      })
-    ),
-    gameReporter: fromChatCompletionStream(
-      openai,
-      ({ context }: { context: typeof initialContext }) => ({
-        model: 'gpt-4-1106-preview',
-        messages: [
-          {
-            role: 'user',
-            content: `The tic-tac-toe game is over. The winner is ${
-              context.winner ?? 'nobody'
-            }. This was the ending board state:
-          
 ${JSON.stringify(context.board, null, 2)}
 
-Provide a game report analyzing the game.`,
-          },
-        ],
-        stream: true,
-      })
-    ),
+And here are the events that led to this game state:
+
+${context.events.join('\n')}
+
+The winner is ${getWinner(context.board)}.
+
+Provide a very short game report analyzing the game.`
+);
+
+function getWinner(board: typeof initialContext.board): Player | null {
+  const lines = [
+    [0, 1, 2],
+    [3, 4, 5],
+    [6, 7, 8],
+    [0, 3, 6],
+    [1, 4, 7],
+    [2, 5, 8],
+    [0, 4, 8],
+    [2, 4, 6],
+  ] as const;
+  for (const [a, b, c] of lines) {
+    if (board[a] !== null && board[a] === board[b] && board[a] === board[c]) {
+      return board[a]!;
+    }
+  }
+  return null;
+}
+
+export const ticTacToeMachine = setup({
+  types: agent.types,
+  actors: {
+    bot,
+    gameReporter,
   },
   actions: {
     updateBoard: assign({
@@ -77,45 +139,22 @@ Provide a game report analyzing the game.`,
       },
       moves: ({ context }) => context.moves + 1,
       player: ({ context }) => (context.player === 'x' ? 'o' : 'x'),
+      events: ({ context, event }) => {
+        return [...context.events, JSON.stringify(event)];
+      },
     }),
     resetGame: assign(initialContext),
-    setWinner: assign({
-      winner: ({ context }) => (context.player === 'x' ? 'o' : 'x'),
+    recordEvent: assign({
+      events: ({ context, event }) => {
+        return [...context.events, JSON.stringify(event)];
+      },
     }),
   },
   guards: {
     checkWin: ({ context }) => {
-      const { board } = context;
-      const winningLines = [
-        [0, 1, 2],
-        [3, 4, 5],
-        [6, 7, 8],
-        [0, 3, 6],
-        [1, 4, 7],
-        [2, 5, 8],
-        [0, 4, 8],
-        [2, 4, 6],
-      ];
-
-      for (let line of winningLines) {
-        const xWon = line.every((index) => {
-          return board[index] === 'x';
-        });
-
-        if (xWon) {
-          return true;
-        }
-
-        const oWon = line.every((index) => {
-          return board[index] === 'o';
-        });
-
-        if (oWon) {
-          return true;
-        }
-      }
+      const winner = getWinner(context.board);
 
-      return false;
+      return !!winner;
     },
     checkDraw: ({ context }) => {
       return context.moves === 9;
@@ -145,11 +184,6 @@ Provide a game report analyzing the game.`,
           invoke: {
             src: 'bot',
             input: ({ context }) => ({ context }),
-            onDone: {
-              actions: raise(({ event }) => {
-                return event.output![0] as any;
-              }),
-            },
           },
           on: {
             'x.play': [
@@ -157,18 +191,8 @@ Provide a game report analyzing the game.`,
                 target: 'o',
                 guard: 'isValidMove',
                 actions: 'updateBoard',
-                meta: {
-                  parameters: {
-                    index: {
-                      description: 'The index of the cell to play on',
-                      type: 'number',
-                      min: 0,
-                      max: 8,
-                    },
-                  },
-                },
               },
-              { reenter: true },
+              { target: 'x', reenter: true },
             ],
           },
         },
@@ -176,13 +200,6 @@ Provide a game report analyzing the game.`,
           invoke: {
             src: 'bot',
             input: ({ context }) => ({ context }),
-            onDone: {
-              // @ts-ignore
-              actions: raise(({ event }) => {
-                console.log('output', event.output);
-                return event.output![0];
-              }),
-            },
           },
           on: {
             'o.play': [
@@ -190,18 +207,8 @@ Provide a game report analyzing the game.`,
                 target: 'x',
                 guard: 'isValidMove',
                 actions: 'updateBoard',
-                meta: {
-                  parameters: {
-                    index: {
-                      description: 'The index of the cell to play on',
-                      type: 'number',
-                      min: 0,
-                      max: 8,
-                    },
-                  },
-                },
               },
-              { reenter: true },
+              { target: 'o', reenter: true },
             ],
           },
         },
@@ -226,14 +233,13 @@ Provide a game report analyzing the game.`,
       states: {
         winner: {
           tags: 'winner',
-          entry: 'setWinner',
         },
         draw: {
           tags: 'draw',
         },
       },
       on: {
-        RESET: {
+        reset: {
           target: 'playing',
           actions: 'resetGame',
         },
@@ -242,7 +248,13 @@ Provide a game report analyzing the game.`,
   },
 });
 
-const actor = createActor(ticTacToeMachine);
+const actor = createActor(ticTacToeMachine, {
+  inspect: (e) => {
+    if (e.type === '@xstate.event') {
+      console.log(e.event);
+    }
+  },
+});
 actor.subscribe((s) => {
   console.log(s.value, s.context);
 });