@statelyai/agent 1.1.6 → 2.0.0-alpha.5

package/examples/verify.ts

@@ -1,120 +0,0 @@
-import { assign, createActor, setup, log } from 'xstate';
-import { getFromTerminal } from './helpers/helpers';
-import { createAgent, fromDecision } from '../src';
-import { z } from 'zod';
-import { openai } from '@ai-sdk/openai';
-
-const agent = createAgent({
-  name: 'verifier',
-  model: openai('gpt-3.5-turbo-16k-0613'),
-  events: {
-    'agent.validateAnswer': z.object({
-      isValid: z.boolean(),
-      feedback: z.string(),
-    }),
-    'agent.answerQuestion': z.object({
-      answer: z.string().describe('The answer from the agent'),
-    }),
-    'agent.validateQuestion': z.object({
-      isValid: z
-        .boolean()
-        .describe(
-          'Whether the question is a valid question; that is, is it possible to even answer this question in a verifiably correct way?'
-        ),
-      explanation: z
-        .string()
-        .describe('An explanation for why the question is or is not valid'),
-    }),
-  },
-});
-
-const machine = setup({
-  types: {
-    context: {} as {
-      question: string | null;
-      answer: string | null;
-      validation: string | null;
-    },
-    events: agent.types.events,
-  },
-  actors: {
-    getFromTerminal,
-    agent: fromDecision(agent),
-  },
-}).createMachine({
-  initial: 'askQuestion',
-  context: { question: null, answer: null, validation: null },
-  states: {
-    askQuestion: {
-      invoke: {
-        src: 'getFromTerminal',
-        input: 'Ask a (potentially silly) question',
-        onDone: {
-          actions: assign({
-            question: ({ event }) => event.output,
-          }),
-          target: 'validateQuestion',
-        },
-      },
-    },
-    validateQuestion: {
-      invoke: {
-        src: 'agent',
-        input: ({ context }) => ({
-          goal: `Validate this question: ${context.question!}`,
-        }),
-      },
-      on: {
-        'agent.validateQuestion': [
-          {
-            target: 'askQuestion',
-            guard: ({ event }) => !event.isValid,
-            actions: log(({ event }) => event.explanation),
-          },
-          {
-            target: 'answerQuestion',
-          },
-        ],
-      },
-    },
-    answerQuestion: {
-      invoke: {
-        src: 'agent',
-        input: ({ context }) => ({
-          goal: `Answer this question: ${context.question}`,
-        }),
-      },
-      on: {
-        'agent.answerQuestion': {
-          actions: assign({
-            answer: ({ event }) => event.answer,
-          }),
-          target: 'validateAnswer',
-        },
-      },
-    },
-    validateAnswer: {
-      invoke: {
-        src: 'agent',
-        input: ({ context }) => ({
-          goal: `Validate if this is a good answer to the question: ${context.question}\nAnswer provided: ${context.answer}`,
-        }),
-      },
-      on: {
-        'agent.validateAnswer': {
-          actions: assign({
-            validation: ({ event }) => event.feedback,
-          }),
-        },
-      },
-    },
-  },
-});
-
-const actor = createActor(machine, {});
-
-actor.subscribe((s) => {
-  console.log(s.value, s.context);
-});
-
-actor.start();

package/examples/weather.ts

@@ -1,178 +0,0 @@
-import { createAgent, fromDecision } from '../src';
-import { assign, createActor, fromPromise, log, setup } from 'xstate';
-import { getFromTerminal } from './helpers/helpers';
-import { z } from 'zod';
-import { openai } from '@ai-sdk/openai';
-
-async function searchTavily(
-  input: string,
-  options: {
-    maxResults?: number;
-    apiKey: string;
-  }
-) {
-  const body: Record<string, unknown> = {
-    query: input,
-    max_results: options.maxResults,
-    api_key: options.apiKey,
-  };
-
-  const response = await fetch('https://api.tavily.com/search', {
-    method: 'POST',
-    headers: {
-      'content-type': 'application/json',
-    },
-    body: JSON.stringify(body),
-  });
-
-  const json = await response.json();
-  if (!response.ok) {
-    throw new Error(
-      `Request failed with status code ${response.status}: ${json.error}`
-    );
-  }
-  if (!Array.isArray(json.results)) {
-    throw new Error(`Could not parse Tavily results. Please try again.`);
-  }
-  return JSON.stringify(json.results);
-}
-
-const getWeather = fromPromise(async ({ input }: { input: string }) => {
-  const results = await searchTavily(
-    `Get the weather for this location: ${input}`,
-    {
-      maxResults: 5,
-      apiKey: process.env.TAVILY_API_KEY!,
-    }
-  );
-  return results;
-});
-
-const agent = createAgent({
-  name: 'weather',
-  model: openai('gpt-4-1106-preview'),
-  events: {
-    'agent.getWeather': z.object({
-      location: z.string().describe('The location to get the weather for'),
-    }),
-    'agent.reportWeather': z.object({
-      location: z
-        .string()
-        .describe('The location the weather is being reported for'),
-      highF: z.number().describe('The high temperature today in Fahrenheit'),
-      lowF: z.number().describe('The low temperature today in Fahrenheit'),
-      summary: z.string().describe('A summary of the weather conditions'),
-    }),
-    'agent.doSomethingElse': z
-      .object({})
-      .describe(
-        'Do something else, because the user did not provide a location'
-      ),
-  },
-});
-
-const machine = setup({
-  types: {
-    context: {} as {
-      location: string;
-      history: string[];
-      count: number;
-    },
-    events: agent.types.events,
-  },
-  actors: {
-    agent: fromDecision(agent),
-    getWeather,
-    getFromTerminal,
-  },
-}).createMachine({
-  initial: 'getLocation',
-  context: {
-    location: '',
-    count: 0,
-    history: [],
-  },
-  states: {
-    getLocation: {
-      invoke: {
-        src: 'getFromTerminal',
-        input: 'Location?',
-        onDone: {
-          actions: assign({
-            location: ({ event }) => event.output,
-          }),
-          target: 'decide',
-        },
-      },
-      always: {
-        guard: ({ context }) => context.count >= 3,
-        target: 'stopped',
-      },
-    },
-    decide: {
-      entry: log('Deciding...'),
-      invoke: {
-        src: 'agent',
-        input: ({ context }) => ({
-          context: {
-            location: context.location,
-          },
-          goal: `Decide what to do based on the given location, which may or may not be a location`,
-        }),
-      },
-      on: {
-        'agent.getWeather': {
-          actions: log(({ event }) => event),
-          target: 'gettingWeather',
-        },
-        'agent.doSomethingElse': 'getLocation',
-      },
-    },
-    gettingWeather: {
-      entry: log('Getting weather...'),
-      invoke: {
-        src: 'getWeather',
-        input: ({ context }) => context.location,
-        onDone: {
-          actions: [
-            log(({ event }) => event.output),
-            assign({
-              count: ({ context }) => context.count + 1,
-            }),
-          ],
-          target: 'reportWeather',
-        },
-      },
-    },
-    reportWeather: {
-      invoke: {
-        src: 'agent',
-        input: ({ context }) => ({
-          goal: 'Report the weather', // TODO
-        }),
-      },
-      on: {
-        'agent.reportWeather': {
-          actions: log(({ event }) => event),
-          target: 'getLocation',
-        },
-      },
-    },
-    stopped: {
-      entry: log('You have used up your search quota. Goodbye!'),
-    },
-  },
-  exit: () => {
-    process.exit();
-  },
-});
-
-const actor = createActor(machine, {
-  input: {
-    location: 'New York',
-  },
-});
-actor.subscribe((s) => {
-  console.log(s.value);
-});
-actor.start();

package/examples/wiki.ts

@@ -1,30 +0,0 @@
-import { z } from 'zod';
-import { createAgent } from '../src';
-import { openai } from '@ai-sdk/openai';
-
-const agent = createAgent({
-  name: 'wiki',
-  model: openai('gpt-4-turbo'),
-  events: {
-    provideAnswer: z.object({
-      answer: z.string().describe('The answer'),
-    }),
-  },
-});
-
-async function main() {
-  const response1 = await agent.generateText({
-    prompt: 'When was Deadpool 2 released?',
-  });
-
-  console.log(response1.text);
-
-  const response2 = await agent.generateText({
-    messages: (x) => x.select((ctx) => ctx.messages),
-    prompt: 'What about the first one?',
-  });
-
-  console.log(response2.text);
-}
-
-main();

package/examples/word.ts

@@ -1,171 +0,0 @@
-import { assign, createActor, log, setup } from 'xstate';
-import { getFromTerminal } from './helpers/helpers';
-import { createAgent, fromDecision } from '../src';
-import { z } from 'zod';
-import { openai } from '@ai-sdk/openai';
-
-const context = {
-  word: null as string | null,
-  guessedWord: null as string | null,
-  lettersGuessed: [] as string[],
-};
-
-const agent = createAgent({
-  name: 'word',
-  model: openai('gpt-4o'),
-  events: {
-    'agent.guessLetter': z.object({
-      letter: z.string().min(1).max(1).describe('The letter guessed'),
-      reasoning: z.string().describe('The reasoning behind the guess'),
-    }),
-
-    'agent.guessWord': z.object({
-      word: z.string().describe('The word guessed'),
-    }),
-
-    'agent.respond': z.object({
-      response: z
-        .string()
-        .describe(
-          'The response from the agent, detailing why the guess was correct or incorrect based on the letters guessed.'
-        ),
-    }),
-  },
-});
-
-const wordGuesserMachine = setup({
-  types: {
-    context: {} as typeof context,
-    events: agent.types.events,
-  },
-  actors: {
-    agent: fromDecision(agent),
-    getFromTerminal,
-  },
-  actions: {
-    resetContext: assign(context),
-  },
-}).createMachine({
-  initial: 'providingWord',
-  context,
-  states: {
-    providingWord: {
-      entry: 'resetContext',
-      invoke: {
-        src: 'getFromTerminal',
-        input: 'Enter a word, and an agent will try to guess it.',
-        onDone: {
-          actions: assign({
-            word: ({ event }) => event.output,
-          }),
-          target: 'guessing',
-        },
-      },
-    },
-    guessing: {
-      always: {
-        guard: ({ context }) => context.lettersGuessed.length > 10,
-        target: 'finalGuess',
-      },
-      invoke: {
-        src: 'agent',
-        input: ({ context }) => ({
-          context: {
-            wordLength: context.word!.length,
-            lettersGuessed: context.lettersGuessed,
-            lettersMatched: context
-              .word!.split('')
-              .map((letter) =>
-                context.lettersGuessed.includes(letter.toUpperCase())
-                  ? letter.toUpperCase()
-                  : '_'
-              )
-              .join(''),
-          },
-          goal: `You are trying to guess the word. Please make your next guess - guess a letter or, if you think you know the word, guess the full word. You can only make 10 total guesses. If you are confident you know the word, it is better to guess the word.`,
-        }),
-      },
-      on: {
-        'agent.guessLetter': {
-          actions: [
-            assign({
-              lettersGuessed: ({ context, event }) => {
-                return [...context.lettersGuessed, event.letter.toUpperCase()];
-              },
-            }),
-            log(({ event }) => event),
-          ],
-          target: 'guessing',
-          reenter: true,
-        },
-        'agent.guessWord': {
-          actions: [
-            assign({
-              guessedWord: ({ event }) => event.word,
-            }),
-            log(({ event }) => event),
-          ],
-          target: 'gameOver',
-        },
-      },
-    },
-    finalGuess: {
-      invoke: {
-        src: 'agent',
-        input: ({ context }) => ({
-          context: {
-            lettersGuessed: context.lettersGuessed,
-          },
-          goal: `You have used all 10 guesses. These letters matched: ${context
-            .word!.split('')
-            .map((letter) =>
-              context.lettersGuessed.includes(letter.toUpperCase())
-                ? letter.toUpperCase()
-                : '_'
-            )
-            .join('')}. Guess the word.`,
-        }),
-      },
-      on: {
-        'agent.guessWord': {
-          actions: [
-            assign({
-              guessedWord: ({ event }) => event.word,
-            }),
-            log(({ event }) => event),
-          ],
-          target: 'gameOver',
-        },
-      },
-    },
-    gameOver: {
-      invoke: {
-        src: 'agent',
-        input: ({ context }) => ({
-          context,
-          goal: `Why do you think you won or lost?`,
-        }),
-      },
-      entry: log(({ context }) => {
-        if (
-          context.guessedWord?.toUpperCase() === context.word?.toUpperCase()
-        ) {
-          return 'The agent won!';
-        } else {
-          return 'The agent lost! The word was ' + context.word;
-        }
-      }),
-      on: {
-        'agent.respond': {
-          actions: log(({ event }) => event.response),
-          target: 'providingWord',
-        },
-      },
-    },
-  },
-  exit: () => process.exit(),
-});
-
-const game = createActor(wordGuesserMachine);
-
-game.start();

package/src/adapters/vercel.ts

@@ -1,7 +0,0 @@
-import { generateText, streamText } from 'ai';
-import { AIAdapter } from '../types';
-
-export const vercelAdapter: AIAdapter = {
-  generateText,
-  streamText,
-};