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

package/examples/cot.ts

@@ -1,19 +1,13 @@
 import { z } from 'zod';
-import { createAgent, fromDecision, TypesFromAgent } from '../src';
+import { createAgent } from '../src';
 import { openai } from '@ai-sdk/openai';
-import { assign, createActor, log, setup } from 'xstate';
-import { fromTerminal } from './helpers/helpers';
+import { getFromTerminal } from './helpers/helpers';
 import { chainOfThoughtStrategy } from '../src/strategies/chainOfThought';
 
 const agent = createAgent({
   id: 'chain-of-thought',
-  model: openai('gpt-4o-mini'),
+  model: openai('gpt-4o'),
   events: {
-    'agent.think': z.object({
-      thought: z
-        .string()
-        .describe('The thought process to answering the question'),
-    }),
     'agent.answer': z.object({
       answer: z.string().describe('The answer to the question'),
     }),
@@ -24,51 +18,23 @@ const agent = createAgent({
   strategy: chainOfThoughtStrategy,
 });
 
-const machine = setup({
-  types: {} as TypesFromAgent<typeof agent>,
-  actors: { getFromTerminal: fromTerminal },
-}).createMachine({
-  initial: 'asking',
-  context: {
-    question: null,
-  },
-  states: {
-    asking: {
-      invoke: {
-        src: 'getFromTerminal',
-        input: 'What would you like to ask?',
-        onDone: {
-          actions: assign({
-            question: ({ event }) => event.output,
-          }),
-          target: 'answering',
-        },
-      },
-    },
-    answering: {
-      on: {
-        'agent.answer': {
-          actions: log(({ event }) => `Answer: ${event.answer}`),
-          target: 'answered',
-        },
+// agent.onMessage((msg) => console.log(msg.content));
+
+async function main() {
+  const msg = await getFromTerminal('what?');
+
+  const decision = await agent.decide({
+    messages: agent.getMessages(),
+    goal: 'Answer the question.',
+    state: {
+      value: 'thinking',
+      context: {
+        question: msg,
       },
     },
-    answered: {
-      type: 'final',
-    },
-  },
-});
-
-const actor = createActor(machine).start();
+  });
 
-agent.onMessage(console.log);
+  console.log(decision?.nextEvent?.answer);
+}
 
-agent.interact(actor, (obs) => {
-  if (obs.state.matches('answering')) {
-    return {
-      goal: 'Answer the question',
-      context: obs.state.context,
-      messages: agent.getMessages(),
-    };
-  }
-});
+main();

package/examples/customer-service-sim.ts

@@ -1,4 +1,4 @@
-import { createAgent, EventsFromAgent, fromDecision } from '../src';
+import { createAgent, EventFromAgent, fromDecision } from '../src';
 import { assign, createActor, setup } from 'xstate';
 import { openai } from '@ai-sdk/openai';
 import { z } from 'zod';
@@ -38,8 +38,8 @@ const machine = setup({
       messages: string[];
     },
     events: {} as
-      | EventsFromAgent<typeof customerServiceAgent>
-      | EventsFromAgent<typeof customerAgent>,
+      | EventFromAgent<typeof customerServiceAgent>
+      | EventFromAgent<typeof customerAgent>,
   },
   actors: {
     customerService: fromDecision(customerServiceAgent),

package/examples/email.ts

@@ -1,11 +1,5 @@
 import { z } from 'zod';
-import {
-  ContextFromAgent,
-  createAgent,
-  EventsFromAgent,
-  fromDecision,
-  TypesFromAgent,
-} from '../src';
+import { ContextFromAgent, createAgent, EventFromAgent } from '../src';
 import { openai } from '@ai-sdk/openai';
 import { assign, createActor, setup } from 'xstate';
 import { fromTerminal } from './helpers/helpers';
@@ -33,7 +27,7 @@ const agent = createAgent({
 
 const machine = setup({
   types: {
-    events: {} as EventsFromAgent<typeof agent>,
+    events: {} as EventFromAgent<typeof agent>,
     input: {} as {
       email: string;
       instructions: string;
@@ -107,14 +101,12 @@ agent.interact(actor, ({ state }) => {
   if (state.matches('checking')) {
     return {
       goal: 'Respond to the email given the instructions and the provided clarifications. If not enough information is provided, ask for clarification. Otherwise, if you are absolutely sure that there is no ambiguous or missing information, create and submit a response email.',
-      context: state.context,
     };
   }
 
   if (state.matches('submitting')) {
     return {
       goal: 'Create and submit an email based on the instructions.',
-      context: state.context,
     };
   }
 });

package/examples/example.ts

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { createAgent, EventsFromAgent, fromDecision, fromText } from '../src';
+import { createAgent, EventFromAgent, fromDecision, fromText } from '../src';
 import { openai } from '@ai-sdk/openai';
 import { assign, createActor, setup } from 'xstate';
 
@@ -18,7 +18,7 @@ const agent = createAgent({
 
 const machine = setup({
   types: {
-    events: {} as EventsFromAgent<typeof agent>,
+    events: {} as EventFromAgent<typeof agent>,
   },
   actors: { agent: fromDecision(agent), summarizer: fromText(agent) },
 }).createMachine({

package/examples/goal.ts

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

package/examples/joke.ts

@@ -186,40 +186,40 @@ const jokeMachine = setup({
 
 const actor = createActor(jokeMachine);
 
-agent.interact(actor, (observed) => {
-  if (observed.state.matches('tellingJoke')) {
+agent.interact(actor, ({ state }) => {
+  if (state.matches('tellingJoke')) {
     return {
       goal: 'Tell me a joke about the topic. Do not make any joke that is not relevant to the topic.',
       context: {
-        topic: observed.state.context.topic,
+        topic: state.context.topic,
       },
     };
   }
 
-  if (observed.state.matches('relevance')) {
+  if (state.matches('relevance')) {
     return {
       goal: 'An irrelevant joke has no reference to the topic. If the last joke is completely irrelevant to the topic, ask for a new joke topic. Otherwise, continue.',
       context: {
-        topic: observed.state.context.topic,
-        lastJoke: observed.state.context.jokes.at(-1),
+        topic: state.context.topic,
+        lastJoke: state.context.jokes.at(-1),
       },
     };
   }
 
-  if (observed.state.matches('rateJoke')) {
+  if (state.matches('rateJoke')) {
     return {
       goal: 'Rate the last joke on a scale of 1 to 10.',
       context: {
-        lastJoke: observed.state.context.jokes.at(-1),
+        lastJoke: state.context.jokes.at(-1),
       },
     };
   }
 
-  if (observed.state.matches('decide')) {
+  if (state.matches('decide')) {
     return {
       goal: 'Choose what to do next, given the previous rating of the joke.',
       context: {
-        lastRating: observed.state.context.lastRating,
+        lastRating: state.context.lastRating,
       },
     };
   }

package/examples/learn-from-feedback.ts

@@ -14,10 +14,6 @@ const agent = createAgent({
   },
 });
 
-agent.onMessage((msg) => {
-  console.log(`Message`, msg.content);
-});
-
 agent.on('decision', ({ decision }) => {
   console.log(`Decision: ${decision.nextEvent?.type ?? '??'}`);
 });
@@ -27,7 +23,7 @@ async function main() {
   let count = 0;
 
   while (status !== 'submitted') {
-    console.log(`Attempt ${count} - ${status}`);
+    console.log(`\nState: ${status} (attempt ${count + 1})`);
     if (count++ > 5) {
       break;
     }
@@ -43,27 +39,48 @@ async function main() {
           );
 
         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.',
+          goal: `
+<currentState>editing</currentState>
+
+<actions>
+  <action id="pressEnter">
+    <exploration_value>0.2</exploration_value>
+    <known_outcomes></known_outcomes>
+  </action>
+  <action id="submit">
+    <exploration_value>0.8</exploration_value>
+    <known_outcomes>
+      <outcome probability="0.1">editing</outcome>
+      <outcome probability="0.9">submitted</outcome>
+    </known_outcomes>
+  </action>
+</actions>
+
+<goal>Submit the form.</goal>
+
+Achieve the goal. Consider both exploring unknown actions (high exploration_value) and using actions with known outcomes. Prefer exploration when an action has no known outcomes.
+          `.trim(),
           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,
-                };
-              }),
-            },
+            // context: {
+            //   feedback: relevantFeedback.map((f) => {
+            //     const observation = relevantObservations.find(
+            //       (o) => o.id === f.observationId
+            //     );
+            //     return {
+            //       prevState: observation?.prevState,
+            //       event: observation?.event,
+            //       state: observation?.state,
+            //       comment: f.comment,
+            //     };
+            //   }),
+            // },
           },
         });
 
         if (decision?.nextEvent?.type === 'submit') {
           const observation = await agent.addObservation({
+            goal: decision.goal,
             prevState: { value: 'editing' },
             event: { type: 'submit' },
             state: { value: 'editing' },
@@ -72,15 +89,14 @@ async function main() {
           // 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',
-            },
+            score: 0,
+            comment: 'Form not submitted',
           });
         } else if (decision?.nextEvent?.type === 'pressEnter') {
           status = 'submitted';
 
           await agent.addObservation({
+            goal: decision.goal,
             prevState: { value: 'editing' },
             event: { type: 'pressEnter' },
             state: { value: 'submitted' },
@@ -93,8 +109,15 @@ async function main() {
     }
   }
 
-  console.log('End of conversation.');
+  if (status === 'submitted') {
+    console.log('Success!');
+  } else {
+    console.log('Failure!');
+  }
   process.exit();
 }
 
+agent.onMessage((msg) => {
+  // console.log(msg.content);
+});
 main().catch(console.error);

package/examples/number.ts

@@ -1,4 +1,4 @@
-import { createAgent, EventsFromAgent, fromDecision } from '../src';
+import { createAgent, EventFromAgent, fromDecision } from '../src';
 import { assign, createActor, log, setup } from 'xstate';
 import { z } from 'zod';
 import { openai } from '@ai-sdk/openai';
@@ -21,7 +21,7 @@ const machine = setup({
       previousGuesses: number[];
       answer: number | null;
     },
-    events: {} as EventsFromAgent<typeof agent>,
+    events: {} as EventFromAgent<typeof agent>,
   },
   actors: {
     agent: fromDecision(agent),

package/examples/raffle.ts

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

package/examples/support.ts

@@ -1,5 +1,5 @@
 import { openai } from '@ai-sdk/openai';
-import { createAgent, EventsFromAgent, fromDecision } from '../src';
+import { createAgent, EventFromAgent, 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: {} as EventsFromAgent<typeof agent>,
+    events: {} as EventFromAgent<typeof agent>,
     input: {} as string,
     context: {} as {
       customerIssue: string;
@@ -110,8 +110,8 @@ const actor = createActor(machine, {
 
 actor.start();
 
-agent.interact(actor, (observation) => {
-  if (observation.state.matches('frontline')) {
+agent.interact(actor, ({ state }) => {
+  if (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.`,
@@ -121,31 +121,27 @@ agent.interact(actor, (observation) => {
       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')) {
+  if (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')) {
+  if (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')) {
+  if (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

@@ -3,7 +3,7 @@ import { z } from 'zod';
 import {
   ContextFromAgent,
   createAgent,
-  EventsFromAgent,
+  EventFromAgent,
   fromDecision,
   fromTextStream,
   TypesFromAgent,
@@ -105,7 +105,7 @@ export const ticTacToeMachine = setup({
   types: {
     context: {} as ContextFromAgent<typeof xAgent>,
     events: {} as
-      | EventsFromAgent<typeof xAgent>
+      | EventFromAgent<typeof xAgent>
       | {
           type: 'reset';
         },

package/examples/todo.ts

@@ -1,6 +1,6 @@
-import { assign, setup, assertEvent, createActor, createMachine } from 'xstate';
+import { assign, setup, createActor } from 'xstate';
 import { z } from 'zod';
-import { createAgent, EventsFromAgent, fromDecision } from '../src';
+import { createAgent, EventFromAgent, 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
-      | EventsFromAgent<typeof agent>
+      | EventFromAgent<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, EventsFromAgent, fromDecision } from '../src';
+import { createAgent, EventFromAgent, 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: {} as EventsFromAgent<typeof agent>,
+    events: {} as EventFromAgent<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, EventsFromAgent, fromDecision } from '../src';
+import { createAgent, EventFromAgent, 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: {} as EventsFromAgent<typeof agent>,
+    events: {} as EventFromAgent<typeof agent>,
   },
   actors: {
     getFromTerminal: fromTerminal,

package/examples/weather-agent.ts

@@ -122,19 +122,17 @@ const machine = setup({
 // Create and start the actor
 const actor = createActor(machine).start();
 
-agent.interact(actor, (obs) => {
-  if (obs.state.matches('processing')) {
+agent.interact(actor, ({ state }) => {
+  if (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')) {
+  if (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, EventsFromAgent, fromDecision } from '../src';
+import { createAgent, EventFromAgent, fromDecision } from '../src';
 import { assign, createActor, fromPromise, log, setup } from 'xstate';
 import { fromTerminal } from './helpers/helpers';
 import { z } from 'zod';
@@ -78,7 +78,7 @@ const machine = setup({
       count: number;
       result: string | null;
     },
-    events: {} as EventsFromAgent<typeof agent>,
+    events: {} as EventFromAgent<typeof agent>,
   },
   actors: {
     agent: fromDecision(agent),
@@ -156,20 +156,23 @@ const machine = setup({
 const actor = createActor(machine);
 actor.start();
 
-agent.interact(actor, (obs) => {
-  if (obs.state.matches('decide')) {
+agent.interact(actor, ({ state }) => {
+  if (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,
+        location: state.context.location,
       },
     };
   }
 
-  if (obs.state.matches('reportWeather')) {
+  if (state.matches('reportWeather')) {
     return {
       goal: `Report the weather for the given location`,
-      context: obs.state.context,
+      context: {
+        location: state.context.location,
+        result: state.context.result,
+      },
     };
   }
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@statelyai/agent",
-  "version": "2.0.0-next.2",
+  "version": "2.0.0-next.3",
   "description": "Stateful agents that make decisions based on finite-state machine models",
   "main": "dist/index.js",
   "module": "dist/index.mjs",