@aigne/core 1.6.0 → 1.8.0

package/CHANGELOG.md

@@ -22,6 +22,33 @@
 * rename @aigne/core-next to @aigne/core ([3a81009](https://github.com/AIGNE-io/aigne-framework/commit/3a8100962c81813217b687ae28e8de604419c622))
 * use text resource from MCP correctly ([8b9eba8](https://github.com/AIGNE-io/aigne-framework/commit/8b9eba83352ec096a2a5d4f410d4c4bde7420bce))
 
+## [1.8.0](https://github.com/AIGNE-io/aigne-framework/compare/core-v1.7.0...core-v1.8.0) (2025-04-17)
+
+
+### Features
+
+* **ci:** support coverage examples with model matrix ([#59](https://github.com/AIGNE-io/aigne-framework/issues/59)) ([1edd704](https://github.com/AIGNE-io/aigne-framework/commit/1edd70426b80a69e3751b2d5fe818297711d0777))
+* **cli:** support model and download customization for aigne run ([#61](https://github.com/AIGNE-io/aigne-framework/issues/61)) ([51f6619](https://github.com/AIGNE-io/aigne-framework/commit/51f6619e6c591a84f1f2339b26ef66d89fa9486e))
+
+
+### Bug Fixes
+
+* **mcp:** set default timeout to 60s ([#67](https://github.com/AIGNE-io/aigne-framework/issues/67)) ([40dc029](https://github.com/AIGNE-io/aigne-framework/commit/40dc029b7795650283a505fd71b9566e5f0a4471))
+
+## [1.7.0](https://github.com/AIGNE-io/aigne-framework/compare/core-v1.6.0...core-v1.7.0) (2025-04-15)
+
+
+### Features
+
+* add TerminalTracer for better UX in terminal ([#56](https://github.com/AIGNE-io/aigne-framework/issues/56)) ([9875a5d](https://github.com/AIGNE-io/aigne-framework/commit/9875a5d46abb55073340ffae841fed6bd6b83ff4))
+* **cli:** support run agents from remote URL ([#60](https://github.com/AIGNE-io/aigne-framework/issues/60)) ([5f49920](https://github.com/AIGNE-io/aigne-framework/commit/5f4992089d36f9e780ba55a912a1d35508cad28e))
+* **core:** support oauth for McpAgent with example ([#55](https://github.com/AIGNE-io/aigne-framework/issues/55)) ([9420f3a](https://github.com/AIGNE-io/aigne-framework/commit/9420f3a56cf18986cd45f173044e660be76daab4))
+
+
+### Bug Fixes
+
+* remove usage of new Node.js exists API for compatibility ([#57](https://github.com/AIGNE-io/aigne-framework/issues/57)) ([c10cc08](https://github.com/AIGNE-io/aigne-framework/commit/c10cc086d8ecd0744f38cdb1367d4c8816b723b3))
+
 ## [1.6.0](https://github.com/AIGNE-io/aigne-framework/compare/core-v1.5.0...core-v1.6.0) (2025-04-08)
 
 

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

@@ -1,3 +1,4 @@
+import { inspect } from "node:util";
 import { type ZodType } from "zod";
 import type { Context } from "../execution-engine/context.js";
 import { type Nullish, type PromiseOrValue } from "../utils/type-utils.js";
@@ -15,7 +16,7 @@ export interface AgentOptions<I extends Message = Message, O extends Message = M
     outputSchema?: AgentInputOutputSchema<O>;
     includeInputInOutput?: boolean;
     tools?: (Agent | FunctionAgentFn)[];
-    disableLogging?: boolean;
+    disableEvents?: boolean;
     memory?: AgentMemory | AgentMemoryOptions | true;
 }
 export declare abstract class Agent<I extends Message = Message, O extends Message = Message> {
@@ -37,7 +38,7 @@ export declare abstract class Agent<I extends Message = Message, O extends Messa
     readonly tools: Agent<Message, Message>[] & {
         [key: string]: Agent<Message, Message>;
     };
-    private disableLogging?;
+    private disableEvents?;
     /**
      * Attach agent to context:
      * - subscribe to topic and call process method when message received
@@ -50,10 +51,12 @@ export declare abstract class Agent<I extends Message = Message, O extends Messa
     private checkContextStatus;
     private newDefaultContext;
     call(input: I | string, context?: Context): Promise<O>;
+    protected checkUsageAgentCalls(context: Context): void;
     protected preprocess(_: I, context: Context): void;
     protected postprocess(input: I, output: O, context: Context): void;
     abstract process(input: I, context: Context): Promise<O | TransferAgentOutput>;
     shutdown(): Promise<void>;
+    [inspect.custom](): string;
 }
 export type AgentInputOutputSchema<I extends Message = Message> = ZodType<I> | ((agent: Agent) => ZodType<I>);
 export interface FunctionAgentOptions<I extends Message = Message, O extends Message = Message> extends AgentOptions<I, O> {

package/lib/cjs/agents/agent.js

@@ -34,6 +34,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FunctionAgent = exports.Agent = void 0;
+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");
@@ -55,7 +56,7 @@ class Agent {
         this.publishTopic = options.publishTopic;
         if (options.tools?.length)
             this.tools.push(...options.tools.map(functionToAgent));
-        this.disableLogging = options.disableLogging;
+        this.disableEvents = options.disableEvents;
         if (options.memory) {
             this.memory =
                 options.memory instanceof memory_js_1.AgentMemory
@@ -92,7 +93,7 @@ class Agent {
     subscribeTopic;
     publishTopic;
     tools = (0, type_utils_js_1.createAccessorArray)([], (arr, name) => arr.find((t) => t.name === name));
-    disableLogging;
+    disableEvents;
     /**
      * Attach agent to context:
      * - subscribe to topic and call process method when message received
@@ -107,7 +108,7 @@ class Agent {
                     await context.call(this, message);
                 }
                 catch (error) {
-                    context.emit("error", error);
+                    context.emit("agentFailed", { agent: this, error });
                 }
             });
         }
@@ -131,31 +132,45 @@ class Agent {
     }
     async call(input, context) {
         const ctx = context ?? (await this.newDefaultContext());
-        const _input = typeof input === "string" ? (0, prompt_builder_js_1.createMessage)(input) : input;
-        const parsedInput = this.inputSchema.parse(_input);
-        logger_js_1.logger.debug("Call agent %s start with input: %O", this.name, input);
-        this.preprocess(parsedInput, ctx);
-        this.checkContextStatus(ctx);
-        const result = this.process(parsedInput, ctx)
-            .then((output) => {
-            const parsedOutput = this.outputSchema.parse(output);
-            return this.includeInputInOutput ? { ...parsedInput, ...parsedOutput } : parsedOutput;
-        })
-            .then((output) => {
-            this.postprocess(parsedInput, output, ctx);
+        const message = typeof input === "string" ? (0, prompt_builder_js_1.createMessage)(input) : input;
+        logger_js_1.logger.core("Call agent %s started with input: %O", this.name, input);
+        if (!this.disableEvents)
+            ctx.emit("agentStarted", { agent: this, input: message });
+        try {
+            const parsedInput = this.inputSchema.parse(message);
+            this.preprocess(parsedInput, ctx);
+            this.checkContextStatus(ctx);
+            const output = await this.process(parsedInput, ctx)
+                .then((output) => {
+                const parsedOutput = this.outputSchema.parse(output);
+                return this.includeInputInOutput ? { ...parsedInput, ...parsedOutput } : parsedOutput;
+            })
+                .then((output) => {
+                this.postprocess(parsedInput, output, ctx);
+                return output;
+            });
+            logger_js_1.logger.core("Call agent %s succeed with output: %O", this.name, input);
+            if (!this.disableEvents)
+                ctx.emit("agentSucceed", { agent: this, output });
             return output;
-        });
-        return logger_js_1.logger.debug.spinner(result, `Call agent ${this.name}`, (output) => logger_js_1.logger.debug("Call agent %s succeed with output: %O", this.name, (0, types_js_1.replaceTransferAgentToName)(output)), { disabled: this.disableLogging });
+        }
+        catch (error) {
+            logger_js_1.logger.core("Call agent %s failed with error: %O", this.name, error);
+            if (!this.disableEvents)
+                ctx.emit("agentFailed", { agent: this, error });
+            throw error;
+        }
+    }
+    checkUsageAgentCalls(context) {
+        const { limits, usage } = context;
+        if (limits?.maxAgentCalls && usage.agentCalls >= limits.maxAgentCalls) {
+            throw new Error(`Exceeded max agent calls ${usage.agentCalls}/${limits.maxAgentCalls}`);
+        }
+        usage.agentCalls++;
     }
     preprocess(_, context) {
         this.checkContextStatus(context);
-        if (context) {
-            const { limits, usage } = context;
-            if (limits?.maxAgentCalls && usage.agentCalls >= limits.maxAgentCalls) {
-                throw new Error(`Exceeded max agent calls ${usage.agentCalls}/${limits.maxAgentCalls}`);
-            }
-            usage.agentCalls++;
-        }
+        this.checkUsageAgentCalls(context);
     }
     postprocess(input, output, context) {
         this.checkContextStatus(context);
@@ -169,6 +184,9 @@ class Agent {
     async shutdown() {
         this.memory?.detach();
     }
+    [node_util_1.inspect.custom]() {
+        return this.name;
+    }
 }
 exports.Agent = Agent;
 function checkAgentInputOutputSchema(schema) {

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

@@ -28,6 +28,10 @@ export declare const aiAgentOptionsSchema: z.ZodObject<{
     memory: z.ZodOptional<z.ZodUnion<[z.ZodBoolean, z.ZodAny, z.ZodAny]>>;
 }, "strip", z.ZodTypeAny, {
     description?: string | undefined;
+    memory?: any;
+    includeInputInOutput?: boolean | undefined;
+    subscribeTopic?: string | string[] | undefined;
+    publishTopic?: string | string[] | ((...args: unknown[]) => unknown) | undefined;
     tools?: (Agent<Message, Message> | ((...args: unknown[]) => unknown))[] | undefined;
     toolChoice?: Agent<Message, Message> | "auto" | "none" | "required" | "router" | undefined;
     name?: string | undefined;
@@ -36,13 +40,13 @@ export declare const aiAgentOptionsSchema: z.ZodObject<{
     outputKey?: string | undefined;
     enableHistory?: boolean | undefined;
     maxHistoryMessages?: number | undefined;
-    includeInputInOutput?: boolean | undefined;
-    subscribeTopic?: string | string[] | undefined;
-    publishTopic?: string | string[] | ((...args: unknown[]) => unknown) | undefined;
     disableLogging?: boolean | undefined;
-    memory?: any;
 }, {
     description?: string | undefined;
+    memory?: any;
+    includeInputInOutput?: boolean | undefined;
+    subscribeTopic?: string | string[] | undefined;
+    publishTopic?: string | string[] | ((...args: unknown[]) => unknown) | undefined;
     tools?: (Agent<Message, Message> | ((...args: unknown[]) => unknown))[] | undefined;
     toolChoice?: Agent<Message, Message> | "auto" | "none" | "required" | "router" | undefined;
     name?: string | undefined;
@@ -51,11 +55,7 @@ export declare const aiAgentOptionsSchema: z.ZodObject<{
     outputKey?: string | undefined;
     enableHistory?: boolean | undefined;
     maxHistoryMessages?: number | undefined;
-    includeInputInOutput?: boolean | undefined;
-    subscribeTopic?: string | string[] | undefined;
-    publishTopic?: string | string[] | ((...args: unknown[]) => unknown) | undefined;
     disableLogging?: boolean | undefined;
-    memory?: any;
 }>;
 export declare class AIAgent<I extends Message = Message, O extends Message = Message> extends Agent<I, O> {
     static from<I extends Message, O extends Message>(options: AIAgentOptions<I, O>): AIAgent<I, O>;

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

@@ -62,7 +62,10 @@ class AIAgent extends agent_js_1.Agent {
         const toolsMap = new Map(toolAgents?.map((i) => [i.name, i]));
         const toolCallMessages = [];
         for (;;) {
-            const { text, json, toolCalls } = await model.call({ ...modelInput, messages: messages.concat(toolCallMessages) }, context);
+            const { text, json, toolCalls } = await context.call(model, {
+                ...modelInput,
+                messages: messages.concat(toolCallMessages),
+            });
             if (toolCalls?.length) {
                 const executedToolCalls = [];
                 // Execute tools
@@ -71,7 +74,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 tool.call({ ...call.function.arguments, ...input }, context);
+                    const output = await context.call(tool, { ...call.function.arguments, ...input }, { disableTransfer: true });
                     // NOTE: Return transfer output immediately
                     if ((0, types_js_1.isTransferAgentOutput)(output)) {
                         return output;

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

@@ -1,4 +1,5 @@
 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 { RequestOptions } from "@modelcontextprotocol/sdk/shared/protocol.js";
 import type { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
@@ -15,6 +16,15 @@ export interface MCPAgentOptions extends AgentOptions {
 export type MCPServerOptions = SSEServerParameters | StdioServerParameters;
 export type SSEServerParameters = {
     url: string;
+    /**
+     * Additional options to pass to the SSEClientTransport.
+     */
+    opts?: SSEClientTransportOptions;
+    /**
+     * The timeout for requests to the server, in milliseconds.
+     * @default 60000
+     */
+    timeout?: number;
     /**
      * Whether to automatically reconnect to the server if the connection is lost.
      * @default 10 set to 0 to disable automatic reconnection
@@ -31,7 +41,7 @@ export declare class MCPAgent extends Agent {
     static from(options: MCPAgentOptions): MCPAgent;
     private static fromTransport;
     constructor(options: MCPAgentOptions);
-    private client;
+    client: Client;
     readonly prompts: MCPPrompt[] & {
         [key: string]: MCPPrompt;
     };
@@ -44,6 +54,7 @@ export declare class MCPAgent extends Agent {
 }
 export interface ClientWithReconnectOptions {
     transportCreator?: () => PromiseOrValue<Transport>;
+    timeout?: number;
     maxReconnects?: number;
     shouldReconnect?: (error: Error) => boolean;
 }
@@ -60,7 +71,6 @@ export interface MCPBaseOptions<I extends Message = Message, O extends Message =
 export declare abstract class MCPBase<I extends Message, O extends Message> extends Agent<I, O> {
     constructor(options: MCPBaseOptions<I, O>);
     protected client: ClientWithReconnect;
-    protected get mcpServer(): string | undefined;
 }
 export declare class MCPTool extends MCPBase<Message, CallToolResult> {
     process(input: Message): Promise<CallToolResult>;

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

@@ -17,7 +17,11 @@ const agent_js_1 = require("./agent.js");
 const MCP_AGENT_CLIENT_NAME = "MCPAgent";
 const MCP_AGENT_CLIENT_VERSION = "0.0.1";
 const DEFAULT_MAX_RECONNECTS = 10;
-const debug = logger_js_1.logger.base.extend("mcp");
+const DEFAULT_TIMEOUT = () => zod_1.z.coerce
+    .number()
+    .int()
+    .min(0)
+    .safeParse(process.env.MCP_TIMEOUT || process.env.TIMEOUT).data || 60e3;
 function isSSEServerParameters(options) {
     return "url" in options && typeof options.url === "string";
 }
@@ -37,7 +41,7 @@ class MCPAgent extends agent_js_1.Agent {
     static from(options) {
         (0, type_utils_js_1.checkArguments)("MCPAgent.from", mcpAgentOptionsSchema, options);
         if (isSSEServerParameters(options)) {
-            const transport = () => new sse_js_1.SSEClientTransport(new URL(options.url));
+            const transport = () => new sse_js_1.SSEClientTransport(new URL(options.url), options.opts);
             return MCPAgent.fromTransport(transport, options);
         }
         if (isStdioServerParameters(options)) {
@@ -59,29 +63,36 @@ class MCPAgent extends agent_js_1.Agent {
             version: MCP_AGENT_CLIENT_VERSION,
         }, undefined, isSSEServerParameters(options) ? { transportCreator, ...options } : undefined);
         const transport = transportCreator();
-        await debug.spinner(client.connect(transport), `Connecting to MCP server: ${getMCPServerString(options)}`);
+        logger_js_1.logger.mcp(`Connecting to MCP server: ${getMCPServerString(options)}`);
+        await client.connect(transport);
         const mcpServer = getMCPServerName(client);
         const { tools: isToolsAvailable, prompts: isPromptsAvailable, resources: isResourcesAvailable, } = client.getServerCapabilities() ?? {};
+        logger_js_1.logger.mcp(`Listing tools from ${mcpServer}`);
         const tools = isToolsAvailable
-            ? await debug
-                .spinner(client.listTools(), `Listing tools from ${mcpServer}`, ({ tools }) => debug("%O", tools))
-                .then(({ tools }) => tools.map((tool) => (0, mcp_utils_js_1.toolFromMCPTool)(tool, { client })))
+            ? await client.listTools().then(({ tools }) => {
+                logger_js_1.logger.mcp(`Listing tools from ${mcpServer} completed %O`, tools?.map((i) => i.name));
+                return tools.map((tool) => (0, mcp_utils_js_1.toolFromMCPTool)(tool, { client }));
+            })
             : undefined;
+        logger_js_1.logger.mcp(`Listing prompts from ${mcpServer}`);
         const prompts = isPromptsAvailable
-            ? await debug
-                .spinner(client.listPrompts(), `Listing prompts from ${mcpServer}`, ({ prompts }) => debug("%O", prompts))
-                .then(({ prompts }) => prompts.map((prompt) => (0, mcp_utils_js_1.promptFromMCPPrompt)(prompt, { client })))
+            ? await client.listPrompts().then(({ prompts }) => {
+                logger_js_1.logger.mcp(`Listing prompts from ${mcpServer} completed %O`, prompts?.map((i) => i.name));
+                return prompts.map((prompt) => (0, mcp_utils_js_1.promptFromMCPPrompt)(prompt, { client }));
+            })
             : undefined;
+        logger_js_1.logger.mcp(`Listing resources from ${mcpServer}`);
+        // TODO: should conditionally call listResourceTemplates based on the server capabilities
+        // but the capability is not correct in the current SDK version
         const resources = isResourcesAvailable
-            ? await debug
-                .spinner(
-            // TODO: should conditionally call listResourceTemplates based on the server capabilities
-            // but the capability is not correct in the current SDK version
-            Promise.all([
+            ? await Promise.all([
                 client.listResources().catch(() => ({ resources: [] })),
                 client.listResourceTemplates().catch(() => ({ resourceTemplates: [] })),
-            ]), `Listing resources from ${mcpServer}`, ([{ resources }, { resourceTemplates }]) => debug("%O\n%O", resources, resourceTemplates))
-                .then(([{ resources }, { resourceTemplates }]) => [...resources, ...resourceTemplates].map((resource) => (0, mcp_utils_js_1.resourceFromMCPResource)(resource, { client })))
+            ]).then(([{ resources }, { resourceTemplates }]) => {
+                const result = [...resources, ...resourceTemplates].map((resource) => (0, mcp_utils_js_1.resourceFromMCPResource)(resource, { client }));
+                logger_js_1.logger.mcp(`Listing resources from ${mcpServer} completed %O`, result.map((i) => i.name));
+                return result;
+            })
             : undefined;
         return new MCPAgent({
             name: client.getServerVersion()?.name,
@@ -134,22 +145,28 @@ class ClientWithReconnect extends index_js_1.Client {
             throw new Error("reconnect requires a transportCreator");
         await (0, p_retry_1.default)(async () => {
             await this.close();
-            await this.connect(await transportCreator());
+            await this.connect(await transportCreator(), {
+                timeout: this.reconnectOptions?.timeout ?? DEFAULT_TIMEOUT(),
+            });
         }, {
             retries: this.reconnectOptions?.maxReconnects ?? DEFAULT_MAX_RECONNECTS,
             shouldRetry: this.shouldReconnect,
-            onFailedAttempt: (error) => debug("Reconnect attempt failed: %O", error),
+            onFailedAttempt: (error) => logger_js_1.logger.mcp("Reconnect attempt failed: %O", error),
         });
     }
     async request(request, resultSchema, options) {
+        const mergedOptions = {
+            ...options,
+            timeout: options?.timeout ?? DEFAULT_TIMEOUT(),
+        };
         try {
-            return await super.request(request, resultSchema, options);
+            return await super.request(request, resultSchema, mergedOptions);
         }
         catch (error) {
             if (this.shouldReconnect(error)) {
-                debug("Error occurred, reconnecting to MCP server: %O", error);
+                logger_js_1.logger.mcp("Error occurred, reconnecting to MCP server: %O", error);
                 await this.reconnect();
-                return await super.request(request, resultSchema, options);
+                return await super.request(request, resultSchema, mergedOptions);
             }
             throw error;
         }
@@ -161,21 +178,18 @@ class MCPBase extends agent_js_1.Agent {
         this.client = options.client;
     }
     client;
-    get mcpServer() {
-        return getMCPServerName(this.client);
-    }
 }
 exports.MCPBase = MCPBase;
 class MCPTool extends MCPBase {
     async process(input) {
-        const result = await debug.spinner(this.client.callTool({ name: this.name, arguments: input }), `Call tool ${this.name} from ${this.mcpServer}`, (output) => debug("input: %O\noutput: %O", input, output));
+        const result = await this.client.callTool({ name: this.name, arguments: input });
         return result;
     }
 }
 exports.MCPTool = MCPTool;
 class MCPPrompt extends MCPBase {
     async process(input) {
-        const result = await debug.spinner(this.client.getPrompt({ name: this.name, arguments: input }), `Get prompt ${this.name} from ${this.mcpServer}`, (output) => debug("input: %O\noutput: %O", input, output));
+        const result = await this.client.getPrompt({ name: this.name, arguments: input });
         return result;
     }
 }
@@ -188,7 +202,7 @@ class MCPResource extends MCPBase {
     uri;
     async process(input) {
         const uri = new uriTemplate_js_1.UriTemplate(this.uri).expand(input);
-        const result = await debug.spinner(this.client.readResource({ uri }), `Read resource ${this.name} from ${this.mcpServer}`, (output) => debug("input: %O\noutput: %O", input, output));
+        const result = await this.client.readResource({ uri });
         return result;
     }
 }
@@ -208,6 +222,10 @@ const mcpAgentOptionsSchema = zod_1.z.union([
     }),
     zod_1.z.object({
         url: zod_1.z.string(),
+        opts: zod_1.z.object({}).optional(),
+        timeout: zod_1.z.number().optional(),
+        maxReconnects: zod_1.z.number().optional(),
+        shouldReconnect: zod_1.z.function().args(zod_1.z.instanceof(Error)).returns(zod_1.z.boolean()).optional(),
     }),
     zod_1.z.object({
         command: zod_1.z.string(),

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

@@ -1,26 +1,26 @@
 import { ReadableStream } from "node:stream/web";
-import type { Context } from "../execution-engine/context.js";
-import type { MessagePayload, MessageQueueListener, Unsubscribe } from "../execution-engine/message-queue.js";
+import { type Context, type Runnable } from "../execution-engine/context.js";
+import type { MessagePayload } from "../execution-engine/message-queue.js";
 import { type PromiseOrValue } from "../utils/type-utils.js";
 import { Agent, type AgentOptions, type Message } from "./agent.js";
 export interface UserAgentOptions<I extends Message = Message, O extends Message = Message> extends AgentOptions<I, O> {
     context: Context;
     process?: (input: I, context: Context) => PromiseOrValue<O>;
+    activeAgent?: Runnable;
 }
 export declare class UserAgent<I extends Message = Message, O extends Message = Message> extends Agent<I, O> {
     static from<I extends Message, O extends Message>(options: UserAgentOptions<I, O>): UserAgent<I, O>;
     constructor(options: UserAgentOptions<I, O>);
-    readonly context: Context;
-    private get ctx();
+    context: Context;
     private _process?;
+    private activeAgent?;
     call(input: string | I, context?: Context): Promise<O>;
     process(input: I, context: Context): Promise<O>;
-    publish(topic: string | string[], message: Message | string): void;
-    subscribe(topic: string, listener?: undefined): Promise<MessagePayload>;
-    subscribe(topic: string, listener: MessageQueueListener): Unsubscribe;
-    subscribe(topic: string, listener?: MessageQueueListener): Unsubscribe | Promise<MessagePayload>;
-    unsubscribe(topic: string, listener: MessageQueueListener): void;
+    publish: Context["publish"];
+    subscribe: Context["subscribe"];
+    unsubscribe: Context["unsubscribe"];
     get stream(): ReadableStream<MessagePayload & {
         topic: string;
     }>;
+    protected checkUsageAgentCalls(_context: Context): void;
 }

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

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UserAgent = void 0;
 const web_1 = require("node:stream/web");
+const context_js_1 = require("../execution-engine/context.js");
 const type_utils_js_1 = require("../utils/type-utils.js");
 const agent_js_1 = require("./agent.js");
 class UserAgent extends agent_js_1.Agent {
@@ -9,40 +10,46 @@ class UserAgent extends agent_js_1.Agent {
         return new UserAgent(options);
     }
     constructor(options) {
-        super({ ...options, disableLogging: true });
+        super({ ...options, disableEvents: true });
         this._process = options.process;
         this.context = options.context;
+        this.activeAgent = options.activeAgent;
     }
     context;
-    get ctx() {
-        if (!this.context)
-            throw new Error("UserAgent must have a context");
-        return this.context;
-    }
     _process;
+    activeAgent;
     call(input, context) {
+        if (!context)
+            this.context = this.context.newContext({ reset: true });
         return super.call(input, context ?? this.context);
     }
     async process(input, context) {
         if (this._process) {
             return this._process(input, context);
         }
+        if (this.activeAgent) {
+            const [output, agent] = await context.call(this.activeAgent, input, {
+                returnActiveAgent: true,
+            });
+            this.activeAgent = agent;
+            return output;
+        }
         const publicTopic = typeof this.publishTopic === "function" ? await this.publishTopic(input) : this.publishTopic;
         if (publicTopic?.length) {
-            context.publish(publicTopic, input, this);
+            context.publish(publicTopic, (0, context_js_1.createPublishMessage)(input, this));
             return {};
         }
         throw new Error("UserAgent must have a process function or a publishTopic");
     }
-    publish(topic, message) {
-        return this.ctx.publish(topic, message, this);
-    }
-    subscribe(topic, listener) {
-        return this.ctx.subscribe(topic, listener);
-    }
-    unsubscribe(topic, listener) {
-        this.ctx.unsubscribe(topic, listener);
-    }
+    publish = ((...args) => {
+        return this.context.publish(...args);
+    });
+    subscribe = ((...args) => {
+        return this.context.subscribe(...args);
+    });
+    unsubscribe = ((...args) => {
+        this.context.unsubscribe(...args);
+    });
     get stream() {
         let subscriptions = [];
         return new web_1.ReadableStream({
@@ -59,5 +66,8 @@ class UserAgent extends agent_js_1.Agent {
             },
         });
     }
+    checkUsageAgentCalls(_context) {
+        // ignore calls usage check for UserAgent
+    }
 }
 exports.UserAgent = UserAgent;