@aigne/core 1.18.6 → 1.20.1

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

@@ -15,6 +15,7 @@ exports.readableStreamToArray = readableStreamToArray;
 exports.stringToAgentResponseStream = stringToAgentResponseStream;
 exports.toReadableStream = toReadableStream;
 exports.readAllString = readAllString;
+exports.mergeReadableStreams = mergeReadableStreams;
 const fast_deep_equal_1 = __importDefault(require("fast-deep-equal"));
 const agent_js_1 = require("../agents/agent.js");
 const type_utils_js_1 = require("./type-utils.js");
@@ -28,16 +29,18 @@ function objectToAgentResponseStream(json) {
     });
 }
 function mergeAgentResponseChunk(output, chunk) {
-    if (chunk.delta.text) {
-        for (const [key, text] of Object.entries(chunk.delta.text)) {
-            const original = output[key];
-            const t = (original || "") + (text || "");
-            if (t)
-                Object.assign(output, { [key]: t });
+    if ((0, agent_js_1.isAgentResponseDelta)(chunk)) {
+        if (chunk.delta.text) {
+            for (const [key, text] of Object.entries(chunk.delta.text)) {
+                const original = output[key];
+                const t = (original || "") + (text || "");
+                if (t)
+                    Object.assign(output, { [key]: t });
+            }
+        }
+        if (chunk.delta.json) {
+            Object.assign(output, (0, type_utils_js_1.omitBy)(chunk.delta.json, (v) => v === undefined));
         }
-    }
-    if (chunk.delta.json) {
-        Object.assign(output, (0, type_utils_js_1.omitBy)(chunk.delta.json, (v) => v === undefined));
     }
     return output;
 }
@@ -88,7 +91,7 @@ function asyncGeneratorToReadableStream(generator) {
         },
     });
 }
-function onAgentResponseStreamEnd(stream, callback, options) {
+function onAgentResponseStreamEnd(stream, options) {
     const json = {};
     const reader = stream.getReader();
     return new ReadableStream({
@@ -97,18 +100,17 @@ function onAgentResponseStreamEnd(stream, callback, options) {
                 while (true) {
                     const { value, done } = await reader.read();
                     if (done) {
-                        const result = await callback(json);
+                        const result = (await options?.onResult?.(json)) ?? json;
                         if (result && !(0, fast_deep_equal_1.default)(result, json)) {
                             let chunk = { delta: { json: result } };
-                            if (options?.processChunk)
-                                chunk = options.processChunk(chunk);
+                            chunk = (await options?.onChunk?.(chunk)) ?? chunk;
                             controller.enqueue(chunk);
                         }
                         controller.close();
                         return;
                     }
                     mergeAgentResponseChunk(json, value);
-                    const chunk = options?.processChunk ? options.processChunk(value) : value;
+                    const chunk = (await options?.onChunk?.(value)) ?? value;
                     if (!(0, agent_js_1.isEmptyChunk)(chunk)) {
                         controller.enqueue(chunk);
                         break;
@@ -116,7 +118,7 @@ function onAgentResponseStreamEnd(stream, callback, options) {
                 }
             }
             catch (error) {
-                controller.error((await options?.errorCallback?.(error)) ?? error);
+                controller.error((await options?.onError?.(error)) ?? error);
             }
         },
     });
@@ -197,3 +199,34 @@ function toReadableStream(stream) {
 async function readAllString(stream) {
     return (await readableStreamToArray((stream instanceof ReadableStream ? stream : toReadableStream(stream)).pipeThrough(new TextDecoderStream()))).join("");
 }
+function mergeReadableStreams(...streams) {
+    let readers;
+    return new ReadableStream({
+        async pull(controller) {
+            try {
+                readers ??= streams.map((s) => ({ reader: s.getReader(), data: [] }));
+                while (readers.length) {
+                    const chunk = await Promise.race(readers.map((i) => {
+                        i.reading ??= i.reader.read().then((result) => ({ result, item: i }));
+                        return i.reading;
+                    }));
+                    if (chunk.result.value) {
+                        controller.enqueue(chunk.result.value);
+                        chunk.item.reading = undefined;
+                        return;
+                    }
+                    if (chunk.result.done) {
+                        readers = readers.filter((i) => i !== chunk.item);
+                    }
+                }
+                controller.close();
+            }
+            catch (error) {
+                controller.error(error);
+                if (readers)
+                    for (const item of readers)
+                        item.reader.releaseLock();
+            }
+        },
+    });
+}

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

@@ -15,6 +15,8 @@ export declare function isNotEmpty<T>(arr: T[]): arr is [T, ...T[]];
 export declare function duplicates<T>(arr: T[], key?: (item: T) => unknown): T[];
 export declare function remove<T>(arr: T[], remove: T[] | ((item: T) => boolean)): T[];
 export declare function unique<T>(arr: T[], key?: (item: T) => unknown): T[];
+export declare function omit<T extends Record<string, unknown>, K extends keyof T>(obj: T, ...keys: (K | K[])[]): Omit<T, K>;
+export declare function omitDeep<T, K>(obj: T, ...keys: (K | K[])[]): unknown;
 export declare function omitBy<T extends Record<string, unknown>, K extends keyof T>(obj: T, predicate: (value: T[K], key: K) => boolean): Partial<T>;
 export declare function orArrayToArray<T>(value?: T | T[]): T[];
 export declare function createAccessorArray<T>(array: T[], accessor: (array: T[], name: string) => T | undefined): T[] & {

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

@@ -8,6 +8,8 @@ exports.isNotEmpty = isNotEmpty;
 exports.duplicates = duplicates;
 exports.remove = remove;
 exports.unique = unique;
+exports.omit = omit;
+exports.omitDeep = omitDeep;
 exports.omitBy = omitBy;
 exports.orArrayToArray = orArrayToArray;
 exports.createAccessorArray = createAccessorArray;
@@ -73,6 +75,22 @@ function unique(arr, key = (item) => item) {
         return true;
     });
 }
+function omit(obj, ...keys) {
+    const flattenedKeys = new Set(keys.flat());
+    return Object.fromEntries(Object.entries(obj).filter(([key]) => !flattenedKeys.has(key)));
+}
+function omitDeep(obj, ...keys) {
+    if (Array.isArray(obj)) {
+        return obj.map((item) => omitDeep(item, ...keys));
+    }
+    if (isRecord(obj)) {
+        const flattenedKeys = new Set(keys.flat());
+        return Object.fromEntries(Object.entries(obj)
+            .filter(([key]) => !flattenedKeys.has(key))
+            .map(([key, value]) => [key, omitDeep(value, ...keys)]));
+    }
+    return obj;
+}
 function omitBy(obj, predicate) {
     return Object.fromEntries(Object.entries(obj).filter(([key, value]) => {
         const k = key;

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

@@ -1,7 +1,8 @@
 import { nodejs } from "@aigne/platform-helpers/nodejs/index.js";
 import { ZodObject, type ZodType } from "zod";
-import type { Context, UserContext } from "../aigne/context.js";
+import type { AgentEvent, Context, UserContext } from "../aigne/context.js";
 import type { MessagePayload } from "../aigne/message-queue.js";
+import type { ContextUsage } from "../aigne/usage.js";
 import type { Memory, MemoryAgent } from "../memory/memory.js";
 import type { MemoryRecorderInput } from "../memory/recorder.js";
 import type { MemoryRetrieverInput } from "../memory/retriever.js";
@@ -12,7 +13,11 @@ export * from "./types.js";
 /**
  * Basic message type that can contain any key-value pairs
  */
-export type Message = Record<string, unknown>;
+export interface Message extends Record<string, unknown> {
+    $meta?: {
+        usage: ContextUsage;
+    };
+}
 /**
  * Topics the agent subscribes to, can be a single topic string or an array of topic strings
  */
@@ -328,7 +333,7 @@ export declare abstract class Agent<I extends Message = Message, O extends Messa
      * Regular mode waits for the agent to complete processing and return the final result,
      * suitable for scenarios where a complete result is needed at once.
      *
-     * @param input Input message to the agent, can be a string or structured object
+     * @param input Input message to the agent
      * @param options Invocation options, must set streaming to false or leave unset
      * @returns Final JSON response
      *
@@ -336,7 +341,7 @@ export declare abstract class Agent<I extends Message = Message, O extends Messa
      * Here's an example of invoking an agent with regular mode:
      * {@includeCode ../../test/agents/agent.test.ts#example-invoke}
      */
-    invoke(input: I | string, options?: Partial<AgentInvokeOptions> & {
+    invoke(input: I, options?: Partial<AgentInvokeOptions> & {
         streaming?: false;
     }): Promise<O>;
     /**
@@ -346,7 +351,7 @@ export declare abstract class Agent<I extends Message = Message, O extends Messa
      * suitable for scenarios requiring real-time progress updates, such as
      * chat bot typing effects.
      *
-     * @param input Input message to the agent, can be a string or structured object
+     * @param input Input message to the agent
      * @param options Invocation options, must set streaming to true for this overload
      * @returns Streaming response object
      *
@@ -354,7 +359,7 @@ export declare abstract class Agent<I extends Message = Message, O extends Messa
      * Here's an example of invoking an agent with streaming response:
      * {@includeCode ../../test/agents/agent.test.ts#example-invoke-streaming}
      */
-    invoke(input: I | string, options: Partial<AgentInvokeOptions> & {
+    invoke(input: I, options: Partial<AgentInvokeOptions> & {
         streaming: true;
     }): Promise<AgentResponseStream<O>>;
     /**
@@ -366,7 +371,7 @@ export declare abstract class Agent<I extends Message = Message, O extends Messa
      * @param options Invocation options
      * @returns Agent response (streaming or regular)
      */
-    invoke(input: I | string, options?: Partial<AgentInvokeOptions>): Promise<AgentResponse<O>>;
+    invoke(input: I, options?: Partial<AgentInvokeOptions>): Promise<AgentResponse<O>>;
     protected invokeSkill<I extends Message, O extends Message>(skill: Agent<I, O>, input: I, options: AgentInvokeOptions): Promise<O>;
     /**
      * Process agent output
@@ -594,7 +599,7 @@ export type AgentResponseStream<T> = ReadableStream<AgentResponseChunk<T>>;
  *
  * @template T Response data type
  */
-export type AgentResponseChunk<T> = AgentResponseDelta<T>;
+export type AgentResponseChunk<T> = AgentResponseDelta<T> | AgentResponseProgress;
 /**
  * Check if a response chunk is empty
  *
@@ -622,6 +627,24 @@ export interface AgentResponseDelta<T> {
         json?: Partial<T> | TransferAgentOutput;
     };
 }
+export declare function isAgentResponseDelta<T>(chunk: AgentResponseChunk<T>): chunk is AgentResponseDelta<T>;
+export interface AgentResponseProgress {
+    progress: ({
+        event: "agentStarted";
+        input: Message;
+    } | {
+        event: "agentSucceed";
+        output: Message;
+    } | {
+        event: "agentFailed";
+        error: Error;
+    }) & Omit<AgentEvent, "agent"> & {
+        agent: {
+            name: string;
+        };
+    };
+}
+export declare function isAgentResponseProgress<T>(chunk: AgentResponseChunk<T>): chunk is AgentResponseProgress;
 /**
  * Creates a text delta for streaming responses
  *

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

@@ -12,7 +12,7 @@ import type { GuideRailAgentOutput } from "./guide-rail-agent.js";
  * @template I The input message type the agent accepts
  * @template O The output message type the agent returns
  */
-export interface AIAgentOptions<I extends Message = Message, O extends Message = Message> extends AgentOptions<I, O> {
+export interface AIAgentOptions<InputKey extends string = string, I extends Message & InputMessage<InputKey> = Message & InputMessage<InputKey>, O extends Message = Message> extends AgentOptions<Omit<I, InputKey> & Partial<InputMessage<InputKey>>, O> {
     /**
      * The language model to use for this agent
      *
@@ -26,10 +26,14 @@ export interface AIAgentOptions<I extends Message = Message, O extends Message =
      * more complex prompt templates
      */
     instructions?: string | PromptBuilder;
+    /**
+     * Pick a message from input to use as the user's message
+     */
+    inputKey?: InputKey;
     /**
      * Custom key to use for text output in the response
      *
-     * Defaults to $message if not specified
+     * Defaults to `message` if not specified
      */
     outputKey?: string;
     /**
@@ -106,6 +110,9 @@ export declare const aiAgentToolChoiceSchema: z.ZodUnion<[z.ZodNativeEnum<typeof
 export declare const aiAgentOptionsSchema: ZodObject<{
     [key in keyof AIAgentOptions]: ZodType<AIAgentOptions[key]>;
 }>;
+type InputMessage<K> = K extends string ? {
+    [key in K]: string;
+} : Message;
 /**
  * AI-powered agent that leverages language models
  *
@@ -126,7 +133,7 @@ export declare const aiAgentOptionsSchema: ZodObject<{
  * Basic AIAgent creation:
  * {@includeCode ../../test/agents/ai-agent.test.ts#example-ai-agent-basic}
  */
-export declare class AIAgent<I extends Message = Message, O extends Message = Message> extends Agent<I, O> {
+export declare class AIAgent<InputKey extends string = string, I extends Message & InputMessage<InputKey> = Message & InputMessage<InputKey>, O extends Message = Message> extends Agent<I, O> {
     /**
      * Create an AIAgent with the specified options
      *
@@ -139,13 +146,13 @@ export declare class AIAgent<I extends Message = Message, O extends Message = Me
      * AI agent with custom instructions:
      * {@includeCode ../../test/agents/ai-agent.test.ts#example-ai-agent-instructions}
      */
-    static from<I extends Message, O extends Message>(options: AIAgentOptions<I, O>): AIAgent<I, O>;
+    static from<InputKey extends string, I extends Message & InputMessage<InputKey>, O extends Message>(options: AIAgentOptions<InputKey, I, O>): AIAgent<InputKey, I, O>;
     /**
      * Create an AIAgent instance
      *
      * @param options Configuration options for the AI agent
      */
-    constructor(options: AIAgentOptions<I, O>);
+    constructor(options: AIAgentOptions<InputKey, I, O>);
     /**
      * The language model used by this agent
      *
@@ -163,6 +170,10 @@ export declare class AIAgent<I extends Message = Message, O extends Message = Me
      * {@includeCode ../../test/agents/ai-agent.test.ts#example-ai-agent-prompt-builder}
      */
     instructions: PromptBuilder;
+    /**
+     * Pick a message from input to use as the user's message
+     */
+    inputKey?: InputKey;
     /**
      * Custom key to use for text output in the response
      *
@@ -170,7 +181,7 @@ export declare class AIAgent<I extends Message = Message, O extends Message = Me
      * Setting a custom output key:
      * {@includeCode ../../test/agents/ai-agent.test.ts#example-ai-agent-custom-output-key}
      */
-    outputKey?: string;
+    outputKey: string;
     /**
      * Controls how the agent uses tools during execution
      *
@@ -224,3 +235,4 @@ export declare class AIAgent<I extends Message = Message, O extends Message = Me
      */
     _processRouter(input: I, model: ChatModel, modelInput: ChatModelInput, options: AgentInvokeOptions, toolsMap: Map<string, Agent>): AgentProcessAsyncGenerator<O>;
 }
+export {};

package/lib/dts/agents/guide-rail-agent.d.ts

@@ -59,4 +59,4 @@ export interface GuideRailAgentOutput extends Message {
  * - Monitor and audit agent behavior
  */
 export type GuideRailAgent = Agent<GuideRailAgentInput, GuideRailAgentOutput>;
-export declare const guideRailAgentOptions: AgentOptions<GuideRailAgentInput, GuideRailAgentOutput>;
+export declare const guideRailAgentOptions: AgentOptions<any, GuideRailAgentOutput>;

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

@@ -192,7 +192,7 @@ export declare abstract class MCPBase<I extends Message, O extends Message> exte
 export declare class MCPTool extends MCPBase<Message, CallToolResult> {
     process(input: Message): Promise<CallToolResult>;
 }
-export interface MCPPromptInput extends Message {
+export interface MCPPromptInput extends Record<string, unknown> {
     [key: string]: string;
 }
 export declare class MCPPrompt extends MCPBase<MCPPromptInput, GetPromptResult> {

package/lib/dts/aigne/aigne.d.ts

@@ -129,12 +129,12 @@ export declare class AIGNE<U extends UserContext = UserContext> {
      * 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 message - Input message to send to the agent
      * @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<U> & {
+    invoke<I extends Message, O extends Message>(agent: Agent<I, O>, message: I, options: InvokeOptions<U> & {
         returnActiveAgent: true;
         streaming?: false;
     }): Promise<[O, Agent]>;
@@ -143,12 +143,12 @@ export declare class AIGNE<U extends UserContext = UserContext> {
      * 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 message - Input message to send to the agent
      * @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<U> & {
+    invoke<I extends Message, O extends Message>(agent: Agent<I, O>, message: I, options: InvokeOptions<U> & {
         returnActiveAgent: true;
         streaming: true;
     }): Promise<[AgentResponseStream<O>, Promise<Agent>]>;
@@ -157,7 +157,7 @@ export declare class AIGNE<U extends UserContext = UserContext> {
      * 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 message - Input message to send to the agent
      * @param options - Optional configuration parameters for the invocation
      * @returns A promise resolving to the agent's complete response
      *
@@ -165,7 +165,7 @@ export declare class AIGNE<U extends UserContext = UserContext> {
      * 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<U> & {
+    invoke<I extends Message, O extends Message>(agent: Agent<I, O>, message: I, options?: InvokeOptions<U> & {
         returnActiveAgent?: false;
         streaming?: false;
     }): Promise<O>;
@@ -174,7 +174,7 @@ export declare class AIGNE<U extends UserContext = UserContext> {
      * 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 message - Input message to send to the agent
      * @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
      *
@@ -182,7 +182,7 @@ export declare class AIGNE<U extends UserContext = UserContext> {
      * 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<U> & {
+    invoke<I extends Message, O extends Message>(agent: Agent<I, O>, message: I, options: InvokeOptions<U> & {
         returnActiveAgent?: false;
         streaming: true;
     }): Promise<AgentResponseStream<O>>;
@@ -196,7 +196,7 @@ export declare class AIGNE<U extends UserContext = UserContext> {
      * @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<U>): UserAgent<I, O> | Promise<AgentResponse<O> | [AgentResponse<O>, Agent]>;
+    invoke<I extends Message, O extends Message>(agent: Agent<I, O>, message?: I, options?: InvokeOptions<U>): 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).
@@ -210,7 +210,7 @@ export declare class AIGNE<U extends UserContext = UserContext> {
      * 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, options?: InvokeOptions<U>): void;
+    publish(topic: string | string[], payload: Omit<MessagePayload, "context"> | Message, options?: InvokeOptions<U>): 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.

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

@@ -41,6 +41,8 @@ export type ContextEmitEventMap = {
  */
 export interface InvokeOptions<U extends UserContext = UserContext> extends Partial<Omit<AgentInvokeOptions<U>, "context">> {
     returnActiveAgent?: boolean;
+    returnProgressChunks?: boolean;
+    returnMetadata?: boolean;
     disableTransfer?: boolean;
     sourceAgent?: Agent;
 }
@@ -53,6 +55,8 @@ export interface UserContext extends Record<string, unknown> {
  * @hidden
  */
 export interface Context<U extends UserContext = UserContext> extends TypedEventEmitter<ContextEventMap, ContextEmitEventMap> {
+    id: string;
+    parentId?: string;
     model?: ChatModel;
     skills?: Agent[];
     usage: ContextUsage;
@@ -74,11 +78,11 @@ export interface Context<U extends UserContext = UserContext> extends TypedEvent
      * @param options.streaming return a stream of the output
      * @returns the output of the agent and the final active agent
      */
-    invoke<I extends Message, O extends Message>(agent: Agent<I, O>, message: I | string, options: InvokeOptions & {
+    invoke<I extends Message, O extends Message>(agent: Agent<I, O>, message: I, options: InvokeOptions & {
         returnActiveAgent: true;
         streaming?: false;
     }): Promise<[O, Agent]>;
-    invoke<I extends Message, O extends Message>(agent: Agent<I, O>, message: I | string, options: InvokeOptions & {
+    invoke<I extends Message, O extends Message>(agent: Agent<I, O>, message: I, options: InvokeOptions & {
         returnActiveAgent: true;
         streaming: true;
     }): Promise<[AgentResponseStream<O>, Promise<Agent>]>;
@@ -88,19 +92,19 @@ export interface Context<U extends UserContext = UserContext> extends TypedEvent
      * @param message Message to pass to the agent
      * @returns the output of the agent
      */
-    invoke<I extends Message, O extends Message>(agent: Agent<I, O>, message: I | string, options?: InvokeOptions & {
+    invoke<I extends Message, O extends Message>(agent: Agent<I, O>, message: I, options?: InvokeOptions & {
         streaming?: false;
     }): Promise<O>;
-    invoke<I extends Message, O extends Message>(agent: Agent<I, O>, message: I | string, options: InvokeOptions & {
+    invoke<I extends Message, O extends Message>(agent: Agent<I, O>, message: I, options: InvokeOptions & {
         streaming: true;
     }): Promise<AgentResponseStream<O>>;
-    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]>;
+    invoke<I extends Message, O extends Message>(agent: Agent<I, O>, message?: I, options?: InvokeOptions): UserAgent<I, O> | Promise<AgentResponse<O> | [AgentResponse<O>, Agent]>;
     /**
      * Publish a message to a topic, the aigne will invoke the listeners of the topic
      * @param topic topic name, or an array of topic names
      * @param payload message to publish
      */
-    publish(topic: string | string[], payload: Omit<MessagePayload, "context"> | Message | string, options?: InvokeOptions): void;
+    publish(topic: string | string[], payload: Omit<MessagePayload, "context"> | Message, options?: InvokeOptions): 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>;
@@ -139,6 +143,7 @@ export declare class AIGNEContext implements Context {
         reset?: boolean;
     }): AIGNEContext;
     invoke: Context["invoke"];
+    private onInvocationResult;
     publish: Context["publish"];
     subscribe: Context["subscribe"];
     unsubscribe: Context["unsubscribe"];

package/lib/dts/aigne/message-queue.d.ts

@@ -21,7 +21,7 @@ export interface MessagePayload {
 /**
  * @hidden
  */
-export declare function toMessagePayload(payload: Omit<MessagePayload, "context"> | string | Message, options?: Partial<Pick<MessagePayload, "role" | "source">>): Omit<MessagePayload, "context">;
+export declare function toMessagePayload(payload: Omit<MessagePayload, "context"> | Message, options?: Partial<Pick<MessagePayload, "role" | "source">>): Omit<MessagePayload, "context">;
 /**
  * @hidden
  */

package/lib/dts/aigne/usage.d.ts

@@ -5,6 +5,7 @@ export interface ContextUsage {
     inputTokens: number;
     outputTokens: number;
     agentCalls: number;
+    duration: number;
 }
 /**
  * @hidden

package/lib/dts/loader/agent-yaml.d.ts

@@ -5,11 +5,11 @@ export declare function loadAgentFromYamlFile(path: string): Promise<{
     name: string;
     description?: string | undefined;
     skills?: string[] | undefined;
-    instructions?: string | undefined;
     memory?: true | {
         provider: string;
         subscribeTopic?: string[] | undefined;
     } | undefined;
+    instructions?: string | undefined;
     inputSchema?: ZodObject<Record<string, ZodType<any, z.ZodTypeDef, any>>, z.UnknownKeysParam, z.ZodTypeAny, {
         [x: string]: any;
     }, {
@@ -20,6 +20,7 @@ export declare function loadAgentFromYamlFile(path: string): Promise<{
     }, {
         [x: string]: any;
     }> | undefined;
+    inputKey?: string | undefined;
     outputKey?: string | undefined;
     toolChoice?: AIAgentToolChoice | undefined;
 } | {

package/lib/dts/prompt/prompt-builder.d.ts

@@ -3,33 +3,19 @@ import { Agent, type AgentInvokeOptions, type Message } from "../agents/agent.js
 import type { AIAgent } from "../agents/ai-agent.js";
 import type { ChatModel, ChatModelInput } from "../agents/chat-model.js";
 import { ChatMessagesTemplate } from "./template.js";
-export declare const MESSAGE_KEY = "$message";
-export declare function createMessage<V extends Message>(message: string, variables?: V): {
-    [MESSAGE_KEY]: string;
-} & typeof variables;
-export declare function createMessage<I extends Message, V extends Message>(message: I, variables?: V): I & typeof variables;
-export declare function createMessage<I extends Message, V extends Message>(message: string | I, variables?: V): ({
-    [MESSAGE_KEY]: string;
-} | I) & typeof variables;
-export declare function getMessage(input: Message): string | undefined;
 export interface PromptBuilderOptions {
     instructions?: string | ChatMessagesTemplate;
 }
 export interface PromptBuildOptions extends Pick<AgentInvokeOptions, "context"> {
-    agent?: AIAgent;
+    agent?: AIAgent<any, any, any>;
     input?: Message;
     model?: ChatModel;
     outputSchema?: Agent["outputSchema"];
 }
 export declare class PromptBuilder {
-    static from(instructions: string): PromptBuilder;
-    static from(instructions: GetPromptResult): PromptBuilder;
-    static from(instructions: {
-        path: string;
-    }): Promise<PromptBuilder>;
     static from(instructions: string | {
         path: string;
-    } | GetPromptResult): PromptBuilder | Promise<PromptBuilder>;
+    } | GetPromptResult): PromptBuilder;
     private static fromFile;
     private static fromMCPPromptResult;
     constructor(options?: PromptBuilderOptions);

package/lib/dts/utils/event-stream.d.ts

@@ -1,4 +1,5 @@
-import type { AgentResponseChunk, AgentResponseStream, Message } from "../agents/agent.js";
+import { type AgentResponseChunk, type AgentResponseProgress, type AgentResponseStream, type Message } from "../agents/agent.js";
+import type { Context } from "../aigne/context.js";
 export declare class EventStreamParser<T> extends TransformStream<string, T | Error> {
     constructor();
 }
@@ -9,3 +10,6 @@ export declare class AgentResponseStreamParser<O extends Message> extends Transf
 export declare class AgentResponseStreamSSE<O extends Message> extends ReadableStream<string> {
     constructor(stream: AgentResponseStream<O>);
 }
+export declare class AgentResponseProgressStream extends ReadableStream<AgentResponseProgress> {
+    constructor(context: Context);
+}

package/lib/dts/utils/stream-utils.d.ts

@@ -1,15 +1,15 @@
 import { type AgentProcessAsyncGenerator, type AgentResponseChunk, type AgentResponseStream, type Message } from "../agents/agent.js";
-import type { MESSAGE_KEY } from "../prompt/prompt-builder.js";
 import { type PromiseOrValue } from "./type-utils.js";
 import "./stream-polyfill.js";
 export declare function objectToAgentResponseStream<T extends Message>(json: T): AgentResponseStream<T>;
 export declare function mergeAgentResponseChunk<T extends Message>(output: T, chunk: AgentResponseChunk<T>): T;
 export declare function agentResponseStreamToObject<T extends Message>(stream: AgentResponseStream<T> | AgentProcessAsyncGenerator<T>): Promise<T>;
 export declare function asyncGeneratorToReadableStream<T extends Message>(generator: AgentProcessAsyncGenerator<T>): AgentResponseStream<T>;
-export declare function onAgentResponseStreamEnd<T extends Message>(stream: AgentResponseStream<T>, callback: (result: T) => PromiseOrValue<Partial<T> | void>, options?: {
-    errorCallback?: (error: Error) => PromiseOrValue<Error>;
-    processChunk?: (chunk: AgentResponseChunk<T>) => AgentResponseChunk<T>;
-}): ReadableStream<any>;
+export declare function onAgentResponseStreamEnd<T extends Message>(stream: AgentResponseStream<T>, options?: {
+    onChunk?: (chunk: AgentResponseChunk<T>) => PromiseOrValue<AgentResponseChunk<T> | undefined | void>;
+    onResult?: (result: T) => PromiseOrValue<Partial<T> | undefined | void>;
+    onError?: (error: Error) => PromiseOrValue<Error>;
+}): AgentResponseStream<T>;
 export declare function isAsyncGenerator<T extends AsyncGenerator>(value: AsyncGenerator | unknown): value is T;
 export declare function arrayToAgentProcessAsyncGenerator<T extends Message>(chunks: (AgentResponseChunk<T> | Error)[], result?: Partial<T>): AgentProcessAsyncGenerator<T>;
 export declare function arrayToReadableStream<T>(chunks: (T | Error)[]): ReadableStream<T>;
@@ -17,8 +17,10 @@ export declare function readableStreamToArray<T>(stream: ReadableStream<T>, opti
     catchError: true;
 }): Promise<(T | Error)[]>;
 export declare function readableStreamToArray<T>(stream: ReadableStream<T>, options?: {
-    catchError?: false;
+    catchError?: boolean;
 }): Promise<T[]>;
-export declare function stringToAgentResponseStream(str: string, key?: "text" | typeof MESSAGE_KEY | string): AgentResponseStream<Message>;
+export declare function stringToAgentResponseStream(str: string, key?: "text" | string): AgentResponseStream<Message>;
 export declare function toReadableStream(stream: NodeJS.ReadStream): ReadableStream<Uint8Array<ArrayBufferLike>>;
 export declare function readAllString(stream: NodeJS.ReadStream | ReadableStream): Promise<string>;
+export declare function mergeReadableStreams<T1, T2>(s1: ReadableStream<T1>, s2: ReadableStream<T2>): ReadableStream<T1 | T2>;
+export declare function mergeReadableStreams(...streams: ReadableStream<any>[]): ReadableStream<any>;

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

@@ -15,6 +15,8 @@ export declare function isNotEmpty<T>(arr: T[]): arr is [T, ...T[]];
 export declare function duplicates<T>(arr: T[], key?: (item: T) => unknown): T[];
 export declare function remove<T>(arr: T[], remove: T[] | ((item: T) => boolean)): T[];
 export declare function unique<T>(arr: T[], key?: (item: T) => unknown): T[];
+export declare function omit<T extends Record<string, unknown>, K extends keyof T>(obj: T, ...keys: (K | K[])[]): Omit<T, K>;
+export declare function omitDeep<T, K>(obj: T, ...keys: (K | K[])[]): unknown;
 export declare function omitBy<T extends Record<string, unknown>, K extends keyof T>(obj: T, predicate: (value: T[K], key: K) => boolean): Partial<T>;
 export declare function orArrayToArray<T>(value?: T | T[]): T[];
 export declare function createAccessorArray<T>(array: T[], accessor: (array: T[], name: string) => T | undefined): T[] & {