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

package/examples/weather.ts

@@ -1,4 +1,4 @@
-import { createAgent, 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';
@@ -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 EventFromAgent<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,25 @@ const machine = setup({
 });
 
 const actor = createActor(machine);
-actor.subscribe((s) => {
-  console.log(s.value);
-});
 actor.start();
+
+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: state.context.location,
+      },
+    };
+  }
+
+  if (state.matches('reportWeather')) {
+    return {
+      goal: `Report the weather for the given location`,
+      context: {
+        location: state.context.location,
+        result: state.context.result,
+      },
+    };
+  }
+});

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.3",
   "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",

package/src/agent.test.ts

@@ -1,5 +1,5 @@
 import { test, expect, vi } from 'vitest';
-import { createAgent } from './';
+import { createAgent, TypesFromAgent } from './';
 import { createActor, createMachine } from 'xstate';
 import { LanguageModelV1CallOptions } from 'ai';
 import { z } from 'zod';
@@ -17,12 +17,12 @@ test('an agent has the expected interface', () => {
   expect(agent.addMessage).toBeDefined();
   expect(agent.addObservation).toBeDefined();
   expect(agent.addFeedback).toBeDefined();
-  expect(agent.addPlan).toBeDefined();
+  expect(agent.addDecision).toBeDefined();
 
   expect(agent.getMessages).toBeDefined();
   expect(agent.getObservations).toBeDefined();
   expect(agent.getFeedback).toBeDefined();
-  expect(agent.getPlans).toBeDefined();
+  expect(agent.getDecisions).toBeDefined();
 
   expect(agent.interact).toBeDefined();
 });
@@ -70,34 +70,24 @@ test('agent.addFeedback() adds to feedback', () => {
     model: {} as any,
   });
 
-  const feedback = agent.addFeedback({
-    attributes: {
-      score: -1,
-    },
+  const obs = agent.addObservation({
+    prevState: { value: 'playing' },
+    state: { value: 'lost' },
+    event: { type: 'play', position: 3 },
     goal: 'Win the game',
-    observationId: 'obs-1',
+  });
+
+  const feedback = agent.addFeedback({
+    score: 0,
+    observationId: obs.id,
   });
 
   expect(feedback.episodeId).toEqual(agent.episodeId);
 
   expect(agent.getFeedback()).toContainEqual(
     expect.objectContaining({
-      attributes: {
-        score: -1,
-      },
-      goal: 'Win the game',
-      observationId: 'obs-1',
-      episodeId: expect.any(String),
-      timestamp: expect.any(Number),
-    })
-  );
-  expect(agent.getFeedback()).toContainEqual(
-    expect.objectContaining({
-      attributes: {
-        score: -1,
-      },
-      goal: 'Win the game',
-      observationId: 'obs-1',
+      score: 0,
+      observationId: obs.id,
       episodeId: expect.any(String),
       timestamp: expect.any(Number),
     })
@@ -115,6 +105,7 @@ test('agent.addObservation() adds to observations', () => {
     prevState: { value: 'playing', context: {} },
     event: { type: 'play', position: 3 },
     state: { value: 'lost', context: {} },
+    goal: 'Win the game',
   });
 
   expect(observation.episodeId).toEqual(agent.episodeId);
@@ -139,6 +130,7 @@ test('agent.addObservation() adds to observations (initial state)', () => {
 
   const observation = agent.addObservation({
     state: { value: 'lost' },
+    goal: 'Win the game',
   });
 
   expect(observation.episodeId).toEqual(agent.episodeId);
@@ -176,6 +168,7 @@ test('agent.addObservation() adds to observations with machine hash', () => {
     event: { type: 'play', position: 3 },
     state: { value: 'lost', context: {} },
     machine,
+    goal: 'Win the game',
   });
 
   expect(observation.episodeId).toEqual(agent.episodeId);
@@ -203,13 +196,11 @@ test('agent.addFeedback() adds to feedback (with observation)', () => {
     state: {
       value: 'playing',
     },
+    goal: 'Win the game',
   });
 
   const feedback = agent.addFeedback({
-    attributes: {
-      score: -1,
-    },
-    goal: 'Win the game',
+    score: 0,
     observationId: observation.id,
   });
 
@@ -217,10 +208,7 @@ test('agent.addFeedback() adds to feedback (with observation)', () => {
 
   expect(agent.getFeedback()).toContainEqual(
     expect.objectContaining({
-      attributes: {
-        score: -1,
-      },
-      goal: 'Win the game',
+      score: 0,
       observationId: observation.id,
       episodeId: expect.any(String),
       timestamp: expect.any(Number),
@@ -228,10 +216,7 @@ test('agent.addFeedback() adds to feedback (with observation)', () => {
   );
   expect(agent.getFeedback()).toContainEqual(
     expect.objectContaining({
-      attributes: {
-        score: -1,
-      },
-      goal: 'Win the game',
+      score: 0,
       observationId: observation.id,
       episodeId: expect.any(String),
       timestamp: expect.any(Number),
@@ -297,17 +282,14 @@ test('You can listen for feedback events', () => {
   agent.on('feedback', fn);
 
   agent.addFeedback({
-    attributes: {
-      score: -1,
-    },
-    goal: 'Win the game',
+    score: -1,
     observationId: 'obs-1',
   });
 
   expect(fn).toHaveBeenCalled();
 });
 
-test('You can listen for plan events', async () => {
+test('You can listen for decision events', async () => {
   const fn = vi.fn();
   const model = new MockLanguageModelV1({
     doGenerate: async (params: LanguageModelV1CallOptions) => {
@@ -339,7 +321,7 @@ test('You can listen for plan events', async () => {
     },
   });
 
-  agent.on('plan', fn);
+  agent.on('decision', fn);
 
   await agent.decide({
     goal: 'Win the game',
@@ -364,7 +346,7 @@ test('You can listen for plan events', async () => {
 
   expect(fn).toHaveBeenCalledWith(
     expect.objectContaining({
-      plan: expect.objectContaining({
+      decision: expect.objectContaining({
         nextEvent: {
           type: 'WIN',
         },
@@ -386,12 +368,14 @@ test('agent.types provides context and event types', () => {
     },
   });
 
-  agent.types satisfies { context: any; events: any };
+  let types = {} as TypesFromAgent<typeof agent>;
+
+  types satisfies { context: any; events: any };
 
-  agent.types.context satisfies { score: number };
+  types.context satisfies { score: number };
 
   // @ts-expect-error
-  agent.types.context satisfies { score: string };
+  types.context satisfies { score: string };
 });
 
 test('It allows unrecognized events', () => {
@@ -436,15 +420,16 @@ test('You can listen for message events', () => {
   );
 });
 
-test('agent.getPlans() returns plans from context', () => {
+test('agent.getDecisions() returns decisions from context', () => {
   const agent = createAgent({
     id: 'test',
     events: {},
     model: {} as any,
-    planner: async (agent) => {
+    strategy: async (agent) => {
       return {
+        id: Date.now().toString(),
         episodeId: agent.episodeId,
-        planner: 'test-planner',
+        strategy: 'test-strategy',
         goal: '',
         goalState: undefined,
         paths: [
@@ -459,10 +444,10 @@ test('agent.getPlans() returns plans from context', () => {
     },
   });
 
-  const plans = agent.getPlans();
+  const decisions = agent.getDecisions();
 
-  expect(plans).toBeDefined();
-  expect(Array.isArray(plans)).toBe(true);
+  expect(decisions).toBeDefined();
+  expect(Array.isArray(decisions)).toBe(true);
 });
 
 test('Event listeners can be unsubscribed', () => {