@statelyai/agent 0.0.7 → 0.1.0

package/dist/index.mjs

@@ -0,0 +1,7 @@
+// src/index.ts
+function helloWorld() {
+  return "Hello World!";
+}
+export {
+  helloWorld
+};

package/examples/chatbot.ts

@@ -0,0 +1,79 @@
+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';
+
+const agent = createAgent({
+  name: 'chatbot',
+  model: openai('gpt-4-turbo'),
+  events: {
+    'agent.respond': z.object({
+      response: z.string().describe('The response from the agent'),
+    }),
+    'agent.endConversation': z.object({}).describe('Stop the conversation'),
+  },
+});
+
+const machine = setup({
+  types: {
+    context: {} as {
+      conversation: string[];
+    },
+    events: agent.eventTypes,
+  },
+  actors: { agent: fromDecision(agent), getFromTerminal },
+}).createMachine({
+  initial: 'listening',
+  context: {
+    conversation: [],
+  },
+  states: {
+    listening: {
+      invoke: {
+        src: 'getFromTerminal',
+        input: 'User:',
+        onDone: {
+          actions: assign({
+            conversation: (x) =>
+              x.context.conversation.concat('User: ' + x.event.output),
+          }),
+          target: 'responding',
+        },
+      },
+    },
+    responding: {
+      invoke: {
+        src: 'agent',
+        input: (x) => ({
+          context: {
+            conversation: x.context.conversation,
+          },
+          goal: 'Respond to the user, unless they want to end the conversation.',
+        }),
+      },
+      on: {
+        'agent.respond': {
+          actions: [
+            assign({
+              conversation: (x) =>
+                x.context.conversation.concat('Assistant: ' + x.event.response),
+            }),
+            log((x) => `Agent: ${x.event.response}`),
+          ],
+          target: 'listening',
+        },
+        'agent.endConversation': 'finished',
+      },
+    },
+    finished: {
+      type: 'final',
+    },
+  },
+  exit: () => {
+    console.log('End of conversation.');
+    process.exit();
+  },
+});
+
+createActor(machine).start();

package/examples/cot.ts

@@ -0,0 +1,91 @@
+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';
+
+const agent = createAgent({
+  name: 'chain-of-thought',
+  model: openai('gpt-4o'),
+  events: {
+    'agent.think': z.object({
+      thought: z
+        .string()
+        .describe('The thought process to answering the question'),
+    }),
+    'agent.answer': z.object({
+      answer: z.string().describe('The answer to the question'),
+    }),
+  },
+});
+
+const machine = setup({
+  types: {
+    context: {} as {
+      question: string | null;
+      thought: string | null;
+    },
+    events: agent.eventTypes,
+  },
+  actors: { agent: fromDecision(agent), getFromTerminal },
+}).createMachine({
+  initial: 'asking',
+  context: {
+    question: null,
+    thought: null,
+  },
+  states: {
+    asking: {
+      invoke: {
+        src: 'getFromTerminal',
+        input: 'What would you like to ask?',
+        onDone: {
+          actions: assign({
+            question: (x) => x.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),
+            assign({
+              thought: (x) => x.event.thought,
+            }),
+          ],
+          target: 'answering',
+        },
+      },
+    },
+    answering: {
+      invoke: {
+        src: 'agent',
+        input: (x) => ({
+          context: x.context,
+          goal: 'Answer the question',
+        }),
+      },
+      on: {
+        'agent.answer': {
+          actions: [log((x) => x.event.answer)],
+          target: 'answered',
+        },
+      },
+    },
+    answered: {
+      type: 'final',
+    },
+  },
+});
+
+createActor(machine).start();

package/examples/email.ts

@@ -0,0 +1,118 @@
+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';
+
+const agent = createAgent({
+  name: 'email',
+  model: openai('gpt-4'),
+  events: {
+    askForClarification: z.object({
+      questions: z.array(z.string()).describe('The questions to ask the agent'),
+    }),
+    submitEmail: z.object({
+      email: z.string().describe('The email to submit'),
+    }),
+  },
+});
+
+const machine = setup({
+  types: {
+    events: agent.eventTypes,
+    input: {} as {
+      email: string;
+      instructions: string;
+    },
+    context: {} as {
+      email: string;
+      instructions: string;
+      clarifications: string[];
+      replyEmail: string | null;
+    },
+  },
+  actors: { agent: fromDecision(agent), getFromTerminal },
+}).createMachine({
+  initial: 'checking',
+  context: (x) => ({
+    email: x.input.email,
+    instructions: x.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.select((ctx) => ctx.messages),
+          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')),
+          target: 'clarifying',
+        },
+        submitEmail: {
+          target: 'submitting',
+        },
+      },
+    },
+    clarifying: {
+      invoke: {
+        src: 'getFromTerminal',
+        input: `Please provide answers to the questions above`,
+        onDone: {
+          actions: assign({
+            clarifications: (x) =>
+              x.context.clarifications.concat(x.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({
+            replyEmail: ({ event }) => event.email,
+          }),
+          target: 'done',
+        },
+      },
+    },
+    done: {
+      type: 'final',
+      entry: (x) => console.log(x.context.replyEmail),
+    },
+  },
+  exit: () => {
+    console.log('End of conversation.');
+    process.exit();
+  },
+});
+
+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();

package/examples/example.ts

@@ -0,0 +1,81 @@
+import { z } from 'zod';
+import { createAgent, fromDecision, fromText } from '../src';
+import { openai } from '@ai-sdk/openai';
+import { assign, createActor, setup } from 'xstate';
+
+const agent = createAgent({
+  name: 'example',
+  model: openai('gpt-4-turbo'),
+  events: {
+    'agent.englishSummary': z.object({
+      text: z.string().describe('The summary in English'),
+    }),
+    'agent.spanishSummary': z.object({
+      text: z.string().describe('The summary in Spanish'),
+    }),
+  },
+});
+
+const machine = setup({
+  types: {
+    events: agent.eventTypes,
+  },
+  actors: { agent: fromDecision(agent), summarizer: fromText(agent) },
+}).createMachine({
+  initial: 'summarizing',
+  context: {
+    patientVisit:
+      'During my visit, the doctor explained my condition clearly. She listened to my concerns and recommended a treatment plan. My condition was diagnosed as X after a series of tests. I feel relieved to have a clear path forward with managing my health. Also, the staff were very friendly and helpful at check-in and check-out. Furthermore, the facilities were clean and well-maintained.',
+  },
+  states: {
+    summarizing: {
+      invoke: [
+        {
+          src: 'summarizer',
+          input: {
+            context: true,
+            prompt:
+              'Summarize the patient visit in a single sentence. The summary should be in English.',
+          },
+          onDone: {
+            actions: assign({
+              englishSummary: ({ event }) => event.output.text,
+            }),
+          },
+        },
+        {
+          src: 'summarizer',
+          input: {
+            context: true,
+            prompt:
+              'Summarize the patient visit in a single sentence. The summary should be in Spanish.',
+          },
+          onDone: {
+            actions: assign({
+              spanishSummary: ({ event }) => event.output.text,
+            }),
+          },
+        },
+      ],
+      always: {
+        guard: ({ context }) =>
+          context.englishSummary && context.spanishSummary,
+        target: 'summarized',
+      },
+    },
+    summarized: {
+      entry: ({ context }) => {
+        console.log(context.englishSummary);
+        console.log(context.spanishSummary);
+      },
+    },
+  },
+});
+
+const actor = createActor(machine);
+
+actor.subscribe((s) => {
+  console.log(s.context);
+});
+
+actor.start();

package/examples/goal.ts

@@ -0,0 +1,94 @@
+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';
+
+const agent = createAgent({
+  name: 'goal',
+  model: openai('gpt-4-turbo'),
+  events: {
+    'agent.createGoal': z.object({
+      goal: z.string().describe('The goal for the conversation'),
+    }),
+    'agent.respond': z.object({
+      response: z.string().describe('The response from the agent'),
+    }),
+  },
+});
+
+const decider = fromDecision(agent);
+
+const machine = setup({
+  types: {
+    context: {} as {
+      question: string | null;
+      goal: string | null;
+    },
+    events: agent.eventTypes,
+  },
+  actors: { decider, getFromTerminal },
+}).createMachine({
+  initial: 'gettingQuestion',
+  context: {
+    question: null,
+    goal: null,
+  },
+  states: {
+    gettingQuestion: {
+      invoke: {
+        src: 'getFromTerminal',
+        input: 'What would you like to ask?',
+        onDone: {
+          actions: assign({
+            question: ({ event }) => event.output,
+          }),
+          target: 'makingGoal',
+        },
+      },
+    },
+    makingGoal: {
+      invoke: {
+        src: 'decider',
+        input: {
+          context: true,
+          goal: 'Determine what the user wants to accomplish. What is their ideal goal state? ',
+          maxRetries: 3,
+        },
+      },
+      on: {
+        'agent.createGoal': {
+          actions: [
+            assign({
+              goal: ({ event }) => event.goal,
+            }),
+            log((x) => x.event),
+          ],
+          target: 'responding',
+        },
+      },
+    },
+    responding: {
+      invoke: {
+        src: 'decider',
+        input: {
+          context: true,
+          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),
+        },
+      },
+    },
+    responded: {
+      type: 'final',
+    },
+  },
+});
+
+const actor = createActor(machine);
+
+actor.start();