@aigne/core 1.1.0-beta.6 → 1.3.0

package/lib/cjs/utils/mcp-utils.js

@@ -2,26 +2,23 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.toolFromMCPTool = toolFromMCPTool;
 exports.promptFromMCPPrompt = promptFromMCPPrompt;
-const json_schema_to_zod_1 = require("@n8n/json-schema-to-zod");
+exports.resourceFromMCPResource = resourceFromMCPResource;
+const json_schema_to_zod_1 = require("@aigne/json-schema-to-zod");
+const uriTemplate_js_1 = require("@modelcontextprotocol/sdk/shared/uriTemplate.js");
+const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
 const zod_1 = require("zod");
-const mcp_agent_1 = require("../agents/mcp-agent");
+const mcp_agent_js_1 = require("../agents/mcp-agent.js");
 function toolFromMCPTool(client, tool) {
-    return new mcp_agent_1.MCPTool({
+    return new mcp_agent_js_1.MCPTool({
         client,
         name: tool.name,
         description: tool.description,
         inputSchema: (0, json_schema_to_zod_1.jsonSchemaToZod)(tool.inputSchema),
-        outputSchema: zod_1.z
-            .object({
-            _meta: zod_1.z.record(zod_1.z.unknown()).optional(),
-            content: zod_1.z.array(zod_1.z.record(zod_1.z.unknown())),
-            isError: zod_1.z.boolean().optional(),
-        })
-            .passthrough(),
+        outputSchema: types_js_1.CallToolResultSchema,
     });
 }
 function promptFromMCPPrompt(client, prompt) {
-    return new mcp_agent_1.MCPPrompt({
+    return new mcp_agent_js_1.MCPPrompt({
         client,
         name: prompt.name,
         description: prompt.description,
@@ -31,11 +28,26 @@ function promptFromMCPPrompt(client, prompt) {
                 Object.fromEntries(prompt.arguments.map((i) => [i.name, { type: "string", description: i.description }])),
             required: prompt.arguments?.filter((i) => i.required).map((i) => i.name),
         }),
-        outputSchema: zod_1.z
-            .object({
-            description: zod_1.z.string().optional(),
-            messages: zod_1.z.array(zod_1.z.record(zod_1.z.unknown())),
-        })
-            .passthrough(),
+        outputSchema: types_js_1.GetPromptResultSchema,
     });
 }
+function resourceFromMCPResource(client, resource) {
+    const [uri, variables] = isResourceTemplate(resource)
+        ? [
+            resource.uriTemplate,
+            // TODO: use template.variableNames when it's available https://github.com/modelcontextprotocol/typescript-sdk/pull/188
+            new uriTemplate_js_1.UriTemplate(resource.uriTemplate).parts.flatMap((i) => (typeof i === "object" ? i.names : [])),
+        ]
+        : [resource.uri, []];
+    return new mcp_agent_js_1.MCPResource({
+        client,
+        name: resource.name,
+        uri,
+        description: resource.description,
+        inputSchema: zod_1.z.object(Object.fromEntries(variables.map((i) => [i, zod_1.z.string()]))),
+        outputSchema: types_js_1.ReadResourceResultSchema,
+    });
+}
+function isResourceTemplate(resource) {
+    return typeof resource.uriTemplate === "string";
+}

package/lib/cjs/utils/run-chat-loop.d.ts

@@ -1,10 +1,11 @@
-import type { AgentInput, AgentOutput } from "../agents/agent";
-import type { UserAgent } from "../execution-engine";
+import type { Message } from "../agents/agent.js";
+import type { UserAgent } from "../agents/user-agent.js";
 export interface ChatLoopOptions {
     log?: typeof console.log;
-    initialCall?: AgentInput | string;
+    initialCall?: Message | string;
     welcome?: string;
     defaultQuestion?: string;
-    onResponse?: (response: AgentOutput) => void;
+    onResponse?: (response: Message) => void;
+    inputKey?: string;
 }
 export declare function runChatLoopInTerminal(userAgent: UserAgent, { log, ...options }?: ChatLoopOptions): Promise<void>;

package/lib/cjs/utils/run-chat-loop.js

@@ -5,15 +5,28 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.runChatLoopInTerminal = runChatLoopInTerminal;
 const inquirer_1 = __importDefault(require("inquirer"));
-const logger_1 = require("./logger");
+const logger_js_1 = require("./logger.js");
 async function runChatLoopInTerminal(userAgent, { log = console.log.bind(console), ...options } = {}) {
+    let isLoopExited = false;
+    let prompt;
     if (options?.welcome)
         log(options.welcome);
     if (options?.initialCall) {
         await callAgent(userAgent, options.initialCall, { ...options, log });
     }
+    (async () => {
+        for await (const output of userAgent.stream) {
+            if (isLoopExited)
+                return;
+            if (options?.onResponse)
+                options.onResponse(output);
+            else
+                log(output);
+            prompt?.ui.close();
+        }
+    })();
     for (let i = 0;; i++) {
-        const { question } = await inquirer_1.default.prompt([
+        prompt = inquirer_1.default.prompt([
             {
                 type: "input",
                 name: "question",
@@ -21,7 +34,14 @@ async function runChatLoopInTerminal(userAgent, { log = console.log.bind(console
                 default: i === 0 ? options?.defaultQuestion : undefined,
             },
         ]);
-        if (!question.trim())
+        let question;
+        try {
+            question = (await prompt).question;
+        }
+        catch {
+            // ignore abort error from inquirer
+        }
+        if (!question?.trim())
             continue;
         const cmd = COMMANDS[question.trim()];
         if (cmd) {
@@ -34,9 +54,10 @@ async function runChatLoopInTerminal(userAgent, { log = console.log.bind(console
         }
         await callAgent(userAgent, question, { ...options, log });
     }
+    isLoopExited = true;
 }
 async function callAgent(agent, input, options) {
-    const response = await logger_1.logger.spinner(agent.call(input), "🤖");
+    const response = await logger_js_1.logger.spinner(agent.call(options.inputKey && typeof input === "string" ? { [options.inputKey]: input } : input), "🤖");
     if (options?.onResponse)
         options.onResponse(response);
     else

package/lib/cjs/utils/type-utils.d.ts

@@ -1,4 +1,7 @@
+export type PromiseOrValue<T> = T | Promise<T>;
+export type Nullish<T> = T | null | undefined;
 export declare function isNonNullable<T>(value: T): value is NonNullable<T>;
+export declare function isNotEmpty<T>(arr: T[]): arr is [T, ...T[]];
 export declare function orArrayToArray<T>(value?: T | T[]): T[];
 export declare function get(obj: unknown, path: string | string[], type?: undefined): unknown | undefined;
 export declare function get(obj: unknown, path: string | string[], type: "string"): string | undefined;

package/lib/cjs/utils/type-utils.js

@@ -1,24 +1,24 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isNonNullable = isNonNullable;
+exports.isNotEmpty = isNotEmpty;
 exports.orArrayToArray = orArrayToArray;
 exports.get = get;
 exports.createAccessorArray = createAccessorArray;
-const lodash_1 = require("lodash");
-const isNil_1 = __importDefault(require("lodash/isNil"));
+const lodash_es_1 = require("lodash-es");
 function isNonNullable(value) {
-    return !(0, isNil_1.default)(value);
+    return !(0, lodash_es_1.isNil)(value);
+}
+function isNotEmpty(arr) {
+    return arr.length > 0;
 }
 function orArrayToArray(value) {
-    if ((0, isNil_1.default)(value))
+    if ((0, lodash_es_1.isNil)(value))
         return [];
     return Array.isArray(value) ? value : [value];
 }
 function get(obj, path, type) {
-    const v = (0, lodash_1.get)(obj, path);
+    const v = (0, lodash_es_1.get)(obj, path);
     if (type === "string" && typeof v === "string")
         return v;
     if (type === "number" && typeof v === "number")

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

@@ -1,57 +1,61 @@
-import EventEmitter from "node:events";
-import { type ZodObject, type ZodType } from "zod";
-import type { Context } from "../execution-engine/context";
-import { type TransferAgentOutput } from "./types";
-export type AgentInput = Record<string, unknown>;
-export type AgentOutput = Record<string, unknown> & Partial<TransferAgentOutput>;
+import { type ZodType } from "zod";
+import type { Context } from "../execution-engine/context.js";
+import { type Nullish, type PromiseOrValue } from "../utils/type-utils.js";
+import { AgentMemory, type AgentMemoryOptions } from "./memory.js";
+import { type TransferAgentOutput } from "./types.js";
+export type Message = Record<string, unknown>;
 export type SubscribeTopic = string | string[];
-export type PublishTopic<O extends AgentOutput = AgentOutput> = string | string[] | ((output: O) => string | string[] | Promise<string | string[]>);
-export interface AgentOptions<I extends AgentInput = AgentInput, O extends AgentOutput = AgentOutput> {
+export type PublishTopic<O extends Message> = string | string[] | ((output: O) => PromiseOrValue<Nullish<string | string[]>>);
+export interface AgentOptions<I extends Message = Message, O extends Message = Message> {
     subscribeTopic?: SubscribeTopic;
     publishTopic?: PublishTopic<O>;
     name?: string;
     description?: string;
-    inputSchema?: ZodObject<{
-        [key in keyof I]: ZodType;
-    }>;
-    outputSchema?: ZodObject<{
-        [key in keyof O]: ZodType;
-    }>;
+    inputSchema?: ZodType<I>;
+    outputSchema?: ZodType<O>;
     includeInputInOutput?: boolean;
     tools?: (Agent | FunctionAgentFn)[];
     disableLogging?: boolean;
+    memory?: AgentMemory | AgentMemoryOptions | true;
 }
-export declare class Agent<I extends AgentInput = AgentInput, O extends AgentOutput = AgentOutput> extends EventEmitter {
-    static from<I extends AgentInput = AgentInput, O extends AgentOutput = AgentOutput>(options: AgentOptions<I, O>): Agent<I, O>;
-    constructor(options: AgentOptions<I, O>);
+export declare abstract class Agent<I extends Message = Message, O extends Message = Message> {
+    constructor({ inputSchema, outputSchema, ...options }: AgentOptions<I, O>);
+    readonly memory?: AgentMemory;
     readonly name: string;
+    /**
+     * Default topic this agent will subscribe to
+     */
+    get topic(): string;
     readonly description?: string;
-    readonly inputSchema: ZodObject<{
-        [key in keyof I]: ZodType;
-    }>;
-    readonly outputSchema: ZodObject<{
-        [key in keyof O]: ZodType;
-    }>;
+    readonly inputSchema: ZodType<I>;
+    readonly outputSchema: ZodType<O>;
     readonly includeInputInOutput?: boolean;
     readonly subscribeTopic?: SubscribeTopic;
-    readonly publishTopic?: PublishTopic<AgentOutput>;
-    readonly tools: Agent<AgentInput, AgentOutput>[] & {
-        [key: string]: Agent<AgentInput, AgentOutput>;
+    readonly publishTopic?: PublishTopic<Message>;
+    readonly tools: Agent<Message, Message>[] & {
+        [key: string]: Agent<Message, Message>;
     };
     private disableLogging?;
-    addTool<I extends AgentInput, O extends AgentOutput>(tool: Agent<I, O> | FunctionAgentFn<I, O>): void;
+    /**
+     * Attach agent to context:
+     * - subscribe to topic and call process method when message received
+     * - subscribe to memory topic if memory is enabled
+     * @param context Context to attach
+     */
+    attach(context: Context): void;
+    addTool<I extends Message, O extends Message>(tool: Agent<I, O> | FunctionAgentFn<I, O>): void;
     get isCallable(): boolean;
     call(input: I | string, context?: Context): Promise<O>;
-    process?(input: I, context?: Context): Promise<O>;
+    abstract process(input: I, context?: Context): Promise<O | TransferAgentOutput>;
     shutdown(): Promise<void>;
 }
-export interface FunctionAgentOptions<I extends AgentInput = AgentInput, O extends AgentOutput = AgentOutput> extends AgentOptions<I, O> {
+export interface FunctionAgentOptions<I extends Message = Message, O extends Message = Message> extends AgentOptions<I, O> {
     fn?: FunctionAgentFn<I, O>;
 }
-export declare class FunctionAgent<I extends AgentInput = AgentInput, O extends AgentOutput = AgentOutput> extends Agent<I, O> {
-    static from<I extends AgentInput, O extends AgentOutput>(options: FunctionAgentOptions<I, O> | FunctionAgentFn<I, O>): FunctionAgent<I, O>;
+export declare class FunctionAgent<I extends Message = Message, O extends Message = Message> extends Agent<I, O> {
+    static from<I extends Message, O extends Message>(options: FunctionAgentOptions<I, O> | FunctionAgentFn<I, O>): FunctionAgent<I, O>;
     constructor(options: FunctionAgentOptions<I, O>);
     fn: FunctionAgentFn<I, O>;
-    process(input: I, context?: Context): Promise<O>;
+    process(input: I, context?: Context): Promise<TransferAgentOutput | O>;
 }
-export type FunctionAgentFn<I extends AgentInput = AgentInput, O extends AgentOutput = AgentOutput> = (input: I, context?: Context) => O | Promise<O> | Agent | Promise<Agent>;
+export type FunctionAgentFn<I extends Message = Message, O extends Message = Message> = (input: I, context?: Context) => O | Promise<O> | Agent | Promise<Agent>;

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

@@ -1,24 +1,20 @@
-import type { Context } from "../execution-engine/context";
-import type { ChatModel } from "../models/chat";
-import { PromptBuilder } from "../prompt/prompt-builder";
-import { Agent, type AgentInput, type AgentOptions, type AgentOutput } from "./agent";
-export interface AIAgentOptions<I extends AgentInput = AgentInput, O extends AgentOutput = AgentOutput> extends AgentOptions<I, O> {
+import type { Context } from "../execution-engine/context.js";
+import type { ChatModel } from "../models/chat-model.js";
+import { PromptBuilder } from "../prompt/prompt-builder.js";
+import { Agent, type AgentOptions, type Message } from "./agent.js";
+export interface AIAgentOptions<I extends Message = Message, O extends Message = Message> extends AgentOptions<I, O> {
     model?: ChatModel;
     instructions?: string | PromptBuilder;
     outputKey?: string;
     toolChoice?: AIAgentToolChoice;
-    enableHistory?: boolean;
-    maxHistoryMessages?: number;
 }
 export type AIAgentToolChoice = "auto" | "none" | "required" | "router" | Agent;
-export declare class AIAgent<I extends AgentInput = AgentInput, O extends AgentOutput = AgentOutput> extends Agent<I, O> {
-    static from<I extends AgentInput, O extends AgentOutput>(options: AIAgentOptions<I, O>): AIAgent<I, O>;
+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>;
     constructor(options: AIAgentOptions<I, O>);
     model?: ChatModel;
     instructions: PromptBuilder;
     outputKey?: string;
     toolChoice?: AIAgentToolChoice;
-    enableHistory?: boolean;
-    maxHistoryMessages: number;
-    process(input: I, context?: Context): Promise<O>;
+    process(input: I, context?: Context): Promise<import("./types.js").TransferAgentOutput | O>;
 }

package/lib/dts/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/dts/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/dts/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/dts/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/dts/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/dts/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/dts/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";

package/lib/dts/execution-engine/message-queue.d.ts

@@ -1,5 +1,20 @@
-import { EventEmitter } from "node:events";
+import type { Message } from "../agents/agent.js";
 export declare const UserInputTopic = "UserInputTopic";
 export declare const UserOutputTopic = "UserOutputTopic";
-export declare class MessageQueue extends EventEmitter {
+export interface MessagePayload {
+    role: "user" | "agent";
+    source?: string;
+    message: Message;
+}
+export type MessageQueueListener = (message: MessagePayload) => void;
+export type MessageRequest = MessagePayload;
+export type Unsubscribe = () => void;
+export declare class MessageQueue {
+    private events;
+    publish(topic: string | string[], message: MessageRequest): void;
+    error(error: Error): 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/dts/execution-engine/utils.d.ts

@@ -0,0 +1,4 @@
+import type { FunctionAgentFn } from "../agents/agent.js";
+import type { Runnable } from "./context.js";
+export declare function sequential(..._agents: [Runnable, ...Runnable[]]): FunctionAgentFn;
+export declare function parallel(..._agents: [Runnable, ...Runnable[]]): FunctionAgentFn;