@statelyai/agent 1.1.6 → 2.0.0-alpha.6

package/examples/support.ts

@@ -1,147 +0,0 @@
-import { openai } from '@ai-sdk/openai';
-import { createAgent, fromDecision } from '../src';
-import { z } from 'zod';
-import { createActor, log, setup } from 'xstate';
-
-const agent = createAgent({
-  name: 'support-agent',
-  model: openai('gpt-4-1106-preview'),
-  events: {
-    'agent.respond': z.object({
-      response: z.string().describe('The response from the agent'),
-    }),
-    'agent.frontline.classify': z.object({
-      category: z
-        .enum(['billing', 'technical', 'other'])
-        .describe('The category of the customer issue'),
-    }),
-    'agent.refund': z
-      .object({
-        response: z.string().describe('The response from the agent'),
-      })
-      .describe('The agent wants to refund the user'),
-    'agent.technical.solve': z.object({
-      solution: z
-        .string()
-        .describe('The solution provided by the technical agent'),
-    }),
-    'agent.endConversation': z
-      .object({
-        response: z.string().describe('The response from the agent'),
-      })
-      .describe('The agent ends the conversation'),
-  },
-});
-
-const machine = setup({
-  types: {
-    events: agent.types.events,
-    input: {} as string,
-    context: {} as {
-      customerIssue: string;
-    },
-  },
-  actors: { agent: fromDecision(agent) },
-}).createMachine({
-  initial: 'frontline',
-  context: ({ input }) => ({
-    customerIssue: input,
-  }),
-  states: {
-    frontline: {
-      invoke: {
-        src: 'agent',
-        input: ({ context }) => ({
-          context,
-          system: `You are frontline support staff for LangCorp, a company that sells computers.
-          Be concise in your responses.
-          You can chat with customers and help them with basic questions, but if the customer is having a billing or technical problem,
-          do not try to answer the question directly or gather information.
-          Instead, immediately transfer them to the billing or technical team by asking the user to hold for a moment.
-          Otherwise, just respond conversationally.`,
-          goal: `The previous conversation is an interaction between a customer support representative and a user.
-          Classify whether the representative is routing the user to a billing or technical team, or whether they are just responding conversationally.`,
-        }),
-      },
-      on: {
-        'agent.frontline.classify': [
-          {
-            actions: log(({ event }) => event),
-            guard: ({ event }) => event.category === 'billing',
-            target: 'billing',
-          },
-          {
-            actions: log(({ event }) => event),
-            guard: ({ event }) => event.category === 'technical',
-            target: 'technical',
-          },
-          {
-            actions: log(({ event }) => event),
-            target: 'conversational',
-          },
-        ],
-      },
-    },
-    billing: {
-      invoke: {
-        src: 'agent',
-        input: {
-          system:
-            'Your job is to detect whether a billing support representative wants to refund the user.',
-          goal: `The following text is a response from a customer support representative. Extract whether they want to refund the user or not.`,
-        },
-      },
-      on: {
-        'agent.refund': {
-          actions: log(({ event }) => event),
-          target: 'refund',
-        },
-      },
-    },
-    technical: {
-      invoke: {
-        src: 'agent',
-        input: {
-          context: true,
-          system: `You are an expert at diagnosing technical computer issues. You work for a company called LangCorp that sells computers. Help the user to the best of your ability, but be concise in your responses.`,
-          goal: 'Solve the customer issue.',
-        },
-      },
-      on: {
-        'agent.technical.solve': {
-          actions: log(({ event }) => event),
-          target: 'conversational',
-        },
-      },
-    },
-    conversational: {
-      invoke: {
-        src: 'agent',
-        input: {
-          goal: 'You are a customer support agent that is ending the conversation with the customer. Respond politely and thank them for their time.',
-        },
-      },
-      on: {
-        'agent.endConversation': {
-          actions: log((x) => x.event),
-          target: 'end',
-        },
-      },
-    },
-    refund: {
-      entry: () => console.log('Refunding...'),
-      after: {
-        1000: { target: 'conversational' },
-      },
-    },
-    end: {
-      type: 'final',
-    },
-  },
-});
-
-const actor = createActor(machine, {
-  input: `I've changed my mind and I want a refund for order #182818!`,
-});
-
-actor.start();

package/examples/ticTacToe.ts

@@ -1,224 +0,0 @@
-import { assign, setup, assertEvent, createActor } from 'xstate';
-import { z } from 'zod';
-import { createAgent, fromDecision, fromTextStream } from '../src';
-import { openai } from '@ai-sdk/openai';
-
-const agent = createAgent({
-  name: 'tic-tac-toe-bot',
-  model: openai('gpt-4-0125-preview'),
-  events: {
-    'agent.x.play': z.object({
-      index: z
-        .number()
-        .min(0)
-        .max(8)
-        .describe('The index of the cell to play on'),
-    }),
-    'agent.o.play': z.object({
-      index: z
-        .number()
-        .min(0)
-        .max(8)
-        .describe('The index of the cell to play on'),
-    }),
-    reset: z.object({}).describe('Reset the game to the initial state'),
-  },
-  context: {
-    board: z
-      .array(z.union([z.literal(null), z.literal('x'), z.literal('o')]))
-      .describe('The 3x3 board represented as a 9-element array.'),
-    moves: z
-      .number()
-      .min(0)
-      .max(9)
-      .describe('The number of moves made in the game.'),
-    player: z
-      .union([z.literal('x'), z.literal('o')])
-      .describe('The current player (x or o)'),
-    gameReport: z.string(),
-  },
-});
-
-type Player = 'x' | 'o';
-
-const initialContext = {
-  board: Array(9).fill(null) as Array<Player | null>,
-  moves: 0,
-  player: 'x' as Player,
-  gameReport: '',
-} satisfies typeof agent.types.context;
-
-function getWinner(board: typeof initialContext.board): Player | null {
-  const lines = [
-    [0, 1, 2],
-    [3, 4, 5],
-    [6, 7, 8],
-    [0, 3, 6],
-    [1, 4, 7],
-    [2, 5, 8],
-    [0, 4, 8],
-    [2, 4, 6],
-  ] as const;
-  for (const [a, b, c] of lines) {
-    if (board[a] !== null && board[a] === board[b] && board[a] === board[c]) {
-      return board[a]!;
-    }
-  }
-  return null;
-}
-
-export const ticTacToeMachine = setup({
-  types: {
-    context: agent.types.context,
-    events: agent.types.events,
-  },
-  actors: {
-    agent: fromDecision(agent),
-    gameReporter: fromTextStream(agent),
-  },
-  actions: {
-    updateBoard: assign({
-      board: ({ context, event }) => {
-        assertEvent(event, ['agent.x.play', 'agent.o.play']);
-        const updatedBoard = [...context.board];
-        updatedBoard[event.index] = context.player;
-        return updatedBoard;
-      },
-      moves: ({ context }) => context.moves + 1,
-      player: ({ context }) => (context.player === 'x' ? 'o' : 'x'),
-    }),
-    resetGame: assign(initialContext),
-    printBoard: ({ context }) => {
-      // Print the context.board in a 3 x 3 grid format
-      let boardString = '';
-      for (let i = 0; i < context.board.length; i++) {
-        if ([0, 3, 6].includes(i)) {
-          boardString += context.board[i] ?? ' ';
-        } else {
-          boardString += ' | ' + (context.board[i] ?? ' ');
-          if ([2, 5].includes(i)) {
-            boardString += '\n--+---+--\n';
-          }
-        }
-      }
-
-      console.log(boardString);
-    },
-  },
-  guards: {
-    checkWin: ({ context }) => {
-      const winner = getWinner(context.board);
-
-      return !!winner;
-    },
-    checkDraw: ({ context }) => {
-      return context.moves === 9;
-    },
-    isValidMove: ({ context, event }) => {
-      try {
-        assertEvent(event, ['agent.o.play', 'agent.x.play']);
-      } catch {
-        return false;
-      }
-
-      return context.board[event.index] === null;
-    },
-  },
-}).createMachine({
-  initial: 'playing',
-  context: initialContext,
-  states: {
-    playing: {
-      always: [
-        { target: 'gameOver.winner', guard: 'checkWin' },
-        { target: 'gameOver.draw', guard: 'checkDraw' },
-      ],
-      initial: 'x',
-      states: {
-        x: {
-          entry: 'printBoard',
-          on: {
-            'agent.x.play': [
-              {
-                target: 'o',
-                guard: 'isValidMove',
-                actions: 'updateBoard',
-              },
-              { target: 'x', reenter: true },
-            ],
-          },
-        },
-        o: {
-          entry: 'printBoard',
-          on: {
-            'agent.o.play': [
-              {
-                target: 'x',
-                guard: 'isValidMove',
-                actions: 'updateBoard',
-              },
-              { target: 'o', reenter: true },
-            ],
-          },
-        },
-      },
-    },
-    gameOver: {
-      initial: 'winner',
-      invoke: {
-        src: 'gameReporter',
-        input: ({ context }) => ({
-          context: {
-            events: agent.getObservations().map((o) => o.event),
-            board: context.board,
-          },
-          prompt: 'Provide a short game report analyzing the game.',
-        }),
-        onSnapshot: {
-          actions: assign({
-            gameReport: ({ context, event }) => {
-              console.log(
-                context.gameReport + (event.snapshot.context?.textDelta ?? '')
-              );
-              return (
-                context.gameReport + (event.snapshot.context?.textDelta ?? '')
-              );
-            },
-          }),
-        },
-      },
-      states: {
-        winner: {
-          tags: 'winner',
-        },
-        draw: {
-          tags: 'draw',
-        },
-      },
-      on: {
-        reset: {
-          target: 'playing',
-          actions: 'resetGame',
-        },
-      },
-    },
-  },
-});
-
-const actor = createActor(ticTacToeMachine);
-
-agent.interact(actor, (observed) => {
-  if (observed.state.matches('playing')) {
-    return {
-      goal: `You are playing a game of tic tac toe. This is the current game state. The 3x3 board is represented by a 9-element array. The first element is the top-left cell, the second element is the top-middle cell, the third element is the top-right cell, the fourth element is the middle-left cell, and so on. The value of each cell is either null, x, or o. The value of null means that the cell is empty. The value of x means that the cell is occupied by an x. The value of o means that the cell is occupied by an o.
-
-${JSON.stringify(observed.state.context, null, 2)}
-
-Execute the single best next move to try to win the game. Do not play on an existing cell.`,
-    };
-  }
-
-  return;
-});
-
-actor.start();

package/examples/todo.ts

@@ -1,137 +0,0 @@
-import { assign, setup, assertEvent, createActor, createMachine } from 'xstate';
-import { z } from 'zod';
-import { createAgent, fromDecision } from '../src';
-import { openai } from '@ai-sdk/openai';
-import { getFromTerminal } from './helpers/helpers';
-
-const agent = createAgent({
-  name: 'todo',
-  model: openai('gpt-4o'),
-  events: {
-    addTodo: z.object({
-      title: z.string().min(1).max(100).describe('The title of the todo'),
-      content: z.string().min(1).max(100).describe('The content of the todo'),
-    }),
-    deleteTodo: z.object({
-      index: z.number().describe('The index of the todo to delete'),
-    }),
-    toggleTodo: z
-      .object({
-        index: z.number().describe('The index of the todo to toggle'),
-      })
-      .describe('Toggle whether the todo item is done or not'),
-    doNothing: z.object({}).describe('Do nothing'),
-  },
-});
-
-interface Todo {
-  title: string;
-  content: string;
-  done: boolean;
-}
-
-const machine = setup({
-  types: {
-    context: {} as {
-      todos: Todo[];
-      command: string | null;
-    },
-    events: {} as
-      | typeof agent.types.events
-      | { type: 'assist'; command: string },
-  },
-  actors: { agent: fromDecision(agent), getFromTerminal },
-}).createMachine({
-  context: {
-    command: null,
-    todos: [],
-  },
-  on: {
-    addTodo: {
-      actions: assign({
-        todos: ({ context, event }) => [
-          ...context.todos,
-          {
-            title: event.title,
-            content: event.content,
-            done: false,
-          },
-        ],
-        command: null,
-      }),
-      target: '.idle',
-    },
-    deleteTodo: {
-      actions: assign({
-        todos: ({ context, event }) => {
-          const todos = [...context.todos];
-          todos.splice(event.index, 1);
-          return todos;
-        },
-        command: null,
-      }),
-      target: '.idle',
-    },
-    toggleTodo: {
-      actions: assign({
-        todos: ({ context, event }) => {
-          const todos = context.todos.map((todo, i) => {
-            if (i === event.index) {
-              return {
-                ...todo,
-                done: !todo.done,
-              };
-            }
-            return todo;
-          });
-
-          return todos;
-        },
-        command: null,
-      }),
-      target: '.idle',
-    },
-    doNothing: { target: '.idle' },
-  },
-  initial: 'idle',
-  states: {
-    idle: {
-      invoke: {
-        src: 'getFromTerminal',
-        input: '\nEnter a command:',
-        onDone: {
-          actions: assign({
-            command: ({ event }) => event.output,
-          }),
-          target: 'assisting',
-        },
-      },
-      on: {
-        assist: {
-          target: 'assisting',
-          actions: assign({
-            command: ({ event }) => event.command,
-          }),
-        },
-      },
-    },
-    assisting: {
-      invoke: {
-        src: 'agent',
-        input: (x) => ({
-          context: {
-            command: x.context.command,
-            todos: x.context.todos,
-          },
-          goal: 'Interpret the command as an action for this todo list; for example, "I need donuts" would add a todo item with the message "Get donuts".',
-        }),
-      },
-    },
-  },
-});
-
-const actor = createActor(machine);
-actor.subscribe((s) => {
-  console.log(s.context.todos);
-});
-actor.start();

package/examples/tutor.ts

@@ -1,100 +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 agent = createAgent({
-  name: 'tutor',
-  model: openai('gpt-4-1106-preview'),
-  events: {
-    teach: z.object({
-      instruction: z
-        .string()
-        .describe(
-          'The feedback to give the human, correcting any grammatical errors, misspellings, etc.'
-        ),
-    }),
-    respond: z.object({
-      response: z.string().describe('The response to the human in Spanish'),
-    }),
-  },
-  system:
-    'You are an expert Spanish tutor. You will respond to the human in Spanish.',
-});
-
-const machine = setup({
-  types: {
-    context: {} as {
-      conversation: string[];
-    },
-    events: agent.types.events,
-  },
-  actors: { agent: fromDecision(agent), getFromTerminal },
-}).createMachine({
-  initial: 'human',
-  context: {
-    conversation: [],
-  },
-  states: {
-    human: {
-      invoke: {
-        src: 'getFromTerminal',
-        input: 'Say something in Spanish:',
-        onDone: {
-          actions: assign({
-            conversation: (x) =>
-              x.context.conversation.concat(`User: ` + x.event.output),
-          }),
-          target: 'ai',
-        },
-      },
-    },
-    ai: {
-      initial: 'teaching',
-      states: {
-        teaching: {
-          invoke: {
-            src: 'agent',
-            input: (x) => ({
-              context: true,
-              goal: 'Give brief feedback to the human based on the most recent response of the conversation',
-              maxTokens: 100,
-            }),
-          },
-          on: {
-            teach: {
-              actions: (x) => console.log(x.event.instruction),
-              target: 'responding',
-            },
-          },
-        },
-        responding: {
-          invoke: {
-            src: 'agent',
-            input: (x) => ({
-              context: true,
-              goal: 'Respond to the last message of the conversation in Spanish',
-            }),
-          },
-          on: {
-            respond: {
-              actions: [
-                assign({
-                  conversation: (x) =>
-                    x.context.conversation.concat(`Agent: ` + x.event.response),
-                }),
-                log((x) => x.event.response),
-              ],
-              target: 'done',
-            },
-          },
-        },
-        done: { type: 'final' },
-      },
-      onDone: { target: 'human' },
-    },
-  },
-});
-
-createActor(machine).start();