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

package/dist/index.js

@@ -40,7 +40,7 @@ module.exports = __toCommonJS(src_exports);
 // src/agent.ts
 var import_xstate4 = require("xstate");
 
-// src/planners/simplePlanner.ts
+// src/strategies/simple.ts
 var import_ai3 = require("ai");
 
 // src/utils.ts
@@ -79,6 +79,15 @@ function getAllMachineTransitions(stateNode) {
 function wrapInXml(tagName, content) {
   return `<${tagName}>${content}</${tagName}>`;
 }
+function convertToXml(obj) {
+  return Object.entries(obj).map(([key, value]) => {
+    if (typeof value === "object" && value !== null) {
+      return wrapInXml(key, convertToXml(value));
+    } else {
+      return wrapInXml(key, value);
+    }
+  }).join("");
+}
 function randomId(prefix) {
   const timestamp = Date.now().toString(36);
   const random = Math.random().toString(36).substring(2, 9);
@@ -106,10 +115,16 @@ function getTransitions(state, machine) {
   });
   return getAllTransitions(resolvedState);
 }
+function isMachineActor(actor) {
+  return "src" in actor && typeof actor.src === "object" && actor.src !== null && "definition" in actor.src;
+}
 
-// src/planners/simplePlanner.ts
+// src/strategies/simple.ts
 var import_xstate3 = require("xstate");
 
+// src/text.ts
+var import_ai = require("ai");
+
 // src/templates/defaultText.ts
 var defaultTextTemplate = (data) => {
   const preamble = [
@@ -123,7 +138,6 @@ ${data.goal}
 };
 
 // src/text.ts
-var import_ai = require("ai");
 var import_xstate = require("xstate");
 async function getMessages(agent, prompt, options) {
   let messages = [];
@@ -212,27 +226,42 @@ async function agentDecide(agent, options) {
     ...options
   };
   const {
-    planner = simplePlanner,
+    strategy = agent.strategy,
     goal,
+    allowedEvents,
     events = agent.events,
     state,
     machine,
     model = agent.model,
-    ...otherPlanInput
+    messages,
+    ...otherDecideInput
   } = resolvedOptions;
-  const plan = await planner(agent, {
-    model,
-    goal,
-    events,
-    state,
-    machine,
-    ...otherPlanInput
-  });
-  if (plan?.nextEvent) {
-    agent.addPlan(plan);
-    await resolvedOptions.execute?.(plan.nextEvent);
+  const filteredEventSchemas = allowedEvents ? Object.fromEntries(
+    Object.entries(events).filter(([key]) => {
+      return allowedEvents.includes(key);
+    })
+  ) : events;
+  let attempts = 0;
+  const maxAttempts = resolvedOptions.maxAttempts ?? 2;
+  let decision;
+  while (attempts++ < maxAttempts) {
+    decision = await strategy(agent, {
+      model,
+      goal,
+      events: filteredEventSchemas,
+      state,
+      machine,
+      messages,
+      // TODO: fix UIMessage thing
+      ...otherDecideInput
+    });
+    if (decision?.nextEvent) {
+      agent.addDecision(decision);
+      await resolvedOptions.execute?.(decision.nextEvent);
+      break;
+    }
   }
-  return plan;
+  return decision;
 }
 function fromDecision(agent, defaultInput) {
   return (0, import_xstate2.fromPromise)(async ({ input, self }) => {
@@ -250,15 +279,18 @@ function fromDecision(agent, defaultInput) {
       value: snapshot.value,
       context: resolvedInput.context
     };
-    const plan = await agentDecide(agent, {
+    const decision = await agentDecide(agent, {
       machine: parentRef.logic,
-      state,
+      state: snapshot,
+      context: resolvedInput.context,
       execute: async (event) => {
         parentRef.send(event);
       },
-      ...resolvedInput
+      ...resolvedInput,
+      // @ts-ignore
+      messages: resolvedInput.messages
     });
-    return plan;
+    return decision;
   });
 }
 function getToolMap(_agent, input) {
@@ -304,46 +336,48 @@ function getToolMap(_agent, input) {
   return toolMap;
 }
 
-// src/planners/simplePlanner.ts
-var simplePlannerPromptTemplate = (data) => {
+// src/strategies/simple.ts
+var simpleStrategyPromptTemplate = (data) => {
   return `
-${defaultTextTemplate(data)}
+${convertToXml(data)}
 
 Make at most one tool call to achieve the above goal. If the goal cannot be achieved with any tool calls, do not make any tool call.
   `.trim();
 };
-async function simplePlanner(agent, input) {
+async function simpleStrategy(agent, input) {
   const toolMap = getToolMap(agent, input);
   if (!toolMap) {
     return void 0;
   }
-  const prompt = simplePlannerPromptTemplate({
-    context: input.state.context,
+  const prompt = simpleStrategyPromptTemplate({
+    context: input.context,
     goal: input.goal
   });
   const messages = await getMessages(agent, prompt, input);
   const model = input.model ? agent.wrap(input.model) : agent.model;
   const {
     state,
+    context,
     machine,
-    previousPlan,
+    prevDecision,
     events,
     goal,
     model: _,
     ...rest
   } = input;
-  const machineState = input.machine ? input.machine.resolveState({
+  const machineState = input.machine && input.state ? input.machine.resolveState({
     ...input.state,
-    context: input.state.context
+    context: input.state.context ?? {}
   }) : void 0;
   const result = await (0, import_ai3.generateText)({
     ...rest,
+    system: input.system ?? agent.description,
     model,
     messages,
     tools: toolMap,
     toolChoice: input.toolChoice ?? "required"
   });
-  result.responseMessages.forEach((m) => {
+  result.response.messages.forEach((m) => {
     const message = m;
     agent.addMessage({
       ...message,
@@ -357,7 +391,7 @@ async function simplePlanner(agent, input) {
     return void 0;
   }
   return {
-    planner: "simple",
+    strategy: "simple",
     goal: input.goal,
     goalState: input.state,
     nextEvent: singleResult.result,
@@ -388,13 +422,11 @@ function createAgentMiddleware(agent) {
     },
     wrapGenerate: async ({ doGenerate, params }) => {
       const id = randomId();
-      params.prompt.forEach((p) => {
+      params.prompt.forEach((message) => {
         agent.addMessage({
           id,
-          ...p,
-          timestamp: Date.now(),
-          correlationId: params.providerMetadata?.correlationId,
-          parentCorrelationId: params.providerMetadata?.parentCorrelationId
+          ...message,
+          timestamp: Date.now()
         });
       });
       const result = await doGenerate();
@@ -407,9 +439,7 @@ function createAgentMiddleware(agent) {
         agent.addMessage({
           id,
           ...message,
-          timestamp: Date.now(),
-          correlationId: params.providerMetadata?.correlationId,
-          parentCorrelationId: params.providerMetadata?.parentCorrelationId
+          timestamp: Date.now()
         });
       });
       const { stream, ...rest } = await doStream();
@@ -434,9 +464,7 @@ function createAgentMiddleware(agent) {
             timestamp: Date.now(),
             role: "assistant",
             content,
-            responseId: id,
-            correlationId: params.providerMetadata?.correlationId,
-            parentCorrelationId: params.providerMetadata?.parentCorrelationId
+            responseId: id
           });
         }
       });
@@ -480,17 +508,18 @@ var agentLogic = (0, import_xstate4.fromTransition)(
         });
         break;
       }
-      case "agent.plan": {
-        state.plans.push(event.plan);
+      case "agent.decision": {
+        state.decisions.push(event.decision);
         emit({
-          type: "plan",
-          // @ts-ignore TODO: fix types in XState
-          plan: event.plan
+          type: "decision",
+          decision: event.decision
         });
         break;
       }
-      default:
+      default: {
+        console.warn("Unrecognized event", event);
         break;
+      }
     }
     return state;
   },
@@ -498,31 +527,28 @@ var agentLogic = (0, import_xstate4.fromTransition)(
     feedback: [],
     messages: [],
     observations: [],
-    plans: []
+    decisions: []
   })
 );
 function createAgent({
   id,
-  name,
   description,
   model,
   events,
   context,
-  planner = simplePlanner,
-  stringify = JSON.stringify,
-  getMemory,
-  logic = agentLogic,
-  ...generateTextOptions
+  episodeId,
+  strategy = simpleStrategy,
+  logic = agentLogic
 }) {
   return new Agent({
     id,
     context,
     events,
-    name,
     description,
-    planner,
+    strategy,
     model,
-    logic
+    logic,
+    episodeId
   });
 }
 var Agent = class extends import_xstate4.Actor {
@@ -535,17 +561,18 @@ var Agent = class extends import_xstate4.Actor {
     model,
     events,
     context,
-    planner = simplePlanner
+    episodeId,
+    strategy = simpleStrategy
   }) {
     super(logic);
     this.model = model;
-    this.episodeId = id ?? randomId();
+    this.episodeId = episodeId ?? randomId("episode-");
     this.name = name;
     this.description = description;
     this.events = events;
     this.context = context;
-    this.planner = planner;
-    this.types = {};
+    this.strategy = strategy;
+    this.id = id ?? randomId();
     this.start();
   }
   /**
@@ -554,6 +581,12 @@ var Agent = class extends import_xstate4.Actor {
   onMessage(fn) {
     return this.on("message", (ev) => fn(ev.message));
   }
+  /**
+   * Called whenever the agent (LLM assistant) receives some feedback.
+   */
+  onFeedback(fn) {
+    return this.on("feedback", (ev) => fn(ev.feedback));
+  }
   /**
    * Retrieves messages from the agent's short-term (local) memory.
    */
@@ -577,7 +610,6 @@ var Agent = class extends import_xstate4.Actor {
     const feedback = {
       ...feedbackInput,
       attributes: { ...feedbackInput.attributes },
-      reward: feedbackInput.reward ?? 0,
       timestamp: feedbackInput.timestamp ?? Date.now(),
       episodeId: this.episodeId
     };
@@ -616,20 +648,21 @@ var Agent = class extends import_xstate4.Actor {
   getObservations() {
     return this.getSnapshot().context.observations;
   }
-  addPlan(plan) {
+  addDecision(decision) {
     this.send({
-      type: "agent.plan",
-      plan
+      type: "agent.decision",
+      decision
     });
   }
   /**
    * Retrieves strategies from the agent's short-term (local) memory.
    */
-  getPlans() {
-    return this.getSnapshot().context.plans;
+  getDecisions() {
+    return this.getSnapshot().context.decisions;
   }
   interact(actorRef, getInput) {
-    const actorRefCheck = isActorRef(actorRef);
+    const actorRefCheck = isActorRef(actorRef) && actorRef.src;
+    const machine = isMachineActor(actorRef) ? actorRef.src : void 0;
     let prevState = void 0;
     let subscribed = true;
     const agent = this;
@@ -637,14 +670,14 @@ var Agent = class extends import_xstate4.Actor {
       const observation = agent.addObservation(observationInput);
       const input = getInput?.(observation);
       if (input) {
-        await agentDecide(agent, {
-          machine: actorRefCheck ? actorRef.src : void 0,
+        const res = await agentDecide(agent, {
+          machine,
           state: observation.state,
-          execute: async (event) => {
-            actorRef.send(event);
-          },
           ...input
         });
+        if (res?.nextEvent) {
+          actorRef.send(res.nextEvent);
+        }
       }
       prevState = observationInput.state;
     }
@@ -665,8 +698,7 @@ var Agent = class extends import_xstate4.Actor {
     if (actorRef._processingStatus === 1) {
       handleObservation({
         prevState: void 0,
-        event: { type: "" },
-        // TODO: unknown events?
+        event: void 0,
         state: actorRef.getSnapshot(),
         machine: actorRef.src
       });
@@ -706,14 +738,14 @@ var Agent = class extends import_xstate4.Actor {
     });
   }
   /**
-   * Resolves with an `AgentPlan` based on the information provided in the `options`, including:
+   * Resolves with an `AgentDecision` based on the information provided in the `options`, including:
    *
    * - The `goal` for the agent to achieve
    * - The observed current `state`
    * - The `machine` (e.g. a state machine) that specifies what can happen next
    * - Additional `context`
    */
-  decide(opts) {
+  async decide(opts) {
     return agentDecide(this, opts);
   }
 };