@statelyai/agent 1.1.5 → 2.0.0-alpha.10

package/examples/cot.ts

@@ -1,89 +0,0 @@
-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'),
-    }),
-  },
-  context: {
-    question: z.string().nullable(),
-    thought: z.string().nullable(),
-  },
-});
-
-const machine = setup({
-  types: agent.types,
-  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

@@ -1,118 +0,0 @@
-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.types.events,
-    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.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')),
-          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

@@ -1,81 +0,0 @@
-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.types.events,
-  },
-  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: (x) => ({
-            context: x.context,
-            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: (x) => ({
-            context: x.context,
-            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

@@ -1,94 +0,0 @@
-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.types.events,
-  },
-  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();

package/examples/helpers/helpers.ts

@@ -1,17 +0,0 @@
-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);
-    });
-
-    return topic;
-  }
-);

package/examples/helpers/loader.ts

@@ -1,32 +0,0 @@
-// Adapted from https://stackoverflow.com/questions/34848505/how-to-make-a-loading-animation-in-console-application-written-in-javascript-or
-
-/**
- * Create and display a loader in the console.
- *
- * @param {string} [text=""] Text to display after loader
- * @param {array.<string>} [chars=["⠙", "⠘", "⠰", "⠴", "⠤", "⠦", "⠆", "⠃", "⠋", "⠉"]]
- * Array of characters representing loader steps
- * @param {number} [delay=100] Delay in ms between loader steps
- * @example
- * let loader = loadingAnimation("Loading…");
- *
- * // Stop loader after 1 second
- * setTimeout(() => clearInterval(loader), 1000);
- * @returns {number} An interval that can be cleared to stop the animation
- */
-export function loadingAnimation(
-  text: string = '',
-  chars: Array<string> = ['⠙', '⠘', '⠰', '⠴', '⠤', '⠦', '⠆', '⠃', '⠋', '⠉'],
-  delay: number = 100
-) {
-  let x = 0;
-
-  const i = setInterval(function () {
-    process.stdout.write('\r' + chars[x++] + ' ' + text);
-    x = x % chars.length;
-  }, delay);
-
-  return {
-    stop: () => clearInterval(i),
-  };
-}

package/examples/helpers/runner.ts

@@ -1,27 +0,0 @@
-import dotenv from 'dotenv';
-import { existsSync, readdirSync } from 'fs';
-dotenv.config();
-
-function showExamples() {
-  const exampleFiles = readdirSync('./examples', { withFileTypes: true });
-  exampleFiles.forEach((file) => {
-    if (file.isDirectory()) return;
-    const exampleName = file.name.split('.')[0];
-    console.log(`- ${exampleName}`);
-  });
-  process.exit();
-}
-
-const exampleParams = process.argv.slice(2);
-if (exampleParams.length === 0) {
-  console.error('No example specified, you can choose from:');
-  showExamples();
-}
-const exampleName = exampleParams[0];
-const filePath = `./examples/${exampleName}.ts`;
-if (existsSync(filePath)) {
-  require(`../${exampleName}.ts`);
-} else {
-  console.error(`Example ${exampleName} does not exist, you can choose from:`);
-  showExamples();
-}

package/examples/joke.ts

@@ -1,225 +0,0 @@
-import { assign, createActor, fromCallback, log, setup } from 'xstate';
-import { createAgent, fromDecision } from '../src';
-import { loadingAnimation } from './helpers/loader';
-import { z } from 'zod';
-import { openai } from '@ai-sdk/openai';
-import { getFromTerminal } from './helpers/helpers';
-
-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)]!;
-}
-
-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)]!;
-}
-
-const loader = fromCallback(({ input }: { input: string }) => {
-  const anim = loadingAnimation(input);
-
-  return () => {
-    anim.stop();
-  };
-});
-
-const agent = createAgent({
-  name: 'joke-teller',
-  model: openai('gpt-4-turbo'),
-  events: {
-    askForTopic: z.object({
-      topic: z.string().describe('The topic for the joke'),
-    }),
-    'agent.tellJoke': z.object({
-      joke: z.string().describe('The joke text'),
-    }),
-    'agent.endJokes': z.object({}).describe('End the jokes'),
-    'agent.rateJoke': z.object({
-      rating: z.number().min(1).max(10),
-      explanation: z.string(),
-    }),
-    'agent.continue': z.object({}).describe('Continue'),
-    'agent.markAsIrrelevant': z
-      .object({
-        explanation: z.string(),
-      })
-      .describe('Explains why the joke was irrelevant'),
-    'agent.markAsRelevant': z.object({}).describe('The joke was relevant'),
-  },
-  context: {
-    topic: z.string().describe('The topic for the joke'),
-    jokes: z.array(z.string()).describe('The jokes told so far'),
-    desire: z.string().nullable().describe('The user desire'),
-    lastRating: z.number().nullable().describe('The last joke rating'),
-    loader: z.string().nullable().describe('The loader text'),
-  },
-});
-
-const jokeMachine = setup({
-  types: agent.types,
-  actors: {
-    agent: fromDecision(agent),
-    loader,
-    getFromTerminal,
-  },
-}).createMachine({
-  id: 'joke',
-  context: () => ({
-    topic: '',
-    jokes: [],
-    desire: null,
-    lastRating: null,
-    loader: null,
-  }),
-  initial: 'waitingForTopic',
-  states: {
-    waitingForTopic: {
-      invoke: {
-        src: 'getFromTerminal',
-        input: 'Give me a joke topic.',
-        onDone: {
-          actions: assign({
-            topic: ({ event }) => event.output,
-          }),
-          target: 'tellingJoke',
-        },
-      },
-    },
-    tellingJoke: {
-      invoke: [
-        {
-          src: 'agent',
-          input: ({ context }) => ({
-            context: {
-              topic: context.topic,
-            },
-            goal: `Tell me a joke about the topic. Do not make any joke that is not relevant to the topic.`,
-          }),
-        },
-        {
-          src: 'loader',
-          input: getRandomFunnyPhrase,
-        },
-      ],
-      on: {
-        'agent.tellJoke': {
-          actions: [
-            assign({
-              jokes: ({ context, event }) => [...context.jokes, event.joke],
-            }),
-            log((x) => x.event.joke),
-          ],
-          target: 'relevance',
-        },
-      },
-    },
-    relevance: {
-      invoke: {
-        src: 'agent',
-        input: (x) => ({
-          context: {
-            topic: x.context.topic,
-            lastJoke: x.context.jokes[x.context.jokes.length - 1],
-          },
-          goal: 'An irrelevant joke has no reference to the topic. If the last joke is completely irrelevant to the topic, ask for a new joke topic. Otherwise, continue.',
-        }),
-      },
-      on: {
-        'agent.markAsIrrelevant': {
-          actions: log((x) => 'Irrelevant joke: ' + x.event.explanation),
-          target: 'waitingForTopic',
-          description: 'Continue',
-        },
-        'agent.markAsRelevant': {
-          actions: log('Joke was relevant'),
-          target: 'rateJoke',
-        },
-      },
-    },
-    rateJoke: {
-      invoke: [
-        {
-          src: 'agent',
-          input: ({ context }) => ({
-            context: {
-              jokes: context.jokes,
-            },
-            goal: `Rate the last joke on a scale of 1 to 10.`,
-          }),
-        },
-        {
-          src: 'loader',
-          input: getRandomRatingPhrase,
-        },
-      ],
-      on: {
-        'agent.rateJoke': {
-          actions: [
-            assign({
-              lastRating: ({ event }) => event.rating,
-            }),
-            log(
-              ({ event }) => `Rating: ${event.rating}\n\n${event.explanation}`
-            ),
-          ],
-          target: 'decide',
-        },
-      },
-    },
-    decide: {
-      invoke: {
-        src: 'agent',
-        input: ({ context }) => ({
-          context: {
-            lastRating: context.lastRating,
-          },
-          goal: `Choose what to do next, given the previous rating of the joke.`,
-        }),
-      },
-      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',
-        },
-        'agent.endJokes': {
-          target: 'end',
-          actions: log('That joke was good enough. Goodbye!'),
-          description: 'End the jokes, since the last joke rated 7 or higher',
-        },
-      },
-    },
-    end: {
-      type: 'final',
-    },
-  },
-  exit: () => {
-    process.exit();
-  },
-});
-
-const actor = createActor(jokeMachine);
-
-actor.start();