@aigne/core 1.13.0 → 1.14.0

package/lib/cjs/aigne/aigne.d.ts

@@ -1,38 +1,285 @@
-import { Agent } from "../agents/agent.js";
+import { Agent, type AgentResponse, type AgentResponseStream, type Message } from "../agents/agent.js";
+import type { UserAgent } from "../agents/user-agent.js";
 import { ChatModel } from "../models/chat-model.js";
-import { AIGNEContext, type Context } from "./context.js";
-import { MessageQueue } from "./message-queue.js";
+import { AIGNEContext, type InvokeOptions } from "./context.js";
+import { type MessagePayload, MessageQueue, type MessageQueueListener, type Unsubscribe } from "./message-queue.js";
 import type { ContextLimits } from "./usage.js";
+/**
+ * Options for the AIGNE class.
+ */
 export interface AIGNEOptions {
+    /**
+     * The name of the AIGNE instance.
+     */
     name?: string;
+    /**
+     * The description of the AIGNE instance.
+     */
     description?: string;
+    /**
+     * Global model to use for all agents not specifying a model.
+     */
     model?: ChatModel;
+    /**
+     * Skills to use for the AIGNE instance.
+     */
     skills?: Agent[];
+    /**
+     * Agents to use for the AIGNE instance.
+     */
     agents?: Agent[];
+    /**
+     * Limits for the AIGNE instance, such as timeout, max tokens, max invocations, etc.
+     */
     limits?: ContextLimits;
 }
+/**
+ * AIGNE is a class that orchestrates multiple agents to build complex AI applications.
+ * It serves as the central coordination point for agent interactions, message passing, and execution flow.
+ *
+ * @example
+ * Here's a simple example of how to use AIGNE:
+ * {@includeCode ../../test/aigne/aigne.test.ts#example-simple}
+ *
+ * @example
+ * Here's an example of how to use AIGNE with streaming response:
+ * {@includeCode ../../test/aigne/aigne.test.ts#example-streaming}
+ */
 export declare class AIGNE {
-    static load({ path, ...options }: {
-        path: string;
-    } & AIGNEOptions): Promise<AIGNE>;
+    /**
+     * Loads an AIGNE instance from a directory containing an aigne.yaml file and agent definitions.
+     * This static method provides a convenient way to initialize an AIGNE system from configuration files.
+     *
+     * @param path - Path to the directory containing the aigne.yaml file.
+     * @param options - Options to override the loaded configuration.
+     * @returns A fully initialized AIGNE instance with configured agents and skills.
+     */
+    static load(path: string, options?: AIGNEOptions): Promise<AIGNE>;
+    /**
+     * Creates a new AIGNE instance with the specified options.
+     *
+     * @param options - Configuration options for the AIGNE instance including name, description, model, and agents.
+     */
     constructor(options?: AIGNEOptions);
+    /**
+     * Optional name identifier for this AIGNE instance.
+     */
     name?: string;
+    /**
+     * Optional description of this AIGNE instance's purpose or functionality.
+     */
     description?: string;
-    readonly messageQueue: MessageQueue;
+    /**
+     * Global model to use for all agents that don't specify their own model.
+     */
     model?: ChatModel;
-    readonly skills: Agent<import("../agents/agent.js").Message, import("../agents/agent.js").Message>[] & {
-        [key: string]: Agent<import("../agents/agent.js").Message, import("../agents/agent.js").Message>;
+    /**
+     * Usage limits applied to this AIGNE instance's execution.
+     */
+    limits?: ContextLimits;
+    /**
+     * Message queue for handling inter-agent communication.
+     *
+     * @hidden
+     */
+    readonly messageQueue: MessageQueue;
+    /**
+     * Collection of skill agents available to this AIGNE instance.
+     * Provides indexed access by skill name.
+     */
+    readonly skills: 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>;
+    /**
+     * Collection of primary agents managed by this AIGNE instance.
+     * Provides indexed access by agent name.
+     */
+    readonly agents: Agent<Message, Message>[] & {
+        [key: string]: Agent<Message, Message>;
     };
-    limits?: ContextLimits;
+    /**
+     * Adds one or more agents to this AIGNE instance.
+     * Each agent is attached to this AIGNE instance, allowing it to access the AIGNE's resources.
+     *
+     * @param agents - One or more Agent instances to add to this AIGNE.
+     */
     addAgent(...agents: Agent[]): void;
+    /**
+     * Creates a new execution context for this AIGNE instance.
+     * Contexts isolate state for different flows or conversations.
+     *
+     * @returns A new AIGNEContext instance bound to this AIGNE.
+     */
     newContext(): AIGNEContext;
-    publish: Context["publish"];
-    invoke: Context["invoke"];
-    subscribe: Context["subscribe"];
-    unsubscribe: Context["unsubscribe"];
+    /**
+     * Creates a user agent for consistent interactions with a specified agent.
+     * This method allows you to create a wrapper around an agent for repeated invocations.
+     *
+     * @param agent - Target agent to be wrapped for consistent invocation
+     * @returns A user agent instance that provides a convenient interface for interacting with the target agent
+     *
+     * @example
+     * Here's an example of how to create a user agent and invoke it consistently:
+     * {@includeCode ../../test/aigne/aigne.test.ts#example-user-agent}
+     */
+    invoke<I extends Message, O extends Message>(agent: Agent<I, O>): UserAgent<I, O>;
+    /**
+     * Invokes an agent with a message and returns both the output and the active agent.
+     * This overload is useful when you need to track which agent was ultimately responsible for generating the response.
+     *
+     * @param agent - Target agent to invoke
+     * @param message - Input message to send to the agent (can be a string or a structured message object)
+     * @param options.returnActiveAgent - Must be true to return the final active agent
+     * @param options.streaming - Must be false to return a response stream
+     * @returns A promise resolving to a tuple containing the agent's response and the final active agent
+     */
+    invoke<I extends Message, O extends Message>(agent: Agent<I, O>, message: I | string, options: InvokeOptions & {
+        returnActiveAgent: true;
+        streaming?: false;
+    }): Promise<[O, Agent]>;
+    /**
+     * Invokes an agent with a message and returns both a stream of the response and the active agent.
+     * This overload is useful when you need streaming responses while also tracking which agent provided them.
+     *
+     * @param agent - Target agent to invoke
+     * @param message - Input message to send to the agent (can be a string or a structured message object)
+     * @param options.returnActiveAgent - Must be true to return the final active agent
+     * @param options.streaming - Must be true to return a response stream
+     * @returns A promise resolving to a tuple containing the agent's response stream and a promise for the final agent
+     */
+    invoke<I extends Message, O extends Message>(agent: Agent<I, O>, message: I | string, options: InvokeOptions & {
+        returnActiveAgent: true;
+        streaming: true;
+    }): Promise<[AgentResponseStream<O>, Promise<Agent>]>;
+    /**
+     * Invokes an agent with a message and returns just the output.
+     * This is the standard way to invoke an agent when you only need the response.
+     *
+     * @param agent - Target agent to invoke
+     * @param message - Input message to send to the agent (can be a string or a structured message object)
+     * @param options - Optional configuration parameters for the invocation
+     * @returns A promise resolving to the agent's complete response
+     *
+     * @example
+     * Here's a simple example of how to invoke an agent:
+     * {@includeCode ../../test/aigne/aigne.test.ts#example-simple}
+     */
+    invoke<I extends Message, O extends Message>(agent: Agent<I, O>, message: I | string, options?: InvokeOptions & {
+        returnActiveAgent?: false;
+        streaming?: false;
+    }): Promise<O>;
+    /**
+     * Invokes an agent with a message and returns a stream of the response.
+     * This allows processing the response incrementally as it's being generated.
+     *
+     * @param agent - Target agent to invoke
+     * @param message - Input message to send to the agent (can be a string or a structured message object)
+     * @param options - Configuration with streaming enabled to receive incremental response chunks
+     * @returns A promise resolving to a stream of the agent's response that can be consumed incrementally
+     *
+     * @example
+     * Here's an example of how to invoke an agent with streaming response:
+     * {@includeCode ../../test/aigne/aigne.test.ts#example-streaming}
+     */
+    invoke<I extends Message, O extends Message>(agent: Agent<I, O>, message: I | string, options: InvokeOptions & {
+        returnActiveAgent?: false;
+        streaming: true;
+    }): Promise<AgentResponseStream<O>>;
+    /**
+     * General implementation signature that handles all overload cases.
+     * This unified signature supports all the different invocation patterns defined by the overloads.
+     *
+     * @param agent - Target agent to invoke or wrap
+     * @param message - Optional input message to send to the agent
+     * @param options - Optional configuration parameters for the invocation
+     * @returns Either a UserAgent (when no message provided) or a promise resolving to the agent's response
+     * with optional active agent information based on the provided options
+     */
+    invoke<I extends Message, O extends Message>(agent: Agent<I, O>, message?: I | string, options?: InvokeOptions): UserAgent<I, O> | Promise<AgentResponse<O> | [AgentResponse<O>, Agent]>;
+    /**
+     * Publishes a message to the message queue for inter-agent communication.
+     * This method broadcasts a message to all subscribers of the specified topic(s).
+     * It creates a new context internally and delegates to the context's publish method.
+     *
+     * @param topic - The topic or array of topics to publish the message to
+     * @param payload - The message payload to be delivered to subscribers
+     *
+     * @example
+     * Here's an example of how to publish a message:
+     * {@includeCode ../../test/aigne/aigne.test.ts#example-publish-message}
+     */
+    publish(topic: string | string[], payload: Omit<MessagePayload, "context"> | Message | string): void;
+    /**
+     * Subscribes to receive the next message on a specific topic.
+     * This overload returns a Promise that resolves with the next message published to the topic.
+     * It's useful for one-time message handling or when using async/await patterns.
+     *
+     * @param topic - The topic to subscribe to
+     * @returns A Promise that resolves with the next message payload published to the specified topic
+     *
+     * @example
+     * Here's an example of how to subscribe to a topic and receive the next message:
+     * {@includeCode ../../test/aigne/aigne.test.ts#example-publish-message}
+     */
+    subscribe(topic: string | string[], listener?: undefined): Promise<MessagePayload>;
+    /**
+     * Subscribes to messages on a specific topic with a listener callback.
+     * This overload registers a listener function that will be called for each message published to the topic.
+     * It's useful for continuous message handling or event-driven architectures.
+     *
+     * @param topic - The topic to subscribe to
+     * @param listener - Callback function that will be invoked when messages arrive on the specified topic
+     * @returns An Unsubscribe function that can be called to cancel the subscription
+     *
+     * @example
+     * Here's an example of how to subscribe to a topic with a listener:
+     * {@includeCode ../../test/aigne/aigne.test.ts#example-subscribe-topic}
+     */
+    subscribe(topic: string | string[], listener: MessageQueueListener): Unsubscribe;
+    /**
+     * Generic subscribe signature that handles both Promise and listener patterns.
+     * This is the implementation signature that supports both overloaded behaviors.
+     *
+     * @param topic - The topic to subscribe to
+     * @param listener - Optional callback function
+     * @returns Either a Promise for the next message or an Unsubscribe function
+     */
+    subscribe(topic: string | string[], listener?: MessageQueueListener): Unsubscribe | Promise<MessagePayload>;
+    /**
+     * Unsubscribes a listener from a specific topic in the message queue.
+     * This method stops a previously registered listener from receiving further messages.
+     * It should be called when message processing is complete or when the component is no longer interested
+     * in messages published to the specified topic.
+     *
+     * @param topic - The topic to unsubscribe from
+     * @param listener - The listener function that was previously subscribed to the topic
+     *
+     * @example
+     * {@includeCode ../../test/aigne/aigne.test.ts#example-subscribe-topic}
+     */
+    unsubscribe(topic: string | string[], listener: MessageQueueListener): void;
+    /**
+     * Gracefully shuts down the AIGNE instance and all its agents and skills.
+     * This ensures proper cleanup of resources before termination.
+     *
+     * @returns A promise that resolves when shutdown is complete.
+     *
+     * @example
+     * Here's an example of shutdown an AIGNE instance:
+     * {@includeCode ../../test/aigne/aigne.test.ts#example-shutdown}
+     */
     shutdown(): Promise<void>;
+    /**
+     * Asynchronous dispose method for the AIGNE instance.
+     *
+     * @example
+     * Here's an example of using async dispose:
+     * {@includeCode ../../test/aigne/aigne.test.ts#example-shutdown-using}
+     */
+    [Symbol.asyncDispose](): Promise<void>;
+    /**
+     * Initializes handlers for process exit events to ensure clean shutdown.
+     * This registers handlers for SIGINT and exit events to properly terminate all agents.
+     */
     private initProcessExitHandler;
 }

package/lib/cjs/aigne/aigne.js

@@ -8,18 +8,43 @@ 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");
+/**
+ * AIGNE is a class that orchestrates multiple agents to build complex AI applications.
+ * It serves as the central coordination point for agent interactions, message passing, and execution flow.
+ *
+ * @example
+ * Here's a simple example of how to use AIGNE:
+ * {@includeCode ../../test/aigne/aigne.test.ts#example-simple}
+ *
+ * @example
+ * Here's an example of how to use AIGNE with streaming response:
+ * {@includeCode ../../test/aigne/aigne.test.ts#example-streaming}
+ */
 class AIGNE {
-    static async load({ path, ...options }) {
+    /**
+     * Loads an AIGNE instance from a directory containing an aigne.yaml file and agent definitions.
+     * This static method provides a convenient way to initialize an AIGNE system from configuration files.
+     *
+     * @param path - Path to the directory containing the aigne.yaml file.
+     * @param options - Options to override the loaded configuration.
+     * @returns A fully initialized AIGNE instance with configured agents and skills.
+     */
+    static async load(path, options) {
         const { model, agents, skills, ...aigne } = await (0, index_js_1.load)({ path });
         return new AIGNE({
             ...options,
-            model: options.model || model,
-            name: options.name || aigne.name || undefined,
-            description: options.description || aigne.description || undefined,
-            agents: agents.concat(options.agents ?? []),
-            skills: skills.concat(options.skills ?? []),
+            model: options?.model || model,
+            name: options?.name || aigne.name || undefined,
+            description: options?.description || aigne.description || undefined,
+            agents: agents.concat(options?.agents ?? []),
+            skills: skills.concat(options?.skills ?? []),
         });
     }
+    /**
+     * Creates a new AIGNE instance with the specified options.
+     *
+     * @param options - Configuration options for the AIGNE instance including name, description, model, and agents.
+     */
     constructor(options) {
         if (options)
             (0, type_utils_js_1.checkArguments)("AIGNE", aigneOptionsSchema, options);
@@ -33,13 +58,44 @@ class AIGNE {
             this.addAgent(...options.agents);
         this.initProcessExitHandler();
     }
+    /**
+     * Optional name identifier for this AIGNE instance.
+     */
     name;
+    /**
+     * Optional description of this AIGNE instance's purpose or functionality.
+     */
     description;
-    messageQueue = new message_queue_js_1.MessageQueue();
+    /**
+     * Global model to use for all agents that don't specify their own model.
+     */
     model;
+    /**
+     * Usage limits applied to this AIGNE instance's execution.
+     */
+    limits;
+    /**
+     * Message queue for handling inter-agent communication.
+     *
+     * @hidden
+     */
+    messageQueue = new message_queue_js_1.MessageQueue();
+    /**
+     * Collection of skill agents available to this AIGNE instance.
+     * Provides indexed access by skill name.
+     */
     skills = (0, type_utils_js_1.createAccessorArray)([], (arr, name) => arr.find((i) => i.name === name));
+    /**
+     * Collection of primary agents managed by this AIGNE instance.
+     * Provides indexed access by agent name.
+     */
     agents = (0, type_utils_js_1.createAccessorArray)([], (arr, name) => arr.find((i) => i.name === name));
-    limits;
+    /**
+     * Adds one or more agents to this AIGNE instance.
+     * Each agent is attached to this AIGNE instance, allowing it to access the AIGNE's resources.
+     *
+     * @param agents - One or more Agent instances to add to this AIGNE.
+     */
     addAgent(...agents) {
         (0, type_utils_js_1.checkArguments)("AIGNE.addAgent", aigneAddAgentArgsSchema, agents);
         for (const agent of agents) {
@@ -47,21 +103,61 @@ class AIGNE {
             agent.attach(this);
         }
     }
+    /**
+     * Creates a new execution context for this AIGNE instance.
+     * Contexts isolate state for different flows or conversations.
+     *
+     * @returns A new AIGNEContext instance bound to this AIGNE.
+     */
     newContext() {
         return new context_js_1.AIGNEContext(this);
     }
-    publish = ((...args) => {
-        return new context_js_1.AIGNEContext(this).publish(...args);
-    });
-    invoke = ((...args) => {
-        return new context_js_1.AIGNEContext(this).invoke(...args);
-    });
-    subscribe = ((...args) => {
-        return this.messageQueue.subscribe(...args);
-    });
-    unsubscribe = ((...args) => {
-        this.messageQueue.unsubscribe(...args);
-    });
+    invoke(agent, message, options) {
+        return new context_js_1.AIGNEContext(this).invoke(agent, message, options);
+    }
+    /**
+     * Publishes a message to the message queue for inter-agent communication.
+     * This method broadcasts a message to all subscribers of the specified topic(s).
+     * It creates a new context internally and delegates to the context's publish method.
+     *
+     * @param topic - The topic or array of topics to publish the message to
+     * @param payload - The message payload to be delivered to subscribers
+     *
+     * @example
+     * Here's an example of how to publish a message:
+     * {@includeCode ../../test/aigne/aigne.test.ts#example-publish-message}
+     */
+    publish(topic, payload) {
+        return new context_js_1.AIGNEContext(this).publish(topic, payload);
+    }
+    subscribe(topic, listener) {
+        return this.messageQueue.subscribe(topic, listener);
+    }
+    /**
+     * Unsubscribes a listener from a specific topic in the message queue.
+     * This method stops a previously registered listener from receiving further messages.
+     * It should be called when message processing is complete or when the component is no longer interested
+     * in messages published to the specified topic.
+     *
+     * @param topic - The topic to unsubscribe from
+     * @param listener - The listener function that was previously subscribed to the topic
+     *
+     * @example
+     * {@includeCode ../../test/aigne/aigne.test.ts#example-subscribe-topic}
+     */
+    unsubscribe(topic, listener) {
+        this.messageQueue.unsubscribe(topic, listener);
+    }
+    /**
+     * Gracefully shuts down the AIGNE instance and all its agents and skills.
+     * This ensures proper cleanup of resources before termination.
+     *
+     * @returns A promise that resolves when shutdown is complete.
+     *
+     * @example
+     * Here's an example of shutdown an AIGNE instance:
+     * {@includeCode ../../test/aigne/aigne.test.ts#example-shutdown}
+     */
     async shutdown() {
         for (const tool of this.skills) {
             await tool.shutdown();
@@ -70,6 +166,20 @@ class AIGNE {
             await agent.shutdown();
         }
     }
+    /**
+     * Asynchronous dispose method for the AIGNE instance.
+     *
+     * @example
+     * Here's an example of using async dispose:
+     * {@includeCode ../../test/aigne/aigne.test.ts#example-shutdown-using}
+     */
+    async [Symbol.asyncDispose]() {
+        await this.shutdown();
+    }
+    /**
+     * Initializes handlers for process exit events to ensure clean shutdown.
+     * This registers handlers for SIGINT and exit events to properly terminate all agents.
+     */
     initProcessExitHandler() {
         const shutdownAndExit = () => this.shutdown().finally(() => process.exit(0));
         process.on("SIGINT", shutdownAndExit);

package/lib/cjs/aigne/context.d.ts

@@ -6,12 +6,18 @@ 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";
+/**
+ * @hidden
+ */
 export interface AgentEvent {
     parentContextId?: string;
     contextId: string;
     timestamp: number;
     agent: Agent;
 }
+/**
+ * @hidden
+ */
 export interface ContextEventMap {
     agentStarted: [AgentEvent & {
         input: Message;
@@ -23,13 +29,22 @@ export interface ContextEventMap {
         error: Error;
     }];
 }
+/**
+ * @hidden
+ */
 export type ContextEmitEventMap = {
     [K in keyof ContextEventMap]: OmitPropertiesFromArrayFirstElement<ContextEventMap[K], "contextId" | "parentContextId" | "timestamp">;
 };
+/**
+ * @hidden
+ */
 export interface InvokeOptions extends AgentInvokeOptions {
     returnActiveAgent?: boolean;
     disableTransfer?: boolean;
 }
+/**
+ * @hidden
+ */
 export interface Context extends TypedEventEmitter<ContextEventMap, ContextEmitEventMap> {
     model?: ChatModel;
     skills?: Agent[];
@@ -76,12 +91,12 @@ export interface Context extends TypedEventEmitter<ContextEventMap, ContextEmitE
      * @param topic topic name, or an array of topic names
      * @param payload message to publish
      */
-    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;
+    publish(topic: string | string[], payload: Omit<MessagePayload, "context"> | Message | string): void;
+    subscribe(topic: string | string[], listener?: undefined): Promise<MessagePayload>;
+    subscribe(topic: string | string[], listener: MessageQueueListener): Unsubscribe;
+    subscribe(topic: string | string[], listener?: MessageQueueListener): Unsubscribe | Promise<MessagePayload>;
+    subscribe(topic: string | string[], listener?: MessageQueueListener): Unsubscribe | Promise<MessagePayload>;
+    unsubscribe(topic: string | 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).
@@ -94,7 +109,9 @@ export interface Context extends TypedEventEmitter<ContextEventMap, ContextEmitE
         reset?: boolean;
     }): Context;
 }
-export declare function createPublishMessage(message: string | Message, from?: Agent): Omit<MessagePayload, "context">;
+/**
+ * @hidden
+ */
 export declare class AIGNEContext implements Context {
     constructor(parent?: ConstructorParameters<typeof AIGNEContextInternal>[0]);
     parentId?: string;
@@ -109,7 +126,6 @@ export declare class AIGNEContext implements Context {
         reset?: boolean;
     }): AIGNEContext;
     invoke: Context["invoke"];
-    private onInvokeSuccess;
     publish: Context["publish"];
     subscribe: Context["subscribe"];
     unsubscribe: Context["unsubscribe"];

package/lib/cjs/aigne/context.js

@@ -4,7 +4,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AIGNEContext = void 0;
-exports.createPublishMessage = createPublishMessage;
 const node_events_1 = __importDefault(require("node:events"));
 const uuid_1 = require("uuid");
 const zod_1 = require("zod");
@@ -16,13 +15,9 @@ const stream_utils_js_1 = require("../utils/stream-utils.js");
 const type_utils_js_1 = require("../utils/type-utils.js");
 const message_queue_js_1 = require("./message-queue.js");
 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),
-    };
-}
+/**
+ * @hidden
+ */
 class AIGNEContext {
     constructor(parent) {
         if (parent instanceof AIGNEContext) {
@@ -73,15 +68,13 @@ class AIGNEContext {
         return Promise.resolve(newContext.internal.invoke(agent, msg, newContext, options)).then(async (response) => {
             if (!options?.streaming) {
                 const { __activeAgent__: activeAgent, ...output } = await (0, stream_utils_js_1.agentResponseStreamToObject)(response);
-                this.onInvokeSuccess(activeAgent, output, newContext);
                 if (options?.returnActiveAgent) {
                     return [output, activeAgent];
                 }
                 return output;
             }
             const activeAgentPromise = Promise.withResolvers();
-            const stream = (0, stream_utils_js_1.onAgentResponseStreamEnd)((0, stream_utils_js_1.asyncGeneratorToReadableStream)(response), async ({ __activeAgent__: activeAgent, ...output }) => {
-                this.onInvokeSuccess(activeAgent, output, newContext);
+            const stream = (0, stream_utils_js_1.onAgentResponseStreamEnd)((0, stream_utils_js_1.asyncGeneratorToReadableStream)(response), async ({ __activeAgent__: activeAgent }) => {
                 activeAgentPromise.resolve(activeAgent);
             }, {
                 processChunk(chunk) {
@@ -103,18 +96,11 @@ class AIGNEContext {
             return stream;
         });
     });
-    async onInvokeSuccess(activeAgent, output, context) {
-        if (activeAgent instanceof agent_js_1.Agent) {
-            const publishTopics = typeof activeAgent.publishTopic === "function"
-                ? await activeAgent.publishTopic(output)
-                : activeAgent.publishTopic;
-            if (publishTopics?.length) {
-                context.publish(publishTopics, createPublishMessage(output, activeAgent));
-            }
-        }
-    }
     publish = ((topic, payload) => {
-        return this.internal.messageQueue.publish(topic, { ...payload, context: this });
+        return this.internal.messageQueue.publish(topic, {
+            ...(0, message_queue_js_1.toMessagePayload)(payload),
+            context: this,
+        });
     });
     subscribe = ((...args) => {
         return this.internal.messageQueue.subscribe(...args);