@statelyai/agent 2.0.0-next.1 → 2.0.0-next.2

package/examples/river-crossing.ts

@@ -1,8 +1,8 @@
-import { createAgent } from '../src';
+import { createAgent, TypesFromAgent } from '../src';
 import { assign, createActor, setup } from 'xstate';
 import { openai } from '@ai-sdk/openai';
 import { z } from 'zod';
-import { experimental_createShortestPathPlanner } from '../src/planners/shortestPath';
+import { experimental_shortestPathStrategy } from '../src/strategies/shortestPath';
 
 const agent = createAgent({
   id: 'river-crossing-solver',
@@ -45,10 +45,7 @@ const agent = createAgent({
 });
 
 const riverCrossingMachine = setup({
-  types: {
-    context: agent.types.context,
-    events: agent.types.events,
-  },
+  types: {} as TypesFromAgent<typeof agent>,
 }).createMachine({
   initial: 'solving',
   context: {
@@ -121,7 +118,7 @@ async function main() {
       machine: riverCrossingMachine,
       goal: 'Get all items safely across the river. Remember: Cannot leave wolf with goat or goat with cabbage unattended.',
       state: riverActor.getSnapshot(),
-      planner: experimental_createShortestPathPlanner(),
+      strategy: experimental_shortestPathStrategy,
     });
 
     console.log(decision?.nextEvent);

package/examples/simple.ts

@@ -1,7 +1,8 @@
 import { createAgent, fromDecision } from '../src';
 import { z } from 'zod';
-import { setup, createActor } from 'xstate';
+import { setup, createActor, createMachine } from 'xstate';
 import { openai } from '@ai-sdk/openai';
+import { chainOfThoughtStrategy } from '../src/strategies/chainOfThought';
 
 const agent = createAgent({
   id: 'simple',
@@ -13,18 +14,10 @@ const agent = createAgent({
   },
 });
 
-const machine = setup({
-  actors: { agent: fromDecision(agent) },
-}).createMachine({
+const machine = createMachine({
   initial: 'thinking',
   states: {
     thinking: {
-      invoke: {
-        src: 'agent',
-        input: {
-          goal: 'Think about a random topic, and then share that thought.',
-        },
-      },
       on: {
         'agent.thought': {
           actions: ({ event }) => console.log(event.text),
@@ -39,3 +32,13 @@ const machine = setup({
 });
 
 const actor = createActor(machine).start();
+
+agent.onMessage(console.log);
+
+agent.interact(actor, (obs) => {
+  if (obs.state.matches('thinking')) {
+    return {
+      goal: 'Think about a random topic, and then share that thought.',
+    };
+  }
+});

package/examples/summary.ts

@@ -1,4 +1,4 @@
-import { createAgent, fromDecision } from '../src';
+import { createAgent, fromDecision, TypesFromAgent } from '../src';
 import { assign, createActor, setup } from 'xstate';
 import { z } from 'zod';
 import { openai } from '@ai-sdk/openai';
@@ -27,10 +27,7 @@ const agent = createAgent({
 });
 
 const machine = setup({
-  types: {
-    context: agent.types.context,
-    events: agent.types.events,
-  },
+  types: {} as TypesFromAgent<typeof agent>,
   actors: {
     agent: fromDecision(agent),
     fromTerminal,

package/examples/support.ts

@@ -1,5 +1,5 @@
 import { openai } from '@ai-sdk/openai';
-import { createAgent, fromDecision } from '../src';
+import { createAgent, EventsFromAgent, fromDecision } from '../src';
 import { z } from 'zod';
 import { createActor, log, setup } from 'xstate';
 
@@ -35,7 +35,7 @@ const agent = createAgent({
 
 const machine = setup({
   types: {
-    events: agent.types.events,
+    events: {} as EventsFromAgent<typeof agent>,
     input: {} as string,
     context: {} as {
       customerIssue: string;
@@ -49,20 +49,6 @@ const machine = setup({
   }),
   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': [
           {
@@ -83,14 +69,6 @@ const machine = setup({
       },
     },
     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),
@@ -99,14 +77,6 @@ const machine = setup({
       },
     },
     technical: {
-      invoke: {
-        src: 'agent',
-        input: ({ context }) => ({
-          context,
-          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),
@@ -115,12 +85,6 @@ const machine = setup({
       },
     },
     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(({ event }) => event),
@@ -145,3 +109,43 @@ const actor = createActor(machine, {
 });
 
 actor.start();
+
+agent.interact(actor, (observation) => {
+  if (observation.state.matches('frontline')) {
+    return {
+      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.`,
+      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.`,
+      context: observation.state.context,
+    };
+  }
+
+  if (observation.state.matches('billing')) {
+    return {
+      goal: `The following text is a response from a customer support representative. Extract whether they want to refund the user or not.`,
+      system: `Your job is to detect whether a billing support representative wants to refund the user.`,
+      context: observation.state.context,
+    };
+  }
+
+  if (observation.state.matches('technical')) {
+    return {
+      goal: 'Solve the customer issue.',
+      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.`,
+      context: observation.state.context,
+    };
+  }
+
+  if (observation.state.matches('conversational')) {
+    return {
+      goal: 'You are a customer support agent that is ending the conversation with the customer. Respond politely and thank them for their time.',
+      system: `You are a customer support agent that is ending the conversation with the customer. Respond politely and thank them for their time.`,
+      context: observation.state.context,
+    };
+  }
+});

package/examples/ticTacToe.ts

@@ -1,7 +1,16 @@
 import { assign, setup, assertEvent, createActor } from 'xstate';
 import { z } from 'zod';
-import { createAgent, fromDecision, fromTextStream } from '../src';
+import {
+  ContextFromAgent,
+  createAgent,
+  EventsFromAgent,
+  fromDecision,
+  fromTextStream,
+  TypesFromAgent,
+} from '../src';
 import { openai } from '@ai-sdk/openai';
+import { generateObject, generateText } from 'ai';
+import * as fs from 'fs';
 
 const events = {
   'agent.x.play': z.object({
@@ -52,6 +61,17 @@ const oAgent = createAgent({
   context,
 });
 
+const feedbackAgent = createAgent({
+  id: 'tic-tac-toe-expert',
+  model: openai('gpt-4o-mini'),
+  description: 'You are an expert in tic-tac-toe.',
+  events: {
+    'agent.feedback': z.object({
+      feedback: z.string(),
+    }),
+  },
+});
+
 type Player = 'x' | 'o';
 
 const initialContext = {
@@ -60,7 +80,7 @@ const initialContext = {
   player: 'x' as Player,
   gameReport: '',
   lastReason: '',
-} satisfies typeof xAgent.types.context;
+} satisfies ContextFromAgent<typeof xAgent>;
 
 function getWinner(board: typeof initialContext.board): Player | null {
   const lines = [
@@ -83,9 +103,9 @@ function getWinner(board: typeof initialContext.board): Player | null {
 
 export const ticTacToeMachine = setup({
   types: {
-    context: xAgent.types.context,
+    context: {} as ContextFromAgent<typeof xAgent>,
     events: {} as
-      | typeof xAgent.types.events
+      | EventsFromAgent<typeof xAgent>
       | {
           type: 'reset';
         },
@@ -236,6 +256,23 @@ const actor = createActor(ticTacToeMachine);
 
 xAgent.interact(actor, (observed) => {
   if (observed.state.matches({ playing: 'x' })) {
+    // get similar observations
+    const similarObservations = xAgent.getObservations().filter((o) => {
+      return (
+        o.prevState &&
+        JSON.stringify(o.prevState.context.board) ===
+          JSON.stringify(observed.state.context.board)
+      );
+    });
+
+    console.log('Similar:', similarObservations);
+
+    const similarFeedbacks = similarObservations.map((o) => {
+      return xAgent.getFeedback().filter((f) => f.observationId === o.id);
+    });
+
+    console.log('Feedbacks:', similarFeedbacks);
+
     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. 
 
@@ -262,4 +299,9 @@ Execute the single best next move to try to win the game. Do not play on an exis
   return;
 });
 
+xAgent.on('observation', (observation) => {
+  // append the observation to a jsonl file
+  fs.appendFileSync('observations.jsonl', JSON.stringify(observation) + '\n');
+});
+
 actor.start();

package/examples/todo.ts

@@ -1,6 +1,6 @@
 import { assign, setup, assertEvent, createActor, createMachine } from 'xstate';
 import { z } from 'zod';
-import { createAgent, fromDecision } from '../src';
+import { createAgent, EventsFromAgent, fromDecision } from '../src';
 import { openai } from '@ai-sdk/openai';
 import { fromTerminal } from './helpers/helpers';
 
@@ -37,7 +37,7 @@ const machine = setup({
       command: string | null;
     },
     events: {} as
-      | typeof agent.types.events
+      | EventsFromAgent<typeof agent>
       | { type: 'assist'; command: string },
   },
   actors: { agent: fromDecision(agent), getFromTerminal: fromTerminal },

package/examples/tutor.ts

@@ -1,6 +1,6 @@
 import { assign, createActor, log, setup } from 'xstate';
 import { fromTerminal } from './helpers/helpers';
-import { createAgent, fromDecision } from '../src';
+import { createAgent, EventsFromAgent, fromDecision } from '../src';
 import { z } from 'zod';
 import { openai } from '@ai-sdk/openai';
 
@@ -28,7 +28,7 @@ const machine = setup({
     context: {} as {
       conversation: string[];
     },
-    events: agent.types.events,
+    events: {} as EventsFromAgent<typeof agent>,
   },
   actors: { agent: fromDecision(agent), getFromTerminal: fromTerminal },
 }).createMachine({

package/examples/verify.ts

@@ -1,6 +1,6 @@
 import { assign, createActor, setup, log } from 'xstate';
 import { fromTerminal } from './helpers/helpers';
-import { createAgent, fromDecision } from '../src';
+import { createAgent, EventsFromAgent, fromDecision } from '../src';
 import { z } from 'zod';
 import { openai } from '@ai-sdk/openai';
 
@@ -35,7 +35,7 @@ const machine = setup({
       answer: string | null;
       validation: string | null;
     },
-    events: agent.types.events,
+    events: {} as EventsFromAgent<typeof agent>,
   },
   actors: {
     getFromTerminal: fromTerminal,

package/examples/weather-agent.ts

@@ -0,0 +1,141 @@
+import { z } from 'zod';
+import { createAgent } from '../src';
+import { assign, createActor, fromPromise, setup } from 'xstate';
+// import { anthropic } from '@ai-sdk/anthropic';
+import { fromTerminal } from './helpers/helpers';
+import { openai } from '@ai-sdk/openai';
+
+// Create the weather agent
+const agent = createAgent({
+  id: 'weather-agent',
+  model: openai('gpt-4o'),
+  events: {
+    'weather.check': z.object({
+      location: z.string().describe('The location to check weather for'),
+    }),
+    'weather.report': z.object({
+      temperature: z.string(),
+      conditions: z.string(),
+    }),
+    'agent.respond': z.object({
+      response: z.string(),
+    }),
+  },
+});
+
+// Create the weather tool/service
+const getWeather = (location: string) => {
+  if (
+    location.toLowerCase().includes('sf') ||
+    location.toLowerCase().includes('san francisco')
+  ) {
+    return {
+      temperature: '60 degrees',
+      conditions: 'foggy',
+    };
+  }
+  return {
+    temperature: '90 degrees',
+    conditions: 'sunny',
+  };
+};
+
+// Create the state machine
+const machine = setup({
+  types: {
+    context: {} as {
+      input: string | null;
+      location: string | null;
+      weather: any;
+    },
+  },
+  actors: {
+    getFromTerminal: fromTerminal,
+    getWeather: fromPromise(async ({ input }: { input: string }) => {
+      return getWeather(input);
+    }),
+  },
+}).createMachine({
+  context: {
+    input: null,
+    location: null,
+    weather: null,
+  },
+  initial: 'user',
+  states: {
+    user: {
+      invoke: {
+        src: 'getFromTerminal',
+        input: 'Ask me about the weather!',
+        onDone: {
+          actions: assign({
+            input: ({ event }) => event.output,
+          }),
+          target: 'processing',
+        },
+      },
+    },
+    processing: {
+      entry: () => console.log('Processing...'),
+      on: {
+        'weather.check': {
+          actions: assign({
+            input: ({ event }) => event.location,
+          }),
+          target: 'checking',
+        },
+        'agent.respond': {
+          actions: ({ event }) => console.log(event.response),
+          target: 'responded',
+        },
+      },
+    },
+    checking: {
+      entry: ({ event }) => console.log('Checking weather...', event),
+      invoke: {
+        src: 'getWeather',
+        input: ({ context }) => context.input!,
+        onDone: {
+          actions: assign({
+            weather: ({ event }) => event.output,
+          }),
+          target: 'responding',
+        },
+      },
+    },
+    responding: {
+      on: {
+        'agent.respond': {
+          actions: ({ event }) => console.log(event.response),
+          target: 'responded',
+        },
+      },
+    },
+    responded: {
+      after: {
+        1000: { target: 'user' },
+      },
+    },
+  },
+});
+
+// Create and start the actor
+const actor = createActor(machine).start();
+
+agent.interact(actor, (obs) => {
+  if (obs.state.matches('processing')) {
+    return {
+      goal: 'Determine if user is asking about weather and for which location. If so, get the weather. Otherwise, respond to the user.',
+      context: obs.state.context,
+      messages: agent.getMessages(),
+    };
+  }
+
+  if (obs.state.matches('responding')) {
+    return {
+      goal: 'Provide a natural response about the weather in ${context.location}',
+      context: obs.state.context,
+      messages: agent.getMessages(),
+    };
+  }
+});

package/examples/weather.ts

@@ -1,4 +1,4 @@
-import { createAgent, fromDecision } from '../src';
+import { createAgent, EventsFromAgent, fromDecision } from '../src';
 import { assign, createActor, fromPromise, log, setup } from 'xstate';
 import { fromTerminal } from './helpers/helpers';
 import { z } from 'zod';
@@ -75,10 +75,10 @@ const machine = setup({
   types: {
     context: {} as {
       location: string;
-      history: string[];
       count: number;
+      result: string | null;
     },
-    events: agent.types.events,
+    events: {} as EventsFromAgent<typeof agent>,
   },
   actors: {
     agent: fromDecision(agent),
@@ -90,7 +90,7 @@ const machine = setup({
   context: {
     location: '',
     count: 0,
-    history: [],
+    result: null,
   },
   states: {
     getLocation: {
@@ -111,15 +111,6 @@ const machine = setup({
     },
     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),
@@ -138,6 +129,7 @@ const machine = setup({
             log(({ event }) => event.output),
             assign({
               count: ({ context }) => context.count + 1,
+              result: ({ event }) => event.output,
             }),
           ],
           target: 'reportWeather',
@@ -145,13 +137,6 @@ const machine = setup({
       },
     },
     reportWeather: {
-      invoke: {
-        src: 'agent',
-        input: ({ context }) => ({
-          goal: 'Report the weather', // TODO
-          context,
-        }),
-      },
       on: {
         'agent.reportWeather': {
           actions: log(({ event }) => event),
@@ -169,7 +154,22 @@ const machine = setup({
 });
 
 const actor = createActor(machine);
-actor.subscribe((s) => {
-  console.log(s.value);
-});
 actor.start();
+
+agent.interact(actor, (obs) => {
+  if (obs.state.matches('decide')) {
+    return {
+      goal: `Decide what to do based on the given location, which may or may not be a location`,
+      context: {
+        location: obs.state.context.location,
+      },
+    };
+  }
+
+  if (obs.state.matches('reportWeather')) {
+    return {
+      goal: `Report the weather for the given location`,
+      context: obs.state.context,
+    };
+  }
+});

package/examples/word.ts

@@ -1,6 +1,11 @@
 import { assign, createActor, log, setup } from 'xstate';
 import { fromTerminal } from './helpers/helpers';
-import { createAgent, fromDecision } from '../src';
+import {
+  ContextFromAgent,
+  createAgent,
+  fromDecision,
+  TypesFromAgent,
+} from '../src';
 import { z } from 'zod';
 import { openai } from '@ai-sdk/openai';
 
@@ -36,13 +41,10 @@ const context = {
   word: null,
   guessedWord: null,
   lettersGuessed: [],
-} satisfies typeof agent.types.context;
+} satisfies ContextFromAgent<typeof agent>;
 
 const wordGuesserMachine = setup({
-  types: {
-    context: agent.types.context,
-    events: agent.types.events,
-  },
+  types: {} as TypesFromAgent<typeof agent>,
   actors: {
     agent: fromDecision(agent),
     getFromTerminal: fromTerminal,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@statelyai/agent",
-  "version": "2.0.0-next.1",
+  "version": "2.0.0-next.2",
   "description": "Stateful agents that make decisions based on finite-state machine models",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -15,6 +15,7 @@
   "author": "David Khourshid <david@stately.ai>",
   "license": "MIT",
   "devDependencies": {
+    "@ai-sdk/anthropic": "^0.0.54",
     "@ai-sdk/openai": "^0.0.40",
     "@changesets/changelog-github": "^0.5.0",
     "@changesets/cli": "^2.27.9",