@statelyai/agent 0.0.8 → 0.1.0

package/examples/wordGuesser.ts

@@ -1,144 +0,0 @@
-import { assign, log, setup } from 'xstate';
-import { getFromTerminal } from './helpers/helpers';
-import { createAgent, createOpenAIAdapter, defineEvents } from '../src';
-import OpenAI from 'openai';
-import { z } from 'zod';
-
-const openAI = new OpenAI({
-  apiKey: process.env.OPENAI_API_KEY,
-});
-
-const adapter = createOpenAIAdapter(openAI, {
-  model: 'gpt-4-1106-preview',
-});
-
-const events = defineEvents({
-  guessLetter: z.object({
-    letter: z.string().min(1).max(1).describe('The letter guessed'),
-  }),
-
-  guessWord: z.object({
-    word: z.string().describe('The word guessed'),
-  }),
-});
-
-const context = {
-  word: null as string | null,
-  guessedWord: null as string | null,
-  letters: [] as string[],
-};
-
-const wordGuesserMachine = setup({
-  types: {
-    context: {} as typeof context,
-    events: events.types,
-  },
-  actors: {
-    getFromTerminal,
-    guesser: adapter.fromEvent(
-      (input: typeof context) => `
-You are trying to guess the word. The word has ${
-        input.word!.length
-      } letters. You have guessed the following letters so far: ${input.letters.join(
-        ', '
-      )}. These letters matched: ${input
-        .word!.split('')
-        .map((letter) =>
-          input.letters.includes(letter.toUpperCase())
-            ? letter.toUpperCase()
-            : '_'
-        )
-        .join('')}
-Please make your next guess - type a letter or the full word. You can only make 10 total guesses.
-    `
-    ),
-  },
-  schemas: {
-    events: events.schemas,
-  },
-}).createMachine({
-  initial: 'providingWord',
-  context,
-  states: {
-    providingWord: {
-      invoke: {
-        src: 'getFromTerminal',
-        input: 'Enter a word',
-        onDone: {
-          actions: assign({
-            word: ({ event }) => event.output,
-          }),
-          target: 'guessing',
-        },
-      },
-    },
-    guessing: {
-      always: {
-        guard: ({ context }) => context.letters.length > 10,
-        target: 'finalGuess',
-      },
-      invoke: {
-        src: 'guesser',
-        input: ({ context }) => context,
-      },
-      on: {
-        guessLetter: {
-          actions: assign({
-            letters: ({ context, event }) => {
-              return [...context.letters, event.letter.toUpperCase()];
-            },
-          }),
-          target: 'guessing',
-          reenter: true,
-        },
-        guessWord: {
-          actions: assign({
-            guessedWord: ({ event }) => event.word,
-          }),
-          target: 'gameOver',
-        },
-      },
-    },
-    finalGuess: {
-      invoke: {
-        src: 'guesser',
-        input: ({ context }) => context,
-      },
-      on: {
-        guessWord: {
-          actions: assign({
-            guessedWord: ({ event }) => event.word,
-          }),
-          target: 'gameOver',
-        },
-      },
-    },
-    gameOver: {
-      entry: log(({ context }) => {
-        if (
-          context.guessedWord?.toUpperCase() === context.word?.toUpperCase()
-        ) {
-          return 'You won!';
-        } else {
-          return 'You lost! The word was ' + context.word;
-        }
-      }),
-    },
-  },
-  exit: () => process.exit(),
-});
-
-const actor = createAgent(wordGuesserMachine, {
-  inspect: (ev) => {
-    if (ev.type === '@xstate.event') {
-      console.log(ev.event);
-    }
-  },
-});
-
-actor.subscribe((s) => {
-  console.log(s.value);
-  console.log(s.context);
-});
-
-actor.start();

package/src/adapter.test.ts

@@ -1,217 +0,0 @@
-import { test, expect } from 'vitest';
-import { createOpenAIAdapter, createTool } from './adapters/openai';
-import OpenAI from 'openai';
-import { createActor, toPromise } from 'xstate';
-
-test('fromTool - weather or illustration', async () => {
-  const openAi = new OpenAI({
-    apiKey: process.env.OPENAI_API_KEY,
-  });
-
-  const adapter = createOpenAIAdapter(openAi, {
-    model: 'gpt-3.5-turbo',
-  });
-
-  const toolChoice = adapter.fromTool(() => 'Create an image of a donut', {
-    makeIllustration: {
-      description: 'Make an illustration',
-      run: async () => 'Illustration',
-      inputSchema: {
-        type: 'object',
-        properties: {
-          name: {
-            type: 'string',
-            description: 'The name of the illustration',
-          },
-        },
-        required: ['name'],
-      },
-    },
-    getWeather: {
-      description: 'Get the weather for a location',
-      run: async () => 'Weather',
-      inputSchema: {
-        type: 'object',
-        properties: {
-          location: {
-            type: 'object',
-            properties: {
-              city: {
-                type: 'string',
-                description: 'The name of the city',
-              },
-              state: {
-                type: 'string',
-                description: 'The name of the state',
-              },
-            },
-            required: ['city', 'state'],
-          },
-        },
-        required: ['location'],
-      },
-    },
-  });
-
-  const actor = createActor(toolChoice);
-
-  actor.start();
-
-  const res = await toPromise(actor);
-
-  expect(res?.result).toBe('Illustration');
-});
-
-test('fromTool - GitHub PR description inserter', async () => {
-  const openAi = new OpenAI({
-    apiKey: process.env.OPENAI_API_KEY,
-  });
-
-  const adapter = createOpenAIAdapter(openAi, {
-    model: 'gpt-3.5-turbo-16k-0613',
-  });
-
-  const toolChoice = adapter.fromTool(
-    (input: string) =>
-      `Create a GitHub PR description for the following: ${input}`,
-    {
-      fetchGitHubPR: {
-        description: 'Fetch a GitHub PR',
-        run: async (input: string) => {
-          return {
-            title: 'Title',
-            body: input,
-          };
-        },
-        inputSchema: {
-          type: 'object',
-          properties: {
-            repo: {
-              type: 'string',
-              description: 'The name of the repo',
-            },
-            number: {
-              type: 'number',
-              description: 'The number of the PR',
-            },
-          },
-          required: ['repo', 'number'],
-        },
-      },
-      createPullRequestDescription: {
-        description: 'Create a GitHub PR description',
-        run: () => 'Description',
-        inputSchema: {
-          type: 'object',
-          properties: {
-            title: {
-              type: 'string',
-              description: 'The title of the PR',
-            },
-            body: {
-              type: 'string',
-              description: 'The body of the PR',
-            },
-          },
-          required: ['title', 'body'],
-        },
-      },
-    }
-  );
-
-  const actor = createActor(toolChoice, {
-    input:
-      // 'Get the details from this: https://github.com/microsoft/TypeScript/pull/47198',
-      'Make a summary of this PR: (some code here)',
-  });
-
-  actor.start();
-
-  const res = await toPromise(actor);
-
-  expect(res?.tool).toEqual('createPullRequestDescription');
-  expect(res?.result).toEqual('Description');
-});
-
-test('fromTool - joke creator or rater', async () => {
-  const openAi = new OpenAI({
-    apiKey: process.env.OPENAI_API_KEY,
-  });
-
-  const adapter = createOpenAIAdapter(openAi, {
-    model: 'gpt-4-1106-preview',
-  });
-
-  const rateJoke = createTool({
-    description: 'Rate a joke',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        joke: {
-          type: 'string',
-          description: 'The joke to rate',
-        },
-      },
-    },
-    run: async ({ topic }: { topic: string }) => {
-      return `Here is a joke about ${topic}`;
-    },
-  });
-
-  const createJoke = createTool({
-    description: 'Create a joke',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        category: {
-          type: 'string',
-          description: 'The category of the joke',
-        },
-      },
-      required: ['category'],
-    },
-    run: async () => {
-      return 'Some joke';
-    },
-  });
-
-  const toolChoice = adapter.fromTool(
-    (input: string) => `
-The user provided this input:
-
-<input>
-${input}
-</input>
-
-Determine what to do:
-- If the input is asking for a joke, create a joke,
-- But if the input is providing a joke, then rate the joke.
-    `,
-    {
-      rateJoke,
-      createJoke,
-    }
-  );
-
-  const actor = createActor(toolChoice, {
-    // input: 'Why did the chicken cross the road? To get to the other side!',
-    input: 'Tell me a joke about chickens',
-  });
-
-  actor.start();
-
-  const res = await toPromise(actor);
-
-  expect(res?.tool).toEqual('createJoke');
-  expect(res?.result).toEqual('Some joke');
-
-  const actor2 = createActor(toolChoice, {
-    input:
-      'Check this joke out: Why did the chicken cross the road? To get to the other side!',
-  });
-
-  actor2.start();
-
-  const res2 = await toPromise(actor2);
-  expect(res2?.tool).toEqual('rateJoke');
-});

package/src/adapters/openai.ts

@@ -1,303 +0,0 @@
-import type OpenAI from 'openai';
-import {
-  AnyEventObject,
-  Observer,
-  fromObservable,
-  fromPromise,
-  isMachineSnapshot,
-  toObserver,
-} from 'xstate';
-import { getAllTransitions } from '../utils';
-import { ChatCompletionCreateParamsNonStreaming } from 'openai/resources';
-import { ChatCompletionCreateParamsBase } from 'openai/resources/chat/completions';
-import { StatelyAgentAdapter, Tool } from '../types';
-
-/**
- * Creates [promise actor logic](https://stately.ai/docs/promise-actors) that uses the OpenAI API to generate a completion.
- *
- * @param openai The OpenAI instance.
- * @param inputFn A function that maps arbitrary input to OpenAI chat completion input.
- *
- */
-export function fromChatCompletion<TInput>(
-  openai: OpenAI,
-  agentSettings: StatelyAgentAdapter,
-  inputFn: (
-    input: TInput
-  ) => string | OpenAI.Chat.Completions.ChatCompletionCreateParamsNonStreaming
-) {
-  return fromPromise<OpenAI.Chat.Completions.ChatCompletion, TInput>(
-    async ({ input }) => {
-      const openAiInput = inputFn(input);
-      const params: ChatCompletionCreateParamsNonStreaming =
-        typeof openAiInput === 'string'
-          ? {
-              model: agentSettings.model,
-              messages: [
-                {
-                  role: 'user',
-                  content: openAiInput,
-                },
-              ],
-            }
-          : openAiInput;
-      const response = await openai.chat.completions.create(params);
-
-      return response;
-    }
-  );
-}
-
-/**
- * Creates [observable actor logic](https://stately.ai/docs/observable-actors) that uses the OpenAI API to generate a completion stream.
- *
- * @param openai The OpenAI instance to use.
- * @param inputFn A function that maps arbitrary input to OpenAI chat completion input.
- */
-export function fromChatStream<TInput>(
-  openai: OpenAI,
-  agentSettings: StatelyAgentAdapter,
-  inputFn: (
-    input: TInput
-  ) => string | OpenAI.Chat.Completions.ChatCompletionCreateParamsStreaming
-) {
-  return fromObservable<OpenAI.Chat.Completions.ChatCompletionChunk, TInput>(
-    ({ input }) => {
-      const observers = new Set<Observer<any>>();
-
-      (async () => {
-        const openAiInput = inputFn(input);
-        const resolvedParams: ChatCompletionCreateParamsBase =
-          typeof openAiInput === 'string'
-            ? {
-                model: agentSettings.model,
-                messages: [
-                  {
-                    role: 'user',
-                    content: openAiInput,
-                  },
-                ],
-              }
-            : openAiInput;
-        const stream = await openai.chat.completions.create({
-          ...resolvedParams,
-          stream: true,
-        });
-
-        for await (const part of stream) {
-          observers.forEach((observer) => {
-            observer.next?.(part);
-          });
-        }
-      })();
-
-      return {
-        subscribe: (...args) => {
-          const observer = toObserver(...(args as any));
-          observers.add(observer);
-
-          return {
-            unsubscribe: () => {
-              observers.delete(observer);
-            },
-          };
-        },
-      };
-    }
-  );
-}
-
-/**
- * Creates [promise actor logic](https://stately.ai/docs/promise-actors) that passes the next possible transitions as functions to [OpenAI tool calls](https://platform.openai.com/docs/guides/function-calling) and returns an array of potential next events.
- *
- * @param openai The OpenAI instance to use.
- * @param inputFn A function that maps arbitrary input to OpenAI chat completion input.
- */
-export function fromEvent<TInput>(
-  openai: OpenAI,
-  agentSettings: StatelyAgentAdapter,
-  inputFn: (
-    input: TInput
-  ) => string | OpenAI.Chat.Completions.ChatCompletionCreateParamsNonStreaming
-) {
-  return fromPromise<AnyEventObject[] | undefined, TInput>(
-    async ({ input, self, system }) => {
-      const parentSnapshot = self._parent?.getSnapshot();
-
-      if (!parentSnapshot || !isMachineSnapshot(parentSnapshot)) {
-        return undefined;
-      }
-
-      const schemas = parentSnapshot.machine.schemas as any;
-      const eventSchemaMap = schemas.events ?? {};
-
-      const transitions = getAllTransitions(self._parent!.getSnapshot());
-      const functionNameMapping: Record<string, string> = {};
-      const tools = transitions
-        .filter((t) => {
-          return !t.eventType.startsWith('xstate.');
-        })
-        .map((t) => {
-          const name = t.eventType.replace(/\./g, '_');
-          functionNameMapping[name] = t.eventType;
-          const eventSchema = eventSchemaMap[t.eventType];
-          const {
-            description,
-            properties: { type, ...properties },
-          } = eventSchema ?? {};
-
-          return {
-            type: 'function',
-            function: {
-              name,
-              description: t.description ?? description,
-              parameters: {
-                type: 'object',
-                properties: properties ?? {},
-              },
-            },
-          } as const;
-        });
-
-      const openAiInput = inputFn(input);
-      const completionParams: ChatCompletionCreateParamsNonStreaming =
-        typeof openAiInput === 'string'
-          ? {
-              model: agentSettings.model,
-              messages: [
-                {
-                  role: 'user',
-                  content: openAiInput,
-                },
-              ],
-            }
-          : openAiInput;
-      const completion = await openai.chat.completions.create({
-        ...completionParams,
-        tools,
-      });
-
-      const toolCalls = completion.choices[0]?.message.tool_calls;
-
-      if (toolCalls?.length) {
-        const events = toolCalls.map((tc) => {
-          return {
-            type: functionNameMapping[tc.function.name],
-            ...JSON.parse(tc.function.arguments),
-          };
-        });
-
-        const event = events[0]!;
-
-        // @ts-ignore
-        system._relay(self, self._parent, event);
-      }
-
-      return undefined;
-    }
-  );
-}
-
-export function createTool<TInput, T>({
-  description,
-  inputSchema,
-  run,
-}: Tool<TInput, T>): Tool<TInput, T> {
-  return {
-    description,
-    inputSchema,
-    run,
-  };
-}
-
-/**
- * Creates [promise actor logic](https://stately.ai/docs/promise-actors) that passes the next possible transitions as functions to [OpenAI tool calls](https://platform.openai.com/docs/guides/function-calling) and returns an array of potential next events.
- *
- * @param openai The OpenAI instance to use.
- * @param inputFn A function that maps arbitrary input to OpenAI chat completion input.
- */
-export function fromTool<TInput>(
-  openai: OpenAI,
-  agentSettings: StatelyAgentAdapter,
-  tools: {
-    [key: string]: Tool<any, any>;
-  },
-  inputFn: (
-    input: TInput
-  ) => string | OpenAI.Chat.Completions.ChatCompletionCreateParamsNonStreaming
-) {
-  return fromPromise<
-    | {
-        result: any;
-        tool: string;
-        toolCall: OpenAI.Chat.Completions.ChatCompletionMessageToolCall;
-      }
-    | undefined,
-    TInput
-  >(async ({ input }) => {
-    const resolvedTools = Object.entries(tools).map(([key, value]) => {
-      return {
-        type: 'function',
-        function: {
-          name: key,
-          description: value.description,
-          parameters: value.inputSchema,
-        },
-      } as const;
-    });
-
-    const openAiInput = inputFn(input);
-    const completionParams: ChatCompletionCreateParamsNonStreaming =
-      typeof openAiInput === 'string'
-        ? {
-            model: agentSettings.model,
-            messages: [
-              {
-                role: 'user',
-                content: openAiInput,
-              },
-            ],
-          }
-        : openAiInput;
-    const completion = await openai.chat.completions.create({
-      ...completionParams,
-      tools: resolvedTools,
-    });
-
-    const toolCalls = completion.choices[0]?.message.tool_calls;
-
-    if (toolCalls?.length) {
-      const toolCall = toolCalls[0]!;
-      const tool = tools[toolCall.function.name];
-      const args = JSON.parse(toolCall.function.arguments);
-
-      if (tool) {
-        const result = await tool.run(args);
-
-        return {
-          toolCall,
-          tool: toolCall.function.name,
-          result,
-        };
-      }
-    }
-
-    return undefined;
-  });
-}
-
-export function createOpenAIAdapter<
-  T extends {
-    model: ChatCompletionCreateParamsBase['model'];
-  }
->(openai: OpenAI, settings: T): StatelyAgentAdapter {
-  const agentSettings: StatelyAgentAdapter = {
-    model: settings.model,
-    fromEvent: (input) => fromEvent(openai, agentSettings, input),
-    fromChat: (input) => fromChatCompletion(openai, agentSettings, input),
-    fromChatStream: (input) => fromChatStream(openai, agentSettings, input),
-    fromTool: (input, tools) => fromTool(openai, agentSettings, tools, input),
-  };
-
-  return agentSettings;
-}