@statelyai/agent 1.1.6 → 2.0.0-alpha.11

package/examples/multi.ts

@@ -1,103 +0,0 @@
-import { createAgent, fromDecision } from '../src';
-import { z } from 'zod';
-import { assign, createActor, log, setup } from 'xstate';
-import { getFromTerminal } from './helpers/helpers';
-import { openai } from '@ai-sdk/openai';
-
-const agent = createAgent({
-  name: 'multi',
-  model: openai('gpt-4-1106-preview'),
-  events: {
-    'agent.respond': z.object({
-      response: z.string().describe('The response from the agent'),
-    }),
-  },
-});
-
-const machine = setup({
-  types: {
-    context: {} as {
-      topic: string | null;
-      discourse: string[];
-    },
-  },
-  actors: {
-    getFromTerminal,
-    agent: fromDecision(agent),
-  },
-}).createMachine({
-  initial: 'asking',
-  context: {
-    topic: null,
-    discourse: [],
-  },
-  states: {
-    asking: {
-      invoke: {
-        src: 'getFromTerminal',
-        input: 'What is the question?',
-        onDone: {
-          actions: assign({
-            topic: ({ event }) => event.output,
-          }),
-          target: 'positiveResponse',
-        },
-      },
-    },
-    positiveResponse: {
-      invoke: {
-        src: 'agent',
-        input: ({ context }) => ({
-          context,
-          goal: 'Debate the topic, and take the positive position. Respond directly to the last message of the discourse. Keep it short.',
-        }),
-      },
-      on: {
-        'agent.respond': {
-          actions: [
-            assign({
-              discourse: ({ context, event }) =>
-                context.discourse.concat(event.response),
-            }),
-            log(({ event }) => event.response),
-          ],
-          target: 'negativeResponse',
-        },
-      },
-    },
-    negativeResponse: {
-      invoke: {
-        src: 'agent',
-        input: ({ context }) => ({
-          model: openai('gpt-3.5-turbo-16k-0613'),
-          context,
-          goal: 'Debate the topic, and take the negative position. Respond directly to the last message of the discourse. Keep it short.',
-        }),
-      },
-      on: {
-        'agent.respond': {
-          actions: [
-            assign({
-              discourse: ({ context, event }) =>
-                context.discourse.concat(event.response),
-            }),
-            log(({ event }) => event.response),
-          ],
-          target: 'positiveResponse',
-        },
-      },
-      always: {
-        guard: ({ context }) => context.discourse.length >= 5,
-        target: 'debateOver',
-      },
-    },
-    debateOver: {
-      type: 'final',
-    },
-  },
-  exit: () => {
-    process.exit();
-  },
-});
-
-createActor(machine).start();

package/examples/newspaper.ts

@@ -1,324 +0,0 @@
-// Based on GPT Newspaper:
-// https://github.com/assafelovic/gpt-newspaper
-// https://gist.github.com/TheGreatBonnie/58dc21ebbeeb8cbb08df665db762738c
-
-import { TavilySearchAPIRetriever } from '@langchain/community/retrievers/tavily_search_api';
-import { ChatOpenAI } from '@langchain/openai';
-import { HumanMessage, SystemMessage } from '@langchain/core/messages';
-import { assign, createActor, fromPromise, setup } from 'xstate';
-
-interface AgentState {
-  topic: string;
-  searchResults?: string;
-  article?: string;
-  critique?: string;
-  revisionCount: number;
-}
-
-function model() {
-  return new ChatOpenAI({
-    temperature: 0,
-    modelName: 'gpt-4-1106-preview',
-    openAIApiKey: process.env.OPENAI_API_KEY,
-  });
-}
-
-async function search({ topic }: Pick<AgentState, 'topic'>): Promise<string> {
-  const retriever = new TavilySearchAPIRetriever({
-    k: 10,
-    apiKey: process.env.TAVILY_API_KEY,
-  });
-  // let topic = state.agentState.topic;
-  // must be at least 5 characters long
-  if (topic.length < 5) {
-    topic = 'topic: ' + topic;
-  }
-  const docs = await retriever.invoke(topic);
-  return JSON.stringify(docs);
-}
-
-async function curate(
-  input: Pick<AgentState, 'topic' | 'searchResults'>
-): Promise<string> {
-  const response = await model().invoke(
-    [
-      new SystemMessage(
-        `You are a personal newspaper editor. 
-         Your sole task is to return a list of URLs of the 5 most relevant articles for the provided topic or query as a JSON list of strings
-         in this format:
-         {
-          urls: ["url1", "url2", "url3", "url4", "url5"]
-         }
-         .`.replace(/\s+/g, ' ')
-      ),
-      new HumanMessage(
-        `Today's date is ${new Date().toLocaleDateString('en-GB')}.
-       Topic or Query: ${input.topic}
-       
-       Here is a list of articles:
-       ${input.searchResults}`.replace(/\s+/g, ' ')
-      ),
-    ],
-    {
-      response_format: {
-        type: 'json_object',
-      },
-    }
-  );
-  const urls = JSON.parse(response.content as string).urls;
-  const searchResults = JSON.parse(input.searchResults!);
-  const newSearchResults = searchResults.filter((result: any) => {
-    return urls.includes(result.metadata.source);
-  });
-  return JSON.stringify(newSearchResults);
-}
-
-async function critique(
-  input: Pick<AgentState, 'article' | 'critique'>
-): Promise<string | undefined> {
-  let feedbackInstructions = '';
-  if (input.critique) {
-    feedbackInstructions =
-      `The writer has revised the article based on your previous critique: ${input.critique}
-       The writer might have left feedback for you encoded between <FEEDBACK> tags.
-       The feedback is only for you to see and will be removed from the final article.
-    `.replace(/\s+/g, ' ');
-  }
-  const response = await model().invoke([
-    new SystemMessage(
-      `You are a personal newspaper writing critique. Your sole purpose is to provide short feedback on a written 
-      article so the writer will know what to fix.       
-      Today's date is ${new Date().toLocaleDateString('en-GB')}
-      Your task is to provide a really short feedback on the article only if necessary.
-      if you think the article is good, please return [DONE].
-      you can provide feedback on the revised article or just
-      return [DONE] if you think the article is good.
-      Please return a string of your critique or [DONE].`.replace(/\s+/g, ' ')
-    ),
-    new HumanMessage(
-      `${feedbackInstructions}
-       This is the article: ${input.article}`
-    ),
-  ]);
-  const content = response.content as string;
-  console.log('critique:', content);
-  return content.includes('[DONE]') ? undefined : content;
-}
-
-async function write(
-  input: Pick<AgentState, 'searchResults' | 'topic'>
-): Promise<string> {
-  const response = await model().invoke([
-    new SystemMessage(
-      `You are a personal newspaper writer. Your sole purpose is to write a well-written article about a 
-      topic using a list of articles. Write 5 paragraphs in markdown.`.replace(
-        /\s+/g,
-        ' '
-      )
-    ),
-    new HumanMessage(
-      `Today's date is ${new Date().toLocaleDateString('en-GB')}.
-      Your task is to write a critically acclaimed article for me about the provided query or 
-      topic based on the sources. 
-      Here is a list of articles: ${input.searchResults}
-      This is the topic: ${input.topic}
-      Please return a well-written article based on the provided information.`.replace(
-        /\s+/g,
-        ' '
-      )
-    ),
-  ]);
-  const content = response.content as string;
-  return content;
-}
-
-async function revise(
-  input: Pick<AgentState, 'article' | 'critique'>
-): Promise<string> {
-  const response = await model().invoke([
-    new SystemMessage(
-      `You are a personal newspaper editor. Your sole purpose is to edit a well-written article about a 
-      topic based on given critique.`.replace(/\s+/g, ' ')
-    ),
-    new HumanMessage(
-      `Your task is to edit the article based on the critique given.
-      This is the article: ${input.article}
-      This is the critique: ${input.critique}
-      Please return the edited article based on the critique given.
-      You may leave feedback about the critique encoded between <FEEDBACK> tags like this:
-      <FEEDBACK> here goes the feedback ...</FEEDBACK>`.replace(/\s+/g, ' ')
-    ),
-  ]);
-  const content = response.content as string;
-  return content;
-}
-
-const machine = setup({
-  types: {
-    context: {} as AgentState,
-  },
-  actors: {
-    search: fromPromise(({ input }: { input: Pick<AgentState, 'topic'> }) => {
-      return search(input);
-    }),
-    curate: fromPromise(
-      ({ input }: { input: Pick<AgentState, 'topic' | 'searchResults'> }) => {
-        return curate(input);
-      }
-    ),
-    critique: fromPromise(
-      ({ input }: { input: Pick<AgentState, 'article' | 'critique'> }) => {
-        return critique(input);
-      }
-    ),
-    write: fromPromise(
-      ({ input }: { input: Pick<AgentState, 'searchResults' | 'topic'> }) => {
-        return write(input);
-      }
-    ),
-    revise: fromPromise(
-      ({ input }: { input: Pick<AgentState, 'article' | 'critique'> }) => {
-        return revise(input);
-      }
-    ),
-  },
-}).createMachine({
-  context: {
-    topic: 'Orlando',
-    revisionCount: 0,
-  },
-  initial: 'search',
-  states: {
-    search: {
-      invoke: {
-        src: 'search',
-        input: ({ context }) => ({
-          topic: context.topic,
-        }),
-        onDone: {
-          actions: assign({
-            searchResults: ({ event }) => event.output,
-          }),
-          target: 'curate',
-        },
-      },
-    },
-    curate: {
-      invoke: {
-        src: 'curate',
-        input: ({ context }) => ({
-          topic: context.topic,
-          searchResults: context.searchResults!,
-        }),
-        onDone: {
-          actions: assign({
-            searchResults: ({ event }) => event.output,
-          }),
-          target: 'write',
-        },
-      },
-    },
-    write: {
-      invoke: {
-        src: 'write',
-        input: ({ context }) => ({
-          topic: context.topic,
-          searchResults: context.searchResults!,
-        }),
-        onDone: {
-          actions: assign({
-            article: ({ event }) => event.output,
-          }),
-          target: 'critique',
-        },
-      },
-    },
-    critique: {
-      invoke: {
-        src: 'critique',
-        input: ({ context }) => ({
-          article: context.article!,
-          critique: context.critique,
-        }),
-        onDone: [
-          {
-            guard: ({ event }) => event.output === undefined,
-            target: 'done',
-          },
-          {
-            actions: assign({
-              article: ({ event }) => event.output,
-            }),
-            target: 'revise',
-          },
-        ],
-      },
-    },
-    revise: {
-      always: {
-        guard: ({ context }) => context.revisionCount > 3,
-        target: 'done',
-      },
-      entry: assign({
-        revisionCount: ({ context }) => context.revisionCount + 1,
-      }),
-      invoke: {
-        src: 'revise',
-        input: ({ context }) => ({
-          article: context.article!,
-          critique: context.critique,
-        }),
-        onDone: {
-          actions: assign({
-            article: ({ event }) => event.output,
-          }),
-          target: 'revise',
-          reenter: true,
-        },
-      },
-    },
-    done: {
-      type: 'final',
-    },
-  },
-  output: ({ context }) => context.article,
-});
-
-const actor = createActor(machine, {
-  // inspect: (inspEv) => {
-  //   if (inspEv.type === '@xstate.event') {
-  //     console.log(JSON.stringify(inspEv.event, null, 2));
-  //   }
-  // },
-});
-
-actor.subscribe({
-  next: (s) => {
-    console.log('State:', s.value);
-    console.log(
-      'Context:',
-      JSON.stringify(
-        s.context,
-        (k, v) => {
-          if (typeof v === 'string') {
-            // truncate if longer than 50 chars
-            return v.length > 50 ? `${v.slice(0, 50)}...` : v;
-          }
-          return v;
-        },
-        2
-      )
-    );
-  },
-  complete: () => {
-    console.log(actor.getSnapshot().output);
-  },
-  error: (err) => {
-    console.error(err);
-  },
-});
-
-actor.start();
-
-// keep the process alive by invoking a promise that never resolves
-new Promise(() => {});

package/examples/number.ts

@@ -1,102 +0,0 @@
-import { createAgent, fromDecision } from '../src';
-import { assign, createActor, log, setup } from 'xstate';
-import { z } from 'zod';
-import { openai } from '@ai-sdk/openai';
-import { getFromTerminal } from './helpers/helpers';
-
-const agent = createAgent({
-  name: 'number-guesser',
-  model: openai('gpt-3.5-turbo-1106'),
-  events: {
-    'agent.guess': z.object({
-      number: z.number().min(1).max(10).describe('The number guessed'),
-    }),
-  },
-});
-
-const machine = setup({
-  types: {
-    context: {} as {
-      previousGuesses: number[];
-      answer: number | null;
-    },
-    events: agent.types.events,
-  },
-  actors: {
-    agent: fromDecision(agent),
-    getFromTerminal,
-  },
-}).createMachine({
-  context: {
-    answer: null,
-    previousGuesses: [],
-  },
-  initial: 'providing',
-  states: {
-    providing: {
-      invoke: {
-        src: 'getFromTerminal',
-        input: 'Enter a number between 1 and 10',
-        onDone: {
-          actions: assign({
-            answer: (x) => +x.event.output,
-          }),
-          target: 'guessing',
-        },
-      },
-    },
-    guessing: {
-      always: {
-        guard: ({ context }) =>
-          context.answer === context.previousGuesses.at(-1),
-        target: 'winner',
-      },
-      invoke: {
-        src: 'agent',
-        input: ({ context }) => ({
-          goal: `
-          Guess the number between 1 and 10. The previous guesses were ${
-            context.previousGuesses.length
-              ? context.previousGuesses.join(', ')
-              : 'not made yet'
-          } and the last result was ${
-            context.previousGuesses.length === 0
-              ? 'not given yet'
-              : context.previousGuesses.at(-1)! - context.answer! > 0
-              ? 'too high'
-              : 'too low'
-          }.
-        `,
-        }),
-      },
-      on: {
-        'agent.guess': {
-          actions: [
-            assign({
-              previousGuesses: ({ context, event }) => [
-                ...context.previousGuesses,
-                event.number,
-              ],
-            }),
-            log((x) => x.event.number),
-          ],
-          target: 'guessing',
-          reenter: true,
-        },
-      },
-    },
-    winner: {
-      entry: log('You guessed the correct number!'),
-      type: 'final',
-    },
-  },
-  exit: () => {
-    process.exit();
-  },
-});
-
-const actor = createActor(machine, {
-  input: { answer: 4 },
-});
-
-actor.start();

package/examples/raffle.ts

@@ -1,105 +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: 'raffle-chooser',
-  model: openai('gpt-4-turbo'),
-  events: {
-    'agent.collectEntries': z.object({}).describe('Collect more entries'),
-    'agent.draw': z.object({}).describe('Draw a winner'),
-    'agent.reportWinner': z.object({
-      winningEntry: z.string().describe('The winning entry'),
-      firstRunnerUp: z.string().describe('The first runner up entry'),
-      secondRunnerUp: z.string().describe('The second runner up entry'),
-      explanation: z
-        .string()
-        .describe('Explanation for why you chose the winning entry'),
-    }),
-  },
-});
-
-const machine = setup({
-  types: {
-    context: {} as {
-      lastInput: string | null;
-      entries: string[];
-    },
-    events: {} as typeof agent.types.events | { type: 'draw' },
-  },
-  actors: { agent: fromDecision(agent), getFromTerminal },
-}).createMachine({
-  /** @xstate-layout N4IgpgJg5mDOIC5QAoC2BDAxgCwJYDswBKAOjHwBcwAnAqAYggHtCSCA3JgazBLSzyFS5KrXxQEHJpnQVcLANoAGALrKViUAAcmsXHJaaQAD0QAmAOwBmEmYCsADgCMZgJxmALE4ceHSuwA0IACe5gBsZiR29q5KPnaOrmEOAL4pQfw4BMQkEGCiqAR09OgwlCSYTAA2VWCYFACilLRw6kY6egb4RqYIZg52JB52Ya5jSq5+To4eQaEILhYkA0qjVlYeSlsOYWFpGRhZQrn5NIX4xaUiudToAO5tSCAd+vLdT727SiRKHsl2FjCwxcrlmIUQTl2ticHk26ycMPsqXSIEyghyEFud0uZQoJGoYB01AoAHUCIRqI9tLpXoYPohXBYnCQnP4HK4nFYLF5vK45hCPDYmVtdk5uYzuWkUfgmHl4E80dkiO0aV0eogALRhfkIDWDMZjJn9MxhKwjSb7VGHdHCSg0OgqzpvdUIDxmHWc5l2caeKxhVYDFyWxXHPIFIriR2096gXoeVw2VmgiIOBzWJRiqwe2FRdzcpRWE0JPPB61Km73B1PF5q+kIPweEhWMWjCz+BJKJketwkQEWCyuOywv0WaJ2UsCcvY-AUqO12MQls-Ue+Px2KzspweoHLXxsjO-eNmMxSlJAA */
-  context: {
-    lastInput: null,
-    entries: [],
-  },
-  initial: 'entering',
-  states: {
-    entering: {
-      entry: log(({ context }) => context.entries),
-      invoke: {
-        src: 'getFromTerminal',
-        input: 'What technology are you most interested in right now?',
-        onDone: [
-          {
-            actions: assign({
-              lastInput: ({ event }) => event.output,
-            }),
-            target: 'determining',
-          },
-        ],
-      },
-    },
-    determining: {
-      invoke: {
-        src: 'agent',
-        input: {
-          context: true,
-          goal: 'If the last input explicitly says to end the drawing and/or choose a winner, start the drawing process. Otherwise, get more entries.',
-        },
-      },
-      on: {
-        'agent.collectEntries': {
-          target: 'entering',
-          actions: assign({
-            entries: ({ context }) => [...context.entries, context.lastInput!],
-            lastInput: null,
-          }),
-        },
-        'agent.draw': 'drawing',
-      },
-    },
-    drawing: {
-      entry: log('And the winner is...'),
-      invoke: {
-        src: 'agent',
-        input: {
-          context: true,
-          goal: 'Choose the technology that sounds most exciting to you from the entries. Be as unbiased as possible in your choice. Explain why you chose the winning entry.',
-        },
-      },
-      on: {
-        'agent.reportWinner': {
-          actions: log(
-            ({ event }) =>
-              `\n🎉🎉🎉 ${event.winningEntry} 🎉🎉🎉\n\n${event.explanation}`
-          ),
-          target: 'winner',
-        },
-      },
-    },
-    winner: {
-      type: 'final',
-    },
-  },
-  exit: () => {
-    process.exit(0);
-  },
-});
-
-const actor = createActor(machine);
-
-actor.start();

package/examples/sandbox.ts

@@ -1,28 +0,0 @@
-import { z } from 'zod';
-import { createAgent } from '../src';
-import { openai } from '@ai-sdk/openai';
-import { createMachine } from 'xstate';
-
-const agent = createAgent({
-  model: openai('gpt-4o'),
-  events: {
-    doSomething: z.object({}).describe('Do something'),
-  },
-});
-
-async function main() {
-  const machine = createMachine({
-    on: {
-      doSomething: {},
-    },
-  });
-  const result = await agent.decide({
-    goal: 'Do not do anything',
-    state: { value: {}, context: {} },
-    machine,
-  });
-
-  console.log(result);
-}
-
-main();

package/examples/simple.ts

@@ -1,39 +0,0 @@
-import { createAgent, fromDecision } from '../src';
-import { z } from 'zod';
-import { setup, createActor } from 'xstate';
-import { openai } from '@ai-sdk/openai';
-
-const agent = createAgent({
-  name: 'simple',
-  model: openai('gpt-3.5-turbo-16k-0613'),
-  events: {
-    'agent.thought': z.object({
-      text: z.string().describe('The text of the thought'),
-    }),
-  },
-});
-
-const machine = setup({
-  actors: { agent: fromDecision(agent) },
-}).createMachine({
-  initial: 'thinking',
-  states: {
-    thinking: {
-      invoke: {
-        src: 'agent',
-        input: 'Think about a random topic, and then share that thought.',
-      },
-      on: {
-        'agent.thought': {
-          actions: ({ event }) => console.log(event.text),
-          target: 'thought',
-        },
-      },
-    },
-    thought: {
-      type: 'final',
-    },
-  },
-});
-
-const actor = createActor(machine).start();