@statelyai/agent 0.0.6 → 0.0.8

package/examples/joke.ts

@@ -1,53 +1,37 @@
 import OpenAI from 'openai';
 import { assign, fromCallback, fromPromise, log, setup } from 'xstate';
-import { createAgent, createOpenAIAdapter, createSchemas } from '../src';
+import { createAgent, createOpenAIAdapter, defineEvents } from '../src';
 import { loadingAnimation } from './helpers/loader';
+import { z } from 'zod';
 
 const openai = new OpenAI({
   apiKey: process.env.OPENAI_API_KEY,
 });
 
-const schemas = createSchemas({
-  context: {
-    type: 'object',
-    properties: {
-      topic: { type: 'string' },
-      jokes: {
-        type: 'array',
-        items: {
-          type: 'string',
-        },
-      },
-      desire: { type: ['string', 'null'] },
-      lastRating: { type: ['string', 'null'] },
-    },
-    required: ['topic', 'jokes', 'desire', 'lastRating'],
-  },
-  events: {
-    askForTopic: {
-      type: 'object',
-      properties: {
-        topic: {
-          type: 'string',
-        },
-      },
-    },
-    endJokes: {
-      type: 'object',
-      properties: {},
-    },
-  },
+const events = defineEvents({
+  askForTopic: z.object({
+    topic: z.string().describe('The topic for the joke'),
+  }),
+  tellJoke: z.object({
+    joke: z.string().describe('The joke text'),
+  }),
+  endJokes: z.object({}).describe('End the jokes'),
+
+  rateJoke: z.object({
+    rating: z.number().min(1).max(10),
+    explanation: z.string(),
+  }),
 });
 
 const adapter = createOpenAIAdapter(openai, {
   model: 'gpt-3.5-turbo-1106',
 });
 
-const getJokeCompletion = adapter.fromChat(
+const getJokeCompletion = adapter.fromEvent(
   (topic: string) => `Tell me a joke about ${topic}.`
 );
 
-const rateJoke = adapter.fromChat(
+const rateJoke = adapter.fromEvent(
   (joke: string) => `Rate this joke on a scale of 1 to 10: ${joke}`
 );
 
@@ -66,7 +50,7 @@ const getTopic = fromPromise(async () => {
 });
 
 const decide = adapter.fromEvent(
-  (lastRating: string) =>
+  (lastRating: number) =>
     `Choose what to do next, given the previous rating of the joke: ${lastRating}`
 );
 export function getRandomFunnyPhrase() {
@@ -109,8 +93,19 @@ const loader = fromCallback(({ input }: { input: string }) => {
 });
 
 const jokeMachine = setup({
-  schemas,
-  types: schemas.types,
+  schemas: {
+    events: events.schemas,
+  },
+  types: {
+    context: {} as {
+      topic: string;
+      jokes: string[];
+      desire: string | null;
+      lastRating: number | null;
+      loader: string | null;
+    },
+    events: events.types,
+  },
   actors: {
     getJokeCompletion,
     getTopic,
@@ -119,6 +114,7 @@ const jokeMachine = setup({
     loader,
   },
 }).createMachine({
+  id: 'joke',
   context: () => ({
     topic: '',
     jokes: [],
@@ -144,54 +140,45 @@ const jokeMachine = setup({
         {
           src: 'getJokeCompletion',
           input: ({ context }) => context.topic,
-          onDone: {
-            actions: [
-              assign({
-                jokes: ({ context, event }) =>
-                  context.jokes.concat(
-                    event.output.choices[0]!.message.content!
-                  ),
-              }),
-              log((x) => `\n` + x.context.jokes.at(-1)),
-            ],
-            target: 'rateJoke',
-          },
         },
         {
           src: 'loader',
           input: getRandomFunnyPhrase,
         },
       ],
+      on: {
+        tellJoke: {
+          actions: assign({
+            jokes: ({ context, event }) => [...context.jokes, event.joke],
+          }),
+          target: 'rateJoke',
+        },
+      },
     },
     rateJoke: {
       invoke: [
         {
           src: 'rateJoke',
           input: ({ context }) => context.jokes[context.jokes.length - 1]!,
-          onDone: {
-            actions: [
-              assign({
-                lastRating: ({ event }) =>
-                  event.output.choices[0]!.message.content!,
-              }),
-              log(({ context }) => '\n' + context.lastRating),
-            ],
-            target: 'decide',
-          },
         },
         {
           src: 'loader',
           input: getRandomRatingPhrase,
         },
       ],
+      on: {
+        rateJoke: {
+          actions: assign({
+            lastRating: ({ event }) => event.rating,
+          }),
+          target: 'decide',
+        },
+      },
     },
     decide: {
       invoke: {
         src: 'decide',
         input: ({ context }) => context.lastRating!,
-        onDone: {
-          actions: log(({ event }) => event),
-        },
       },
       on: {
         askForTopic: {
@@ -216,5 +203,11 @@ const jokeMachine = setup({
   },
 });
 
-const agent = createAgent(jokeMachine);
+const agent = createAgent(jokeMachine, {
+  inspect: (ev) => {
+    if (ev.type === '@xstate.event') {
+      console.log(`\n${ev.actorRef.id}`, ev.event);
+    }
+  },
+});
 agent.start();

package/examples/numberGuesser.ts

@@ -1,6 +1,7 @@
 import OpenAI from 'openai';
-import { createAgent, createOpenAIAdapter, createSchemas } from '../src';
+import { createAgent, createOpenAIAdapter, defineEvents } from '../src';
 import { assign, setup } from 'xstate';
+import { z } from 'zod';
 const openai = new OpenAI({
   apiKey: process.env.OPENAI_API_KEY,
 });
@@ -23,40 +24,10 @@ const guessLogic = adapter.fromEvent(
 `
 );
 
-const schemas = createSchemas({
-  context: {
-    type: 'object',
-    properties: {
-      lastGuess: {
-        type: ['number', 'null'],
-        description: 'The last guess',
-      },
-      previousGuesses: {
-        type: 'array',
-        items: {
-          type: 'number',
-        },
-        description: 'The previous guesses',
-      },
-      answer: {
-        type: 'number',
-        description: 'The answer',
-      },
-    },
-  },
-  events: {
-    guess: {
-      properties: {
-        number: {
-          // integer
-          type: 'number',
-          minimum: 1,
-          maximum: 10,
-        },
-      },
-      required: ['number'],
-    },
-  },
+const events = defineEvents({
+  guess: z.object({
+    number: z.number().min(1).max(10).describe('The number guessed'),
+  }),
 });
 
 const machine = setup({
@@ -66,9 +37,11 @@ const machine = setup({
       answer: number;
     },
     input: {} as { answer: number },
-    events: schemas.types.events,
+    events: events.types,
+  },
+  schemas: {
+    events: events.schemas,
   },
-  schemas,
   actors: {
     guessLogic,
   },

package/examples/ticTacToe.ts

@@ -1,6 +1,8 @@
 import { assign, setup, assertEvent } from 'xstate';
 import OpenAI from 'openai';
-import { createOpenAIAdapter, createSchemas, createAgent } from '../src';
+import { z } from 'zod';
+import { zodToJsonSchema } from 'zod-to-json-schema';
+import { createOpenAIAdapter, defineEvents, createAgent } from '../src';
 
 const openai = new OpenAI({
   apiKey: process.env.OPENAI_API_KEY,
@@ -8,70 +10,32 @@ const openai = new OpenAI({
 
 type Player = 'x' | 'o';
 
-const schemas = createSchemas({
-  context: {
-    type: 'object',
-    properties: {
-      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',
-        },
-      },
-    },
-    required: ['board', 'moves', 'player', 'gameReport', 'events'],
-  },
-  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 events = defineEvents({
+  'x.play': z.object({
+    index: z
+      .number()
+      .min(0)
+      .max(8)
+      .describe('The index of the cell to play on'),
+  }),
+  'o.play': z.object({
+    index: z
+      .number()
+      .min(0)
+      .max(8)
+      .describe('The index of the cell to play on'),
+  }),
+  reset: z.object({}).describe('Reset the game to the initial state'),
 });
 
+interface GameContext {
+  board: (Player | null)[];
+  moves: number;
+  player: Player;
+  gameReport: string;
+  events: string[];
+}
+
 const adapter = createOpenAIAdapter(openai, {
   model: 'gpt-4-1106-preview',
 });
@@ -82,10 +46,10 @@ const initialContext = {
   player: 'x' as Player,
   gameReport: '',
   events: [],
-} satisfies typeof schemas.types.context;
+} satisfies GameContext;
 
 const bot = adapter.fromEvent(
-  ({ context }: { context: typeof schemas.types.context }) => `
+  ({ context }: { context: GameContext }) => `
 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)}
@@ -94,11 +58,7 @@ Execute the single best next move to try to win the game. Do not play on an exis
 );
 
 const gameReporter = adapter.fromChatStream(
-  ({
-    context,
-  }: {
-    context: typeof schemas.types.context;
-  }) => `Here is the game board:
+  ({ context }: { context: GameContext }) => `Here is the game board:
 
 ${JSON.stringify(context.board, null, 2)}
 
@@ -131,8 +91,13 @@ function getWinner(board: typeof initialContext.board): Player | null {
 }
 
 export const ticTacToeMachine = setup({
-  schemas,
-  types: schemas.types,
+  schemas: {
+    events: events.schemas,
+  },
+  types: {
+    context: {} as GameContext,
+    events: events.types,
+  },
   actors: {
     bot,
     gameReporter,

package/examples/weather.ts

@@ -1,7 +1,8 @@
 import OpenAI from 'openai';
-import { createAgent, createOpenAIAdapter, createSchemas } from '../src';
+import { createAgent, createOpenAIAdapter, defineEvents } from '../src';
 import { assign, fromPromise, log, setup } from 'xstate';
 import { getFromTerminal } from './helpers/helpers';
+import { z } from 'zod';
 
 async function searchTavily(
   input: string,
@@ -40,28 +41,21 @@ const openai = new OpenAI({
   apiKey: process.env.OPENAI_API_KEY,
 });
 
-const schemas = createSchemas({
-  context: {
-    location: { type: 'string' },
-    history: { type: 'array', items: { type: 'string' } },
-    count: { type: 'number' },
-  },
-  events: {
-    getWeather: {
-      description: 'Get the weather for a location',
-      properties: {
-        location: {
-          type: 'string',
-          description: 'The location to get the weather for',
-        },
-      },
-    },
-    doSomethingElse: {
-      description:
-        'Do something else, because the user did not provide a location',
-      properties: {},
-    },
-  },
+const events = defineEvents({
+  getWeather: z.object({
+    location: z.string().describe('The location to get the weather for'),
+  }),
+  reportWeather: z.object({
+    location: z
+      .string()
+      .describe('The location the weather is being reported for'),
+    highF: z.number().describe('The high temperature today in Fahrenheit'),
+    lowF: z.number().describe('The low temperature today in Fahrenheit'),
+    summary: z.string().describe('A summary of the weather conditions'),
+  }),
+  doSomethingElse: z
+    .object({})
+    .describe('Do something else, because the user did not provide a location'),
 });
 
 const adapter = createOpenAIAdapter(openai, {
@@ -79,11 +73,23 @@ const getWeather = fromPromise(async ({ input }: { input: string }) => {
   return results;
 });
 
+const reportWeather = adapter.fromEvent(() => 'Report the weather');
+
 const machine = setup({
-  schemas,
-  types: schemas.types,
+  schemas: {
+    events: events.schemas,
+  },
+  types: {
+    context: {} as {
+      location: string;
+      history: string[];
+      count: number;
+    },
+    events: events.types,
+  },
   actors: {
     getWeather,
+    reportWeather,
     decide: adapter.fromEvent(
       (input: string) =>
         `Decide what to do based on the given input, which may or may not be a location: ${input}`
@@ -140,6 +146,17 @@ const machine = setup({
               count: ({ context }) => context.count + 1,
             }),
           ],
+          target: 'reportWeather',
+        },
+      },
+    },
+    reportWeather: {
+      invoke: {
+        src: 'reportWeather',
+      },
+      on: {
+        reportWeather: {
+          actions: log(({ event }) => event),
           target: 'getLocation',
         },
       },
@@ -153,8 +170,12 @@ const machine = setup({
   },
 });
 
-createAgent(machine, {
+const actor = createAgent(machine, {
   input: {
     location: 'New York',
   },
-}).start();
+});
+actor.subscribe((s) => {
+  console.log(s.value);
+});
+actor.start();

package/examples/wordGuesser.ts

@@ -0,0 +1,144 @@
+import { assign, log, setup } from 'xstate';
+import { getFromTerminal } from './helpers/helpers';
+import { createAgent, createOpenAIAdapter, defineEvents } from '../src';
+import OpenAI from 'openai';
+import { z } from 'zod';
+
+const openAI = new OpenAI({
+  apiKey: process.env.OPENAI_API_KEY,
+});
+
+const adapter = createOpenAIAdapter(openAI, {
+  model: 'gpt-4-1106-preview',
+});
+
+const events = defineEvents({
+  guessLetter: z.object({
+    letter: z.string().min(1).max(1).describe('The letter guessed'),
+  }),
+
+  guessWord: z.object({
+    word: z.string().describe('The word guessed'),
+  }),
+});
+
+const context = {
+  word: null as string | null,
+  guessedWord: null as string | null,
+  letters: [] as string[],
+};
+
+const wordGuesserMachine = setup({
+  types: {
+    context: {} as typeof context,
+    events: events.types,
+  },
+  actors: {
+    getFromTerminal,
+    guesser: adapter.fromEvent(
+      (input: typeof context) => `
+You are trying to guess the word. The word has ${
+        input.word!.length
+      } letters. You have guessed the following letters so far: ${input.letters.join(
+        ', '
+      )}. These letters matched: ${input
+        .word!.split('')
+        .map((letter) =>
+          input.letters.includes(letter.toUpperCase())
+            ? letter.toUpperCase()
+            : '_'
+        )
+        .join('')}
+Please make your next guess - type a letter or the full word. You can only make 10 total guesses.
+    `
+    ),
+  },
+  schemas: {
+    events: events.schemas,
+  },
+}).createMachine({
+  initial: 'providingWord',
+  context,
+  states: {
+    providingWord: {
+      invoke: {
+        src: 'getFromTerminal',
+        input: 'Enter a word',
+        onDone: {
+          actions: assign({
+            word: ({ event }) => event.output,
+          }),
+          target: 'guessing',
+        },
+      },
+    },
+    guessing: {
+      always: {
+        guard: ({ context }) => context.letters.length > 10,
+        target: 'finalGuess',
+      },
+      invoke: {
+        src: 'guesser',
+        input: ({ context }) => context,
+      },
+      on: {
+        guessLetter: {
+          actions: assign({
+            letters: ({ context, event }) => {
+              return [...context.letters, event.letter.toUpperCase()];
+            },
+          }),
+          target: 'guessing',
+          reenter: true,
+        },
+        guessWord: {
+          actions: assign({
+            guessedWord: ({ event }) => event.word,
+          }),
+          target: 'gameOver',
+        },
+      },
+    },
+    finalGuess: {
+      invoke: {
+        src: 'guesser',
+        input: ({ context }) => context,
+      },
+      on: {
+        guessWord: {
+          actions: assign({
+            guessedWord: ({ event }) => event.word,
+          }),
+          target: 'gameOver',
+        },
+      },
+    },
+    gameOver: {
+      entry: log(({ context }) => {
+        if (
+          context.guessedWord?.toUpperCase() === context.word?.toUpperCase()
+        ) {
+          return 'You won!';
+        } else {
+          return 'You lost! The word was ' + context.word;
+        }
+      }),
+    },
+  },
+  exit: () => process.exit(),
+});
+
+const actor = createAgent(wordGuesserMachine, {
+  inspect: (ev) => {
+    if (ev.type === '@xstate.event') {
+      console.log(ev.event);
+    }
+  },
+});
+
+actor.subscribe((s) => {
+  console.log(s.value);
+  console.log(s.context);
+});
+
+actor.start();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@statelyai/agent",
-  "version": "0.0.6",
+  "version": "0.0.8",
   "description": "",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -18,7 +18,9 @@
     "ts-node": "^10.9.2",
     "tsup": "^8.0.1",
     "typescript": "^5.3.3",
-    "vitest": "^1.2.2"
+    "vitest": "^1.2.2",
+    "zod": "^3.22.4",
+    "zod-to-json-schema": "^3.22.4"
   },
   "publishConfig": {
     "access": "public"
@@ -29,7 +31,7 @@
   "packageManager": "pnpm@8.11.0",
   "scripts": {
     "build": "tsup src/index.ts --format cjs,esm --dts",
-    "lint": "tsc",
+    "lint": "tsc --noEmit",
     "test": "vitest",
     "example": "ts-node examples/helpers/runner.ts",
     "changeset": "changeset",