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

package/examples/example.ts

@@ -1,10 +1,10 @@
 import { z } from 'zod';
-import { createAgent, fromDecision, fromText } from '../src';
+import { createAgent, EventsFromAgent, fromDecision, fromText } from '../src';
 import { openai } from '@ai-sdk/openai';
 import { assign, createActor, setup } from 'xstate';
 
 const agent = createAgent({
-  name: 'example',
+  id: 'example',
   model: openai('gpt-4o-mini'),
   events: {
     'agent.englishSummary': z.object({
@@ -18,7 +18,7 @@ const agent = createAgent({
 
 const machine = setup({
   types: {
-    events: agent.types.events,
+    events: {} as EventsFromAgent<typeof agent>,
   },
   actors: { agent: fromDecision(agent), summarizer: fromText(agent) },
 }).createMachine({

package/examples/goal.ts

@@ -1,11 +1,11 @@
 import { z } from 'zod';
-import { createAgent, fromDecision } from '../src';
+import { createAgent, EventsFromAgent, fromDecision } from '../src';
 import { openai } from '@ai-sdk/openai';
 import { assign, createActor, log, setup } from 'xstate';
 import { fromTerminal } from './helpers/helpers';
 
 const agent = createAgent({
-  name: 'goal',
+  id: 'goal',
   model: openai('gpt-4o-mini'),
   events: {
     'agent.createGoal': z.object({
@@ -25,7 +25,7 @@ const machine = setup({
       question: string | null;
       goal: string | null;
     },
-    events: agent.types.events,
+    events: {} as EventsFromAgent<typeof agent>,
   },
   actors: { decider, getFromTerminal: fromTerminal },
 }).createMachine({

package/examples/joke.ts

@@ -1,5 +1,5 @@
 import { assign, createActor, fromCallback, log, setup } from 'xstate';
-import { createAgent, fromDecision } from '../src';
+import { createAgent, fromDecision, TypesFromAgent } from '../src';
 import { loadingAnimation } from './helpers/loader';
 import { z } from 'zod';
 import { openai } from '@ai-sdk/openai';
@@ -45,7 +45,7 @@ const loader = fromCallback(({ input }: { input: string }) => {
 });
 
 const agent = createAgent({
-  name: 'joke-teller',
+  id: 'joke-teller',
   model: openai('gpt-4o-mini'),
   events: {
     askForTopic: z
@@ -81,7 +81,7 @@ const agent = createAgent({
 });
 
 const jokeMachine = setup({
-  types: agent.types,
+  types: {} as TypesFromAgent<typeof agent>,
   actors: {
     agent: fromDecision(agent),
     loader,

package/examples/jugs.ts

@@ -1,11 +1,11 @@
-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 { shortestPathPlanner } from '../src/planners/shortestPathPlanner';
+import { experimental_shortestPathStrategy } from '../src/strategies/shortestPath';
 
 const agent = createAgent({
-  name: 'die-hard-solver',
+  id: 'die-hard-solver',
   model: openai('gpt-4o'),
   events: {
     fill3: z.object({}).describe('Fill the 3-gallon jug'),
@@ -38,10 +38,7 @@ const agent = createAgent({
 });
 
 const waterJugMachine = setup({
-  types: {
-    context: agent.types.context,
-    events: agent.types.events,
-  },
+  types: {} as TypesFromAgent<typeof agent>,
 }).createMachine({
   initial: 'solving',
   context: { jug3: 0, jug5: 0 },
@@ -106,7 +103,7 @@ async function main() {
       machine: waterJugMachine,
       goal: 'Get exactly 4 gallons of water in the 5-gallon jug',
       state: waterJugActor.getSnapshot(),
-      planner: shortestPathPlanner,
+      strategy: experimental_shortestPathStrategy,
     });
 
     console.log(decision?.nextEvent);

package/examples/learn-from-feedback.ts

@@ -0,0 +1,100 @@
+import { z } from 'zod';
+import { createAgent } from '../src';
+import { openai } from '@ai-sdk/openai';
+
+const agent = createAgent({
+  id: 'chatbot',
+  model: openai('gpt-4o-mini'),
+  events: {
+    submit: z.object({}).describe('Submit the form'),
+    pressEnter: z.object({}).describe('Press the enter key'),
+  },
+  context: {
+    userMessage: z.string(),
+  },
+});
+
+agent.onMessage((msg) => {
+  console.log(`Message`, msg.content);
+});
+
+agent.on('decision', ({ decision }) => {
+  console.log(`Decision: ${decision.nextEvent?.type ?? '??'}`);
+});
+
+async function main() {
+  let status = 'editing';
+  let count = 0;
+
+  while (status !== 'submitted') {
+    console.log(`Attempt ${count} - ${status}`);
+    if (count++ > 5) {
+      break;
+    }
+    switch (status) {
+      case 'editing': {
+        const relevantObservations = await agent
+          .getObservations()
+          .filter((obs) => obs.prevState.value === 'editing');
+        const relevantFeedback = await agent
+          .getFeedback()
+          .filter((f) =>
+            relevantObservations.find((o) => o.id === f.observationId)
+          );
+
+        const decision = await agent.decide({
+          goal: 'Submit the form. Take the feedback into consideration, and perform the action that will lead to the form being submitted.',
+          state: {
+            value: 'editing',
+            context: {
+              feedback: relevantFeedback.map((f) => {
+                const observation = relevantObservations.find(
+                  (o) => o.id === f.observationId
+                );
+                return {
+                  prevState: observation?.prevState,
+                  event: observation?.event,
+                  state: observation?.state,
+                  feedback: f.attributes.text,
+                };
+              }),
+            },
+          },
+        });
+
+        if (decision?.nextEvent?.type === 'submit') {
+          const observation = await agent.addObservation({
+            prevState: { value: 'editing' },
+            event: { type: 'submit' },
+            state: { value: 'editing' },
+          });
+
+          // don't change the status; pretend submit button is broken
+          await agent.addFeedback({
+            observationId: observation.id,
+            goal: 'Submit the form',
+            attributes: {
+              text: 'Form not submitted',
+            },
+          });
+        } else if (decision?.nextEvent?.type === 'pressEnter') {
+          status = 'submitted';
+
+          await agent.addObservation({
+            prevState: { value: 'editing' },
+            event: { type: 'pressEnter' },
+            state: { value: 'submitted' },
+          });
+        }
+        break;
+      }
+      case 'submitted':
+        break;
+    }
+  }
+
+  console.log('End of conversation.');
+  process.exit();
+}
+
+main().catch(console.error);

package/examples/multi.ts

@@ -5,7 +5,7 @@ import { fromTerminal } from './helpers/helpers';
 import { openai } from '@ai-sdk/openai';
 
 const agent = createAgent({
-  name: 'multi',
+  id: 'multi',
   model: openai('gpt-4o-mini'),
   events: {
     'agent.respond': z.object({

package/examples/number.ts

@@ -1,11 +1,11 @@
-import { createAgent, fromDecision } from '../src';
+import { createAgent, EventsFromAgent, fromDecision } from '../src';
 import { assign, createActor, log, setup } from 'xstate';
 import { z } from 'zod';
 import { openai } from '@ai-sdk/openai';
 import { fromTerminal } from './helpers/helpers';
 
 const agent = createAgent({
-  name: 'number-guesser',
+  id: 'number-guesser',
   model: openai('gpt-3.5-turbo-1106'),
   events: {
     'agent.guess': z.object({
@@ -21,7 +21,7 @@ const machine = setup({
       previousGuesses: number[];
       answer: number | null;
     },
-    events: agent.types.events,
+    events: {} as EventsFromAgent<typeof agent>,
   },
   actors: {
     agent: fromDecision(agent),

package/examples/raffle.ts

@@ -1,11 +1,11 @@
 import { z } from 'zod';
-import { createAgent, fromDecision } from '../src';
+import { createAgent, EventsFromAgent, fromDecision } from '../src';
 import { openai } from '@ai-sdk/openai';
 import { assign, createActor, log, setup } from 'xstate';
 import { fromTerminal } from './helpers/helpers';
 
 const agent = createAgent({
-  name: 'raffle-chooser',
+  id: 'raffle-chooser',
   model: openai('gpt-4o-mini'),
   events: {
     'agent.collectEntries': z.object({}).describe('Collect more entries'),
@@ -27,7 +27,7 @@ const machine = setup({
       lastInput: string | null;
       entries: string[];
     },
-    events: agent.types.events,
+    events: {} as EventsFromAgent<typeof agent>,
   },
   actors: { agent: fromDecision(agent), getFromTerminal: fromTerminal },
 }).createMachine({

package/examples/river-crossing.ts

@@ -1,11 +1,11 @@
-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 { shortestPathPlanner } from '../src/planners/shortestPathPlanner';
+import { experimental_shortestPathStrategy } from '../src/strategies/shortestPath';
 
 const agent = createAgent({
-  name: 'river-crossing-solver',
+  id: 'river-crossing-solver',
   model: openai('gpt-4'),
   events: {
     takeWolf: z
@@ -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: shortestPathPlanner,
+      strategy: experimental_shortestPathStrategy,
     });
 
     console.log(decision?.nextEvent);

package/examples/simple.ts

@@ -1,10 +1,11 @@
 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({
-  name: 'simple',
+  id: 'simple',
   model: openai('gpt-4o-mini'),
   events: {
     'agent.thought': z.object({
@@ -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,11 +1,11 @@
-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';
 import { fromTerminal } from './helpers/helpers';
 
 const agent = createAgent({
-  name: 'summarizing-chat',
+  id: 'summarizing-chat',
   model: openai('gpt-4o'),
   events: {
     'agent.respond': z.object({
@@ -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,10 +1,10 @@
 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';
 
 const agent = createAgent({
-  name: 'support-agent',
+  id: 'support-agent',
   model: openai('gpt-4o-mini'),
   events: {
     'agent.respond': z.object({
@@ -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({
@@ -39,19 +48,30 @@ const context = {
 };
 
 const xAgent = createAgent({
-  name: 'tic-tac-toe-learner',
+  id: 'tic-tac-toe-learner',
   model: openai('gpt-4o-mini'),
   events,
   context,
 });
 
 const oAgent = createAgent({
-  name: 'tic-tac-toe-noob',
+  id: 'tic-tac-toe-noob',
   model: openai('gpt-4o-mini'),
   events,
   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,11 +1,11 @@
 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';
 
 const agent = createAgent({
-  name: 'todo',
+  id: 'todo',
   model: openai('gpt-4o-mini'),
   events: {
     addTodo: z.object({
@@ -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,11 +1,11 @@
 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';
 
 const agent = createAgent({
-  name: 'tutor',
+  id: 'tutor',
   model: openai('gpt-4o-mini'),
   events: {
     teach: z.object({
@@ -19,7 +19,7 @@ const agent = createAgent({
       response: z.string().describe('The response to the human in Spanish'),
     }),
   },
-  system:
+  description:
     'You are an expert Spanish tutor. You will respond to the human in Spanish.',
 });
 
@@ -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({