@aigne/core 1.1.0-beta.5 → 1.3.0

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

@@ -1,10 +1,12 @@
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { type StdioServerParameters } from "@modelcontextprotocol/sdk/client/stdio.js";
-import type { CallToolResult, GetPromptResult } from "@modelcontextprotocol/sdk/types";
-import { Agent, type AgentInput, type AgentOptions, type AgentOutput } from "./agent";
+import type { CallToolResult, GetPromptResult, ReadResourceResult } from "@modelcontextprotocol/sdk/types.js";
+import type { Context } from "../execution-engine/context.js";
+import { Agent, type AgentOptions, type Message } from "./agent.js";
 export interface MCPAgentOptions extends AgentOptions {
     client: Client;
     prompts?: MCPPrompt[];
+    resources?: MCPResource[];
 }
 export type MCPServerOptions = SSEServerParameters | StdioServerParameters;
 export type SSEServerParameters = {
@@ -19,21 +21,35 @@ export declare class MCPAgent extends Agent {
     readonly prompts: MCPPrompt[] & {
         [key: string]: MCPPrompt;
     };
+    readonly resources: MCPResource[] & {
+        [key: string]: MCPResource;
+    };
+    get isCallable(): boolean;
+    process(_input: Message, _context?: Context): Promise<Message>;
     shutdown(): Promise<void>;
 }
-export interface MCPToolBaseOptions<I extends AgentInput, O extends AgentOutput> extends AgentOptions<I, O> {
+export interface MCPToolBaseOptions<I extends Message, O extends Message> extends AgentOptions<I, O> {
     client: Client;
 }
-export declare abstract class MCPBase<I extends AgentInput, O extends AgentOutput> extends Agent<I, O> {
+export declare abstract class MCPBase<I extends Message, O extends Message> extends Agent<I, O> {
     constructor(options: MCPToolBaseOptions<I, O>);
     protected client: Client;
     protected get mcpServer(): string | undefined;
 }
-export declare class MCPTool extends MCPBase<AgentInput, CallToolResult> {
-    process(input: AgentInput): Promise<CallToolResult>;
+export declare class MCPTool extends MCPBase<Message, CallToolResult> {
+    process(input: Message): Promise<CallToolResult>;
 }
-export declare class MCPPrompt extends MCPBase<{
+export interface MCPPromptInput extends Message {
     [key: string]: string;
-}, GetPromptResult> {
-    process(input: AgentInput): Promise<GetPromptResult>;
+}
+export declare class MCPPrompt extends MCPBase<MCPPromptInput, GetPromptResult> {
+    process(input: MCPPromptInput): Promise<GetPromptResult>;
+}
+export interface MCPResourceOptions extends MCPToolBaseOptions<MCPPromptInput, ReadResourceResult> {
+    uri: string;
+}
+export declare class MCPResource extends MCPBase<MCPPromptInput, ReadResourceResult> {
+    constructor(options: MCPResourceOptions);
+    uri: string;
+    process(input: MCPPromptInput): Promise<ReadResourceResult>;
 }

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

@@ -1,10 +1,11 @@
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
-import { StdioClientTransport, } from "@modelcontextprotocol/sdk/client/stdio.js";
-import { logger } from "../utils/logger";
-import { promptFromMCPPrompt, toolFromMCPTool } from "../utils/mcp-utils";
-import { createAccessorArray } from "../utils/type-utils";
-import { Agent } from "./agent";
+import { StdioClientTransport, getDefaultEnvironment, } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { UriTemplate } from "@modelcontextprotocol/sdk/shared/uriTemplate.js";
+import { logger } from "../utils/logger.js";
+import { promptFromMCPPrompt, resourceFromMCPResource, toolFromMCPTool, } from "../utils/mcp-utils.js";
+import { createAccessorArray } from "../utils/type-utils.js";
+import { Agent } from "./agent.js";
 const MCP_AGENT_CLIENT_NAME = "MCPAgent";
 const MCP_AGENT_CLIENT_VERSION = "0.0.1";
 const debug = logger.base.extend("mcp");
@@ -21,7 +22,14 @@ export class MCPAgent extends Agent {
             return MCPAgent.fromTransport(transport);
         }
         if (isStdioServerParameters(options)) {
-            const transport = new StdioClientTransport({ ...options, stderr: "pipe" });
+            const transport = new StdioClientTransport({
+                ...options,
+                env: {
+                    ...getDefaultEnvironment(),
+                    ...options.env,
+                },
+                stderr: "pipe",
+            });
             return MCPAgent.fromTransport(transport);
         }
         return new MCPAgent(options);
@@ -33,7 +41,7 @@ export class MCPAgent extends Agent {
         });
         await debug.spinner(client.connect(transport), "Connecting to MCP server");
         const mcpServer = getMCPServerName(client);
-        const { tools: isToolsAvailable, prompts: isPromptsAvailable } = client.getServerCapabilities() ?? {};
+        const { tools: isToolsAvailable, prompts: isPromptsAvailable, resources: isResourcesAvailable, } = client.getServerCapabilities() ?? {};
         const tools = isToolsAvailable
             ? await debug
                 .spinner(client.listTools(), `Listing tools from ${mcpServer}`, ({ tools }) => debug("%O", tools))
@@ -44,16 +52,42 @@ export class MCPAgent extends Agent {
                 .spinner(client.listPrompts(), `Listing prompts from ${mcpServer}`, ({ prompts }) => debug("%O", prompts))
                 .then(({ prompts }) => prompts.map((prompt) => promptFromMCPPrompt(client, prompt)))
             : undefined;
-        return new MCPAgent({ client, tools, prompts });
+        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([
+                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) => resourceFromMCPResource(client, resource)))
+            : undefined;
+        return new MCPAgent({
+            name: client.getServerVersion()?.name,
+            client,
+            tools,
+            prompts,
+            resources,
+        });
     }
     constructor(options) {
         super(options);
         this.client = options.client;
         if (options.prompts?.length)
             this.prompts.push(...options.prompts);
+        if (options.resources?.length)
+            this.resources.push(...options.resources);
     }
     client;
     prompts = createAccessorArray([], (arr, name) => arr.find((i) => i.name === name));
+    resources = createAccessorArray([], (arr, name) => arr.find((i) => i.name === name));
+    get isCallable() {
+        return false;
+    }
+    async process(_input, _context) {
+        throw new Error("Method not implemented.");
+    }
     async shutdown() {
         super.shutdown();
         await this.client.close();
@@ -81,6 +115,18 @@ export class MCPPrompt extends MCPBase {
         return result;
     }
 }
+export class MCPResource extends MCPBase {
+    constructor(options) {
+        super(options);
+        this.uri = options.uri;
+    }
+    uri;
+    async process(input) {
+        const uri = new 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));
+        return result;
+    }
+}
 function getMCPServerName(client) {
     const info = client.getServerVersion();
     if (!info)

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

@@ -0,0 +1,26 @@
+import type { Context } from "../execution-engine/context.js";
+import type { Message } from "./agent.js";
+export interface AgentMemoryOptions {
+    /**
+     * Enable memory, default is true
+     */
+    enabled?: boolean;
+    subscribeTopic?: string | string[];
+    maxMemoriesInChat?: number;
+}
+export interface Memory {
+    role: "user" | "agent";
+    content: Message;
+    source?: string;
+}
+export declare class AgentMemory {
+    constructor(options: AgentMemoryOptions);
+    enabled?: boolean;
+    subscribeTopic?: string | string[];
+    maxMemoriesInChat?: number;
+    memories: Memory[];
+    private subscriptions;
+    addMemory(memory: Memory): void;
+    attach(context: Context): void;
+    detach(): void;
+}

package/lib/esm/agents/memory.js

@@ -0,0 +1,34 @@
+import { orArrayToArray } from "../utils/type-utils.js";
+export class AgentMemory {
+    constructor(options) {
+        this.enabled = options.enabled ?? true;
+        this.subscribeTopic = options.subscribeTopic;
+        this.maxMemoriesInChat = options.maxMemoriesInChat;
+    }
+    enabled;
+    subscribeTopic;
+    maxMemoriesInChat;
+    memories = [];
+    subscriptions = [];
+    addMemory(memory) {
+        if (this.memories.at(-1)?.content === memory.content)
+            return;
+        // TODO: save all memories into database instead of in-memory,
+        // and give every memory a unique id to avoid duplication
+        this.memories.push(memory);
+    }
+    attach(context) {
+        for (const topic of orArrayToArray(this.subscribeTopic)) {
+            const sub = context.subscribe(topic, ({ role, message, source }) => {
+                this.addMemory({ role, source, content: message });
+            });
+            this.subscriptions.push(sub);
+        }
+    }
+    detach() {
+        for (const sub of this.subscriptions) {
+            sub();
+        }
+        this.subscriptions = [];
+    }
+}

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

@@ -1,9 +1,10 @@
-import type { Agent, AgentOutput } from "./agent";
+import type { Agent, Message } from "./agent.js";
 export declare const transferAgentOutputKey = "$transferAgentTo";
-export interface TransferAgentOutput extends Record<string, unknown> {
+export interface TransferAgentOutput extends Message {
     [transferAgentOutputKey]: {
         agent: Agent;
     };
 }
 export declare function transferToAgentOutput(agent: Agent): TransferAgentOutput;
-export declare function isTransferAgentOutput(output: AgentOutput): output is TransferAgentOutput;
+export declare function isTransferAgentOutput(output: Message): output is TransferAgentOutput;
+export declare function replaceTransferAgentToName(output: Message): Message;

package/lib/esm/agents/types.js

@@ -7,5 +7,14 @@ export function transferToAgentOutput(agent) {
     };
 }
 export function isTransferAgentOutput(output) {
-    return transferAgentOutputKey in output;
+    return !!output[transferAgentOutputKey]?.agent;
+}
+export function replaceTransferAgentToName(output) {
+    if (isTransferAgentOutput(output)) {
+        return {
+            ...output,
+            [transferAgentOutputKey]: output[transferAgentOutputKey].agent.name,
+        };
+    }
+    return output;
 }

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

@@ -0,0 +1,24 @@
+import type { Context } from "../execution-engine/context.js";
+import type { MessagePayload, MessageQueueListener, Unsubscribe } 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>;
+}
+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>);
+    private context?;
+    private get ctx();
+    private _process?;
+    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;
+    get stream(): ReadableStream<MessagePayload & {
+        topic: string;
+    }>;
+}

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

@@ -0,0 +1,58 @@
+import { orArrayToArray } from "../utils/type-utils.js";
+import { Agent } from "./agent.js";
+export class UserAgent extends Agent {
+    static from(options) {
+        return new UserAgent(options);
+    }
+    constructor(options) {
+        super({ ...options, disableLogging: true });
+        this._process = options.process;
+        this.context = options.context;
+    }
+    context;
+    get ctx() {
+        if (!this.context)
+            throw new Error("UserAgent must have a context");
+        return this.context;
+    }
+    _process;
+    async process(input, context) {
+        const ctx = context ?? this.context;
+        if (!ctx)
+            throw new Error("UserAgent must have a context");
+        if (this._process) {
+            return this._process(input, ctx);
+        }
+        const publicTopic = typeof this.publishTopic === "function" ? await this.publishTopic(input) : this.publishTopic;
+        if (publicTopic?.length) {
+            ctx.publish(publicTopic, 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);
+    }
+    get stream() {
+        let subscriptions = [];
+        return new ReadableStream({
+            start: (controller) => {
+                const subscribeTopic = orArrayToArray(this.subscribeTopic);
+                subscriptions = subscribeTopic.map((topic) => this.subscribe(topic, (message) => {
+                    controller.enqueue({ ...message, topic });
+                }));
+            },
+            cancel: () => {
+                for (const unsubscribe of subscriptions) {
+                    unsubscribe();
+                }
+            },
+        });
+    }
+}

package/lib/esm/execution-engine/context.d.ts

@@ -1,10 +1,40 @@
 import type EventEmitter from "node:events";
-import type { Agent, AgentInput, AgentOutput } from "../agents/agent";
-import type { ChatModel } from "../models/chat";
+import type { Agent, FunctionAgentFn, Message } from "../agents/agent.js";
+import type { ChatModel } from "../models/chat-model.js";
+import type { MessagePayload, MessageQueueListener, Unsubscribe } from "./message-queue.js";
+export type Runnable<I extends Message = Message, O extends Message = Message> = Agent<I, O> | FunctionAgentFn;
 export interface Context extends EventEmitter {
     model?: ChatModel;
     tools?: Agent[];
-    publish(topic: string, message: unknown): void;
-    subscribe(topic: string, listener: (message: AgentInput) => void): void;
-    unsubscribe(topic: string, listener: (message: AgentOutput) => void): void;
+    /**
+     * Call an agent with a message
+     * @param agent Agent to call
+     * @param message Message to pass to the agent
+     * @returns the output of the agent
+     */
+    call<I extends Message, O extends Message>(agent: Runnable<I, O>, message: I | string): Promise<O>;
+    /**
+     * Call an agent with a message and return the output and the active agent
+     * @param agent Agent to call
+     * @param message Message to pass to the agent
+     * @param options.returnActiveAgent return the active agent
+     * @returns the output of the agent and the final active agent
+     */
+    call<I extends Message, O extends Message>(agent: Runnable<I, O>, message: I | string, options: {
+        returnActiveAgent?: true;
+    }): Promise<[O, Runnable]>;
+    call<I extends Message, O extends Message>(agent: Runnable<I, O>, message: I | string, options?: {
+        returnActiveAgent?: boolean;
+    }): Promise<O | [O, Runnable]>;
+    /**
+     * Publish a message to a topic, the engine will call the listeners of the topic
+     * @param topic topic name, or an array of topic names
+     * @param message message to publish
+     * @param from the agent who publish the message, if not provided, it will be treated as a user message
+     */
+    publish(topic: string | string[], message: Message | string, from?: Agent): 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;
 }

package/lib/esm/execution-engine/execution-engine.d.ts

@@ -0,0 +1,64 @@
+import EventEmitter from "node:events";
+import { Agent, type Message } from "../agents/agent.js";
+import { UserAgent } from "../agents/user-agent.js";
+import type { ChatModel } from "../models/chat-model.js";
+import type { Context, Runnable } from "./context.js";
+import { type MessagePayload, MessageQueue, type MessageQueueListener, type Unsubscribe } from "./message-queue.js";
+export interface ExecutionEngineOptions {
+    model?: ChatModel;
+    tools?: Agent[];
+    agents?: Agent[];
+}
+export declare class ExecutionEngine extends EventEmitter implements Context {
+    constructor(options?: ExecutionEngineOptions);
+    readonly messageQueue: MessageQueue;
+    model?: ChatModel;
+    tools: Agent[];
+    private agents;
+    addAgent(...agents: Agent[]): void;
+    private createMessageFromInput;
+    /**
+     * Publish a message to a topic, the engine will call the listeners of the topic
+     * @param topic topic name, or an array of topic names
+     * @param message message to publish
+     * @param from the agent who publish the message, if not provided, it will be treated as a user message
+     */
+    publish(topic: string | string[], message: Message | string, from?: Agent): void;
+    /**
+     * Create a user agent to consistently call an agent
+     * @param agent Agent to call
+     * @returns User agent
+     */
+    call<I extends Message, O extends Message>(agent: Runnable<I, O>): UserAgent<I, O>;
+    /**
+     * Call an agent with a message
+     * @param agent Agent to call
+     * @param message Message to pass to the agent
+     * @returns the output of the agent
+     */
+    call<I extends Message, O extends Message>(agent: Runnable<I, O>, message: I | string): Promise<O>;
+    /**
+     * Call an agent with a message and return the output and the active agent
+     * @param agent Agent to call
+     * @param message Message to pass to the agent
+     * @param options.returnActiveAgent return the active agent
+     * @returns the output of the agent and the final active agent
+     */
+    call<I extends Message, O extends Message>(agent: Runnable<I, O>, message: I | string, options: {
+        returnActiveAgent?: true;
+    }): Promise<[O, Runnable]>;
+    /**
+     * Call an agent with a message and return the output and the active agent
+     * @param agent Agent to call
+     * @param message Message to pass to the agent
+     * @returns the output of the agent and the final active agent
+     */
+    private _call;
+    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;
+    private callAgent;
+    shutdown(): Promise<void>;
+    private initProcessExitHandler;
+}

package/lib/esm/execution-engine/execution-engine.js

@@ -0,0 +1,129 @@
+import EventEmitter from "node:events";
+import { isNil } from "lodash-es";
+import { Agent } from "../agents/agent.js";
+import { isTransferAgentOutput, transferAgentOutputKey } from "../agents/types.js";
+import { UserAgent } from "../agents/user-agent.js";
+import { createMessage } from "../prompt/prompt-builder.js";
+import { MessageQueue, } from "./message-queue.js";
+export class ExecutionEngine extends EventEmitter {
+    constructor(options) {
+        super();
+        this.model = options?.model;
+        this.tools = options?.tools ?? [];
+        if (options?.agents?.length)
+            this.addAgent(...options.agents);
+        this.initProcessExitHandler();
+    }
+    messageQueue = new MessageQueue();
+    model;
+    tools;
+    agents = [];
+    addAgent(...agents) {
+        for (const agent of agents) {
+            this.agents.push(agent);
+            agent.attach(this);
+        }
+    }
+    createMessageFromInput(message) {
+        return typeof message === "string" ? createMessage(message) : message;
+    }
+    /**
+     * Publish a message to a topic, the engine will call the listeners of the topic
+     * @param topic topic name, or an array of topic names
+     * @param message message to publish
+     * @param from the agent who publish the message, if not provided, it will be treated as a user message
+     */
+    publish(topic, message, from) {
+        const request = {
+            role: !from || from instanceof UserAgent ? "user" : "agent",
+            source: from?.name,
+            message: this.createMessageFromInput(message),
+        };
+        this.messageQueue.publish(topic, request);
+    }
+    call(agent, message, options) {
+        if (isNil(message)) {
+            let activeAgent = agent;
+            return UserAgent.from({
+                context: this,
+                process: async (input, context) => {
+                    const [output, agent] = await context.call(activeAgent, input, {
+                        returnActiveAgent: true,
+                    });
+                    activeAgent = agent;
+                    return output;
+                },
+            });
+        }
+        return this._call(agent, this.createMessageFromInput(message)).then((result) => options?.returnActiveAgent ? [result.output, result.agent] : result.output);
+    }
+    /**
+     * Call an agent with a message and return the output and the active agent
+     * @param agent Agent to call
+     * @param message Message to pass to the agent
+     * @returns the output of the agent and the final active agent
+     */
+    async _call(agent, message) {
+        const { output, agent: activeAgent } = await this.callAgent(agent, message);
+        if (activeAgent instanceof Agent) {
+            const publishTopics = typeof activeAgent.publishTopic === "function"
+                ? await activeAgent.publishTopic(output)
+                : activeAgent.publishTopic;
+            if (publishTopics?.length) {
+                this.publish(publishTopics, output, activeAgent);
+            }
+        }
+        return { output, agent: activeAgent };
+    }
+    subscribe(topic, listener) {
+        return this.messageQueue.subscribe(topic, listener);
+    }
+    unsubscribe(topic, listener) {
+        this.messageQueue.unsubscribe(topic, listener);
+    }
+    async callAgent(agent, input) {
+        let activeAgent = agent;
+        let output;
+        for (;;) {
+            let result;
+            if (typeof activeAgent === "function") {
+                result = await activeAgent(input, this);
+            }
+            else {
+                result = await activeAgent.call(input, this);
+            }
+            if (!(result instanceof Agent))
+                output = result;
+            const transferToAgent = result instanceof Agent
+                ? result
+                : isTransferAgentOutput(result)
+                    ? result[transferAgentOutputKey].agent
+                    : undefined;
+            if (transferToAgent) {
+                activeAgent = transferToAgent;
+            }
+            else {
+                break;
+            }
+        }
+        if (!output)
+            throw new Error("Unexpected empty output");
+        return {
+            agent: activeAgent,
+            output,
+        };
+    }
+    async shutdown() {
+        for (const tool of this.tools) {
+            await tool.shutdown();
+        }
+        for (const agent of this.agents) {
+            await agent.shutdown();
+        }
+    }
+    initProcessExitHandler() {
+        const shutdownAndExit = () => this.shutdown().finally(() => process.exit(0));
+        process.on("SIGINT", shutdownAndExit);
+        process.on("exit", shutdownAndExit);
+    }
+}

package/lib/esm/execution-engine/index.d.ts

@@ -1,46 +1,4 @@
-import EventEmitter from "node:events";
-import { Agent, type AgentInput, type AgentOptions, type AgentOutput } from "../agents/agent";
-import type { ChatModel } from "../models/chat";
-import type { Context } from "./context";
-export interface ExecutionEngineOptions {
-    model?: ChatModel;
-    tools?: Agent[];
-    agents?: Agent[];
-}
-export interface ExecutionEngineRunOptions {
-    concurrency?: boolean;
-}
-export declare class ExecutionEngine extends EventEmitter implements Context {
-    constructor(options?: ExecutionEngineOptions);
-    private messageQueue;
-    model?: ChatModel;
-    tools: Agent[];
-    private agents;
-    private agentListeners;
-    addAgent(...agents: Agent[]): void;
-    private attachAgentSubscriptions;
-    publish(topic: string, message: unknown): void;
-    subscribe(topic: string, listener: (message: AgentOutput) => void): void;
-    unsubscribe(topic: string, listener: (message: AgentOutput) => void): void;
-    run(agent: Agent): Promise<UserAgent>;
-    run(input: AgentInput | string): Promise<AgentOutput>;
-    run(input: AgentInput | string, ...agents: Agent[]): Promise<AgentOutput>;
-    run(input: AgentInput | string, options: ExecutionEngineRunOptions, ...agents: Agent[]): Promise<AgentOutput>;
-    private splitOptionsAndAgents;
-    private runSequential;
-    private runParallel;
-    private publishUserInputTopic;
-    private runChatLoop;
-    private callAgent;
-    shutdown(): Promise<void>;
-    private initProcessExitHandler;
-}
-export declare class UserAgent<I extends AgentInput = AgentInput, O extends AgentOutput = AgentOutput> extends Agent<I, O> {
-    options: AgentOptions<I, O> & {
-        run: (input: I) => Promise<O>;
-    };
-    constructor(options: AgentOptions<I, O> & {
-        run: (input: I) => Promise<O>;
-    });
-    process(input: I): Promise<O>;
-}
+export * from "./context.js";
+export * from "./execution-engine.js";
+export * from "./message-queue.js";
+export * from "./utils.js";