@aigne/core 1.16.0 → 1.18.0

package/lib/esm/agents/agent.d.ts

@@ -1,8 +1,10 @@
-import { inspect } from "node:util";
 import { ZodObject, type ZodType } from "zod";
-import type { Context } from "../aigne/context.js";
+import type { Context, UserContext } from "../aigne/context.js";
 import type { MessagePayload } from "../aigne/message-queue.js";
-import type { MemoryAgent } from "../memory/memory.js";
+import type { Memory, MemoryAgent } from "../memory/memory.js";
+import type { MemoryRecorderInput } from "../memory/recorder.js";
+import type { MemoryRetrieverInput } from "../memory/retriever.js";
+import { nodejs } from "../utils/nodejs.js";
 import { type Nullish, type PromiseOrValue, type XOr } from "../utils/type-utils.js";
 import type { GuideRailAgent, GuideRailAgentOutput } from "./guide-rail-agent.js";
 import { type TransferAgentOutput } from "./types.js";
@@ -95,11 +97,29 @@ export interface AgentOptions<I extends Message = Message, O extends Message = M
      * One or more memory agents this agent can use
      */
     memory?: MemoryAgent | MemoryAgent[];
+    /**
+     * Maximum number of memory items to retrieve
+     */
+    maxRetrieveMemoryCount?: number;
 }
 export declare const agentOptionsSchema: ZodObject<{
     [key in keyof AgentOptions]: ZodType<AgentOptions[key]>;
 }>;
-export interface AgentInvokeOptions {
+export interface AgentInvokeOptions<U extends UserContext = UserContext> {
+    /**
+     * The execution context for the agent
+     *
+     * The context provides the runtime environment for agent execution, including:
+     * - Event emission and subscription management
+     * - Inter-agent communication and message passing
+     * - Resource usage tracking and limits enforcement
+     * - Timeout and status management
+     * - Memory and state management across agent invocations
+     *
+     * Each agent invocation requires a context to coordinate with the broader
+     * agent system and maintain proper isolation and resource control.
+     */
+    context: Context<U>;
     /**
      * Whether to enable streaming response
      *
@@ -111,6 +131,8 @@ export interface AgentInvokeOptions {
      * and returns the final JSON result
      */
     streaming?: boolean;
+    userContext?: U;
+    memories?: Pick<Memory, "content">[];
 }
 /**
  * Agent is the base class for all agents.
@@ -135,11 +157,24 @@ export interface AgentInvokeOptions {
  * {@includeCode ../../test/agents/agent.test.ts#example-custom-agent}
  */
 export declare abstract class Agent<I extends Message = Message, O extends Message = Message> {
+    /**
+     * Custom object inspection behavior
+     *
+     * When using Node.js's util.inspect function to inspect an agent,
+     * only the agent's name will be shown, making output more concise
+     *
+     * @returns Agent name
+     */
+    [nodejs.customInspect]: () => string;
     constructor(options?: AgentOptions<I, O>);
     /**
      * List of memories this agent can use
      */
     readonly memories: MemoryAgent[];
+    /**
+     * Maximum number of memory items to retrieve
+     */
+    maxRetrieveMemoryCount?: number;
     /**
      * Lifecycle hooks for agent processing.
      *
@@ -278,11 +313,15 @@ export declare abstract class Agent<I extends Message = Message, O extends Messa
     /**
      * Check context status to ensure it hasn't timed out
      *
-     * @param context The context to check
+     * @param options Invocation options containing context
      * @throws Error if the context has timed out
      */
     private checkContextStatus;
     private newDefaultContext;
+    retrieveMemories(input: Pick<MemoryRetrieverInput, "limit"> & {
+        search?: Message | string;
+    }, options: Pick<AgentInvokeOptions, "context">): Promise<Pick<Memory, "content">[]>;
+    recordMemories(input: MemoryRecorderInput, options: Pick<AgentInvokeOptions, "context">): Promise<void>;
     /**
      * Invoke the agent with regular (non-streaming) response
      *
@@ -290,7 +329,6 @@ export declare abstract class Agent<I extends Message = Message, O extends Messa
      * suitable for scenarios where a complete result is needed at once.
      *
      * @param input Input message to the agent, can be a string or structured object
-     * @param context Execution context, providing environment and resource access
      * @param options Invocation options, must set streaming to false or leave unset
      * @returns Final JSON response
      *
@@ -298,7 +336,7 @@ export declare abstract class Agent<I extends Message = Message, O extends Messa
      * Here's an example of invoking an agent with regular mode:
      * {@includeCode ../../test/agents/agent.test.ts#example-invoke}
      */
-    invoke(input: I | string, context?: Context, options?: AgentInvokeOptions & {
+    invoke(input: I | string, options?: Partial<AgentInvokeOptions> & {
         streaming?: false;
     }): Promise<O>;
     /**
@@ -309,7 +347,6 @@ export declare abstract class Agent<I extends Message = Message, O extends Messa
      * chat bot typing effects.
      *
      * @param input Input message to the agent, can be a string or structured object
-     * @param context Execution context, providing environment and resource access
      * @param options Invocation options, must set streaming to true for this overload
      * @returns Streaming response object
      *
@@ -317,7 +354,7 @@ export declare abstract class Agent<I extends Message = Message, O extends Messa
      * Here's an example of invoking an agent with streaming response:
      * {@includeCode ../../test/agents/agent.test.ts#example-invoke-streaming}
      */
-    invoke(input: I | string, context: Context | undefined, options: {
+    invoke(input: I | string, options: Partial<AgentInvokeOptions> & {
         streaming: true;
     }): Promise<AgentResponseStream<O>>;
     /**
@@ -326,12 +363,11 @@ export declare abstract class Agent<I extends Message = Message, O extends Messa
      * Returns either streaming or regular response based on the streaming parameter in options
      *
      * @param input Input message to the agent
-     * @param context Execution context
      * @param options Invocation options
      * @returns Agent response (streaming or regular)
      */
-    invoke(input: I | string, context?: Context, options?: AgentInvokeOptions): Promise<AgentResponse<O>>;
-    protected invokeSkill<I extends Message, O extends Message>(skill: Agent<I, O>, input: I, context: Context): Promise<O>;
+    invoke(input: I | string, options?: Partial<AgentInvokeOptions>): Promise<AgentResponse<O>>;
+    protected invokeSkill<I extends Message, O extends Message>(skill: Agent<I, O>, input: I, options: AgentInvokeOptions): Promise<O>;
     /**
      * Process agent output
      *
@@ -339,7 +375,7 @@ export declare abstract class Agent<I extends Message = Message, O extends Messa
      *
      * @param input Original input message
      * @param output Raw output produced by the agent
-     * @param context Execution context
+     * @param options Invocation options
      * @returns Final processed output
      */
     private processAgentOutput;
@@ -349,7 +385,7 @@ export declare abstract class Agent<I extends Message = Message, O extends Messa
      * Logs error information, triggers failure events, and re-throws the error
      *
      * @param error Caught error
-     * @param context Execution context
+     * @param options Invocation options
      */
     private processAgentError;
     /**
@@ -358,10 +394,10 @@ export declare abstract class Agent<I extends Message = Message, O extends Messa
      * If the context has a maximum invocation limit set, checks if the limit
      * has been exceeded and increments the invocation counter
      *
-     * @param context Execution context
+     * @param options Invocation options containing context and limits
      * @throws Error if maximum invocation limit is exceeded
      */
-    protected checkAgentInvokesUsage(context: Context): void;
+    protected checkAgentInvokesUsage(options: AgentInvokeOptions): void;
     /**
      * Pre-processing operations before handling input
      *
@@ -370,9 +406,9 @@ export declare abstract class Agent<I extends Message = Message, O extends Messa
      * - Verifying invocation limits
      *
      * @param _ Input message (unused)
-     * @param context Execution context
+     * @param options Options for agent invocation
      */
-    protected preprocess(_: I, context: Context): PromiseOrValue<void>;
+    protected preprocess(_: I, options: AgentInvokeOptions): Promise<void>;
     private checkResponseByGuideRails;
     private runGuideRails;
     /**
@@ -400,10 +436,10 @@ export declare abstract class Agent<I extends Message = Message, O extends Messa
      *
      * @param input Input message
      * @param output Output message
-     * @param context Execution context
+     * @param options Options for agent invocation
      */
-    protected postprocess(input: I, output: O, context: Context): PromiseOrValue<void>;
-    protected publishToTopics(output: Message, context: Context): Promise<void>;
+    protected postprocess(input: I, output: O, options: AgentInvokeOptions): Promise<void>;
+    protected publishToTopics(output: Message, options: AgentInvokeOptions): Promise<void>;
     /**
      * Core processing method of the agent, must be implemented in subclasses
      *
@@ -415,7 +451,7 @@ export declare abstract class Agent<I extends Message = Message, O extends Messa
      * - Another agent instance (transfer agent)
      *
      * @param input Input message
-     * @param context Execution context
+     * @param options Options for agent invocation
      * @returns Processing result
      *
      * @example
@@ -434,7 +470,7 @@ export declare abstract class Agent<I extends Message = Message, O extends Messa
      * Example of transfer to another agent:
      * {@includeCode ../../test/agents/agent.test.ts#example-process-transfer}
      */
-    abstract process(input: I, context: Context): PromiseOrValue<AgentProcessResult<O>>;
+    abstract process(input: I, options: AgentInvokeOptions): PromiseOrValue<AgentProcessResult<O>>;
     /**
      * Shut down the agent and clean up resources
      *
@@ -449,15 +485,6 @@ export declare abstract class Agent<I extends Message = Message, O extends Messa
      * {@includeCode ../../test/agents/agent.test.ts#example-agent-shutdown-by-using}
      */
     shutdown(): Promise<void>;
-    /**
-     * Custom object inspection behavior
-     *
-     * When using Node.js's util.inspect function to inspect an agent,
-     * only the agent's name will be shown, making output more concise
-     *
-     * @returns Agent name
-     */
-    [inspect.custom](): string;
     /**
      * Async dispose method for shutdown the agent
      *
@@ -484,6 +511,7 @@ export interface AgentHooks<I extends Message = Message, O extends Message = Mes
      * @param event Object containing the input message
      */
     onStart?: (event: {
+        context: Context;
         input: I;
     }) => PromiseOrValue<void>;
     /**
@@ -496,6 +524,7 @@ export interface AgentHooks<I extends Message = Message, O extends Message = Mes
      * @param event Object containing the input message and either output or error
      */
     onEnd?: (event: XOr<{
+        context: Context;
         input: I;
         output: O;
         error: Error;
@@ -509,6 +538,7 @@ export interface AgentHooks<I extends Message = Message, O extends Message = Mes
      * @param event Object containing the skill being used and input message
      */
     onSkillStart?: (event: {
+        context: Context;
         skill: Agent;
         input: I;
     }) => PromiseOrValue<void>;
@@ -522,6 +552,7 @@ export interface AgentHooks<I extends Message = Message, O extends Message = Mes
      * @param event Object containing the skill used, input message, and either output or error
      */
     onSkillEnd?: (event: XOr<{
+        context: Context;
         skill: Agent;
         input: I;
         output: O;
@@ -537,6 +568,7 @@ export interface AgentHooks<I extends Message = Message, O extends Message = Mes
      * @param event Object containing the source agent, target agent, and input message
      */
     onHandoff?: (event: {
+        context: Context;
         source: Agent;
         target: Agent;
         input: I;
@@ -587,7 +619,7 @@ export interface AgentResponseDelta<T> {
         }> | Partial<{
             [key: string]: string;
         }>;
-        json?: Partial<T | TransferAgentOutput>;
+        json?: Partial<T> | TransferAgentOutput;
     };
 }
 /**
@@ -619,7 +651,7 @@ export declare function jsonDelta<T extends Message>(jsonDelta: NonNullable<Agen
  *
  * @template O Agent output message type
  */
-export type AgentProcessAsyncGenerator<O extends Message> = AsyncGenerator<AgentResponseChunk<O>, Partial<O | TransferAgentOutput> | undefined | void>;
+export type AgentProcessAsyncGenerator<O extends Message> = AsyncGenerator<AgentResponseChunk<O>, Partial<O> | TransferAgentOutput | undefined | void>;
 /**
  * Result type for agent processing method, can be:
  * - Direct or streaming response
@@ -709,10 +741,10 @@ export declare class FunctionAgent<I extends Message = Message, O extends Messag
      * Process input implementation, calls the configured processing function
      *
      * @param input Input message
-     * @param context Execution context
+     * @param options Invocation options
      * @returns Processing result
      */
-    process(input: I, context: Context): PromiseOrValue<AgentProcessResult<O>>;
+    process(input: I, options: AgentInvokeOptions): PromiseOrValue<AgentProcessResult<O>>;
 }
 /**
  * Function type for function agents
@@ -725,4 +757,4 @@ export declare class FunctionAgent<I extends Message = Message, O extends Messag
  * @param context Execution context
  * @returns Processing result, can be synchronous or asynchronous
  */
-export type FunctionAgentFn<I extends Message = any, O extends Message = any> = (input: I, context: Context) => PromiseOrValue<AgentProcessResult<O>>;
+export type FunctionAgentFn<I extends Message = any, O extends Message = any> = (input: I, options: AgentInvokeOptions) => PromiseOrValue<AgentProcessResult<O>>;

package/lib/esm/agents/agent.js

@@ -1,7 +1,7 @@
-import { inspect } from "node:util";
 import { ZodObject, z } from "zod";
-import { createMessage } from "../prompt/prompt-builder.js";
+import { createMessage, getMessage } from "../prompt/prompt-builder.js";
 import { logger } from "../utils/logger.js";
+import { nodejs } from "../utils/nodejs.js";
 import { agentResponseStreamToObject, asyncGeneratorToReadableStream, isAsyncGenerator, objectToAgentResponseStream, onAgentResponseStreamEnd, } from "../utils/stream-utils.js";
 import { checkArguments, createAccessorArray, isEmpty, orArrayToArray, } from "../utils/type-utils.js";
 import { replaceTransferAgentToName, transferToAgentOutput, } from "./types.js";
@@ -19,6 +19,7 @@ export const agentOptionsSchema = z.object({
     skills: z.array(z.union([z.custom(), z.custom()])).optional(),
     disableEvents: z.boolean().optional(),
     memory: z.union([z.custom(), z.array(z.custom())]).optional(),
+    maxRetrieveMemoryCount: z.number().optional(),
     hooks: z
         .object({
         onStart: z.custom().optional(),
@@ -75,6 +76,7 @@ export class Agent {
         else if (options.memory) {
             this.memories.push(options.memory);
         }
+        this.maxRetrieveMemoryCount = options.maxRetrieveMemoryCount;
         this.hooks = options.hooks ?? {};
         this.guideRails = options.guideRails;
     }
@@ -82,6 +84,10 @@ export class Agent {
      * List of memories this agent can use
      */
     memories = [];
+    /**
+     * Maximum number of memory items to retrieve
+     */
+    maxRetrieveMemoryCount;
     /**
      * Lifecycle hooks for agent processing.
      *
@@ -250,68 +256,92 @@ export class Agent {
     /**
      * Check context status to ensure it hasn't timed out
      *
-     * @param context The context to check
+     * @param options Invocation options containing context
      * @throws Error if the context has timed out
      */
-    checkContextStatus(context) {
-        if (context) {
-            const { status } = context;
-            if (status === "timeout") {
-                throw new Error(`AIGNE for agent ${this.name} has timed out`);
-            }
+    checkContextStatus(options) {
+        const { status } = options.context;
+        if (status === "timeout") {
+            throw new Error(`AIGNE for agent ${this.name} has timed out`);
         }
     }
     async newDefaultContext() {
         return import("../aigne/context.js").then((m) => new m.AIGNEContext());
     }
-    async invoke(input, context, options) {
-        const ctx = context ?? (await this.newDefaultContext());
+    async retrieveMemories(input, options) {
+        const memories = [];
+        for (const memory of this.memories) {
+            const ms = (await memory.retrieve({
+                ...input,
+                search: typeof input === "string" ? input : input && getMessage(input),
+                limit: input.limit ?? this.maxRetrieveMemoryCount,
+            }, options.context)).memories;
+            memories.push(...ms);
+        }
+        return memories;
+    }
+    async recordMemories(input, options) {
+        for (const memory of this.memories) {
+            if (memory.autoUpdate) {
+                await memory.record(input, options.context);
+            }
+        }
+    }
+    async invoke(input, options = {}) {
+        const opts = {
+            ...options,
+            context: options.context ?? (await this.newDefaultContext()),
+        };
+        if (options.userContext) {
+            Object.assign(opts.context.userContext, options.userContext);
+        }
         const message = typeof input === "string" ? createMessage(input) : input;
         logger.debug("Invoke agent %s started with input: %O", this.name, input);
         if (!this.disableEvents)
-            ctx.emit("agentStarted", { agent: this, input: message });
+            opts.context.emit("agentStarted", { agent: this, input: message });
         try {
-            await this.hooks.onStart?.({ input: message });
+            await this.hooks.onStart?.({ context: opts.context, input: message });
             const parsedInput = checkArguments(`Agent ${this.name} input`, this.inputSchema, message);
-            await this.preprocess(parsedInput, ctx);
-            this.checkContextStatus(ctx);
-            let response = await this.process(parsedInput, ctx);
+            await this.preprocess(parsedInput, opts);
+            this.checkContextStatus(opts);
+            let response = await this.process(parsedInput, opts);
             if (response instanceof Agent) {
                 response = transferToAgentOutput(response);
             }
-            if (options?.streaming) {
+            if (opts.streaming) {
                 const stream = response instanceof ReadableStream
                     ? response
                     : isAsyncGenerator(response)
                         ? asyncGeneratorToReadableStream(response)
                         : objectToAgentResponseStream(response);
                 return this.checkResponseByGuideRails(message, onAgentResponseStreamEnd(stream, async (result) => {
-                    return await this.processAgentOutput(parsedInput, result, ctx);
+                    return await this.processAgentOutput(parsedInput, result, opts);
                 }, {
                     errorCallback: async (error) => {
-                        return await this.processAgentError(message, error, ctx);
+                        return await this.processAgentError(message, error, opts);
                     },
-                }), ctx);
+                }), opts);
             }
             return await this.checkResponseByGuideRails(message, this.processAgentOutput(parsedInput, response instanceof ReadableStream
                 ? await agentResponseStreamToObject(response)
                 : isAsyncGenerator(response)
                     ? await agentResponseStreamToObject(response)
-                    : response, ctx), ctx);
+                    : response, opts), opts);
         }
         catch (error) {
-            throw await this.processAgentError(message, error, ctx);
+            throw await this.processAgentError(message, error, opts);
         }
     }
-    async invokeSkill(skill, input, context) {
-        await this.hooks.onSkillStart?.({ skill, input });
+    async invokeSkill(skill, input, options) {
+        const { context } = options;
+        await this.hooks.onSkillStart?.({ context, skill, input });
         try {
             const output = await context.invoke(skill, input);
-            await this.hooks.onSkillEnd?.({ skill, input, output });
+            await this.hooks.onSkillEnd?.({ context, skill, input, output });
             return output;
         }
         catch (error) {
-            await this.hooks.onSkillEnd?.({ skill, input, error });
+            await this.hooks.onSkillEnd?.({ context, skill, input, error });
             throw error;
         }
     }
@@ -322,17 +352,18 @@ export class Agent {
      *
      * @param input Original input message
      * @param output Raw output produced by the agent
-     * @param context Execution context
+     * @param options Invocation options
      * @returns Final processed output
      */
-    async processAgentOutput(input, output, context) {
+    async processAgentOutput(input, output, options) {
+        const { context } = options;
         const parsedOutput = checkArguments(`Agent ${this.name} output`, this.outputSchema, output);
         const finalOutput = this.includeInputInOutput ? { ...input, ...parsedOutput } : parsedOutput;
-        await this.postprocess(input, finalOutput, context);
+        await this.postprocess(input, finalOutput, options);
         logger.debug("Invoke agent %s succeed with output: %O", this.name, finalOutput);
         if (!this.disableEvents)
             context.emit("agentSucceed", { agent: this, output: finalOutput });
-        await this.hooks.onEnd?.({ input, output: finalOutput });
+        await this.hooks.onEnd?.({ context, input, output: finalOutput });
         return finalOutput;
     }
     /**
@@ -341,13 +372,14 @@ export class Agent {
      * Logs error information, triggers failure events, and re-throws the error
      *
      * @param error Caught error
-     * @param context Execution context
+     * @param options Invocation options
      */
-    async processAgentError(input, error, context) {
+    async processAgentError(input, error, options) {
         logger.error("Invoke agent %s failed with error: %O", this.name, error);
         if (!this.disableEvents)
-            context.emit("agentFailed", { agent: this, error });
-        await this.hooks.onEnd?.({ input, error });
+            options.context.emit("agentFailed", { agent: this, error });
+        const { context } = options;
+        await this.hooks.onEnd?.({ context, input, error });
         return error;
     }
     /**
@@ -356,11 +388,11 @@ export class Agent {
      * If the context has a maximum invocation limit set, checks if the limit
      * has been exceeded and increments the invocation counter
      *
-     * @param context Execution context
+     * @param options Invocation options containing context and limits
      * @throws Error if maximum invocation limit is exceeded
      */
-    checkAgentInvokesUsage(context) {
-        const { limits, usage } = context;
+    checkAgentInvokesUsage(options) {
+        const { limits, usage } = options.context;
         if (limits?.maxAgentInvokes && usage.agentCalls >= limits.maxAgentInvokes) {
             throw new Error(`Exceeded max agent invokes ${usage.agentCalls}/${limits.maxAgentInvokes}`);
         }
@@ -374,19 +406,19 @@ export class Agent {
      * - Verifying invocation limits
      *
      * @param _ Input message (unused)
-     * @param context Execution context
+     * @param options Options for agent invocation
      */
-    preprocess(_, context) {
-        this.checkContextStatus(context);
-        this.checkAgentInvokesUsage(context);
+    async preprocess(_, options) {
+        this.checkContextStatus(options);
+        this.checkAgentInvokesUsage(options);
     }
-    async checkResponseByGuideRails(input, output, context) {
+    async checkResponseByGuideRails(input, output, options) {
         if (!this.guideRails?.length)
             return output;
         const result = await output;
         if (result instanceof ReadableStream) {
             return onAgentResponseStreamEnd(result, async (result) => {
-                const error = await this.runGuideRails(input, result, context);
+                const error = await this.runGuideRails(input, result, options);
                 if (error) {
                     return {
                         ...(await this.onGuideRailError(error)),
@@ -395,13 +427,13 @@ export class Agent {
                 }
             });
         }
-        const error = await this.runGuideRails(input, result, context);
+        const error = await this.runGuideRails(input, result, options);
         if (!error)
             return output;
         return { ...(await this.onGuideRailError(error)), $status: "GuideRailError" };
     }
-    async runGuideRails(input, output, context) {
-        const result = await Promise.all((this.guideRails ?? []).map((i) => context.invoke(i, { input, output })));
+    async runGuideRails(input, output, options) {
+        const result = await Promise.all((this.guideRails ?? []).map((i) => options.context.invoke(i, { input, output })));
         return result.find((i) => !!i.abort);
     }
     /**
@@ -431,26 +463,22 @@ export class Agent {
      *
      * @param input Input message
      * @param output Output message
-     * @param context Execution context
+     * @param options Options for agent invocation
      */
-    postprocess(input, output, context) {
-        this.checkContextStatus(context);
-        this.publishToTopics(output, context);
-        for (const memory of this.memories) {
-            if (memory.autoUpdate) {
-                memory.record({
-                    content: [
-                        { role: "user", content: input },
-                        { role: "agent", content: replaceTransferAgentToName(output), source: this.name },
-                    ],
-                }, context);
-            }
-        }
+    async postprocess(input, output, options) {
+        this.checkContextStatus(options);
+        this.publishToTopics(output, options);
+        await this.recordMemories({
+            content: [
+                { role: "user", content: input },
+                { role: "agent", content: replaceTransferAgentToName(output), source: this.name },
+            ],
+        }, options);
     }
-    async publishToTopics(output, context) {
+    async publishToTopics(output, options) {
         const publishTopics = typeof this.publishTopic === "function" ? await this.publishTopic(output) : this.publishTopic;
         if (publishTopics?.length) {
-            context.publish(publishTopics, {
+            options.context.publish(publishTopics, {
                 role: this.constructor.name === "UserAgent" ? "user" : "agent",
                 source: this.name,
                 message: output,
@@ -487,7 +515,7 @@ export class Agent {
      *
      * @returns Agent name
      */
-    [inspect.custom]() {
+    [nodejs.customInspect]() {
         return this.name;
     }
     /**
@@ -602,11 +630,11 @@ export class FunctionAgent extends Agent {
      * Process input implementation, calls the configured processing function
      *
      * @param input Input message
-     * @param context Execution context
+     * @param options Invocation options
      * @returns Processing result
      */
-    process(input, context) {
-        return this._process(input, context);
+    process(input, options) {
+        return this._process(input, options);
     }
 }
 function functionToAgent(agent) {

package/lib/esm/agents/ai-agent.d.ts

@@ -1,8 +1,6 @@
 import { type ZodObject, type ZodType, z } from "zod";
-import type { Context } from "../aigne/context.js";
-import { type DefaultMemoryOptions } from "../memory/default-memory.js";
 import { PromptBuilder } from "../prompt/prompt-builder.js";
-import { Agent, type AgentOptions, type AgentProcessAsyncGenerator, type Message } from "./agent.js";
+import { Agent, type AgentInvokeOptions, type AgentOptions, type AgentProcessAsyncGenerator, type Message } from "./agent.js";
 import { ChatModel, type ChatModelInput } from "./chat-model.js";
 import type { GuideRailAgentOutput } from "./guide-rail-agent.js";
 /**
@@ -14,7 +12,7 @@ import type { GuideRailAgentOutput } from "./guide-rail-agent.js";
  * @template I The input message type the agent accepts
  * @template O The output message type the agent returns
  */
-export interface AIAgentOptions<I extends Message = Message, O extends Message = Message> extends Omit<AgentOptions<I, O>, "memory"> {
+export interface AIAgentOptions<I extends Message = Message, O extends Message = Message> extends AgentOptions<I, O> {
     /**
      * The language model to use for this agent
      *
@@ -66,7 +64,6 @@ export interface AIAgentOptions<I extends Message = Message, O extends Message =
      * The template receives a {{memories}} variable containing serialized memory content.
      */
     memoryPromptTemplate?: string;
-    memory?: AgentOptions<I, O>["memory"] | DefaultMemoryOptions | true;
 }
 /**
  * Tool choice options for AI agents
@@ -215,7 +212,7 @@ export declare class AIAgent<I extends Message = Message, O extends Message = Me
      *
      * @protected
      */
-    process(input: I, context: Context): AgentProcessAsyncGenerator<O>;
+    process(input: I, options: AgentInvokeOptions): AgentProcessAsyncGenerator<O>;
     protected onGuideRailError(error: GuideRailAgentOutput): Promise<O | GuideRailAgentOutput>;
     /**
      * Process router mode requests
@@ -225,5 +222,5 @@ export declare class AIAgent<I extends Message = Message, O extends Message = Me
      *
      * @protected
      */
-    _processRouter(input: I, model: ChatModel, modelInput: ChatModelInput, context: Context, toolsMap: Map<string, Agent>): AgentProcessAsyncGenerator<O>;
+    _processRouter(input: I, model: ChatModel, modelInput: ChatModelInput, options: AgentInvokeOptions, toolsMap: Map<string, Agent>): AgentProcessAsyncGenerator<O>;
 }