@statelyai/agent 1.0.0-beta.1 → 1.0.0

package/dist/index.js

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -15,13 +17,19 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
-  agentDecide: () => agentDecide,
-  agentGenerateText: () => agentGenerateText,
   createAgent: () => createAgent,
   fromDecision: () => fromDecision,
   fromText: () => fromText,
@@ -36,13 +44,36 @@ var import_xstate3 = require("xstate");
 var import_ai = require("ai");
 
 // src/utils.ts
+var import_object_hash = __toESM(require("object-hash"));
 function getAllTransitions(state) {
   const nodes = state._nodes;
-  const transitions = nodes.map((node) => [...node.transitions.values()]).flat(2).map((transition) => ({
-    ...transition,
-    guard: typeof transition.guard === "string" ? { type: transition.guard } : transition.guard
-    // TODO: fix
-  }));
+  const transitions = nodes.map((node) => [...node.transitions.values()]).map((nodeTransitions) => {
+    return nodeTransitions.map((nodeEventTransitions) => {
+      return nodeEventTransitions.map((transition) => {
+        return {
+          ...transition,
+          guard: typeof transition.guard === "string" ? { type: transition.guard } : transition.guard
+          // TODO: fix
+        };
+      });
+    });
+  }).flat(2);
+  return transitions;
+}
+function getAllMachineTransitions(stateNode) {
+  const transitions = [...stateNode.transitions.values()].map((nodeTransitions) => {
+    return nodeTransitions.map((transition) => {
+      return {
+        ...transition,
+        guard: typeof transition.guard === "string" ? { type: transition.guard } : transition.guard
+        // TODO: fix
+      };
+    });
+  }).flat(2);
+  for (const s of Object.values(stateNode.states)) {
+    const stateTransitions = getAllMachineTransitions(s);
+    transitions.push(...stateTransitions);
+  }
   return transitions;
 }
 function wrapInXml(tagName, content) {
@@ -53,6 +84,14 @@ function randomId() {
   const random = Math.random().toString(36).substring(2, 9);
   return timestamp + random;
 }
+var machineHashes = /* @__PURE__ */ new WeakMap();
+function getMachineHash(machine) {
+  if (machineHashes.has(machine)) return machineHashes.get(machine);
+  const transitions = getAllMachineTransitions(machine.root);
+  const machineHash = (0, import_object_hash.default)(transitions);
+  machineHashes.set(machine, machineHash);
+  return machineHash;
+}
 
 // src/templates/defaultText.ts
 var defaultTextTemplate = (data) => {
@@ -66,94 +105,11 @@ ${data.goal}
   `.trim();
 };
 
-// src/planners/simplePlanner.ts
-function getTransitions(state, machine) {
-  if (!machine) {
-    return [];
-  }
-  const resolvedState = machine.resolveState(state);
-  return getAllTransitions(resolvedState);
-}
-var simplePlannerPromptTemplate = (data) => {
-  return `
-${defaultTextTemplate(data)}
-
-Only make a single tool call to achieve the above goal.
-  `.trim();
-};
-async function simplePlanner(agent, input) {
-  const transitions = input.machine ? getTransitions(input.state, input.machine) : Object.entries(input.events).map(([eventType, { description }]) => ({
-    eventType,
-    description
-  }));
-  const filter = (eventType) => Object.keys(input.events).includes(eventType);
-  const functionNameMapping = {};
-  const toolTransitions = transitions.filter((t) => {
-    return filter(t.eventType);
-  }).map((t) => {
-    const name = t.eventType.replace(/\./g, "_");
-    functionNameMapping[name] = t.eventType;
-    return {
-      type: "function",
-      eventType: t.eventType,
-      description: t.description,
-      name
-    };
-  });
-  const toolMap = {};
-  for (const toolTransitionData of toolTransitions) {
-    const toolZodType = input.events?.[toolTransitionData.eventType];
-    if (!toolZodType) {
-      continue;
-    }
-    toolMap[toolTransitionData.name] = (0, import_ai.tool)({
-      description: toolZodType?.description ?? toolTransitionData.description,
-      parameters: toolZodType,
-      execute: async (params) => {
-        const event = {
-          type: toolTransitionData.eventType,
-          ...params
-        };
-        return event;
-      }
-    });
-  }
-  const prompt = simplePlannerPromptTemplate({
-    context: input.state.context,
-    goal: input.goal
-  });
-  const result = await agent.generateText({
-    ...input,
-    prompt,
-    tools: toolMap,
-    toolChoice: "required"
-  });
-  const singleResult = result.toolResults[0];
-  if (!singleResult) {
-    console.warn("No tool call results returned");
-    return void 0;
-  }
-  return {
-    goal: input.goal,
-    state: input.state,
-    steps: [
-      {
-        event: singleResult.result
-      }
-    ],
-    nextEvent: singleResult.result,
-    sessionId: agent.sessionId,
-    timestamp: Date.now()
-  };
-}
-
 // src/text.ts
 var import_xstate = require("xstate");
 async function getMessages(agent, prompt, options) {
   let messages = [];
-  if (options.messages === true) {
-    messages = agent.select((s) => s.messages);
-  } else if (typeof options.messages === "function") {
+  if (typeof options.messages === "function") {
     messages = await options.messages(agent);
   } else if (options.messages) {
     messages = options.messages;
@@ -245,14 +201,13 @@ async function agentStreamText(agent, options) {
   return result;
 }
 function fromTextStream(agent, defaultOptions) {
-  return (0, import_xstate.fromObservable)(({ input, self }) => {
-    const context = input.context === true ? (self._parent?.getSnapshot()).context : input.context;
+  return (0, import_xstate.fromObservable)(({ input }) => {
     const observers = /* @__PURE__ */ new Set();
     (async () => {
       const result = await agentStreamText(agent, {
         ...defaultOptions,
         ...input,
-        context
+        context: input.context
       });
       for await (const part of result.fullStream) {
         if (part.type === "text-delta") {
@@ -276,16 +231,103 @@ function fromTextStream(agent, defaultOptions) {
   });
 }
 function fromText(agent, defaultOptions) {
-  return (0, import_xstate.fromPromise)(async ({ input, self }) => {
-    const context = input.context === true ? (self._parent?.getSnapshot()).context : input.context;
+  return (0, import_xstate.fromPromise)(async ({ input }) => {
     return await agentGenerateText(agent, {
       ...input,
       ...defaultOptions,
-      context
+      context: input.context
     });
   });
 }
 
+// src/planners/simplePlanner.ts
+function getTransitions(state, machine) {
+  if (!machine) {
+    return [];
+  }
+  const resolvedState = machine.resolveState(state);
+  return getAllTransitions(resolvedState);
+}
+var simplePlannerPromptTemplate = (data) => {
+  return `
+${defaultTextTemplate(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) {
+  const transitions = input.machine ? getTransitions(input.state, input.machine) : Object.entries(input.events).map(([eventType, { description }]) => ({
+    eventType,
+    description
+  }));
+  const filter = (eventType) => Object.keys(input.events).includes(eventType);
+  const functionNameMapping = {};
+  const toolTransitions = transitions.filter((t) => {
+    return filter(t.eventType);
+  }).map((t) => {
+    const name = t.eventType.replace(/\./g, "_");
+    functionNameMapping[name] = t.eventType;
+    return {
+      type: "function",
+      eventType: t.eventType,
+      description: t.description,
+      name
+    };
+  });
+  const toolMap = {};
+  for (const toolTransitionData of toolTransitions) {
+    const toolZodType = input.events?.[toolTransitionData.eventType];
+    if (!toolZodType) {
+      continue;
+    }
+    toolMap[toolTransitionData.name] = (0, import_ai.tool)({
+      description: toolZodType?.description ?? toolTransitionData.description,
+      parameters: toolZodType,
+      execute: async (params) => {
+        const event = {
+          type: toolTransitionData.eventType,
+          ...params
+        };
+        return event;
+      }
+    });
+  }
+  if (!Object.keys(toolMap).length) {
+    return void 0;
+  }
+  const prompt = simplePlannerPromptTemplate({
+    context: input.state.context,
+    goal: input.goal
+  });
+  const messages = await getMessages(agent, prompt, input);
+  const result = await agent.generateText({
+    toolChoice: "required",
+    ...input,
+    prompt,
+    messages,
+    tools: toolMap
+  });
+  const singleResult = result.toolResults[0];
+  if (!singleResult) {
+    console.log(toolMap);
+    console.warn("No tool call results returned");
+    return void 0;
+  }
+  return {
+    goal: input.goal,
+    state: input.state,
+    execute: async (state) => {
+      if (JSON.stringify(state) === JSON.stringify(input.state)) {
+        return singleResult.result;
+      }
+      return void 0;
+    },
+    nextEvent: singleResult.result,
+    sessionId: agent.sessionId,
+    timestamp: Date.now()
+  };
+}
+
 // src/decision.ts
 var import_xstate2 = require("xstate");
 async function agentDecide(agent, options) {
@@ -412,6 +454,7 @@ function createAgent({
   description,
   model,
   events,
+  context,
   planner = simplePlanner,
   stringify = JSON.stringify,
   getMemory,
@@ -450,6 +493,7 @@ function createAgent({
     });
     return message;
   };
+  agent.getMessages = () => agent.getSnapshot().context.messages;
   agent.generateText = (opts) => agentGenerateText(agent, opts);
   agent.streamText = (opts) => agentStreamText(agent, opts);
   agent.addFeedback = (feedbackInput) => {
@@ -464,12 +508,17 @@ function createAgent({
     });
     return feedback;
   };
+  agent.getFeedback = () => agent.getSnapshot().context.feedback;
   agent.addObservation = (observationInput) => {
+    const { prevState, event, state } = observationInput;
     const observation = {
-      ...observationInput,
+      prevState,
+      event,
+      state,
       id: observationInput.id ?? randomId(),
       sessionId: agent.sessionId,
-      timestamp: observationInput.timestamp ?? Date.now()
+      timestamp: observationInput.timestamp ?? Date.now(),
+      machineHash: observationInput.machine ? getMachineHash(observationInput.machine) : void 0
     };
     agent.send({
       type: "agent.observe",
@@ -477,12 +526,14 @@ function createAgent({
     });
     return observation;
   };
+  agent.getObservations = () => agent.getSnapshot().context.observations;
   agent.addPlan = (plan) => {
     agent.send({
       type: "agent.plan",
       plan
     });
   };
+  agent.getPlans = () => agent.getSnapshot().context.plans;
   agent.interact = (actorRef, getInput) => {
     let prevState = void 0;
     let subscribed = true;
@@ -509,7 +560,8 @@ function createAgent({
         const observationInput = {
           event: inspEvent.event,
           prevState,
-          state: inspEvent.snapshot
+          state: inspEvent.snapshot,
+          machine: actorRef.src
         };
         await handleObservation(observationInput);
       }
@@ -519,7 +571,8 @@ function createAgent({
         prevState: void 0,
         event: { type: "" },
         // TODO: unknown events?
-        state: actorRef.getSnapshot()
+        state: actorRef.getSnapshot(),
+        machine: actorRef.src
       });
     }
     return {
@@ -529,13 +582,12 @@ function createAgent({
       // TODO: make this actually unsubscribe
     };
   };
+  agent.types = {};
   agent.start();
   return agent;
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  agentDecide,
-  agentGenerateText,
   createAgent,
   fromDecision,
   fromText,