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

package/dist/index.d.ts

@@ -1,7 +1,6 @@
-import * as ai from 'ai';
-import { generateText, streamText, LanguageModel, CoreMessage, GenerateTextResult, LanguageModelV1, CoreTool } from 'ai';
-import { AnyStateMachine, AnyEventObject, ActorRefLike, SnapshotFrom, EventFrom, PromiseActorLogic, ActorLogic, TransitionSnapshot, Values, StateValue, EventObject, Actor, Subscription, ObservableActorLogic } from 'xstate';
+import { AnyStateMachine, ActorRefLike, SnapshotFrom, EventFrom, AnyEventObject, ActorLogic, TransitionSnapshot, Values, StateValue, Actor, Subscription, ObservableActorLogic, PromiseActorLogic } from 'xstate';
 import { SomeZodObject, ZodType, TypeOf } from 'zod';
+import { generateText, streamText, LanguageModel, CoreMessage, GenerateTextResult, LanguageModelV1, CoreTool } from 'ai';
 
 type ZodEventMapping = {
     [eventType: string]: SomeZodObject;
@@ -13,7 +12,11 @@ type ZodContextMapping = {
 type GenerateTextOptions = Parameters<typeof generateText>[0];
 type StreamTextOptions = Parameters<typeof streamText>[0];
 type CostFunction<TAgent extends AnyAgent> = (path: AgentPath<TAgent>) => number;
-type AgentDecideInput<TAgent extends AnyAgent> = Omit<AgentGenerateTextOptions<TAgent>, 'prompt' | 'tools'> & {
+type AgentDecideInput<TAgent extends AnyAgent> = Omit<AgentGenerateTextOptions, 'model' | 'prompt' | 'tools' | 'toolChoice'> & {
+    /**
+     * The parent decision that this decision is a part of.
+     */
+    decisionId?: string;
     /**
      * The currently observed state.
      */
@@ -31,14 +34,15 @@ type AgentDecideInput<TAgent extends AnyAgent> = Omit<AgentGenerateTextOptions<T
      * The events that the agent can trigger. This is a mapping of
      * event types to Zod event schemas.
      */
-    events: ZodEventMapping;
+    events?: ZodEventMapping;
+    allowedEvents?: Array<EventFromAgent<TAgent>['type']>;
     /**
      * The state machine that represents the environment the agent
      * is interacting with.
      */
     machine?: AnyStateMachine;
     /**
-     * The total cost of the path to the goal state.
+     * A function that calculates the total cost of the path to the goal state.
      */
     costFunction?: CostFunction<TAgent>;
     /**
@@ -46,44 +50,75 @@ type AgentDecideInput<TAgent extends AnyAgent> = Omit<AgentGenerateTextOptions<T
      * Defaults to 2.
      */
     maxAttempts?: number;
-};
+    /**
+     * The policy to use for making a decision.
+     */
+    policy?: AgentPolicy<TAgent>;
+    model?: LanguageModel;
+    /**
+     * The previous relevant feedback from the agent.
+     */
+    feedback?: AgentFeedback[];
+    /**
+     * The previous relevant observations from the agent.
+     */
+    observations?: AgentObservation<any>[];
+    /**
+     * The previous relevant decisions from the agent.
+     */
+    decisions?: AgentDecision<TAgent>[];
+    /**
+     * The previous relevant insights from the agent.
+     */
+    insights?: AgentInsight[];
+    toolChoice?: 'auto' | 'none' | 'required';
+} & BaseInput;
 type AgentStep<TAgent extends AnyAgent> = {
     /** The event to take */
     event: EventFromAgent<TAgent>;
     /** The next expected state after taking the event */
-    state: ObservedState<TAgent> | undefined;
+    state: ObservedState<TAgent> | null;
 };
 type AgentPath<TAgent extends AnyAgent> = {
     /** The expected ending state of the path */
-    state: ObservedState<TAgent> | undefined;
+    state: ObservedState<TAgent> | null;
     /** The steps to reach the ending state */
     steps: Array<AgentStep<TAgent>>;
     weight?: number;
 };
-type AgentDecision<TAgent extends AnyAgent> = {
-    id: string;
+interface AgentDecisionInput<TAgent extends AnyAgent> extends BaseInput {
+    goal: string;
+    decisionId?: string | null;
+    policy?: string | null;
+    goalState?: ObservedState<TAgent> | null;
+    nextEvent?: EventFromAgent<TAgent> | null;
+    paths?: AgentPath<TAgent>[];
+}
+interface AgentDecision<TAgent extends AnyAgent = AnyAgent> extends BaseProperties {
     /**
-     * The strategy used to generate the decision
+     * The parent decision that this decision is a part of.
      */
-    strategy: string;
+    decisionId: string | null;
+    /**
+     * The policy used to generate the decision
+     */
+    policy: string | null;
     goal: string;
     /**
      * The ending state of the decision.
      */
-    goalState: ObservedState<TAgent> | undefined;
+    goalState: ObservedState<TAgent> | null;
     /**
      * The next event that the agent decided needs to occur to achieve the `goal`.
      *
      * This next event is chosen from the
      */
-    nextEvent: EventFromAgent<TAgent> | undefined;
+    nextEvent: EventFromAgent<TAgent> | null;
     /**
      * The paths that the agent can take to achieve the goal.
      */
     paths: AgentPath<TAgent>[];
-    episodeId: string;
-    timestamp: number;
-};
+}
 interface TransitionData {
     eventType: string;
     description?: string;
@@ -109,64 +144,62 @@ type PromptTemplate<TAgent extends AnyAgent> = (data: {
      */
     transitions?: TransitionData[];
     /**
-     * Past observations
+     * Relevant past observations
      */
     observations?: AgentObservation<any>[];
+    /**
+     * Relevant feedback
+     */
     feedback?: AgentFeedback[];
-    messages?: AgentMessage[];
-    decisions?: AgentDecision<TAgent>[];
-}) => string;
-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<TAgent>;
     /**
-     * The context to provide in the prompt to the agent. This overrides the `state.context`.
+     * Relevant messages
      */
-    context?: Record<string, any>;
-    machine?: AnyStateMachine;
-    model?: LanguageModel;
-    execute?: (event: AnyEventObject) => Promise<void>;
-    strategy?: AgentStrategy<TAgent>;
-    events?: ZodEventMapping;
-    allowedEvents?: Array<EventFromAgent<TAgent>['type']>;
+    messages?: AgentMessage[];
     /**
-     * The maximum number of times the agent will attempt to make a decision.
-     * Defaults to 2.
+     * Relevant past decisions
      */
-    maxAttempts?: number;
-} & Omit<Parameters<typeof generateText>[0], 'model' | 'tools' | 'prompt'>;
-interface AgentFeedback {
-    observationId: string;
-    score: number;
-    comment: string | undefined;
+    decisions?: AgentDecision<TAgent>[];
     /**
-     * The message correlation that the feedback is relevant for
+     * Relevant past insights
      */
+    insights?: AgentInsight[];
+}) => string;
+type AgentPolicy<TAgent extends AnyAgent = AnyAgent> = (agent: TAgent, input: AgentDecideInput<TAgent>) => Promise<AgentDecision<TAgent> | undefined>;
+type AgentInteractInput<T extends AnyAgent> = Omit<AgentDecideInput<T>, 'state'> & {
+    state?: never;
+};
+interface AgentFeedback extends BaseProperties {
+    decisionId: string;
+    reward: number;
+    comment: string | undefined;
     attributes: Record<string, any>;
-    timestamp: number;
+}
+interface BaseProperties {
+    id: string;
     episodeId: string;
+    timestamp: number;
 }
-interface AgentFeedbackInput {
-    observationId: string;
-    score: number;
+type BaseInput = Partial<BaseProperties>;
+interface AgentFeedbackInput extends BaseInput {
+    /**
+     * The decision ID that this feedback is relevant for.
+     */
+    decisionId: string;
+    reward: number;
     comment?: string;
     attributes?: Record<string, any>;
-    timestamp?: number;
 }
-type AgentMessage = CoreMessage & {
-    timestamp: number;
-    id: string;
+type AgentMessage = BaseProperties & CoreMessage & {
+    /**
+     * The parent decision that this message is a part of.
+     */
+    decisionId?: string;
     /**
      * The response ID of the message, which references
      * which message this message is responding to, if any.
      */
     responseId?: string;
-    result?: GenerateTextResult<any>;
-    episodeId: string;
+    result?: GenerateTextResult<any, any>;
 };
 type JSONObject = {
     [key: string]: JSONValue;
@@ -216,33 +249,31 @@ type AgentMessageInput = CoreMessage & {
      * which message this message is responding to, if any.
      */
     responseId?: string;
-    result?: GenerateTextResult<any>;
+    result?: GenerateTextResult<any, any>;
 };
 interface AgentObservation<TActor extends ActorRefLike> {
     id: string;
+    episodeId: string;
+    /**
+     * The decision that this observation is relevant for
+     */
+    decisionId?: string | undefined;
     goal?: string;
     prevState: SnapshotFrom<TActor> | undefined;
     event: EventFrom<TActor> | undefined;
     state: SnapshotFrom<TActor>;
-    machineHash: string | undefined;
-    episodeId: string;
     timestamp: number;
 }
-interface AgentObservationInput<TAgent extends AnyAgent> {
-    id?: string;
+interface AgentObservationInput<TAgent extends AnyAgent> extends BaseInput {
+    state: ObservedState<TAgent>;
+    /**
+     * The agent decision that the observation is relevant for
+     */
+    decisionId?: string | undefined;
     prevState?: ObservedState<TAgent>;
     event?: AnyEventObject;
-    state: ObservedState<TAgent>;
-    machine?: AnyStateMachine;
-    timestamp?: number;
-    goal: string | undefined;
+    goal?: string | undefined;
 }
-type AgentDecisionInput = {
-    goal: string;
-    model?: LanguageModel;
-    context?: Record<string, any>;
-} & Omit<Parameters<typeof generateText>[0], 'model' | 'tools' | 'prompt'>;
-type AgentDecisionLogic<TAgent extends AnyAgent> = PromiseActorLogic<AgentDecision<TAgent> | undefined, AgentDecisionInput | string>;
 type AgentEmitted<TAgent extends AnyAgent> = {
     type: 'feedback';
     feedback: AgentFeedback;
@@ -255,6 +286,9 @@ type AgentEmitted<TAgent extends AnyAgent> = {
 } | {
     type: 'decision';
     decision: AgentDecision<TAgent>;
+} | {
+    type: 'insight';
+    insight: AgentInsight;
 };
 type AgentLogic<TAgent extends AnyAgent> = ActorLogic<TransitionSnapshot<AgentMemoryContext<TAgent>>, {
     type: 'agent.feedback';
@@ -268,6 +302,9 @@ type AgentLogic<TAgent extends AnyAgent> = ActorLogic<TransitionSnapshot<AgentMe
 } | {
     type: 'agent.decision';
     decision: AgentDecision<TAgent>;
+} | {
+    type: 'agent.insight';
+    insight: AgentInsight;
 }, any, // TODO: input
 any, AgentEmitted<TAgent>>;
 type EventsFromZodEventMapping<TEventSchemas extends ZodEventMapping> = Compute<Values<{
@@ -278,17 +315,17 @@ type EventsFromZodEventMapping<TEventSchemas extends ZodEventMapping> = Compute<
 type ContextFromZodContextMapping<TContextSchema extends ZodContextMapping> = {
     [K in keyof TContextSchema & string]: TypeOf<TContextSchema[K]>;
 };
-type AnyAgent = Agent<any, any, any, any>;
+type AnyAgent = Agent<any, any>;
 type FromAgent<T> = T | ((agent: AnyAgent) => T | Promise<T>);
-type CommonTextOptions<TAgent extends AnyAgent> = {
+type CommonTextOptions = {
     prompt: FromAgent<string>;
     model?: LanguageModel;
-    messages?: FromAgent<CoreMessage[]>;
+    messages?: CoreMessage[];
     template?: PromptTemplate<any>;
     context?: Record<string, any>;
 };
-type AgentGenerateTextOptions<TAgent extends AnyAgent> = Omit<GenerateTextOptions, 'model' | 'prompt' | 'messages'> & CommonTextOptions<TAgent>;
-type AgentStreamTextOptions<TAgent extends AnyAgent> = Omit<StreamTextOptions, 'model' | 'prompt' | 'messages'> & CommonTextOptions<TAgent>;
+type AgentGenerateTextOptions = Omit<GenerateTextOptions, 'model' | 'prompt' | 'messages'> & CommonTextOptions;
+type AgentStreamTextOptions = Omit<StreamTextOptions, 'model' | 'prompt' | 'messages'> & CommonTextOptions;
 interface ObservedState<TAgent extends AnyAgent> {
     /**
      * The current state value of the state machine, e.g.
@@ -302,10 +339,11 @@ interface ObservedState<TAgent extends AnyAgent> {
 }
 type ObservedStateFrom<TActor extends ActorRefLike> = Pick<SnapshotFrom<TActor>, 'value' | 'context'>;
 type AgentMemoryContext<TAgent extends AnyAgent> = {
-    observations: AgentObservation<TAgent>[];
+    observations: AgentObservation<any>[];
     messages: AgentMessage[];
     decisions: AgentDecision<TAgent>[];
     feedback: AgentFeedback[];
+    insights: AgentInsight[];
 };
 interface AgentLongTermMemory<TAgent extends AnyAgent> {
     get<K extends keyof AgentMemoryContext<TAgent>>(key: K): Promise<AgentMemoryContext<TAgent>[K]>;
@@ -316,18 +354,37 @@ type Compute<A extends any> = {
     [K in keyof A]: A[K];
 } & unknown;
 type MaybePromise<T> = T | Promise<T>;
-type EventFromAgent<T extends AnyAgent> = T extends Agent<infer _, infer __, infer TEvents, infer ___> ? TEvents : never;
+type EventFromAgent<T extends AnyAgent> = T extends Agent<infer _, infer TEventSchemas> ? EventsFromZodEventMapping<TEventSchemas> : 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;
+interface StorageAdapter<TAgent extends AnyAgent, TQuery> {
+    addObservation(observationInput: AgentObservationInput<TAgent>): Promise<AgentObservation<any>>;
+    getObservations(queryObject?: TQuery): Promise<AgentObservation<any>[]>;
+    addFeedback(feedbackInput: AgentFeedbackInput): Promise<AgentFeedback>;
+    getFeedback(queryObject?: TQuery): Promise<AgentFeedback[]>;
+    addMessage(messageInput: AgentMessageInput): Promise<AgentMessage>;
+    getMessages(queryObject?: TQuery): Promise<AgentMessage[]>;
+    addDecision(decisionInput: AgentDecideInput<TAgent>): Promise<AgentDecision<TAgent>>;
+    getDecisions(queryObject?: TQuery): Promise<AgentDecision<TAgent>[]>;
+}
+type StorageAdapterQuery<T extends StorageAdapter<any, any>> = T extends StorageAdapter<infer _, infer TQuery> ? TQuery : never;
+interface AgentInsightInput extends BaseInput {
+    observationId: string;
+    attributes: Record<string, any>;
+}
+interface AgentInsight extends BaseProperties {
+    observationId: string;
+    attributes: Record<string, any>;
+}
 
-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, }: {
+declare function createAgent<const TContextSchema extends ZodContextMapping, const TEventSchemas extends ZodEventMapping, TAgent extends AnyAgent = Agent<TContextSchema, TEventSchemas>>({ id, description, model, events, context, episodeId, policy, logic, }: {
     /**
      * The unique identifier for the agent.
      *
-     * This should be the same across all sessions of a specific agent, as it can be
+     * This should be the same across all episodes of a specific agent, as it can be
      * used to retrieve memory for previous episodes of this agent.
      *
      * @example
@@ -340,29 +397,44 @@ declare function createAgent<const TContextSchema extends ZodContextMapping, con
      */
     id?: string;
     /**
-     * A description of the role of the agent
+     * A description of the role of the agent.
      */
     description?: string;
     /**
-     * Events that the agent can cause (send) in an environment
-     * that the agent knows about.
+     * Event schemas for events that the agent can trigger in an environment.
      */
     events: TEventSchemas;
+    /**
+     * The state context schema for the states that the agent can observe.
+     */
     context?: TContextSchema;
-    strategy?: AgentStrategy<Agent<TContextSchema, TEventSchemas>>;
-    stringify?: typeof JSON.stringify;
+    /**
+     * The default policy to use for `agent.decide(…)`.
+     *
+     * A policy is a strategy that the agent uses to decide which event to trigger next.
+     */
+    policy?: AgentPolicy<Agent<TContextSchema, TEventSchemas>>;
     /**
      * A function that retrieves the agent's long term memory
      */
     getMemory?: (agent: Agent<TContextSchema, TEventSchemas>) => AgentLongTermMemory<TAgent>;
     /**
-     * Agent logic
+     * Custom agent logic, which receives events for handling feedback,
+     * observations, messages, decisions, and insights.
      */
     logic?: AgentLogic<TAgent>;
+    /**
+     * The default language model for the agent to use in `agent.decide(…)`.
+     */
     model: LanguageModel;
+    /**
+     * The unique episode ID that this agent will run on.
+     *
+     * An episode is an instance of an agent interacting with an environment.
+     */
     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<any>> {
+declare class Agent<const TContextSchema extends ZodContextMapping, const TEventSchemas extends ZodEventMapping> 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.
@@ -375,11 +447,10 @@ declare class Agent<const TContextSchema extends ZodContextMapping, const TEvent
     description?: string;
     events: TEventSchemas;
     context?: TContextSchema;
-    strategy: AgentStrategy<Agent<TContextSchema, TEventSchemas>>;
+    policy: AgentPolicy<Agent<TContextSchema, TEventSchemas>>;
     model: LanguageModel;
     memory: AgentLongTermMemory<this> | undefined;
-    defaultOptions: AgentDecideOptions<AnyAgent> | undefined;
-    constructor({ logic, id, name, description, model, events, context, episodeId, strategy, }: {
+    constructor({ logic, id, name, description, model, events, context, episodeId, policy, }: {
         logic: AgentLogic<any>;
         id?: string;
         name?: string;
@@ -387,67 +458,40 @@ declare class Agent<const TContextSchema extends ZodContextMapping, const TEvent
         model: GenerateTextOptions['model'];
         events: TEventSchemas;
         context?: TContextSchema;
-        strategy?: AgentStrategy<Agent<TContextSchema, TEventSchemas>>;
+        policy?: AgentPolicy<Agent<TContextSchema, TEventSchemas>>;
         episodeId?: string;
     });
     /**
-     * Called whenever the agent (LLM assistant) receives or sends a message.
+     * Called whenever the agent detects that a message was sent from the human, assistant, or system.
      */
     onMessage(fn: (message: AgentMessage) => void): Subscription;
     /**
-     * Called whenever the agent (LLM assistant) receives some feedback.
+     * Called whenever the agent receives some feedback.
      */
     onFeedback(fn: (feedback: AgentFeedback) => void): Subscription;
     /**
-     * Retrieves messages from the agent's short-term (local) memory.
+     * Called whenever the agent receives an observation.
      */
-    addMessage(messageInput: AgentMessageInput): {
-        id: string;
-        timestamp: number;
-        episodeId: string;
-        role: "assistant";
-        content: ai.AssistantContent;
-        experimental_providerMetadata?: ai.ProviderMetadata;
-        responseId?: string;
-        result?: ai.GenerateTextResult<any>;
-    } | {
-        id: string;
-        timestamp: number;
-        episodeId: string;
-        role: "tool";
-        content: ai.ToolContent;
-        experimental_providerMetadata?: ai.ProviderMetadata;
-        responseId?: string;
-        result?: ai.GenerateTextResult<any>;
-    } | {
-        id: string;
-        timestamp: number;
-        episodeId: string;
-        role: "system";
-        content: string;
-        experimental_providerMetadata?: ai.ProviderMetadata;
-        responseId?: string;
-        result?: ai.GenerateTextResult<any>;
-    } | {
-        id: string;
-        timestamp: number;
-        episodeId: string;
-        role: "user";
-        content: ai.UserContent;
-        experimental_providerMetadata?: ai.ProviderMetadata;
-        responseId?: string;
-        result?: ai.GenerateTextResult<any>;
-    };
+    onObservation(fn: (observation: AgentObservation<this>) => void): Subscription;
+    /**
+     * Called whenever the agent makes a decision.
+     */
+    onDecision(fn: (decision: AgentDecision<this>) => void): Subscription;
+    /**
+     * Adds a message to the agent's short-term (local) memory.
+     */
+    addMessage(messageInput: AgentMessageInput): AgentMessage;
     getMessages(): AgentMessage[];
     addFeedback(feedbackInput: AgentFeedbackInput): {
+        id: string;
         comment: string | undefined;
         attributes: {
             [x: string]: any;
         };
         timestamp: number;
         episodeId: string;
-        observationId: string;
-        score: number;
+        decisionId: string;
+        reward: number;
     };
     /**
      * Retrieves feedback from the agent's short-term (local) memory.
@@ -458,7 +502,9 @@ declare class Agent<const TContextSchema extends ZodContextMapping, const TEvent
      * Retrieves observations from the agent's short-term (local) memory.
      */
     getObservations(): AgentObservation<any>[];
-    addDecision(decision: AgentDecision<this>): void;
+    addInsight(insightInput: AgentInsightInput): AgentInsight;
+    getInsights(): AgentInsight[];
+    addDecision(input: AgentDecisionInput<this>): void;
     /**
      * Retrieves strategies from the agent's short-term (local) memory.
      */
@@ -518,18 +564,30 @@ 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<this> | undefined>;
+    decide(input: AgentDecideInput<this>): Promise<AgentDecision<this> | undefined>;
 }
 
-declare function fromTextStream<TAgent extends AnyAgent>(agent: TAgent, options?: AgentStreamTextOptions<TAgent>): ObservableActorLogic<{
+declare function fromTextStream<TAgent extends AnyAgent>(agent: TAgent, options?: AgentStreamTextOptions): ObservableActorLogic<{
     textDelta: string;
-}, Omit<AgentStreamTextOptions<TAgent>, 'context'> & {
+}, Omit<AgentStreamTextOptions, 'context'> & {
     context?: Record<string, any>;
 }>;
-declare function fromText<TAgent extends AnyAgent>(agent: TAgent, options?: AgentGenerateTextOptions<TAgent>): PromiseActorLogic<GenerateTextResult<Record<string, CoreTool<any, any>>>, Omit<AgentGenerateTextOptions<TAgent>, 'context'> & {
+declare function fromText<TAgent extends AnyAgent>(agent: TAgent, options?: AgentGenerateTextOptions): PromiseActorLogic<GenerateTextResult<Record<string, CoreTool<any, any>>, any>, Omit<AgentGenerateTextOptions, 'context'> & {
     context?: Record<string, any>;
 }>;
 
-declare function fromDecision<T extends AnyAgent>(agent: T, defaultInput?: AgentDecideInput<EventFromAgent<T>>): AgentDecisionLogic<any>;
+type AgentDecideLogicInput = {
+    goal: string;
+    model?: LanguageModel;
+    context?: Record<string, any>;
+} & Omit<Parameters<typeof generateText>[0], 'model' | 'tools' | 'prompt'>;
+type MachineDecisionLogic<TAgent extends AnyAgent> = PromiseActorLogic<AgentDecision<TAgent> | undefined, AgentDecideLogicInput | string>;
+declare function fromDecision<TAgent extends AnyAgent>(agent: TAgent, defaultInput?: AgentDecideInput<TAgent>): MachineDecisionLogic<any>;
+
+declare function chainOfThoughtPolicy<T extends AnyAgent>(agent: T, input: AgentDecideInput<any>): Promise<AgentDecision<any> | undefined>;
+
+declare function experimental_shortestPathPolicy<T extends AnyAgent>(agent: T, input: AgentDecideInput<any>): Promise<AgentDecision<any> | undefined>;
+
+declare function toolPolicy<TAgent extends AnyAgent>(agent: TAgent, input: AgentDecideInput<TAgent>): Promise<AgentDecision<TAgent> | undefined>;
 
-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 };
+export { type AgentDecideInput, type AgentDecision, type AgentDecisionInput, type AgentEmitted, type AgentFeedback, type AgentFeedbackInput, type AgentGenerateTextOptions, type AgentInsight, type AgentInsightInput, type AgentInteractInput, type AgentLogic, type AgentLongTermMemory, type AgentMemoryContext, type AgentMessage, type AgentMessageInput, type AgentObservation, type AgentObservationInput, type AgentPath, type AgentPolicy, type AgentStep, 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 StorageAdapter, type StorageAdapterQuery, type StreamTextOptions, type TransitionData, type TypesFromAgent, chainOfThoughtPolicy, createAgent, experimental_shortestPathPolicy, fromDecision, fromText, fromTextStream, toolPolicy };