@aigne/core 1.16.0 → 1.18.0

package/lib/cjs/agents/agent.js

@@ -40,10 +40,10 @@ exports.FunctionAgent = exports.Agent = exports.agentOptionsSchema = void 0;
 exports.isEmptyChunk = isEmptyChunk;
 exports.textDelta = textDelta;
 exports.jsonDelta = jsonDelta;
-const node_util_1 = require("node:util");
 const zod_1 = require("zod");
 const prompt_builder_js_1 = require("../prompt/prompt-builder.js");
 const logger_js_1 = require("../utils/logger.js");
+const nodejs_js_1 = require("../utils/nodejs.js");
 const stream_utils_js_1 = require("../utils/stream-utils.js");
 const type_utils_js_1 = require("../utils/type-utils.js");
 const types_js_1 = require("./types.js");
@@ -61,6 +61,7 @@ exports.agentOptionsSchema = zod_1.z.object({
     skills: zod_1.z.array(zod_1.z.union([zod_1.z.custom(), zod_1.z.custom()])).optional(),
     disableEvents: zod_1.z.boolean().optional(),
     memory: zod_1.z.union([zod_1.z.custom(), zod_1.z.array(zod_1.z.custom())]).optional(),
+    maxRetrieveMemoryCount: zod_1.z.number().optional(),
     hooks: zod_1.z
         .object({
         onStart: zod_1.z.custom().optional(),
@@ -117,6 +118,7 @@ class Agent {
         else if (options.memory) {
             this.memories.push(options.memory);
         }
+        this.maxRetrieveMemoryCount = options.maxRetrieveMemoryCount;
         this.hooks = options.hooks ?? {};
         this.guideRails = options.guideRails;
     }
@@ -124,6 +126,10 @@ class Agent {
      * List of memories this agent can use
      */
     memories = [];
+    /**
+     * Maximum number of memory items to retrieve
+     */
+    maxRetrieveMemoryCount;
     /**
      * Lifecycle hooks for agent processing.
      *
@@ -292,68 +298,92 @@ 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 Promise.resolve().then(() => __importStar(require("../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 && (0, prompt_builder_js_1.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" ? (0, prompt_builder_js_1.createMessage)(input) : input;
         logger_js_1.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 = (0, type_utils_js_1.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 = (0, types_js_1.transferToAgentOutput)(response);
             }
-            if (options?.streaming) {
+            if (opts.streaming) {
                 const stream = response instanceof ReadableStream
                     ? response
                     : (0, stream_utils_js_1.isAsyncGenerator)(response)
                         ? (0, stream_utils_js_1.asyncGeneratorToReadableStream)(response)
                         : (0, stream_utils_js_1.objectToAgentResponseStream)(response);
                 return this.checkResponseByGuideRails(message, (0, stream_utils_js_1.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 (0, stream_utils_js_1.agentResponseStreamToObject)(response)
                 : (0, stream_utils_js_1.isAsyncGenerator)(response)
                     ? await (0, stream_utils_js_1.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;
         }
     }
@@ -364,17 +394,18 @@ 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 = (0, type_utils_js_1.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_js_1.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;
     }
     /**
@@ -383,13 +414,14 @@ 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_js_1.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;
     }
     /**
@@ -398,11 +430,11 @@ 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}`);
         }
@@ -416,19 +448,19 @@ 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 (0, stream_utils_js_1.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)),
@@ -437,13 +469,13 @@ 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);
     }
     /**
@@ -473,26 +505,22 @@ 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: (0, types_js_1.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: (0, types_js_1.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,
@@ -529,7 +557,7 @@ class Agent {
      *
      * @returns Agent name
      */
-    [node_util_1.inspect.custom]() {
+    [nodejs_js_1.nodejs.customInspect]() {
         return this.name;
     }
     /**
@@ -645,11 +673,11 @@ 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);
     }
 }
 exports.FunctionAgent = FunctionAgent;

package/lib/cjs/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>;
 }

package/lib/cjs/agents/ai-agent.js

@@ -2,8 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AIAgent = exports.aiAgentOptionsSchema = exports.aiAgentToolChoiceSchema = exports.AIAgentToolChoice = void 0;
 const zod_1 = require("zod");
-const default_memory_js_1 = require("../memory/default-memory.js");
-const memory_js_1 = require("../memory/memory.js");
 const prompt_builder_js_1 = require("../prompt/prompt-builder.js");
 const template_js_1 = require("../prompt/template.js");
 const type_utils_js_1 = require("../utils/type-utils.js");
@@ -101,14 +99,7 @@ class AIAgent extends agent_js_1.Agent {
      * @param options Configuration options for the AI agent
      */
     constructor(options) {
-        super({
-            ...options,
-            memory: !options.memory
-                ? undefined
-                : Array.isArray(options.memory) || options.memory instanceof memory_js_1.MemoryAgent
-                    ? options.memory
-                    : new default_memory_js_1.DefaultMemory(options.memory === true ? {} : options.memory),
-        });
+        super(options);
         (0, type_utils_js_1.checkArguments)("AIAgent", exports.aiAgentOptionsSchema, options);
         this.model = options.model;
         this.instructions =
@@ -188,26 +179,26 @@ class AIAgent extends agent_js_1.Agent {
      *
      * @protected
      */
-    async *process(input, context) {
-        const model = this.model ?? context.model;
+    async *process(input, options) {
+        const model = this.model ?? options.context.model;
         if (!model)
             throw new Error("model is required to run AIAgent");
         const { toolAgents, ...modelInput } = await this.instructions.build({
+            ...options,
             agent: this,
             input,
             model,
-            context,
         });
         const toolsMap = new Map(toolAgents?.map((i) => [i.name, i]));
         if (this.toolChoice === "router") {
-            yield* this._processRouter(input, model, modelInput, context, toolsMap);
+            yield* this._processRouter(input, model, modelInput, options, toolsMap);
             return;
         }
         const toolCallMessages = [];
         const outputKey = this.outputKey || prompt_builder_js_1.MESSAGE_KEY;
         for (;;) {
             const modelOutput = {};
-            const stream = await context.invoke(model, { ...modelInput, messages: modelInput.messages.concat(toolCallMessages) }, { streaming: true });
+            const stream = await options.context.invoke(model, { ...modelInput, messages: modelInput.messages.concat(toolCallMessages) }, { streaming: true });
             for await (const value of stream) {
                 if (value.delta.text?.text) {
                     yield { delta: { text: { [outputKey]: value.delta.text.text } } };
@@ -225,7 +216,7 @@ class AIAgent extends agent_js_1.Agent {
                     if (!tool)
                         throw new Error(`Tool not found: ${call.function.name}`);
                     // NOTE: should pass both arguments (model generated) and input (user provided) to the tool
-                    const output = await this.invokeSkill(tool, { ...input, ...call.function.arguments }, context).catch((error) => {
+                    const output = await this.invokeSkill(tool, { ...input, ...call.function.arguments }, options).catch((error) => {
                         if (!this.catchToolsError) {
                             return Promise.reject(error);
                         }
@@ -275,15 +266,15 @@ class AIAgent extends agent_js_1.Agent {
      *
      * @protected
      */
-    async *_processRouter(input, model, modelInput, context, toolsMap) {
-        const { toolCalls: [call] = [], } = await context.invoke(model, modelInput);
+    async *_processRouter(input, model, modelInput, options, toolsMap) {
+        const { toolCalls: [call] = [], } = await options.context.invoke(model, modelInput);
         if (!call) {
             throw new Error("Router toolChoice requires exactly one tool to be executed");
         }
         const tool = toolsMap.get(call.function.name);
         if (!tool)
             throw new Error(`Tool not found: ${call.function.name}`);
-        const stream = await context.invoke(tool, { ...call.function.arguments, ...input }, { streaming: true, sourceAgent: this });
+        const stream = await options.context.invoke(tool, { ...call.function.arguments, ...input }, { streaming: true, sourceAgent: this });
         yield* stream;
     }
 }

package/lib/cjs/agents/chat-model.d.ts

@@ -1,6 +1,5 @@
-import type { Context } from "../aigne/context.js";
 import type { PromiseOrValue } from "../utils/type-utils.js";
-import { Agent, type AgentProcessResult, type Message } from "./agent.js";
+import { Agent, type AgentInvokeOptions, type AgentProcessResult, type Message } from "./agent.js";
 /**
  * ChatModel is an abstract base class for interacting with Large Language Models (LLMs).
  *
@@ -61,10 +60,10 @@ export declare abstract class ChatModel extends Agent<ChatModelInput, ChatModelO
      * Primarily checks if token usage exceeds limits, throwing an exception if limits are exceeded
      *
      * @param input Input message
-     * @param context Execution context
+     * @param options Options for invoking the agent
      * @throws Error if token usage exceeds maximum limit
      */
-    protected preprocess(input: ChatModelInput, context: Context): Promise<void>;
+    protected preprocess(input: ChatModelInput, options: AgentInvokeOptions): Promise<void>;
     /**
      * Performs postprocessing operations after handling output
      *
@@ -72,9 +71,9 @@ export declare abstract class ChatModel extends Agent<ChatModelInput, ChatModelO
      *
      * @param input Input message
      * @param output Output message
-     * @param context Execution context
+     * @param options Options for invoking the agent
      */
-    protected postprocess(input: ChatModelInput, output: ChatModelOutput, context: Context): void;
+    protected postprocess(input: ChatModelInput, output: ChatModelOutput, options: AgentInvokeOptions): Promise<void>;
     /**
      * Processes input messages and generates model responses
      *
@@ -92,10 +91,10 @@ export declare abstract class ChatModel extends Agent<ChatModelInput, ChatModelO
      * - Tool call processing if applicable
      *
      * @param input - The standardized input containing messages and model options
-     * @param context - The execution context with settings and state
+     * @param options - The options for invoking the agent, including context and limits
      * @returns A promise or direct value containing the model's response
      */
-    abstract process(input: ChatModelInput, context: Context): PromiseOrValue<AgentProcessResult<ChatModelOutput>>;
+    abstract process(input: ChatModelInput, options: AgentInvokeOptions): PromiseOrValue<AgentProcessResult<ChatModelOutput>>;
 }
 /**
  * Input message format for ChatModel

package/lib/cjs/agents/chat-model.js

@@ -78,12 +78,12 @@ class ChatModel extends agent_js_1.Agent {
      * Primarily checks if token usage exceeds limits, throwing an exception if limits are exceeded
      *
      * @param input Input message
-     * @param context Execution context
+     * @param options Options for invoking the agent
      * @throws Error if token usage exceeds maximum limit
      */
-    async preprocess(input, context) {
-        super.preprocess(input, context);
-        const { limits, usage } = context;
+    async preprocess(input, options) {
+        super.preprocess(input, options);
+        const { limits, usage } = options.context;
         const usedTokens = usage.outputTokens + usage.inputTokens;
         if (limits?.maxTokens && usedTokens >= limits.maxTokens) {
             throw new Error(`Exceeded max tokens ${usedTokens}/${limits.maxTokens}`);
@@ -112,9 +112,9 @@ class ChatModel extends agent_js_1.Agent {
      *
      * @param input Input message
      * @param output Output message
-     * @param context Execution context
+     * @param options Options for invoking the agent
      */
-    postprocess(input, output, context) {
+    async postprocess(input, output, options) {
         // Restore original tool names in the output
         if (output.toolCalls?.length) {
             const toolsMap = input._toolsMap;
@@ -128,11 +128,11 @@ class ChatModel extends agent_js_1.Agent {
                 }
             }
         }
-        super.postprocess(input, output, context);
+        super.postprocess(input, output, options);
         const { usage } = output;
         if (usage) {
-            context.usage.outputTokens += usage.outputTokens;
-            context.usage.inputTokens += usage.inputTokens;
+            options.context.usage.outputTokens += usage.outputTokens;
+            options.context.usage.inputTokens += usage.inputTokens;
         }
     }
 }

package/lib/cjs/agents/mcp-agent.d.ts

@@ -1,14 +1,13 @@
 import { Client, type ClientOptions } from "@modelcontextprotocol/sdk/client/index.js";
 import { type SSEClientTransportOptions } from "@modelcontextprotocol/sdk/client/sse.js";
-import { type StdioServerParameters } from "@modelcontextprotocol/sdk/client/stdio.js";
+import type { StdioServerParameters } from "@modelcontextprotocol/sdk/client/stdio.js";
 import { type StreamableHTTPClientTransportOptions } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
 import type { RequestOptions } from "@modelcontextprotocol/sdk/shared/protocol.js";
 import type { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
 import type { CallToolResult, GetPromptResult, Implementation, ReadResourceResult, Request } from "@modelcontextprotocol/sdk/types.js";
 import { type ZodType, z } from "zod";
-import type { Context } from "../aigne/context.js";
 import { type PromiseOrValue } from "../utils/type-utils.js";
-import { Agent, type AgentOptions, type Message } from "./agent.js";
+import { Agent, type AgentInvokeOptions, type AgentOptions, type Message } from "./agent.js";
 export interface MCPAgentOptions extends AgentOptions {
     client: Client;
     prompts?: MCPPrompt[];
@@ -150,10 +149,10 @@ export declare class MCPAgent extends Agent {
      * throws an error if called.
      *
      * @param _input Input message (unused)
-     * @param _context Execution context (unused)
+     * @param _options AgentInvokeOptions (unused)
      * @throws Error This method always throws an error since MCPAgent is not directly invokable
      */
-    process(_input: Message, _context?: Context): Promise<Message>;
+    process(_input: Message, _options: AgentInvokeOptions): Promise<Message>;
     /**
      * Shut down the agent and close the MCP connection.
      *

package/lib/cjs/agents/mcp-agent.js

@@ -4,15 +4,16 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MCPResource = exports.MCPPrompt = exports.MCPTool = exports.MCPBase = exports.MCPAgent = void 0;
+const stdio_client_transport_js_1 = require("@aigne/platform-helpers/mcp/stdio-client-transport.js");
 const index_js_1 = require("@modelcontextprotocol/sdk/client/index.js");
 const sse_js_1 = require("@modelcontextprotocol/sdk/client/sse.js");
-const stdio_js_1 = require("@modelcontextprotocol/sdk/client/stdio.js");
 const streamableHttp_js_1 = require("@modelcontextprotocol/sdk/client/streamableHttp.js");
 const uriTemplate_js_1 = require("@modelcontextprotocol/sdk/shared/uriTemplate.js");
 const p_retry_1 = __importDefault(require("p-retry"));
 const zod_1 = require("zod");
 const logger_js_1 = require("../utils/logger.js");
 const mcp_utils_js_1 = require("../utils/mcp-utils.js");
+const nodejs_js_1 = require("../utils/nodejs.js");
 const type_utils_js_1 = require("../utils/type-utils.js");
 const agent_js_1 = require("./agent.js");
 const MCP_AGENT_CLIENT_NAME = "AIGNE/MCPAgent";
@@ -22,7 +23,7 @@ const DEFAULT_TIMEOUT = () => zod_1.z.coerce
     .number()
     .int()
     .min(0)
-    .safeParse(process.env.MCP_TIMEOUT || process.env.TIMEOUT).data || 60e3;
+    .safeParse(nodejs_js_1.nodejs.env.MCP_TIMEOUT || nodejs_js_1.nodejs.env.TIMEOUT).data || 60e3;
 function isSSEServerParameters(options) {
     return "url" in options && typeof options.url === "string";
 }
@@ -66,14 +67,7 @@ class MCPAgent extends agent_js_1.Agent {
             return MCPAgent.fromTransport(transport, options);
         }
         if (isStdioServerParameters(options)) {
-            const transport = () => new stdio_js_1.StdioClientTransport({
-                ...options,
-                env: {
-                    ...(0, stdio_js_1.getDefaultEnvironment)(),
-                    ...options.env,
-                },
-                stderr: "pipe",
-            });
+            const transport = async () => (0, stdio_client_transport_js_1.createStdioClientTransport)(options);
             return MCPAgent.fromTransport(transport, options);
         }
         return new MCPAgent(options);
@@ -83,7 +77,7 @@ class MCPAgent extends agent_js_1.Agent {
             name: MCP_AGENT_CLIENT_NAME,
             version: MCP_AGENT_CLIENT_VERSION,
         }, undefined, isSSEServerParameters(options) ? { transportCreator, ...options } : undefined);
-        const transport = transportCreator();
+        const transport = await transportCreator();
         logger_js_1.logger.debug(`Connecting to MCP server: ${getMCPServerString(options)}`);
         await client.connect(transport);
         const mcpServer = getMCPServerName(client);
@@ -183,10 +177,10 @@ class MCPAgent extends agent_js_1.Agent {
      * throws an error if called.
      *
      * @param _input Input message (unused)
-     * @param _context Execution context (unused)
+     * @param _options AgentInvokeOptions (unused)
      * @throws Error This method always throws an error since MCPAgent is not directly invokable
      */
-    async process(_input, _context) {
+    async process(_input, _options) {
         throw new Error("Method not implemented.");
     }
     /**