@statelyai/agent 1.1.6 → 2.0.0-next.1

package/examples/chatbot-alt.ts

@@ -0,0 +1,57 @@
+import { z } from 'zod';
+import { createAgent } from '../src';
+import { openai } from '@ai-sdk/openai';
+import { getFromTerminal } from './helpers/helpers';
+
+const agent = createAgent({
+  id: 'chatbot',
+  model: openai('gpt-4o-mini'),
+  events: {
+    'agent.respond': z.object({
+      response: z.string().describe('The response from the agent'),
+    }),
+    'agent.endConversation': z.object({}).describe('Stop the conversation'),
+  },
+  context: {
+    userMessage: z.string(),
+  },
+});
+
+async function main() {
+  let status = 'listening';
+  let userMessage = '';
+
+  while (status !== 'finished') {
+    switch (status) {
+      case 'listening':
+        userMessage = await getFromTerminal('User:');
+        status = 'responding';
+        break;
+
+      case 'responding':
+        const decision = await agent.decide({
+          messages: agent.getMessages(),
+          goal: 'Respond to the user, unless they want to end the conversation.',
+          state: {
+            value: status,
+            context: {
+              userMessage: 'User says: ' + userMessage,
+            },
+          },
+        });
+
+        if (decision?.nextEvent?.type === 'agent.respond') {
+          console.log(`Agent: ${decision.nextEvent.response}`);
+          status = 'listening';
+        } else if (decision?.nextEvent?.type === 'agent.endConversation') {
+          status = 'finished';
+        }
+        break;
+    }
+  }
+
+  console.log('End of conversation.');
+  process.exit();
+}
+
+main().catch(console.error);

package/examples/chatbot.ts

@@ -2,11 +2,11 @@ import { z } from 'zod';
 import { createAgent, fromDecision } from '../src';
 import { openai } from '@ai-sdk/openai';
 import { assign, createActor, log, setup } from 'xstate';
-import { getFromTerminal } from './helpers/helpers';
+import { fromTerminal } from './helpers/helpers';
 
 const agent = createAgent({
-  name: 'chatbot',
-  model: openai('gpt-4-turbo'),
+  id: 'chatbot',
+  model: openai('gpt-4o-mini'),
   events: {
     'agent.respond': z.object({
       response: z.string().describe('The response from the agent'),
@@ -20,7 +20,7 @@ const agent = createAgent({
 
 const machine = setup({
   types: agent.types,
-  actors: { agent: fromDecision(agent), getFromTerminal },
+  actors: { getFromTerminal: fromTerminal },
 }).createMachine({
   initial: 'listening',
   context: {
@@ -33,26 +33,16 @@ const machine = setup({
         input: 'User:',
         onDone: {
           actions: assign({
-            userMessage: (x) => x.event.output,
+            userMessage: ({ event }) => event.output,
           }),
           target: 'responding',
         },
       },
     },
     responding: {
-      invoke: {
-        src: 'agent',
-        input: (x) => ({
-          context: {
-            userMessage: 'User says: ' + x.context.userMessage,
-          },
-          messages: agent.getMessages(),
-          goal: 'Respond to the user, unless they want to end the conversation.',
-        }),
-      },
       on: {
         'agent.respond': {
-          actions: [log((x) => `Agent: ${x.event.response}`)],
+          actions: log(({ event }) => `Agent: ${event.response}`),
           target: 'listening',
         },
         'agent.endConversation': 'finished',
@@ -68,4 +58,9 @@ const machine = setup({
   },
 });
 
-createActor(machine).start();
+const actor = createActor(machine).start();
+
+agent.interact(actor, () => ({
+  goal: 'Respond to the user, unless they want to end the conversation.',
+  messages: agent.getMessages(),
+}));

package/examples/cot.ts

@@ -2,11 +2,11 @@ import { z } from 'zod';
 import { createAgent, fromDecision } from '../src';
 import { openai } from '@ai-sdk/openai';
 import { assign, createActor, log, setup } from 'xstate';
-import { getFromTerminal } from './helpers/helpers';
+import { fromTerminal } from './helpers/helpers';
 
 const agent = createAgent({
-  name: 'chain-of-thought',
-  model: openai('gpt-4o'),
+  id: 'chain-of-thought',
+  model: openai('gpt-4o-mini'),
   events: {
     'agent.think': z.object({
       thought: z
@@ -25,7 +25,7 @@ const agent = createAgent({
 
 const machine = setup({
   types: agent.types,
-  actors: { agent: fromDecision(agent), getFromTerminal },
+  actors: { getFromTerminal: fromTerminal },
 }).createMachine({
   initial: 'asking',
   context: {
@@ -39,26 +39,19 @@ const machine = setup({
         input: 'What would you like to ask?',
         onDone: {
           actions: assign({
-            question: (x) => x.event.output,
+            question: ({ event }) => event.output,
           }),
           target: 'thinking',
         },
       },
     },
     thinking: {
-      invoke: {
-        src: 'agent',
-        input: (x) => ({
-          context: x.context,
-          goal: 'Answer the question. Think step-by-step.',
-        }),
-      },
       on: {
         'agent.think': {
           actions: [
-            log((x) => x.event.thought),
+            log(({ event }) => `Thought: ${event.thought}`),
             assign({
-              thought: (x) => x.event.thought,
+              thought: ({ event }) => event.thought,
             }),
           ],
           target: 'answering',
@@ -66,16 +59,9 @@ const machine = setup({
       },
     },
     answering: {
-      invoke: {
-        src: 'agent',
-        input: (x) => ({
-          context: x.context,
-          goal: 'Answer the question',
-        }),
-      },
       on: {
         'agent.answer': {
-          actions: [log((x) => x.event.answer)],
+          actions: log(({ event }) => `Answer: ${event.answer}`),
           target: 'answered',
         },
       },
@@ -86,4 +72,21 @@ const machine = setup({
   },
 });
 
-createActor(machine).start();
+const actor = createActor(machine).start();
+
+agent.interact(actor, (obs) => {
+  if (obs.state.matches('thinking')) {
+    return {
+      goal: 'Think step-by-step about how you would answer the question',
+      context: obs.state.context,
+      messages: agent.getMessages(),
+    };
+  }
+  if (obs.state.matches('answering')) {
+    return {
+      goal: 'Answer the question',
+      context: obs.state.context,
+      messages: agent.getMessages(),
+    };
+  }
+});

package/examples/customer-service-sim.ts

@@ -0,0 +1,107 @@
+import { createAgent, fromDecision } from '../src';
+import { assign, createActor, setup } from 'xstate';
+import { openai } from '@ai-sdk/openai';
+import { z } from 'zod';
+
+// Create customer service agent
+const customerServiceAgent = createAgent({
+  id: 'customer-service',
+  model: openai('gpt-4o'),
+  events: {
+    'agent.respond': z.object({
+      response: z
+        .string()
+        .describe('The response from the customer service agent'),
+    }),
+  },
+  description: 'You are a customer service agent for an airline.',
+});
+
+// Create simulated customer agent
+const customerAgent = createAgent({
+  id: 'customer',
+  model: openai('gpt-4o-mini'),
+  events: {
+    'agent.respond': z.object({
+      response: z.string().describe('The response from the customer'),
+    }),
+    'agent.finish': z.object({}).describe('End the conversation'),
+  },
+  description: `You are Harrison, a customer trying to get a refund for a trip to Alaska.
+You want them to give you ALL the money back. Be extremely persistent. This trip happened 5 years ago.
+If you have nothing more to add to the conversation, send agent.finish event.`,
+});
+
+const machine = setup({
+  types: {
+    context: {} as {
+      messages: string[];
+    },
+    events: {} as
+      | typeof customerServiceAgent.types.events
+      | typeof customerAgent.types.events,
+  },
+  actors: {
+    customerService: fromDecision(customerServiceAgent),
+    customer: fromDecision(customerAgent),
+  },
+}).createMachine({
+  initial: 'customerService',
+  context: {
+    messages: [],
+  },
+  states: {
+    customerService: {
+      invoke: {
+        src: 'customerService',
+        input: ({ context }) => ({
+          goal: 'Respond to the customer message',
+          context,
+        }),
+      },
+      on: {
+        'agent.respond': {
+          target: 'customer',
+          actions: assign({
+            messages: ({ context, event }) => [
+              ...context.messages,
+              event.response,
+            ],
+          }),
+        },
+      },
+    },
+    customer: {
+      invoke: {
+        src: 'customer',
+        input: ({ context }) => ({
+          goal: 'Respond to the customer service agent, or finish the conversation if you have nothing more to add.',
+          context,
+        }),
+      },
+      on: {
+        'agent.respond': {
+          target: 'customerService',
+          actions: assign({
+            messages: ({ context, event }) => [
+              ...context.messages,
+              event.response,
+            ],
+          }),
+        },
+        'agent.finish': 'done',
+      },
+    },
+    done: {
+      type: 'final',
+    },
+  },
+});
+
+const actor = createActor(machine);
+actor.subscribe((state) => {
+  console.log('State:', state.value);
+  console.log('Messages:', state.context.messages);
+});
+
+actor.start();

package/examples/email.ts

@@ -2,11 +2,11 @@ import { z } from 'zod';
 import { createAgent, fromDecision } from '../src';
 import { openai } from '@ai-sdk/openai';
 import { assign, createActor, setup } from 'xstate';
-import { getFromTerminal } from './helpers/helpers';
+import { fromTerminal } from './helpers/helpers';
 
 const agent = createAgent({
-  name: 'email',
-  model: openai('gpt-4'),
+  id: 'email',
+  model: openai('gpt-4o-mini'),
   events: {
     askForClarification: z.object({
       questions: z.array(z.string()).describe('The questions to ask the agent'),
@@ -15,6 +15,14 @@ const agent = createAgent({
       email: z.string().describe('The email to submit'),
     }),
   },
+  context: {
+    email: z.string().describe('The email to respond to'),
+    instructions: z.string().describe('The instructions for the email'),
+    clarifications: z
+      .array(z.string())
+      .describe('The clarifications to the email'),
+    replyEmail: z.string().nullable().describe('The email to submit'),
+  },
 });
 
 const machine = setup({
@@ -24,39 +32,22 @@ const machine = setup({
       email: string;
       instructions: string;
     },
-    context: {} as {
-      email: string;
-      instructions: string;
-      clarifications: string[];
-      replyEmail: string | null;
-    },
+    context: agent.types.context,
   },
-  actors: { agent: fromDecision(agent), getFromTerminal },
+  actors: { getFromTerminal: fromTerminal },
 }).createMachine({
   initial: 'checking',
-  context: (x) => ({
-    email: x.input.email,
-    instructions: x.input.instructions,
+  context: ({ input }) => ({
+    email: input.email,
+    instructions: input.instructions,
     clarifications: [],
     replyEmail: null,
   }),
   states: {
     checking: {
-      invoke: {
-        src: 'agent',
-        input: (x) => ({
-          context: {
-            email: x.context.email,
-            instructions: x.context.instructions,
-            clarifications: x.context.clarifications,
-          },
-          messages: agent.getMessages(),
-          goal: 'Respond to the email given the instructions and the provided clarifications. If not enough information is provided, ask for clarification. Otherwise, if you are absolutely sure that there is no ambiguous or missing information, create and submit a response email.',
-        }),
-      },
       on: {
         askForClarification: {
-          actions: (x) => console.log(x.event.questions.join('\n')),
+          actions: ({ event }) => console.log(event.questions.join('\n')),
           target: 'clarifying',
         },
         submitEmail: {
@@ -70,25 +61,14 @@ const machine = setup({
         input: `Please provide answers to the questions above`,
         onDone: {
           actions: assign({
-            clarifications: (x) =>
-              x.context.clarifications.concat(x.event.output),
+            clarifications: ({ context, event }) =>
+              context.clarifications.concat(event.output),
           }),
           target: 'checking',
         },
       },
     },
     submitting: {
-      invoke: {
-        src: 'agent',
-        input: ({ context }) => ({
-          context: {
-            email: context.email,
-            instructions: context.instructions,
-            clarifications: context.clarifications,
-          },
-          goal: `Create and submit an email based on the instructions.`,
-        }),
-      },
       on: {
         submitEmail: {
           actions: assign({
@@ -100,7 +80,7 @@ const machine = setup({
     },
     done: {
       type: 'final',
-      entry: (x) => console.log(x.context.replyEmail),
+      entry: ({ context }) => console.log(context.replyEmail),
     },
   },
   exit: () => {
@@ -109,10 +89,26 @@ const machine = setup({
   },
 });
 
-createActor(machine, {
+const actor = createActor(machine, {
   input: {
     email: 'That sounds great! When are you available?',
     instructions:
       'Tell them exactly when I am available. Address them by his full (first and last) name.',
   },
 }).start();
+
+agent.interact(actor, ({ state }) => {
+  if (state.matches('checking')) {
+    return {
+      goal: 'Respond to the email given the instructions and the provided clarifications. If not enough information is provided, ask for clarification. Otherwise, if you are absolutely sure that there is no ambiguous or missing information, create and submit a response email.',
+      context: state.context,
+    };
+  }
+
+  if (state.matches('submitting')) {
+    return {
+      goal: 'Create and submit an email based on the instructions.',
+      context: state.context,
+    };
+  }
+});

package/examples/example.ts

@@ -4,8 +4,8 @@ import { openai } from '@ai-sdk/openai';
 import { assign, createActor, setup } from 'xstate';
 
 const agent = createAgent({
-  name: 'example',
-  model: openai('gpt-4-turbo'),
+  id: 'example',
+  model: openai('gpt-4o-mini'),
   events: {
     'agent.englishSummary': z.object({
       text: z.string().describe('The summary in English'),
@@ -32,8 +32,8 @@ const machine = setup({
       invoke: [
         {
           src: 'summarizer',
-          input: (x) => ({
-            context: x.context,
+          input: ({ context }) => ({
+            context,
             prompt:
               'Summarize the patient visit in a single sentence. The summary should be in English.',
           }),
@@ -45,8 +45,8 @@ const machine = setup({
         },
         {
           src: 'summarizer',
-          input: (x) => ({
-            context: x.context,
+          input: ({ context }) => ({
+            context,
             prompt:
               'Summarize the patient visit in a single sentence. The summary should be in Spanish.',
           }),

package/examples/executor.ts

@@ -0,0 +1,66 @@
+import { openai } from '@ai-sdk/openai';
+import { createAgent, fromDecision } from '../src';
+import { assign, createActor, createMachine, fromPromise } from 'xstate';
+import { z } from 'zod';
+import { fromTerminal } from './helpers/helpers';
+
+const agent = createAgent({
+  model: openai('gpt-4o-mini'),
+  events: {
+    getTime: z.object({}).describe('Get the current time'),
+    other: z.object({}).describe('Do something else'),
+  },
+});
+
+const machine = createMachine({
+  initial: 'start',
+  context: {
+    question: null,
+  },
+  states: {
+    start: {
+      invoke: {
+        src: fromTerminal,
+        input: 'What do you want to do?',
+        onDone: {
+          actions: assign({
+            question: ({ event }) => event.output,
+          }),
+          target: 'deciding',
+        },
+      },
+    },
+    deciding: {
+      invoke: {
+        src: fromDecision(agent),
+        input: ({ context }) => ({
+          goal: 'Satisfy the user question',
+          context,
+        }),
+      },
+      on: {
+        getTime: 'gettingTime',
+        other: 'other',
+      },
+    },
+    gettingTime: {
+      invoke: {
+        src: fromPromise(async () => {
+          console.log('Time:', new Date().toLocaleTimeString());
+        }),
+        onDone: 'start',
+      },
+    },
+    other: {
+      entry: () =>
+        console.log(
+          'You want me to do something else. I can only tell the time.'
+        ),
+      after: {
+        1000: 'start',
+      },
+    },
+  },
+});
+
+createActor(machine).start();

package/examples/goal.ts

@@ -2,11 +2,11 @@ import { z } from 'zod';
 import { createAgent, fromDecision } from '../src';
 import { openai } from '@ai-sdk/openai';
 import { assign, createActor, log, setup } from 'xstate';
-import { getFromTerminal } from './helpers/helpers';
+import { fromTerminal } from './helpers/helpers';
 
 const agent = createAgent({
-  name: 'goal',
-  model: openai('gpt-4-turbo'),
+  id: 'goal',
+  model: openai('gpt-4o-mini'),
   events: {
     'agent.createGoal': z.object({
       goal: z.string().describe('The goal for the conversation'),
@@ -27,7 +27,7 @@ const machine = setup({
     },
     events: agent.types.events,
   },
-  actors: { decider, getFromTerminal },
+  actors: { decider, getFromTerminal: fromTerminal },
 }).createMachine({
   initial: 'gettingQuestion',
   context: {
@@ -50,11 +50,11 @@ const machine = setup({
     makingGoal: {
       invoke: {
         src: 'decider',
-        input: {
-          context: true,
+        input: ({ context }) => ({
+          context,
           goal: 'Determine what the user wants to accomplish. What is their ideal goal state? ',
           maxRetries: 3,
-        },
+        }),
       },
       on: {
         'agent.createGoal': {
@@ -62,7 +62,7 @@ const machine = setup({
             assign({
               goal: ({ event }) => event.goal,
             }),
-            log((x) => x.event),
+            log(({ event }) => `Goal: ${event.goal}`),
           ],
           target: 'responding',
         },
@@ -71,15 +71,15 @@ const machine = setup({
     responding: {
       invoke: {
         src: 'decider',
-        input: {
-          context: true,
+        input: ({ context }) => ({
+          context,
           goal: 'Answer the question to achieve the stated goal, unless the goal is impossible to achieve.',
           maxRetries: 3,
-        },
+        }),
       },
       on: {
         'agent.respond': {
-          actions: log(({ event }) => event),
+          actions: log(({ event }) => `Response: ${event.response}`),
         },
       },
     },

package/examples/helpers/helpers.ts

@@ -1,17 +1,29 @@
 import { fromPromise } from 'xstate';
 
-export const getFromTerminal = fromPromise<string, string>(
-  async ({ input }) => {
-    const topic = await new Promise<string>((res) => {
-      console.log(input + '\n');
-      const listener = (data: Buffer) => {
-        const result = data.toString().trim();
-        process.stdin.off('data', listener);
-        res(result);
-      };
-      process.stdin.on('data', listener);
-    });
+export const fromTerminal = fromPromise<string, string>(async ({ input }) => {
+  const topic = await new Promise<string>((res) => {
+    console.log(input + '\n');
+    const listener = (data: Buffer) => {
+      const result = data.toString().trim();
+      process.stdin.off('data', listener);
+      res(result);
+    };
+    process.stdin.on('data', listener);
+  });
 
-    return topic;
-  }
-);
+  return topic;
+});
+
+export async function getFromTerminal(msg: string) {
+  const topic = await new Promise<string>((res) => {
+    console.log(msg + '\n');
+    const listener = (data: Buffer) => {
+      const result = data.toString().trim();
+      process.stdin.off('data', listener);
+      res(result);
+    };
+    process.stdin.on('data', listener);
+  });
+
+  return topic;
+}