@aigne/core 1.6.0 → 1.7.0

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

@@ -2,19 +2,36 @@ import EventEmitter from "node:events";
 import { Agent, type FunctionAgentFn, type Message } from "../agents/agent.js";
 import { UserAgent } from "../agents/user-agent.js";
 import type { ChatModel } from "../models/chat-model.js";
+import { type OmitPropertiesFromArrayFirstElement } from "../utils/type-utils.js";
+import type { Args, Listener, TypedEventEmitter } from "../utils/typed-event-emtter.js";
 import { type MessagePayload, MessageQueue, type MessageQueueListener, type Unsubscribe } from "./message-queue.js";
+import { type ContextLimits, type ContextUsage } from "./usage.js";
 export type Runnable<I extends Message = Message, O extends Message = Message> = Agent<I, O> | FunctionAgentFn;
-export interface ContextUsage {
-    promptTokens: number;
-    completionTokens: number;
-    agentCalls: number;
+export interface AgentEvent {
+    parentContextId?: string;
+    contextId: string;
+    timestamp: number;
+    agent: Agent;
 }
-export interface ContextLimits {
-    maxTokens?: number;
-    maxAgentCalls?: number;
-    timeout?: number;
+export interface ContextEventMap {
+    agentStarted: [AgentEvent & {
+        input: Message;
+    }];
+    agentSucceed: [AgentEvent & {
+        output: Message;
+    }];
+    agentFailed: [AgentEvent & {
+        error: Error;
+    }];
 }
-export interface Context extends EventEmitter {
+export type ContextEmitEventMap = {
+    [K in keyof ContextEventMap]: OmitPropertiesFromArrayFirstElement<ContextEventMap[K], "contextId" | "parentContextId" | "timestamp">;
+};
+export interface CallOptions {
+    returnActiveAgent?: boolean;
+    disableTransfer?: boolean;
+}
+export interface Context extends TypedEventEmitter<ContextEventMap, ContextEmitEventMap> {
     model?: ChatModel;
     tools?: Agent[];
     usage: ContextUsage;
@@ -26,13 +43,6 @@ export interface Context extends EventEmitter {
      * @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
@@ -40,54 +50,82 @@ export interface Context extends EventEmitter {
      * @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: {
+    call<I extends Message, O extends Message>(agent: Runnable<I, O>, message: I | string, options: CallOptions & {
         returnActiveAgent: true;
     }): Promise<[O, Runnable]>;
-    call<I extends Message, O extends Message>(agent: Runnable<I, O>, message: I | string, options?: {
-        returnActiveAgent?: boolean;
-    }): UserAgent<I, O> | Promise<O | [O, Runnable]>;
+    /**
+     * 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, options?: CallOptions): Promise<O>;
+    call<I extends Message, O extends Message>(agent: Runnable<I, O>, message?: I | string, options?: CallOptions): UserAgent<I, O> | 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
+     * @param payload message to publish
      */
-    publish(topic: string | string[], message: Message | string, from?: Agent): void;
+    publish(topic: string | string[], payload: Omit<MessagePayload, "context">): void;
     subscribe(topic: string, listener?: undefined): Promise<MessagePayload>;
     subscribe(topic: string, listener: MessageQueueListener): Unsubscribe;
     subscribe(topic: string, listener?: MessageQueueListener): Unsubscribe | Promise<MessagePayload>;
+    subscribe(topic: string, listener?: MessageQueueListener): Unsubscribe | Promise<MessagePayload>;
     unsubscribe(topic: string, listener: MessageQueueListener): void;
+    /**
+     * Create a child context with the same configuration as the parent context.
+     * If `reset` is true, the child context will have a new state (such as: usage).
+     *
+     * @param options
+     * @param options.reset create a new context with initial state (such as: usage)
+     * @returns new context
+     */
+    newContext(options?: {
+        reset?: boolean;
+    }): Context;
+}
+export declare function createPublishMessage(message: string | Message, from?: Agent): Omit<MessagePayload, "context">;
+export declare class ExecutionContext implements Context {
+    constructor(parent?: ConstructorParameters<typeof ExecutionContextInternal>[0]);
+    parentId?: string;
+    id: string;
+    readonly internal: ExecutionContextInternal;
+    get model(): ChatModel | undefined;
+    get tools(): Agent<Message, Message>[] | undefined;
+    get limits(): ContextLimits | undefined;
+    get status(): "normal" | "timeout";
+    get usage(): ContextUsage;
+    newContext({ reset }?: {
+        reset?: boolean;
+    }): ExecutionContext;
+    call: Context["call"];
+    publish: Context["publish"];
+    subscribe: Context["subscribe"];
+    unsubscribe: Context["unsubscribe"];
+    emit<K extends keyof ContextEmitEventMap>(eventName: K, ...args: Args<K, ContextEmitEventMap>): boolean;
+    on<K extends keyof ContextEventMap>(eventName: K, listener: Listener<K, ContextEventMap>): this;
+    once<K extends keyof ContextEventMap>(eventName: K, listener: Listener<K, ContextEventMap>): this;
+    off<K extends keyof ContextEventMap>(eventName: K, listener: Listener<K, ContextEventMap>): this;
 }
-export declare class ExecutionContext extends EventEmitter implements Context {
-    private readonly engine?;
-    constructor(engine?: {
-        model?: ChatModel;
-        tools?: Agent[];
-        limits?: ContextLimits;
+declare class ExecutionContextInternal {
+    private readonly parent?;
+    constructor(parent?: (Pick<Context, "model" | "tools" | "limits"> & {
         messageQueue?: MessageQueue;
-        emit?: EventEmitter["emit"];
-    } | undefined);
-    private messageQueue;
+    }) | undefined);
+    readonly messageQueue: MessageQueue;
+    readonly events: EventEmitter<ContextEventMap>;
     get model(): ChatModel | undefined;
     get tools(): Agent<Message, Message>[] | undefined;
+    get limits(): ContextLimits | undefined;
     usage: ContextUsage;
-    limits?: ContextLimits | undefined;
     private abortController;
     private timer?;
     private initTimeout;
     get status(): "normal" | "timeout";
-    call<I extends Message, O extends Message>(agent: Runnable<I, O>): UserAgent<I, O>;
-    call<I extends Message, O extends Message>(agent: Runnable<I, O>, message: I | string): Promise<O>;
-    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;
-    }): UserAgent<I, O> | Promise<O | [O, Runnable]>;
-    publish(topic: string | string[], message: Message | string, from?: Agent): void;
-    subscribe(topic: string, listener?: undefined): Promise<MessagePayload>;
-    subscribe(topic: string, listener: MessageQueueListener): Unsubscribe;
-    unsubscribe(topic: string, listener: MessageQueueListener): void;
-    emit(eventName: string | symbol, ...args: unknown[]): boolean;
+    call<I extends Message, O extends Message>(agent: Runnable<I, O>, input: I, context: Context, options?: CallOptions): Promise<{
+        agent: Runnable;
+        output: O;
+    }>;
     private callAgent;
 }
+export {};

package/lib/cjs/execution-engine/context.js

@@ -4,7 +4,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ExecutionContext = void 0;
+exports.createPublishMessage = createPublishMessage;
 const node_events_1 = __importDefault(require("node:events"));
+const uuid_1 = require("uuid");
 const zod_1 = require("zod");
 const agent_js_1 = require("../agents/agent.js");
 const types_js_1 = require("../agents/types.js");
@@ -12,129 +14,174 @@ const user_agent_js_1 = require("../agents/user-agent.js");
 const prompt_builder_js_1 = require("../prompt/prompt-builder.js");
 const type_utils_js_1 = require("../utils/type-utils.js");
 const message_queue_js_1 = require("./message-queue.js");
-class ExecutionContext extends node_events_1.default {
-    engine;
-    constructor(engine) {
-        super();
-        this.engine = engine;
-        this.limits = engine?.limits;
-        this.messageQueue = engine?.messageQueue ?? new message_queue_js_1.MessageQueue();
+const usage_js_1 = require("./usage.js");
+function createPublishMessage(message, from) {
+    return {
+        role: !from || from instanceof user_agent_js_1.UserAgent ? "user" : "agent",
+        source: from?.name,
+        message: (0, prompt_builder_js_1.createMessage)(message),
+    };
+}
+class ExecutionContext {
+    constructor(parent) {
+        if (parent instanceof ExecutionContext) {
+            this.parentId = parent.id;
+            this.internal = parent.internal;
+        }
+        else {
+            this.internal = new ExecutionContextInternal(parent);
+        }
     }
-    messageQueue;
+    parentId;
+    id = (0, uuid_1.v7)();
+    internal;
     get model() {
-        return this.engine?.model;
+        return this.internal.model;
     }
     get tools() {
-        return this.engine?.tools;
+        return this.internal.tools;
     }
-    usage = {
-        promptTokens: 0,
-        completionTokens: 0,
-        agentCalls: 0,
-    };
-    limits;
-    abortController = new AbortController();
-    timer;
-    initTimeout() {
-        if (this.timer)
-            return;
-        const timeout = this.limits?.timeout;
-        if (timeout) {
-            this.timer = setTimeout(() => {
-                this.abortController.abort();
-            }, timeout);
-        }
+    get limits() {
+        return this.internal.limits;
     }
     get status() {
-        return this.abortController.signal.aborted ? "timeout" : "normal";
+        return this.internal.status;
+    }
+    get usage() {
+        return this.internal.usage;
     }
-    call(agent, message, options) {
-        (0, type_utils_js_1.checkArguments)("ExecutionEngine._call", executionEngineCallArgsSchema, {
+    newContext({ reset } = {}) {
+        if (reset)
+            return new ExecutionContext(this.internal);
+        return new ExecutionContext(this);
+    }
+    call = ((agent, message, options) => {
+        (0, type_utils_js_1.checkArguments)("ExecutionContext.call", executionContextCallArgsSchema, {
             agent,
             message,
             options,
         });
         if ((0, type_utils_js_1.isNil)(message)) {
-            let activeAgent = agent;
             return user_agent_js_1.UserAgent.from({
                 context: this,
-                process: async (input, context) => {
-                    const [output, agent] = await context.call(activeAgent, input, {
-                        returnActiveAgent: true,
-                    });
-                    activeAgent = agent;
-                    return output;
-                },
+                activeAgent: agent,
             });
         }
-        return withAbortSignal(this.abortController.signal, new Error("ExecutionEngine is timeout"), async () => {
-            this.initTimeout();
-            const msg = createMessageFromInput(message);
-            return this.callAgent(agent, msg).then(async ({ output, agent: activeAgent }) => {
-                if (activeAgent instanceof agent_js_1.Agent) {
-                    const publishTopics = typeof activeAgent.publishTopic === "function"
-                        ? await activeAgent.publishTopic(output)
-                        : activeAgent.publishTopic;
-                    if (publishTopics?.length) {
-                        this.publish(publishTopics, output, activeAgent);
-                    }
-                }
-                if (options?.returnActiveAgent) {
-                    return [output, activeAgent];
+        const newContext = this.newContext();
+        const msg = (0, prompt_builder_js_1.createMessage)(message);
+        return newContext.internal
+            .call(agent, msg, newContext, options)
+            .then(async ({ output, agent: activeAgent }) => {
+            if (activeAgent instanceof agent_js_1.Agent) {
+                const publishTopics = typeof activeAgent.publishTopic === "function"
+                    ? await activeAgent.publishTopic(output)
+                    : activeAgent.publishTopic;
+                if (publishTopics?.length) {
+                    newContext.publish(publishTopics, createPublishMessage(output, activeAgent));
                 }
-                return output;
-            });
-        });
-    }
-    publish(topic, message, from) {
-        (0, type_utils_js_1.checkArguments)("ExecutionEngineContext.publish", executionEnginePublishArgsSchema, {
-            topic,
-            message,
-            from,
+            }
+            if (options?.returnActiveAgent) {
+                return [output, activeAgent];
+            }
+            return output;
         });
-        const request = {
-            role: !from || from instanceof user_agent_js_1.UserAgent ? "user" : "agent",
-            source: from?.name,
-            message: createMessageFromInput(message),
-            context: this,
+    });
+    publish = ((topic, payload) => {
+        return this.internal.messageQueue.publish(topic, { ...payload, context: this });
+    });
+    subscribe = ((...args) => {
+        return this.internal.messageQueue.subscribe(...args);
+    });
+    unsubscribe = ((...args) => {
+        return this.internal.messageQueue.unsubscribe(...args);
+    });
+    emit(eventName, ...args) {
+        const b = {
+            ...args[0],
+            contextId: this.id,
+            parentContextId: this.parentId,
+            timestamp: Date.now(),
         };
-        this.messageQueue.publish(topic, request);
+        const newArgs = [b, ...args.slice(1)];
+        return this.internal.events.emit(eventName, ...newArgs);
     }
-    subscribe(topic, listener) {
-        return this.messageQueue.subscribe(topic, listener);
+    on(eventName, listener) {
+        this.internal.events.on(eventName, listener);
+        return this;
     }
-    unsubscribe(topic, listener) {
-        this.messageQueue.unsubscribe(topic, listener);
+    once(eventName, listener) {
+        this.internal.events.once(eventName, listener);
+        return this;
     }
-    emit(eventName, ...args) {
-        if (this.engine?.emit)
-            return this.engine.emit(eventName, ...args);
-        return super.emit(eventName, ...args);
+    off(eventName, listener) {
+        this.internal.events.off(eventName, listener);
+        return this;
     }
-    async callAgent(agent, input) {
+}
+exports.ExecutionContext = ExecutionContext;
+class ExecutionContextInternal {
+    parent;
+    constructor(parent) {
+        this.parent = parent;
+        this.messageQueue = this.parent?.messageQueue ?? new message_queue_js_1.MessageQueue();
+    }
+    messageQueue;
+    events = new node_events_1.default();
+    get model() {
+        return this.parent?.model;
+    }
+    get tools() {
+        return this.parent?.tools;
+    }
+    get limits() {
+        return this.parent?.limits;
+    }
+    usage = (0, usage_js_1.newEmptyContextUsage)();
+    abortController = new AbortController();
+    timer;
+    initTimeout() {
+        if (this.timer)
+            return;
+        const timeout = this.limits?.timeout;
+        if (timeout) {
+            this.timer = setTimeout(() => {
+                this.abortController.abort();
+            }, timeout);
+        }
+    }
+    get status() {
+        return this.abortController.signal.aborted ? "timeout" : "normal";
+    }
+    async call(agent, input, context, options) {
+        this.initTimeout();
+        return withAbortSignal(this.abortController.signal, new Error("ExecutionContext is timeout"), () => this.callAgent(agent, input, context, options));
+    }
+    async callAgent(agent, input, context, options) {
         let activeAgent = agent;
         let output;
         for (;;) {
             let result;
             if (typeof activeAgent === "function") {
-                result = await activeAgent(input, this);
+                result = await activeAgent(input, context);
             }
             else {
-                result = await activeAgent.call(input, this);
+                result = await activeAgent.call(input, context);
+            }
+            if (result instanceof agent_js_1.Agent) {
+                activeAgent = result;
+                continue;
             }
-            if (!(result instanceof agent_js_1.Agent))
-                output = result;
-            const transferToAgent = result instanceof agent_js_1.Agent
-                ? result
-                : (0, types_js_1.isTransferAgentOutput)(result)
+            if (!options?.disableTransfer) {
+                const transferToAgent = (0, types_js_1.isTransferAgentOutput)(result)
                     ? result[types_js_1.transferAgentOutputKey].agent
                     : undefined;
-            if (transferToAgent) {
-                activeAgent = transferToAgent;
-            }
-            else {
-                break;
+                if (transferToAgent) {
+                    activeAgent = transferToAgent;
+                    continue;
+                }
             }
+            output = result;
+            break;
         }
         if (!output)
             throw new Error("Unexpected empty output");
@@ -144,7 +191,6 @@ class ExecutionContext extends node_events_1.default {
         };
     }
 }
-exports.ExecutionContext = ExecutionContext;
 function withAbortSignal(signal, error, fn) {
     return new Promise((resolve, reject) => {
         const listener = () => reject(error);
@@ -156,15 +202,7 @@ function withAbortSignal(signal, error, fn) {
         });
     });
 }
-function createMessageFromInput(message) {
-    return typeof message === "string" ? (0, prompt_builder_js_1.createMessage)(message) : message;
-}
-const executionEnginePublishArgsSchema = zod_1.z.object({
-    topic: zod_1.z.union([zod_1.z.string(), zod_1.z.array(zod_1.z.string())]),
-    message: zod_1.z.union([zod_1.z.string(), zod_1.z.record(zod_1.z.unknown())]),
-    from: zod_1.z.instanceof(agent_js_1.Agent).optional(),
-});
-const executionEngineCallArgsSchema = zod_1.z.object({
+const executionContextCallArgsSchema = zod_1.z.object({
     agent: zod_1.z.union([zod_1.z.function(), zod_1.z.instanceof(agent_js_1.Agent)]),
     message: zod_1.z.union([zod_1.z.record(zod_1.z.unknown()), zod_1.z.string()]).optional(),
     options: zod_1.z.object({ returnActiveAgent: zod_1.z.boolean().optional() }).optional(),

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

@@ -1,9 +1,8 @@
-import EventEmitter from "node:events";
-import { Agent, type Message } from "../agents/agent.js";
-import type { UserAgent } from "../agents/user-agent.js";
+import { Agent } from "../agents/agent.js";
 import { ChatModel } from "../models/chat-model.js";
-import { type ContextLimits, ExecutionContext, type Runnable } from "./context.js";
-import { type MessagePayload, MessageQueue, type MessageQueueListener, type Unsubscribe } from "./message-queue.js";
+import { type Context, ExecutionContext } from "./context.js";
+import { MessageQueue } from "./message-queue.js";
+import type { ContextLimits } from "./usage.js";
 export interface ExecutionEngineOptions {
     name?: string;
     description?: string;
@@ -12,7 +11,10 @@ export interface ExecutionEngineOptions {
     agents?: Agent[];
     limits?: ContextLimits;
 }
-export declare class ExecutionEngine extends EventEmitter {
+export interface ExecutionEngineRunOptions {
+    returnActiveAgent?: boolean;
+}
+export declare class ExecutionEngine {
     static load({ path, ...options }: {
         path: string;
     } & ExecutionEngineOptions): Promise<ExecutionEngine>;
@@ -21,52 +23,19 @@ export declare class ExecutionEngine extends EventEmitter {
     description?: string;
     readonly messageQueue: MessageQueue;
     model?: ChatModel;
-    readonly tools: Agent<Message, Message>[] & {
-        [key: string]: Agent<Message, Message>;
+    readonly tools: Agent<import("../agents/agent.js").Message, import("../agents/agent.js").Message>[] & {
+        [key: string]: Agent<import("../agents/agent.js").Message, import("../agents/agent.js").Message>;
     };
-    readonly agents: Agent<Message, Message>[] & {
-        [key: string]: Agent<Message, Message>;
+    readonly agents: Agent<import("../agents/agent.js").Message, import("../agents/agent.js").Message>[] & {
+        [key: string]: Agent<import("../agents/agent.js").Message, import("../agents/agent.js").Message>;
     };
     limits?: ContextLimits;
     addAgent(...agents: Agent[]): void;
     newContext(): ExecutionContext;
-    /**
-     * 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<I extends Message, O extends Message>(agent: Runnable<I, O>, message?: I | string, options?: {
-        returnActiveAgent?: boolean;
-    }): UserAgent<I, O> | Promise<O | [O, Runnable]>;
-    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"];
+    call: Context["call"];
+    subscribe: Context["subscribe"];
+    unsubscribe: Context["unsubscribe"];
     shutdown(): Promise<void>;
     private initProcessExitHandler;
 }

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

@@ -1,10 +1,6 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ExecutionEngine = void 0;
-const node_events_1 = __importDefault(require("node:events"));
 const zod_1 = require("zod");
 const agent_js_1 = require("../agents/agent.js");
 const index_js_1 = require("../loader/index.js");
@@ -12,7 +8,7 @@ const chat_model_js_1 = require("../models/chat-model.js");
 const type_utils_js_1 = require("../utils/type-utils.js");
 const context_js_1 = require("./context.js");
 const message_queue_js_1 = require("./message-queue.js");
-class ExecutionEngine extends node_events_1.default {
+class ExecutionEngine {
     static async load({ path, ...options }) {
         const { model, agents, tools, ...aigne } = await (0, index_js_1.load)({ path });
         return new ExecutionEngine({
@@ -27,7 +23,6 @@ class ExecutionEngine extends node_events_1.default {
     constructor(options) {
         if (options)
             (0, type_utils_js_1.checkArguments)("ExecutionEngine", executionEngineOptionsSchema, options);
-        super();
         this.name = options?.name;
         this.description = options?.description;
         this.model = options?.model;
@@ -55,32 +50,18 @@ class ExecutionEngine extends node_events_1.default {
     newContext() {
         return new context_js_1.ExecutionContext(this);
     }
-    /**
-     * 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) {
-        return new context_js_1.ExecutionContext(this).publish(topic, message, from);
-    }
-    call(agent, message, options) {
-        return new context_js_1.ExecutionContext(this).call(agent, message, options);
-    }
-    subscribe(topic, listener) {
-        (0, type_utils_js_1.checkArguments)("ExecutionEngine.subscribe", executionEngineSubscribeArgsSchema, {
-            topic,
-            listener,
-        });
-        return this.messageQueue.subscribe(topic, listener);
-    }
-    unsubscribe(topic, listener) {
-        (0, type_utils_js_1.checkArguments)("ExecutionEngine.unsubscribe", executionEngineUnsubscribeArgsSchema, {
-            topic,
-            listener,
-        });
-        this.messageQueue.unsubscribe(topic, listener);
-    }
+    publish = ((...args) => {
+        return new context_js_1.ExecutionContext(this).publish(...args);
+    });
+    call = ((...args) => {
+        return new context_js_1.ExecutionContext(this).call(...args);
+    });
+    subscribe = ((...args) => {
+        return this.messageQueue.subscribe(...args);
+    });
+    unsubscribe = ((...args) => {
+        this.messageQueue.unsubscribe(...args);
+    });
     async shutdown() {
         for (const tool of this.tools) {
             await tool.shutdown();
@@ -102,11 +83,3 @@ const executionEngineOptionsSchema = zod_1.z.object({
     agents: zod_1.z.array(zod_1.z.instanceof(agent_js_1.Agent)).optional(),
 });
 const executionEngineAddAgentArgsSchema = zod_1.z.array(zod_1.z.instanceof(agent_js_1.Agent));
-const executionEngineSubscribeArgsSchema = zod_1.z.object({
-    topic: zod_1.z.string(),
-    listener: zod_1.z.function(zod_1.z.tuple([zod_1.z.any()]), zod_1.z.any()).optional(),
-});
-const executionEngineUnsubscribeArgsSchema = zod_1.z.object({
-    topic: zod_1.z.string(),
-    listener: zod_1.z.function(zod_1.z.tuple([zod_1.z.any()]), zod_1.z.any()),
-});

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

@@ -1,3 +1,4 @@
+import { EventEmitter } from "node:events";
 import type { Message } from "../agents/agent.js";
 import type { Context } from "./context.js";
 export declare const UserInputTopic = "UserInputTopic";
@@ -9,11 +10,10 @@ export interface MessagePayload {
     context: Context;
 }
 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;
+    events: EventEmitter<[never]>;
+    publish(topic: string | string[], payload: MessagePayload): void;
     error(error: Error): void;
     subscribe(topic: string, listener?: undefined): Promise<MessagePayload>;
     subscribe(topic: string, listener: MessageQueueListener): Unsubscribe;