@statelyai/agent 0.0.7 → 0.1.0

package/examples/todo.ts

@@ -0,0 +1,132 @@
+import { assign, setup, assertEvent, createActor, createMachine } from 'xstate';
+import { z } from 'zod';
+import { createAgent, fromDecision } from '../src';
+import { openai } from '@ai-sdk/openai';
+import { getFromTerminal } from './helpers/helpers';
+
+const agent = createAgent({
+  name: 'todo',
+  model: openai('gpt-4o'),
+  events: {
+    addTodo: z.object({
+      message: z.string().min(1).max(100).describe('The message of the todo'),
+    }),
+    deleteTodo: z.object({
+      index: z.number().describe('The index of the todo to delete'),
+    }),
+    toggleTodo: z
+      .object({
+        index: z.number().describe('The index of the todo to toggle'),
+      })
+      .describe('Toggle whether the todo item is done or not'),
+    doNothing: z.object({}).describe('Do nothing'),
+  },
+});
+
+interface Todo {
+  message: string;
+  done: boolean;
+}
+
+const machine = setup({
+  types: {
+    context: {} as {
+      todos: Todo[];
+      command: string | null;
+    },
+    events: {} as typeof agent.eventTypes | { type: 'assist'; command: string },
+  },
+  actors: { agent: fromDecision(agent), getFromTerminal },
+}).createMachine({
+  context: {
+    command: null,
+    todos: [],
+  },
+  on: {
+    addTodo: {
+      actions: assign({
+        todos: ({ context, event }) => [
+          ...context.todos,
+          {
+            message: event.message,
+            done: false,
+          },
+        ],
+        command: null,
+      }),
+      target: '.idle',
+    },
+    deleteTodo: {
+      actions: assign({
+        todos: ({ context, event }) => {
+          const todos = [...context.todos];
+          todos.splice(event.index, 1);
+          return todos;
+        },
+        command: null,
+      }),
+      target: '.idle',
+    },
+    toggleTodo: {
+      actions: assign({
+        todos: ({ context, event }) => {
+          const todos = context.todos.map((todo, i) => {
+            if (i === event.index) {
+              return {
+                ...todo,
+                done: !todo.done,
+              };
+            }
+            return todo;
+          });
+
+          return todos;
+        },
+        command: null,
+      }),
+      target: '.idle',
+    },
+    doNothing: { target: '.idle' },
+  },
+  initial: 'idle',
+  states: {
+    idle: {
+      invoke: {
+        src: 'getFromTerminal',
+        input: '\nEnter a command:',
+        onDone: {
+          actions: assign({
+            command: ({ event }) => event.output,
+          }),
+          target: 'assisting',
+        },
+      },
+      on: {
+        assist: {
+          target: 'assisting',
+          actions: assign({
+            command: ({ event }) => event.command,
+          }),
+        },
+      },
+    },
+    assisting: {
+      invoke: {
+        src: 'agent',
+        input: (x) => ({
+          context: {
+            command: x.context.command,
+            todos: x.context.todos,
+          },
+          goal: 'Interpret the command as an action for this todo list; for example, "I need donuts" would add a todo item with the message "Get donuts".',
+        }),
+      },
+    },
+  },
+});
+
+const actor = createActor(machine);
+actor.subscribe((s) => {
+  console.log(s.context.todos);
+});
+actor.start();

package/examples/tutor.ts

@@ -0,0 +1,100 @@
+import { assign, createActor, log, setup } from 'xstate';
+import { getFromTerminal } from './helpers/helpers';
+import { createAgent, fromDecision } from '../src';
+import { z } from 'zod';
+import { openai } from '@ai-sdk/openai';
+
+const agent = createAgent({
+  name: 'tutor',
+  model: openai('gpt-4-1106-preview'),
+  events: {
+    teach: z.object({
+      instruction: z
+        .string()
+        .describe(
+          'The feedback to give the human, correcting any grammatical errors, misspellings, etc.'
+        ),
+    }),
+    respond: z.object({
+      response: z.string().describe('The response to the human in Spanish'),
+    }),
+  },
+  system:
+    'You are an expert Spanish tutor. You will respond to the human in Spanish.',
+});
+
+const machine = setup({
+  types: {
+    context: {} as {
+      conversation: string[];
+    },
+    events: agent.eventTypes,
+  },
+  actors: { agent: fromDecision(agent), getFromTerminal },
+}).createMachine({
+  initial: 'human',
+  context: {
+    conversation: [],
+  },
+  states: {
+    human: {
+      invoke: {
+        src: 'getFromTerminal',
+        input: 'Say something in Spanish:',
+        onDone: {
+          actions: assign({
+            conversation: (x) =>
+              x.context.conversation.concat(`User: ` + x.event.output),
+          }),
+          target: 'ai',
+        },
+      },
+    },
+    ai: {
+      initial: 'teaching',
+      states: {
+        teaching: {
+          invoke: {
+            src: 'agent',
+            input: (x) => ({
+              context: true,
+              goal: 'Give brief feedback to the human based on the most recent response of the conversation',
+              maxTokens: 100,
+            }),
+          },
+          on: {
+            teach: {
+              actions: (x) => console.log(x.event.instruction),
+              target: 'responding',
+            },
+          },
+        },
+        responding: {
+          invoke: {
+            src: 'agent',
+            input: (x) => ({
+              context: true,
+              goal: 'Respond to the last message of the conversation in Spanish',
+            }),
+          },
+          on: {
+            respond: {
+              actions: [
+                assign({
+                  conversation: (x) =>
+                    x.context.conversation.concat(`Agent: ` + x.event.response),
+                }),
+                log((x) => x.event.response),
+              ],
+              target: 'done',
+            },
+          },
+        },
+        done: { type: 'final' },
+      },
+      onDone: { target: 'human' },
+    },
+  },
+});
+
+createActor(machine).start();

package/examples/verify.ts

@@ -0,0 +1,120 @@
+import { assign, createActor, setup, log } from 'xstate';
+import { getFromTerminal } from './helpers/helpers';
+import { createAgent, fromDecision } from '../src';
+import { z } from 'zod';
+import { openai } from '@ai-sdk/openai';
+
+const agent = createAgent({
+  name: 'verifier',
+  model: openai('gpt-3.5-turbo-16k-0613'),
+  events: {
+    'agent.validateAnswer': z.object({
+      isValid: z.boolean(),
+      feedback: z.string(),
+    }),
+    'agent.answerQuestion': z.object({
+      answer: z.string().describe('The answer from the agent'),
+    }),
+    'agent.validateQuestion': z.object({
+      isValid: z
+        .boolean()
+        .describe(
+          'Whether the question is a valid question; that is, is it possible to even answer this question in a verifiably correct way?'
+        ),
+      explanation: z
+        .string()
+        .describe('An explanation for why the question is or is not valid'),
+    }),
+  },
+});
+
+const machine = setup({
+  types: {
+    context: {} as {
+      question: string | null;
+      answer: string | null;
+      validation: string | null;
+    },
+    events: agent.eventTypes,
+  },
+  actors: {
+    getFromTerminal,
+    agent: fromDecision(agent),
+  },
+}).createMachine({
+  initial: 'askQuestion',
+  context: { question: null, answer: null, validation: null },
+  states: {
+    askQuestion: {
+      invoke: {
+        src: 'getFromTerminal',
+        input: 'Ask a (potentially silly) question',
+        onDone: {
+          actions: assign({
+            question: ({ event }) => event.output,
+          }),
+          target: 'validateQuestion',
+        },
+      },
+    },
+    validateQuestion: {
+      invoke: {
+        src: 'agent',
+        input: ({ context }) => ({
+          goal: `Validate this question: ${context.question!}`,
+        }),
+      },
+      on: {
+        'agent.validateQuestion': [
+          {
+            target: 'askQuestion',
+            guard: ({ event }) => !event.isValid,
+            actions: log(({ event }) => event.explanation),
+          },
+          {
+            target: 'answerQuestion',
+          },
+        ],
+      },
+    },
+    answerQuestion: {
+      invoke: {
+        src: 'agent',
+        input: ({ context }) => ({
+          goal: `Answer this question: ${context.question}`,
+        }),
+      },
+      on: {
+        'agent.answerQuestion': {
+          actions: assign({
+            answer: ({ event }) => event.answer,
+          }),
+          target: 'validateAnswer',
+        },
+      },
+    },
+    validateAnswer: {
+      invoke: {
+        src: 'agent',
+        input: ({ context }) => ({
+          goal: `Validate if this is a good answer to the question: ${context.question}\nAnswer provided: ${context.answer}`,
+        }),
+      },
+      on: {
+        'agent.validateAnswer': {
+          actions: assign({
+            validation: ({ event }) => event.feedback,
+          }),
+        },
+      },
+    },
+  },
+});
+
+const actor = createActor(machine, {});
+
+actor.subscribe((s) => {
+  console.log(s.value, s.context);
+});
+
+actor.start();

package/examples/weather.ts

@@ -1,7 +1,8 @@
-import OpenAI from 'openai';
-import { createAgent, createOpenAIAdapter, createSchemas } from '../src';
-import { assign, fromPromise, log, setup } from 'xstate';
+import { createAgent, fromDecision } from '../src';
+import { assign, createActor, fromPromise, log, setup } from 'xstate';
 import { getFromTerminal } from './helpers/helpers';
+import { z } from 'zod';
+import { openai } from '@ai-sdk/openai';
 
 async function searchTavily(
   input: string,
@@ -36,38 +37,6 @@ async function searchTavily(
   return JSON.stringify(json.results);
 }
 
-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 adapter = createOpenAIAdapter(openai, {
-  model: 'gpt-4-1106-preview',
-});
-
 const getWeather = fromPromise(async ({ input }: { input: string }) => {
   const results = await searchTavily(
     `Get the weather for this location: ${input}`,
@@ -79,15 +48,41 @@ const getWeather = fromPromise(async ({ input }: { input: string }) => {
   return results;
 });
 
+const agent = createAgent({
+  name: 'weather',
+  model: openai('gpt-4-1106-preview'),
+  events: {
+    'agent.getWeather': z.object({
+      location: z.string().describe('The location to get the weather for'),
+    }),
+    'agent.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'),
+    }),
+    'agent.doSomethingElse': z
+      .object({})
+      .describe(
+        'Do something else, because the user did not provide a location'
+      ),
+  },
+});
+
 const machine = setup({
-  schemas,
-  types: schemas.types,
+  types: {
+    context: {} as {
+      location: string;
+      history: string[];
+      count: number;
+    },
+    events: agent.eventTypes,
+  },
   actors: {
+    agent: fromDecision(agent),
     getWeather,
-    decide: adapter.fromEvent(
-      (input: string) =>
-        `Decide what to do based on the given input, which may or may not be a location: ${input}`
-    ),
     getFromTerminal,
   },
 }).createMachine({
@@ -117,15 +112,20 @@ const machine = setup({
     decide: {
       entry: log('Deciding...'),
       invoke: {
-        src: 'decide',
-        input: ({ context }) => context.location,
+        src: 'agent',
+        input: ({ context }) => ({
+          context: {
+            location: context.location,
+          },
+          goal: `Decide what to do based on the given location, which may or may not be a location`,
+        }),
       },
       on: {
-        getWeather: {
+        'agent.getWeather': {
           actions: log(({ event }) => event),
           target: 'gettingWeather',
         },
-        doSomethingElse: 'getLocation',
+        'agent.doSomethingElse': 'getLocation',
       },
     },
     gettingWeather: {
@@ -140,6 +140,20 @@ const machine = setup({
               count: ({ context }) => context.count + 1,
             }),
           ],
+          target: 'reportWeather',
+        },
+      },
+    },
+    reportWeather: {
+      invoke: {
+        src: 'agent',
+        input: ({ context }) => ({
+          goal: 'Report the weather', // TODO
+        }),
+      },
+      on: {
+        'agent.reportWeather': {
+          actions: log(({ event }) => event),
           target: 'getLocation',
         },
       },
@@ -153,8 +167,12 @@ const machine = setup({
   },
 });
 
-createAgent(machine, {
+const actor = createActor(machine, {
   input: {
     location: 'New York',
   },
-}).start();
+});
+actor.subscribe((s) => {
+  console.log(s.value);
+});
+actor.start();

package/examples/wiki.ts

@@ -0,0 +1,30 @@
+import { z } from 'zod';
+import { createAgent } from '../src';
+import { openai } from '@ai-sdk/openai';
+
+const agent = createAgent({
+  name: 'wiki',
+  model: openai('gpt-4-turbo'),
+  events: {
+    provideAnswer: z.object({
+      answer: z.string().describe('The answer'),
+    }),
+  },
+});
+
+async function main() {
+  const response1 = await agent.generateText({
+    prompt: 'When was Deadpool 2 released?',
+  });
+
+  console.log(response1.text);
+
+  const response2 = await agent.generateText({
+    messages: true,
+    prompt: 'What about the first one?',
+  });
+
+  console.log(response2.text);
+}
+
+main();

package/examples/word.ts

@@ -0,0 +1,168 @@
+import { assign, createActor, log, setup } from 'xstate';
+import { getFromTerminal } from './helpers/helpers';
+import { createAgent, fromDecision } from '../src';
+import { z } from 'zod';
+import { openai } from '@ai-sdk/openai';
+
+const context = {
+  word: null as string | null,
+  guessedWord: null as string | null,
+  lettersGuessed: [] as string[],
+};
+
+const agent = createAgent({
+  name: 'word',
+  model: openai('gpt-4-1106-preview'),
+  events: {
+    'agent.guessLetter': z.object({
+      letter: z.string().min(1).max(1).describe('The letter guessed'),
+      reasoning: z.string().describe('The reasoning behind the guess'),
+    }),
+
+    'agent.guessWord': z.object({
+      word: z.string().describe('The word guessed'),
+    }),
+
+    'agent.respond': z.object({
+      response: z
+        .string()
+        .describe(
+          'The response from the agent, detailing why the guess was correct or incorrect based on the letters guessed.'
+        ),
+    }),
+  },
+});
+
+const wordGuesserMachine = setup({
+  types: {
+    context: {} as typeof context,
+    events: agent.eventTypes,
+  },
+  actors: {
+    agent: fromDecision(agent),
+    getFromTerminal,
+  },
+}).createMachine({
+  initial: 'providingWord',
+  context,
+  states: {
+    providingWord: {
+      entry: assign(context),
+      invoke: {
+        src: 'getFromTerminal',
+        input: 'Enter a word, and an agent will try to guess it.',
+        onDone: {
+          actions: assign({
+            word: ({ event }) => event.output,
+          }),
+          target: 'guessing',
+        },
+      },
+    },
+    guessing: {
+      always: {
+        guard: ({ context }) => context.lettersGuessed.length > 10,
+        target: 'finalGuess',
+      },
+      invoke: {
+        src: 'agent',
+        input: ({ context }) => ({
+          context: {
+            wordLength: context.word!.length,
+            lettersGuessed: context.lettersGuessed,
+            lettersMatched: context
+              .word!.split('')
+              .map((letter) =>
+                context.lettersGuessed.includes(letter.toUpperCase())
+                  ? letter.toUpperCase()
+                  : '_'
+              )
+              .join(''),
+          },
+          goal: `You are trying to guess the word. Please make your next guess - guess a letter or, if you think you know the word, guess the full word. You can only make 10 total guesses. If you are confident you know the word, it is better to guess the word.`,
+        }),
+      },
+      on: {
+        'agent.guessLetter': {
+          actions: [
+            assign({
+              lettersGuessed: ({ context, event }) => {
+                return [...context.lettersGuessed, event.letter.toUpperCase()];
+              },
+            }),
+            log(({ event }) => event),
+          ],
+          target: 'guessing',
+          reenter: true,
+        },
+        'agent.guessWord': {
+          actions: [
+            assign({
+              guessedWord: ({ event }) => event.word,
+            }),
+            log(({ event }) => event),
+          ],
+          target: 'gameOver',
+        },
+      },
+    },
+    finalGuess: {
+      invoke: {
+        src: 'agent',
+        input: ({ context }) => ({
+          context: {
+            lettersGuessed: context.lettersGuessed,
+          },
+          goal: `You have used all 10 guesses. These letters matched: ${context
+            .word!.split('')
+            .map((letter) =>
+              context.lettersGuessed.includes(letter.toUpperCase())
+                ? letter.toUpperCase()
+                : '_'
+            )
+            .join('')}. Guess the word.`,
+        }),
+      },
+      on: {
+        'agent.guessWord': {
+          actions: [
+            assign({
+              guessedWord: ({ event }) => event.word,
+            }),
+            log(({ event }) => event),
+          ],
+          target: 'gameOver',
+        },
+      },
+    },
+    gameOver: {
+      invoke: {
+        src: 'agent',
+        input: ({ context }) => ({
+          context,
+          goal: `Why do you think you won or lost?`,
+        }),
+      },
+      entry: log(({ context }) => {
+        if (
+          context.guessedWord?.toUpperCase() === context.word?.toUpperCase()
+        ) {
+          return 'The agent won!';
+        } else {
+          return 'The agent lost! The word was ' + context.word;
+        }
+      }),
+      on: {
+        'agent.respond': {
+          actions: log(({ event }) => event.response),
+          target: 'providingWord',
+        },
+      },
+    },
+  },
+  exit: () => process.exit(),
+});
+
+const game = createActor(wordGuesserMachine);
+
+game.start();