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

package/dist/index.d.ts

@@ -13,14 +13,14 @@ type ZodContextMapping = {
 type GenerateTextOptions = Parameters<typeof generateText>[0];
 type StreamTextOptions = Parameters<typeof streamText>[0];
 type CostFunction<TEvent extends EventObject> = (path: AgentPath<TEvent>) => number;
-type AgentPlanInput<TEvent extends EventObject> = Omit<AgentGenerateTextOptions, 'prompt' | 'tools'> & {
+type AgentDecideInput<TEvent extends EventObject> = Omit<AgentGenerateTextOptions, 'prompt' | 'tools'> & {
     /**
      * The currently observed state.
      */
     state: ObservedState;
     /**
      * The goal for the agent to accomplish.
-     * The agent will create a plan based on this goal.
+     * The agent will make a decision based on this goal.
      */
     goal: string;
     /**
@@ -34,15 +34,15 @@ type AgentPlanInput<TEvent extends EventObject> = Omit<AgentGenerateTextOptions,
      */
     machine?: AnyStateMachine;
     /**
-     * The previous plan.
+     * The previous decision made by the agent.
      */
-    previousPlan?: AgentPlan<TEvent>;
+    prevDecision?: AgentDecision<TEvent>;
     /**
      * The total cost of the path to the goal state.
      */
     costFunction?: CostFunction<TEvent>;
     /**
-     * The maximum number of attempts to generate a plan.
+     * The maximum number of attempts to make a decision.
      * Defaults to 2.
      */
     maxAttempts?: number;
@@ -60,14 +60,14 @@ type AgentPath<TEvent extends EventObject> = {
     steps: Array<AgentStep<TEvent>>;
     weight?: number;
 };
-type AgentPlan<TEvent extends EventObject> = {
+type AgentDecision<TEvent extends EventObject> = {
     /**
-     * The planner used to generate the plan
+     * The strategy used to generate the decision
      */
-    planner: string;
+    strategy: string;
     goal: string;
     /**
-     * The ending state of the plan.
+     * The ending state of the decision.
      */
     goalState: ObservedState | undefined;
     /**
@@ -117,17 +117,20 @@ type PromptTemplate<TEvents extends EventObject> = (data: {
     observations?: AgentObservation<any>[];
     feedback?: AgentFeedback[];
     messages?: AgentMessage[];
-    plans?: AgentPlan<TEvents>[];
+    decisions?: AgentDecision<TEvents>[];
 }) => string;
-type AgentPlanner<T extends AnyAgent> = (agent: T, input: AgentPlanInput<T['types']['events']>) => Promise<AgentPlan<T['types']['events']> | undefined>;
+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> = {
     goal: string;
-    model?: LanguageModel;
     state: ObservedState;
+    context?: Record<string, any>;
     machine?: AnyStateMachine;
+    model?: LanguageModel;
     execute?: (event: AnyEventObject) => Promise<void>;
-    planner?: AgentPlanner<T>;
+    strategy?: AgentStrategy<T>;
     events?: ZodEventMapping;
+    allowedEvents?: Array<EventsFromAgent<T>['type']>;
     /**
      * The maximum number of times the agent will attempt to make a decision.
      * Defaults to 2.
@@ -135,22 +138,20 @@ type AgentDecideOptions<T extends AnyAgent> = {
     maxAttempts?: number;
 } & Omit<Parameters<typeof generateText>[0], 'model' | 'tools' | 'prompt'>;
 interface AgentFeedback {
-    goal?: string;
-    observationId?: string;
+    goal: string;
+    observationId: string;
     /**
      * The message correlation that the feedback is relevant for
      */
     attributes: Record<string, any>;
-    reward: number;
     timestamp: number;
     episodeId: string;
 }
 interface AgentFeedbackInput {
-    goal?: string;
-    observationId?: string;
-    attributes?: Record<string, any>;
+    goal: string;
+    observationId: string;
+    attributes: Record<string, any>;
     timestamp?: number;
-    reward?: number;
 }
 type AgentMessage = CoreMessage & {
     timestamp: number;
@@ -235,7 +236,7 @@ type AgentDecisionInput = {
     model?: LanguageModel;
     context?: Record<string, any>;
 } & Omit<Parameters<typeof generateText>[0], 'model' | 'tools' | 'prompt'>;
-type AgentDecisionLogic<TEvents extends EventObject> = PromiseActorLogic<AgentPlan<TEvents> | undefined, AgentDecisionInput | string>;
+type AgentDecisionLogic<TEvents extends EventObject> = PromiseActorLogic<AgentDecision<TEvents> | undefined, AgentDecisionInput | string>;
 type AgentEmitted<TEvents extends EventObject> = {
     type: 'feedback';
     feedback: AgentFeedback;
@@ -246,8 +247,8 @@ type AgentEmitted<TEvents extends EventObject> = {
     type: 'message';
     message: AgentMessage;
 } | {
-    type: 'plan';
-    plan: AgentPlan<TEvents>;
+    type: 'decision';
+    decision: AgentDecision<TEvents>;
 };
 type AgentLogic<TEvents extends EventObject> = ActorLogic<TransitionSnapshot<AgentMemoryContext>, {
     type: 'agent.feedback';
@@ -259,8 +260,8 @@ type AgentLogic<TEvents extends EventObject> = ActorLogic<TransitionSnapshot<Age
     type: 'agent.message';
     message: AgentMessage;
 } | {
-    type: 'agent.plan';
-    plan: AgentPlan<TEvents>;
+    type: 'agent.decision';
+    decision: AgentDecision<TEvents>;
 }, any, // TODO: input
 any, AgentEmitted<TEvents>>;
 type EventsFromZodEventMapping<TEventSchemas extends ZodEventMapping> = Values<{
@@ -297,7 +298,7 @@ type ObservedStateFrom<TActor extends ActorRefLike> = Pick<SnapshotFrom<TActor>,
 type AgentMemoryContext = {
     observations: AgentObservation<any>[];
     messages: AgentMessage[];
-    plans: AgentPlan<any>[];
+    decisions: AgentDecision<any>[];
     feedback: AgentFeedback[];
 };
 interface AgentLongTermMemory {
@@ -308,8 +309,15 @@ interface AgentLongTermMemory {
 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 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, planner, logic, }: {
+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, }: {
     /**
      * The unique identifier for the agent.
      *
@@ -335,7 +343,7 @@ declare function createAgent<const TContextSchema extends ZodContextMapping, con
      */
     events: TEventSchemas;
     context?: TContextSchema;
-    planner?: AgentPlanner<Agent<TContextSchema, TEventSchemas>>;
+    strategy?: AgentStrategy<Agent<TContextSchema, TEventSchemas>>;
     stringify?: typeof JSON.stringify;
     /**
      * A function that retrieves the agent's long term memory
@@ -346,7 +354,8 @@ declare function createAgent<const TContextSchema extends ZodContextMapping, con
      */
     logic?: AgentLogic<TEvents>;
     model: LanguageModel;
-} & GenerateTextOptions): Agent<TContextSchema, TEventSchemas>;
+    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>> {
     /**
      * The name of the agent. All agents with the same name are related and
@@ -360,15 +369,11 @@ declare class Agent<const TContextSchema extends ZodContextMapping, const TEvent
     description?: string;
     events: TEventSchemas;
     context?: TContextSchema;
-    planner?: AgentPlanner<Agent<TContextSchema, TEventSchemas>>;
-    types: {
-        events: TEvents;
-        context: Compute<TContext>;
-    };
+    strategy: AgentStrategy<Agent<TContextSchema, TEventSchemas>>;
     model: LanguageModel;
     memory: AgentLongTermMemory | undefined;
     defaultOptions: AgentDecideOptions<AnyAgent> | undefined;
-    constructor({ logic, id, name, description, model, events, context, planner, }: {
+    constructor({ logic, id, name, description, model, events, context, episodeId, strategy, }: {
         logic: AgentLogic<TEvents>;
         id?: string;
         name?: string;
@@ -376,12 +381,17 @@ declare class Agent<const TContextSchema extends ZodContextMapping, const TEvent
         model: GenerateTextOptions['model'];
         events: TEventSchemas;
         context?: TContextSchema;
-        planner?: AgentPlanner<Agent<TContextSchema, TEventSchemas>>;
+        strategy?: AgentStrategy<Agent<TContextSchema, TEventSchemas>>;
+        episodeId?: string;
     });
     /**
      * Called whenever the agent (LLM assistant) receives or sends a message.
      */
     onMessage(fn: (message: AgentMessage) => void): Subscription;
+    /**
+     * Called whenever the agent (LLM assistant) receives some feedback.
+     */
+    onFeedback(fn: (feedback: AgentFeedback) => void): Subscription;
     /**
      * Retrieves messages from the agent's short-term (local) memory.
      */
@@ -427,11 +437,10 @@ declare class Agent<const TContextSchema extends ZodContextMapping, const TEvent
         attributes: {
             [x: string]: any;
         };
-        reward: number;
         timestamp: number;
         episodeId: string;
-        goal?: string;
-        observationId?: string;
+        goal: string;
+        observationId: string;
     };
     /**
      * Retrieves feedback from the agent's short-term (local) memory.
@@ -442,11 +451,11 @@ declare class Agent<const TContextSchema extends ZodContextMapping, const TEvent
      * Retrieves observations from the agent's short-term (local) memory.
      */
     getObservations(): AgentObservation<any>[];
-    addPlan(plan: AgentPlan<TEvents>): void;
+    addDecision(decision: AgentDecision<TEvents>): void;
     /**
      * Retrieves strategies from the agent's short-term (local) memory.
      */
-    getPlans(): AgentPlan<any>[];
+    getDecisions(): AgentDecision<any>[];
     /**
      * Interacts with this state machine actor by inspecting state transitions and storing them as observations.
      *
@@ -491,18 +500,18 @@ declare class Agent<const TContextSchema extends ZodContextMapping, const TEvent
      * actor.start();
      * ```
      */
-    interact<TActor extends ActorRefLike>(actorRef: TActor, getInput: (observation: AgentObservation<TActor>) => AgentDecisionInput | undefined): Subscription;
+    interact<TActor extends ActorRefLike>(actorRef: TActor, getInput: (observation: AgentObservation<TActor>) => AgentInteractInput<this> | void): Subscription;
     observe<TActor extends ActorRefLike>(actorRef: TActor): Subscription;
     wrap(modelToWrap: LanguageModelV1): LanguageModelV1;
     /**
-     * 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: AgentDecideOptions<this>): Promise<AgentPlan<EventsFromZodEventMapping<this["events"]>> | undefined>;
+    decide(opts: AgentDecideOptions<this>): Promise<AgentDecision<EventsFromAgent<this>> | undefined>;
 }
 
 declare function fromTextStream<T extends AnyAgent>(agent: T, options?: AgentStreamTextOptions): ObservableActorLogic<{
@@ -514,6 +523,6 @@ declare function fromText<T extends AnyAgent>(agent: T, options?: AgentGenerateT
     context?: AgentGenerateTextOptions['context'];
 }>;
 
-declare function fromDecision(agent: AnyAgent, defaultInput?: AgentDecisionInput): AgentDecisionLogic<any>;
+declare function fromDecision<T extends AnyAgent>(agent: T, defaultInput?: AgentDecideInput<EventsFromAgent<T>>): AgentDecisionLogic<any>;
 
-export { type AgentDecideOptions, type AgentDecisionInput, type AgentDecisionLogic, type AgentEmitted, type AgentFeedback, type AgentFeedbackInput, type AgentGenerateTextOptions, type AgentLogic, type AgentLongTermMemory, type AgentMemoryContext, type AgentMessage, type AgentMessageInput, type AgentObservation, type AgentObservationInput, type AgentPath, type AgentPlan, type AgentPlanInput, type AgentPlanner, type AgentStep, type AgentStreamTextOptions, type AnyAgent, type CommonTextOptions, type Compute, type ContextFromZodContextMapping, type CostFunction, type EventsFromZodEventMapping, type FromAgent, type GenerateTextOptions, type LanguageModelV1TextPart, type LanguageModelV1ToolCallPart, type ObservedState, type ObservedStateFrom, type PromptTemplate, type StreamTextOptions, type TransitionData, 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 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 };

package/dist/index.js

@@ -40,7 +40,7 @@ module.exports = __toCommonJS(src_exports);
 // src/agent.ts
 var import_xstate4 = require("xstate");
 
-// src/planners/simple.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);
@@ -110,9 +119,12 @@ function isMachineActor(actor) {
   return "src" in actor && typeof actor.src === "object" && actor.src !== null && "definition" in actor.src;
 }
 
-// src/planners/simple.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 = [
@@ -126,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 = [];
@@ -215,35 +226,42 @@ async function agentDecide(agent, options) {
     ...options
   };
   const {
-    planner = simplePlanner,
+    strategy = agent.strategy,
     goal,
+    allowedEvents,
     events = agent.events,
     state,
     machine,
     model = agent.model,
     messages,
-    ...otherPlanInput
+    ...otherDecideInput
   } = resolvedOptions;
+  const filteredEventSchemas = allowedEvents ? Object.fromEntries(
+    Object.entries(events).filter(([key]) => {
+      return allowedEvents.includes(key);
+    })
+  ) : events;
   let attempts = 0;
   const maxAttempts = resolvedOptions.maxAttempts ?? 2;
-  let plan;
+  let decision;
   while (attempts++ < maxAttempts) {
-    plan = await planner(agent, {
+    decision = await strategy(agent, {
       model,
       goal,
-      events,
+      events: filteredEventSchemas,
       state,
       machine,
       messages,
       // TODO: fix UIMessage thing
-      ...otherPlanInput
+      ...otherDecideInput
     });
-    if (plan?.nextEvent) {
-      agent.addPlan(plan);
-      await resolvedOptions.execute?.(plan.nextEvent);
+    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 }) => {
@@ -261,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) {
@@ -315,37 +336,38 @@ function getToolMap(_agent, input) {
   return toolMap;
 }
 
-// src/planners/simple.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,
@@ -369,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,
@@ -486,12 +508,11 @@ 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;
       }
@@ -506,7 +527,7 @@ var agentLogic = (0, import_xstate4.fromTransition)(
     feedback: [],
     messages: [],
     observations: [],
-    plans: []
+    decisions: []
   })
 );
 function createAgent({
@@ -515,7 +536,8 @@ function createAgent({
   model,
   events,
   context,
-  planner = simplePlanner,
+  episodeId,
+  strategy = simpleStrategy,
   logic = agentLogic
 }) {
   return new Agent({
@@ -523,9 +545,10 @@ function createAgent({
     context,
     events,
     description,
-    planner,
+    strategy,
     model,
-    logic
+    logic,
+    episodeId
   });
 }
 var Agent = class extends import_xstate4.Actor {
@@ -538,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();
   }
   /**
@@ -557,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.
    */
@@ -580,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
     };
@@ -619,17 +648,17 @@ 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) && actorRef.src;
@@ -669,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
       });
@@ -710,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);
   }
 };