@statelyai/agent 0.0.7 → 0.1.0

package/examples/joke.ts

@@ -1,74 +1,10 @@
-import OpenAI from 'openai';
-import { assign, fromCallback, fromPromise, log, setup } from 'xstate';
-import { createAgent, createOpenAIAdapter, createSchemas } from '../src';
+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';
 
-const openai = new OpenAI({
-  apiKey: process.env.OPENAI_API_KEY,
-});
-
-const schemas = createSchemas({
-  context: {
-    type: 'object',
-    properties: {
-      topic: { type: 'string' },
-      jokes: {
-        type: 'array',
-        items: {
-          type: 'string',
-        },
-      },
-      desire: { type: ['string', 'null'] },
-      lastRating: { type: ['string', 'null'] },
-    },
-    required: ['topic', 'jokes', 'desire', 'lastRating'],
-  },
-  events: {
-    askForTopic: {
-      type: 'object',
-      properties: {
-        topic: {
-          type: 'string',
-        },
-      },
-    },
-    endJokes: {
-      type: 'object',
-      properties: {},
-    },
-  },
-});
-
-const adapter = createOpenAIAdapter(openai, {
-  model: 'gpt-3.5-turbo-1106',
-});
-
-const getJokeCompletion = adapter.fromChat(
-  (topic: string) => `Tell me a joke about ${topic}.`
-);
-
-const rateJoke = adapter.fromChat(
-  (joke: string) => `Rate this joke on a scale of 1 to 10: ${joke}`
-);
-
-const getTopic = fromPromise(async () => {
-  const topic = await new Promise<string>((res) => {
-    console.log('Give me a joke topic:');
-    const listener = (data: Buffer) => {
-      const result = data.toString().trim();
-      process.stdin.off('data', listener);
-      res(result);
-    };
-    process.stdin.on('data', listener);
-  });
-
-  return topic;
-});
-
-const decide = adapter.fromEvent(
-  (lastRating: string) =>
-    `Choose what to do next, given the previous rating of the joke: ${lastRating}`
-);
 export function getRandomFunnyPhrase() {
   const funnyPhrases = [
     'Concocting chuckles...',
@@ -108,17 +44,49 @@ const loader = fromCallback(({ input }: { input: string }) => {
   };
 });
 
+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'),
+  },
+});
+
 const jokeMachine = setup({
-  schemas,
-  types: schemas.types,
+  types: {
+    context: {} as {
+      topic: string;
+      jokes: string[];
+      desire: string | null;
+      lastRating: number | null;
+      loader: string | null;
+    },
+    events: agent.eventTypes,
+  },
   actors: {
-    getJokeCompletion,
-    getTopic,
-    rateJoke,
-    decide,
+    agent: fromDecision(agent),
     loader,
+    getFromTerminal,
   },
 }).createMachine({
+  id: 'joke',
   context: () => ({
     topic: '',
     jokes: [],
@@ -130,7 +98,8 @@ const jokeMachine = setup({
   states: {
     waitingForTopic: {
       invoke: {
-        src: 'getTopic',
+        src: 'getFromTerminal',
+        input: 'Give me a joke topic.',
         onDone: {
           actions: assign({
             topic: ({ event }) => event.output,
@@ -142,56 +111,93 @@ const jokeMachine = setup({
     tellingJoke: {
       invoke: [
         {
-          src: 'getJokeCompletion',
-          input: ({ context }) => context.topic,
-          onDone: {
-            actions: [
-              assign({
-                jokes: ({ context, event }) =>
-                  context.jokes.concat(
-                    event.output.choices[0]!.message.content!
-                  ),
-              }),
-              log((x) => `\n` + x.context.jokes.at(-1)),
-            ],
-            target: 'rateJoke',
-          },
+          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: 'rateJoke',
-          input: ({ context }) => context.jokes[context.jokes.length - 1]!,
-          onDone: {
-            actions: [
-              assign({
-                lastRating: ({ event }) =>
-                  event.output.choices[0]!.message.content!,
-              }),
-              log(({ context }) => '\n' + context.lastRating),
-            ],
-            target: 'decide',
-          },
+          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: 'decide',
-        input: ({ context }) => context.lastRating!,
-        onDone: {
-          actions: log(({ event }) => event),
-        },
+        src: 'agent',
+        input: ({ context }) => ({
+          context: {
+            lastRating: context.lastRating,
+          },
+          goal: `Choose what to do next, given the previous rating of the joke.`,
+        }),
       },
       on: {
         askForTopic: {
@@ -200,7 +206,7 @@ const jokeMachine = setup({
           description:
             'Ask for a new topic, because the last joke rated 6 or lower',
         },
-        endJokes: {
+        'agent.endJokes': {
           target: 'end',
           actions: log('That joke was good enough. Goodbye!'),
           description: 'End the jokes, since the last joke rated 7 or higher',
@@ -216,5 +222,6 @@ const jokeMachine = setup({
   },
 });
 
-const agent = createAgent(jokeMachine);
-agent.start();
+const actor = createActor(jokeMachine);
+
+actor.start();

package/examples/multi.ts

@@ -0,0 +1,103 @@
+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

@@ -0,0 +1,324 @@
+// 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(() => {});