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

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import * as ai from 'ai';
 import { generateText, streamText, LanguageModel, CoreMessage, GenerateTextResult, LanguageModelV1, CoreTool } from 'ai';
-import { EventObject, AnyStateMachine, AnyEventObject, ActorRefLike, SnapshotFrom, EventFrom, PromiseActorLogic, ActorLogic, TransitionSnapshot, Values, StateValue, Actor, Subscription, ObservableActorLogic } from 'xstate';
+import { AnyStateMachine, AnyEventObject, ActorRefLike, SnapshotFrom, EventFrom, PromiseActorLogic, ActorLogic, TransitionSnapshot, Values, StateValue, EventObject, Actor, Subscription, ObservableActorLogic } from 'xstate';
 import { SomeZodObject, ZodType, TypeOf } from 'zod';
 
 type ZodEventMapping = {
@@ -12,12 +12,16 @@ type ZodContextMapping = {
 
 type GenerateTextOptions = Parameters<typeof generateText>[0];
 type StreamTextOptions = Parameters<typeof streamText>[0];
-type CostFunction<TEvent extends EventObject> = (path: AgentPath<TEvent>) => number;
-type AgentDecideInput<TEvent extends EventObject> = Omit<AgentGenerateTextOptions, 'prompt' | 'tools'> & {
+type CostFunction<TAgent extends AnyAgent> = (path: AgentPath<TAgent>) => number;
+type AgentDecideInput<TAgent extends AnyAgent> = Omit<AgentGenerateTextOptions<TAgent>, 'prompt' | 'tools'> & {
     /**
      * The currently observed state.
      */
-    state: ObservedState;
+    state: ObservedState<TAgent>;
+    /**
+     * The context to provide in the prompt to the agent. This overrides the `state.context`.
+     */
+    context?: Record<string, any>;
     /**
      * The goal for the agent to accomplish.
      * The agent will make a decision based on this goal.
@@ -33,34 +37,31 @@ type AgentDecideInput<TEvent extends EventObject> = Omit<AgentGenerateTextOption
      * is interacting with.
      */
     machine?: AnyStateMachine;
-    /**
-     * The previous decision made by the agent.
-     */
-    prevDecision?: AgentDecision<TEvent>;
     /**
      * The total cost of the path to the goal state.
      */
-    costFunction?: CostFunction<TEvent>;
+    costFunction?: CostFunction<TAgent>;
     /**
      * The maximum number of attempts to make a decision.
      * Defaults to 2.
      */
     maxAttempts?: number;
 };
-type AgentStep<TEvent extends EventObject> = {
+type AgentStep<TAgent extends AnyAgent> = {
     /** The event to take */
-    event: TEvent;
+    event: EventFromAgent<TAgent>;
     /** The next expected state after taking the event */
-    state: ObservedState | undefined;
+    state: ObservedState<TAgent> | undefined;
 };
-type AgentPath<TEvent extends EventObject> = {
+type AgentPath<TAgent extends AnyAgent> = {
     /** The expected ending state of the path */
-    state: ObservedState | undefined;
+    state: ObservedState<TAgent> | undefined;
     /** The steps to reach the ending state */
-    steps: Array<AgentStep<TEvent>>;
+    steps: Array<AgentStep<TAgent>>;
     weight?: number;
 };
-type AgentDecision<TEvent extends EventObject> = {
+type AgentDecision<TAgent extends AnyAgent> = {
+    id: string;
     /**
      * The strategy used to generate the decision
      */
@@ -69,17 +70,17 @@ type AgentDecision<TEvent extends EventObject> = {
     /**
      * The ending state of the decision.
      */
-    goalState: ObservedState | undefined;
+    goalState: ObservedState<TAgent> | undefined;
     /**
      * The next event that the agent decided needs to occur to achieve the `goal`.
      *
      * This next event is chosen from the
      */
-    nextEvent: TEvent | undefined;
+    nextEvent: EventFromAgent<TAgent> | undefined;
     /**
      * The paths that the agent can take to achieve the goal.
      */
-    paths: AgentPath<TEvent>[];
+    paths: AgentPath<TAgent>[];
     episodeId: string;
     timestamp: number;
 };
@@ -91,17 +92,13 @@ interface TransitionData {
     };
     target?: any;
 }
-type PromptTemplate<TEvents extends EventObject> = (data: {
+type PromptTemplate<TAgent extends AnyAgent> = (data: {
     goal: string;
     /**
      * The observed state
      */
-    state?: ObservedState;
-    /**
-     * The context to provide.
-     * This overrides the observed state.context, if provided.
-     */
-    context?: any;
+    stateValue?: any;
+    context?: Record<string, any>;
     /**
      * The state machine model of the observed environment
      */
@@ -117,20 +114,25 @@ type PromptTemplate<TEvents extends EventObject> = (data: {
     observations?: AgentObservation<any>[];
     feedback?: AgentFeedback[];
     messages?: AgentMessage[];
-    decisions?: AgentDecision<TEvents>[];
+    decisions?: AgentDecision<TAgent>[];
 }) => string;
-type AgentStrategy<T extends AnyAgent> = (agent: T, input: AgentDecideInput<EventsFromAgent<T>>) => Promise<AgentDecision<EventsFromAgent<T>> | undefined>;
-type AgentInteractInput<T extends AnyAgent> = Omit<AgentDecideOptions<T>, 'state'>;
-type AgentDecideOptions<T extends AnyAgent> = {
+type AgentStrategy<TAgent extends AnyAgent> = (agent: TAgent, input: AgentDecideInput<EventFromAgent<TAgent>>) => Promise<AgentDecision<TAgent> | undefined>;
+type AgentInteractInput<T extends AnyAgent> = Omit<AgentDecideOptions<T>, 'state'> & {
+    state?: never;
+};
+type AgentDecideOptions<TAgent extends AnyAgent> = {
     goal: string;
-    state: ObservedState;
+    state: ObservedState<TAgent>;
+    /**
+     * The context to provide in the prompt to the agent. This overrides the `state.context`.
+     */
     context?: Record<string, any>;
     machine?: AnyStateMachine;
     model?: LanguageModel;
     execute?: (event: AnyEventObject) => Promise<void>;
-    strategy?: AgentStrategy<T>;
+    strategy?: AgentStrategy<TAgent>;
     events?: ZodEventMapping;
-    allowedEvents?: Array<EventsFromAgent<T>['type']>;
+    allowedEvents?: Array<EventFromAgent<TAgent>['type']>;
     /**
      * The maximum number of times the agent will attempt to make a decision.
      * Defaults to 2.
@@ -138,8 +140,9 @@ type AgentDecideOptions<T extends AnyAgent> = {
     maxAttempts?: number;
 } & Omit<Parameters<typeof generateText>[0], 'model' | 'tools' | 'prompt'>;
 interface AgentFeedback {
-    goal: string;
     observationId: string;
+    score: number;
+    comment: string | undefined;
     /**
      * The message correlation that the feedback is relevant for
      */
@@ -148,9 +151,10 @@ interface AgentFeedback {
     episodeId: string;
 }
 interface AgentFeedbackInput {
-    goal: string;
     observationId: string;
-    attributes: Record<string, any>;
+    score: number;
+    comment?: string;
+    attributes?: Record<string, any>;
     timestamp?: number;
 }
 type AgentMessage = CoreMessage & {
@@ -216,6 +220,7 @@ type AgentMessageInput = CoreMessage & {
 };
 interface AgentObservation<TActor extends ActorRefLike> {
     id: string;
+    goal?: string;
     prevState: SnapshotFrom<TActor> | undefined;
     event: EventFrom<TActor> | undefined;
     state: SnapshotFrom<TActor>;
@@ -223,21 +228,22 @@ interface AgentObservation<TActor extends ActorRefLike> {
     episodeId: string;
     timestamp: number;
 }
-interface AgentObservationInput {
+interface AgentObservationInput<TAgent extends AnyAgent> {
     id?: string;
-    prevState?: ObservedState;
+    prevState?: ObservedState<TAgent>;
     event?: AnyEventObject;
-    state: ObservedState;
+    state: ObservedState<TAgent>;
     machine?: AnyStateMachine;
     timestamp?: number;
+    goal: string | undefined;
 }
 type AgentDecisionInput = {
     goal: string;
     model?: LanguageModel;
     context?: Record<string, any>;
 } & Omit<Parameters<typeof generateText>[0], 'model' | 'tools' | 'prompt'>;
-type AgentDecisionLogic<TEvents extends EventObject> = PromiseActorLogic<AgentDecision<TEvents> | undefined, AgentDecisionInput | string>;
-type AgentEmitted<TEvents extends EventObject> = {
+type AgentDecisionLogic<TAgent extends AnyAgent> = PromiseActorLogic<AgentDecision<TAgent> | undefined, AgentDecisionInput | string>;
+type AgentEmitted<TAgent extends AnyAgent> = {
     type: 'feedback';
     feedback: AgentFeedback;
 } | {
@@ -248,9 +254,9 @@ type AgentEmitted<TEvents extends EventObject> = {
     message: AgentMessage;
 } | {
     type: 'decision';
-    decision: AgentDecision<TEvents>;
+    decision: AgentDecision<TAgent>;
 };
-type AgentLogic<TEvents extends EventObject> = ActorLogic<TransitionSnapshot<AgentMemoryContext>, {
+type AgentLogic<TAgent extends AnyAgent> = ActorLogic<TransitionSnapshot<AgentMemoryContext<TAgent>>, {
     type: 'agent.feedback';
     feedback: AgentFeedback;
 } | {
@@ -261,29 +267,29 @@ type AgentLogic<TEvents extends EventObject> = ActorLogic<TransitionSnapshot<Age
     message: AgentMessage;
 } | {
     type: 'agent.decision';
-    decision: AgentDecision<TEvents>;
+    decision: AgentDecision<TAgent>;
 }, any, // TODO: input
-any, AgentEmitted<TEvents>>;
-type EventsFromZodEventMapping<TEventSchemas extends ZodEventMapping> = Values<{
+any, AgentEmitted<TAgent>>;
+type EventsFromZodEventMapping<TEventSchemas extends ZodEventMapping> = Compute<Values<{
     [K in keyof TEventSchemas & string]: {
         type: K;
     } & TypeOf<TEventSchemas[K]>;
-}>;
+}>>;
 type ContextFromZodContextMapping<TContextSchema extends ZodContextMapping> = {
     [K in keyof TContextSchema & string]: TypeOf<TContextSchema[K]>;
 };
 type AnyAgent = Agent<any, any, any, any>;
 type FromAgent<T> = T | ((agent: AnyAgent) => T | Promise<T>);
-type CommonTextOptions = {
+type CommonTextOptions<TAgent extends AnyAgent> = {
     prompt: FromAgent<string>;
     model?: LanguageModel;
-    context?: Record<string, any>;
     messages?: FromAgent<CoreMessage[]>;
     template?: PromptTemplate<any>;
+    context?: Record<string, any>;
 };
-type AgentGenerateTextOptions = Omit<GenerateTextOptions, 'model' | 'prompt' | 'messages'> & CommonTextOptions;
-type AgentStreamTextOptions = Omit<StreamTextOptions, 'model' | 'prompt' | 'messages'> & CommonTextOptions;
-interface ObservedState {
+type AgentGenerateTextOptions<TAgent extends AnyAgent> = Omit<GenerateTextOptions, 'model' | 'prompt' | 'messages'> & CommonTextOptions<TAgent>;
+type AgentStreamTextOptions<TAgent extends AnyAgent> = Omit<StreamTextOptions, 'model' | 'prompt' | 'messages'> & CommonTextOptions<TAgent>;
+interface ObservedState<TAgent extends AnyAgent> {
     /**
      * The current state value of the state machine, e.g.
      * `"loading"` or `"processing"` or `"ready"`
@@ -292,32 +298,32 @@ interface ObservedState {
     /**
      * Additional contextual data related to the current state
      */
-    context?: Record<string, unknown>;
+    context?: ContextFromAgent<TAgent>;
 }
 type ObservedStateFrom<TActor extends ActorRefLike> = Pick<SnapshotFrom<TActor>, 'value' | 'context'>;
-type AgentMemoryContext = {
-    observations: AgentObservation<any>[];
+type AgentMemoryContext<TAgent extends AnyAgent> = {
+    observations: AgentObservation<TAgent>[];
     messages: AgentMessage[];
-    decisions: AgentDecision<any>[];
+    decisions: AgentDecision<TAgent>[];
     feedback: AgentFeedback[];
 };
-interface AgentLongTermMemory {
-    get<K extends keyof AgentMemoryContext>(key: K): Promise<AgentMemoryContext[K]>;
-    append<K extends keyof AgentMemoryContext>(key: K, item: AgentMemoryContext[K][0]): Promise<void>;
-    set<K extends keyof AgentMemoryContext>(key: K, items: AgentMemoryContext[K]): Promise<void>;
+interface AgentLongTermMemory<TAgent extends AnyAgent> {
+    get<K extends keyof AgentMemoryContext<TAgent>>(key: K): Promise<AgentMemoryContext<TAgent>[K]>;
+    append<K extends keyof AgentMemoryContext<TAgent>>(key: K, item: AgentMemoryContext<TAgent>[K][0]): Promise<void>;
+    set<K extends keyof AgentMemoryContext<TAgent>>(key: K, items: AgentMemoryContext<TAgent>[K]): Promise<void>;
 }
 type Compute<A extends any> = {
     [K in keyof A]: A[K];
 } & unknown;
 type MaybePromise<T> = T | Promise<T>;
-type EventsFromAgent<T extends AnyAgent> = T extends Agent<infer _, infer __, infer TEvents, infer ___> ? TEvents : never;
+type EventFromAgent<T extends AnyAgent> = T extends Agent<infer _, infer __, infer TEvents, infer ___> ? TEvents : never;
 type TypesFromAgent<T extends AnyAgent> = T extends Agent<infer TContextSchema, infer TEventSchema> ? {
     context: ContextFromZodContextMapping<TContextSchema>;
     events: EventsFromZodEventMapping<TEventSchema>;
 } : never;
 type ContextFromAgent<T extends AnyAgent> = T extends Agent<infer TContextSchema, infer _TEventSchema> ? ContextFromZodContextMapping<TContextSchema> : never;
 
-declare function createAgent<const TContextSchema extends ZodContextMapping, const TEventSchemas extends ZodEventMapping, TEvents extends EventObject = EventsFromZodEventMapping<TEventSchemas>, TContext = ContextFromZodContextMapping<TContextSchema>>({ id, description: description, model, events, context, episodeId, strategy, logic, }: {
+declare function createAgent<const TContextSchema extends ZodContextMapping, const TEventSchemas extends ZodEventMapping, TEvents extends EventObject = EventsFromZodEventMapping<TEventSchemas>, TContext = ContextFromZodContextMapping<TContextSchema>, TAgent extends AnyAgent = Agent<TContextSchema, TEventSchemas>>({ id, description: description, model, events, context, episodeId, strategy, logic, }: {
     /**
      * The unique identifier for the agent.
      *
@@ -348,15 +354,15 @@ declare function createAgent<const TContextSchema extends ZodContextMapping, con
     /**
      * A function that retrieves the agent's long term memory
      */
-    getMemory?: (agent: Agent<TContextSchema, TEventSchemas>) => AgentLongTermMemory;
+    getMemory?: (agent: Agent<TContextSchema, TEventSchemas>) => AgentLongTermMemory<TAgent>;
     /**
      * Agent logic
      */
-    logic?: AgentLogic<TEvents>;
+    logic?: AgentLogic<TAgent>;
     model: LanguageModel;
     episodeId?: string;
 }): Agent<TContextSchema, TEventSchemas>;
-declare class Agent<const TContextSchema extends ZodContextMapping, const TEventSchemas extends ZodEventMapping, TEvents extends EventObject = EventsFromZodEventMapping<TEventSchemas>, TContext = ContextFromZodContextMapping<TContextSchema>> extends Actor<AgentLogic<TEvents>> {
+declare class Agent<const TContextSchema extends ZodContextMapping, const TEventSchemas extends ZodEventMapping, TEvents extends EventObject = EventsFromZodEventMapping<TEventSchemas>, TContext = ContextFromZodContextMapping<TContextSchema>> extends Actor<AgentLogic<any>> {
     /**
      * The name of the agent. All agents with the same name are related and
      * able to share experiences (observations, feedback) with each other.
@@ -371,10 +377,10 @@ declare class Agent<const TContextSchema extends ZodContextMapping, const TEvent
     context?: TContextSchema;
     strategy: AgentStrategy<Agent<TContextSchema, TEventSchemas>>;
     model: LanguageModel;
-    memory: AgentLongTermMemory | undefined;
+    memory: AgentLongTermMemory<this> | undefined;
     defaultOptions: AgentDecideOptions<AnyAgent> | undefined;
     constructor({ logic, id, name, description, model, events, context, episodeId, strategy, }: {
-        logic: AgentLogic<TEvents>;
+        logic: AgentLogic<any>;
         id?: string;
         name?: string;
         description?: string;
@@ -434,24 +440,25 @@ declare class Agent<const TContextSchema extends ZodContextMapping, const TEvent
     };
     getMessages(): AgentMessage[];
     addFeedback(feedbackInput: AgentFeedbackInput): {
+        comment: string | undefined;
         attributes: {
             [x: string]: any;
         };
         timestamp: number;
         episodeId: string;
-        goal: string;
         observationId: string;
+        score: number;
     };
     /**
      * Retrieves feedback from the agent's short-term (local) memory.
      */
     getFeedback(): AgentFeedback[];
-    addObservation(observationInput: AgentObservationInput): AgentObservation<any>;
+    addObservation(observationInput: AgentObservationInput<this>): AgentObservation<any>;
     /**
      * Retrieves observations from the agent's short-term (local) memory.
      */
     getObservations(): AgentObservation<any>[];
-    addDecision(decision: AgentDecision<TEvents>): void;
+    addDecision(decision: AgentDecision<this>): void;
     /**
      * Retrieves strategies from the agent's short-term (local) memory.
      */
@@ -511,18 +518,18 @@ declare class Agent<const TContextSchema extends ZodContextMapping, const TEvent
      * - The `machine` (e.g. a state machine) that specifies what can happen next
      * - Additional `context`
      */
-    decide(opts: AgentDecideOptions<this>): Promise<AgentDecision<EventsFromAgent<this>> | undefined>;
+    decide(opts: AgentDecideOptions<this>): Promise<AgentDecision<this> | undefined>;
 }
 
-declare function fromTextStream<T extends AnyAgent>(agent: T, options?: AgentStreamTextOptions): ObservableActorLogic<{
+declare function fromTextStream<TAgent extends AnyAgent>(agent: TAgent, options?: AgentStreamTextOptions<TAgent>): ObservableActorLogic<{
     textDelta: string;
-}, Omit<AgentStreamTextOptions, 'context'> & {
-    context?: AgentStreamTextOptions['context'];
+}, Omit<AgentStreamTextOptions<TAgent>, 'context'> & {
+    context?: Record<string, any>;
 }>;
-declare function fromText<T extends AnyAgent>(agent: T, options?: AgentGenerateTextOptions): PromiseActorLogic<GenerateTextResult<Record<string, CoreTool<any, any>>>, Omit<AgentGenerateTextOptions, 'context'> & {
-    context?: AgentGenerateTextOptions['context'];
+declare function fromText<TAgent extends AnyAgent>(agent: TAgent, options?: AgentGenerateTextOptions<TAgent>): PromiseActorLogic<GenerateTextResult<Record<string, CoreTool<any, any>>>, Omit<AgentGenerateTextOptions<TAgent>, 'context'> & {
+    context?: Record<string, any>;
 }>;
 
-declare function fromDecision<T extends AnyAgent>(agent: T, defaultInput?: AgentDecideInput<EventsFromAgent<T>>): AgentDecisionLogic<any>;
+declare function fromDecision<T extends AnyAgent>(agent: T, defaultInput?: AgentDecideInput<EventFromAgent<T>>): AgentDecisionLogic<any>;
 
-export { type AgentDecideInput, type AgentDecideOptions, type AgentDecision, type AgentDecisionInput, type AgentDecisionLogic, type AgentEmitted, type AgentFeedback, type AgentFeedbackInput, type AgentGenerateTextOptions, type AgentInteractInput, type AgentLogic, type AgentLongTermMemory, type AgentMemoryContext, type AgentMessage, type AgentMessageInput, type AgentObservation, type AgentObservationInput, type AgentPath, type AgentStep, type AgentStrategy, type AgentStreamTextOptions, type AnyAgent, type CommonTextOptions, type Compute, type ContextFromAgent, type ContextFromZodContextMapping, type CostFunction, type EventsFromAgent, type EventsFromZodEventMapping, type FromAgent, type GenerateTextOptions, type LanguageModelV1TextPart, type LanguageModelV1ToolCallPart, type MaybePromise, type ObservedState, type ObservedStateFrom, type PromptTemplate, type StreamTextOptions, type TransitionData, type TypesFromAgent, createAgent, fromDecision, fromText, fromTextStream };
+export { type AgentDecideInput, type AgentDecideOptions, type AgentDecision, type AgentDecisionInput, type AgentDecisionLogic, type AgentEmitted, type AgentFeedback, type AgentFeedbackInput, type AgentGenerateTextOptions, type AgentInteractInput, type AgentLogic, type AgentLongTermMemory, type AgentMemoryContext, type AgentMessage, type AgentMessageInput, type AgentObservation, type AgentObservationInput, type AgentPath, type AgentStep, type AgentStrategy, type AgentStreamTextOptions, type AnyAgent, type CommonTextOptions, type Compute, type ContextFromAgent, type ContextFromZodContextMapping, type CostFunction, type EventFromAgent, type EventsFromZodEventMapping, type FromAgent, type GenerateTextOptions, type LanguageModelV1TextPart, type LanguageModelV1ToolCallPart, type MaybePromise, type ObservedState, type ObservedStateFrom, type PromptTemplate, type StreamTextOptions, type TransitionData, type TypesFromAgent, createAgent, fromDecision, fromText, fromTextStream };

package/dist/index.js

@@ -128,6 +128,7 @@ var import_ai = require("ai");
 // src/templates/defaultText.ts
 var defaultTextTemplate = (data) => {
   const preamble = [
+    data.stateValue ? wrapInXml("stateValue", JSON.stringify(data.stateValue)) : void 0,
     data.context ? wrapInXml("context", JSON.stringify(data.context)) : void 0
   ].filter(Boolean).join("\n");
   return `
@@ -244,12 +245,16 @@ async function agentDecide(agent, options) {
   let attempts = 0;
   const maxAttempts = resolvedOptions.maxAttempts ?? 2;
   let decision;
+  const minimalState = {
+    value: state.value,
+    context: state.context
+  };
   while (attempts++ < maxAttempts) {
     decision = await strategy(agent, {
       model,
       goal,
       events: filteredEventSchemas,
-      state,
+      state: minimalState,
       machine,
       messages,
       // TODO: fix UIMessage thing
@@ -275,14 +280,9 @@ function fromDecision(agent, defaultInput) {
       ...defaultInput,
       ...inputObject
     };
-    const state = {
-      value: snapshot.value,
-      context: resolvedInput.context
-    };
     const decision = await agentDecide(agent, {
       machine: parentRef.logic,
       state: snapshot,
-      context: resolvedInput.context,
       execute: async (event) => {
         parentRef.send(event);
       },
@@ -350,21 +350,13 @@ async function simpleStrategy(agent, input) {
     return void 0;
   }
   const prompt = simpleStrategyPromptTemplate({
-    context: input.context,
+    stateValue: input.state.value,
+    context: input.context ?? input.state.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,
-    prevDecision,
-    events,
-    goal,
-    model: _,
-    ...rest
-  } = input;
+  const { state, machine, events, goal, model: _, ...rest } = input;
   const machineState = input.machine && input.state ? input.machine.resolveState({
     ...input.state,
     context: input.state.context ?? {}
@@ -391,6 +383,7 @@ async function simpleStrategy(agent, input) {
     return void 0;
   }
   return {
+    id: randomId(),
     strategy: "simple",
     goal: input.goal,
     goalState: input.state,
@@ -609,6 +602,7 @@ var Agent = class extends import_xstate4.Actor {
   addFeedback(feedbackInput) {
     const feedback = {
       ...feedbackInput,
+      comment: feedbackInput.comment ?? void 0,
       attributes: { ...feedbackInput.attributes },
       timestamp: feedbackInput.timestamp ?? Date.now(),
       episodeId: this.episodeId
@@ -668,15 +662,16 @@ var Agent = class extends import_xstate4.Actor {
     const agent = this;
     async function handleObservation(observationInput) {
       const observation = agent.addObservation(observationInput);
-      const input = getInput?.(observation);
-      if (input) {
-        const res = await agentDecide(agent, {
+      const interactInput = getInput?.(observation);
+      if (interactInput) {
+        const decision = await agentDecide(agent, {
           machine,
           state: observation.state,
-          ...input
+          ...interactInput
         });
-        if (res?.nextEvent) {
-          actorRef.send(res.nextEvent);
+        if (decision?.nextEvent) {
+          decision.nextEvent["_decision"] = decision.id;
+          actorRef.send(decision.nextEvent);
         }
       }
       prevState = observationInput.state;
@@ -686,11 +681,14 @@ var Agent = class extends import_xstate4.Actor {
         if (!subscribed || inspEvent.actorRef !== actorRef || inspEvent.type !== "@xstate.snapshot") {
           return;
         }
+        const decisionId = inspEvent.event["_decision"];
+        const decision = decisionId ? agent.getDecisions().find((d) => d.id === decisionId) : void 0;
         const observationInput = {
           event: inspEvent.event,
           prevState,
           state: inspEvent.snapshot,
-          machine: actorRef.src
+          machine: actorRef.src,
+          goal: decision?.goal
         };
         await handleObservation(observationInput);
       }
@@ -700,7 +698,8 @@ var Agent = class extends import_xstate4.Actor {
         prevState: void 0,
         event: void 0,
         state: actorRef.getSnapshot(),
-        machine: actorRef.src
+        machine: actorRef.src,
+        goal: void 0
       });
     }
     return {
@@ -718,11 +717,14 @@ var Agent = class extends import_xstate4.Actor {
         if (inspEvent.actorRef !== actorRef || inspEvent.type !== "@xstate.snapshot") {
           return;
         }
+        const decisionId = inspEvent.event["_decision"];
+        const decision = decisionId ? this.getDecisions().find((d) => d.id === decisionId) : void 0;
         const observationInput = {
           event: inspEvent.event,
           prevState,
           state: inspEvent.snapshot,
-          machine: actorRef.src
+          machine: actorRef.src,
+          goal: decision?.goal
         };
         prevState = observationInput.state;
         this.addObservation(observationInput);

package/dist/index.mjs

@@ -95,6 +95,7 @@ import {
 // src/templates/defaultText.ts
 var defaultTextTemplate = (data) => {
   const preamble = [
+    data.stateValue ? wrapInXml("stateValue", JSON.stringify(data.stateValue)) : void 0,
     data.context ? wrapInXml("context", JSON.stringify(data.context)) : void 0
   ].filter(Boolean).join("\n");
   return `
@@ -215,12 +216,16 @@ async function agentDecide(agent, options) {
   let attempts = 0;
   const maxAttempts = resolvedOptions.maxAttempts ?? 2;
   let decision;
+  const minimalState = {
+    value: state.value,
+    context: state.context
+  };
   while (attempts++ < maxAttempts) {
     decision = await strategy(agent, {
       model,
       goal,
       events: filteredEventSchemas,
-      state,
+      state: minimalState,
       machine,
       messages,
       // TODO: fix UIMessage thing
@@ -246,14 +251,9 @@ function fromDecision(agent, defaultInput) {
       ...defaultInput,
       ...inputObject
     };
-    const state = {
-      value: snapshot.value,
-      context: resolvedInput.context
-    };
     const decision = await agentDecide(agent, {
       machine: parentRef.logic,
       state: snapshot,
-      context: resolvedInput.context,
       execute: async (event) => {
         parentRef.send(event);
       },
@@ -321,21 +321,13 @@ async function simpleStrategy(agent, input) {
     return void 0;
   }
   const prompt = simpleStrategyPromptTemplate({
-    context: input.context,
+    stateValue: input.state.value,
+    context: input.context ?? input.state.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,
-    prevDecision,
-    events,
-    goal,
-    model: _,
-    ...rest
-  } = input;
+  const { state, machine, events, goal, model: _, ...rest } = input;
   const machineState = input.machine && input.state ? input.machine.resolveState({
     ...input.state,
     context: input.state.context ?? {}
@@ -362,6 +354,7 @@ async function simpleStrategy(agent, input) {
     return void 0;
   }
   return {
+    id: randomId(),
     strategy: "simple",
     goal: input.goal,
     goalState: input.state,
@@ -582,6 +575,7 @@ var Agent = class extends Actor {
   addFeedback(feedbackInput) {
     const feedback = {
       ...feedbackInput,
+      comment: feedbackInput.comment ?? void 0,
       attributes: { ...feedbackInput.attributes },
       timestamp: feedbackInput.timestamp ?? Date.now(),
       episodeId: this.episodeId
@@ -641,15 +635,16 @@ var Agent = class extends Actor {
     const agent = this;
     async function handleObservation(observationInput) {
       const observation = agent.addObservation(observationInput);
-      const input = getInput?.(observation);
-      if (input) {
-        const res = await agentDecide(agent, {
+      const interactInput = getInput?.(observation);
+      if (interactInput) {
+        const decision = await agentDecide(agent, {
           machine,
           state: observation.state,
-          ...input
+          ...interactInput
         });
-        if (res?.nextEvent) {
-          actorRef.send(res.nextEvent);
+        if (decision?.nextEvent) {
+          decision.nextEvent["_decision"] = decision.id;
+          actorRef.send(decision.nextEvent);
         }
       }
       prevState = observationInput.state;
@@ -659,11 +654,14 @@ var Agent = class extends Actor {
         if (!subscribed || inspEvent.actorRef !== actorRef || inspEvent.type !== "@xstate.snapshot") {
           return;
         }
+        const decisionId = inspEvent.event["_decision"];
+        const decision = decisionId ? agent.getDecisions().find((d) => d.id === decisionId) : void 0;
         const observationInput = {
           event: inspEvent.event,
           prevState,
           state: inspEvent.snapshot,
-          machine: actorRef.src
+          machine: actorRef.src,
+          goal: decision?.goal
         };
         await handleObservation(observationInput);
       }
@@ -673,7 +671,8 @@ var Agent = class extends Actor {
         prevState: void 0,
         event: void 0,
         state: actorRef.getSnapshot(),
-        machine: actorRef.src
+        machine: actorRef.src,
+        goal: void 0
       });
     }
     return {
@@ -691,11 +690,14 @@ var Agent = class extends Actor {
         if (inspEvent.actorRef !== actorRef || inspEvent.type !== "@xstate.snapshot") {
           return;
         }
+        const decisionId = inspEvent.event["_decision"];
+        const decision = decisionId ? this.getDecisions().find((d) => d.id === decisionId) : void 0;
         const observationInput = {
           event: inspEvent.event,
           prevState,
           state: inspEvent.snapshot,
-          machine: actorRef.src
+          machine: actorRef.src,
+          goal: decision?.goal
         };
         prevState = observationInput.state;
         this.addObservation(observationInput);