@aigne/core 1.18.6 → 1.19.0

package/CHANGELOG.md

@@ -5,6 +5,13 @@
 
 * add user context support ([#131](https://github.com/AIGNE-io/aigne-framework/issues/131)) ([4dd9d20](https://github.com/AIGNE-io/aigne-framework/commit/4dd9d20953f6ac33933723db56efd9b44bafeb02))
 
+## [1.19.0](https://github.com/AIGNE-io/aigne-framework/compare/core-v1.18.6...core-v1.19.0) (2025-06-16)
+
+
+### Features
+
+* support respond progressing chunks by enable `returnProgressChunks` option for aigne.invoke ([cf4c313](https://github.com/AIGNE-io/aigne-framework/commit/cf4c313ee69f255be799ac196da675b79f69bf76))
+
 ## [1.18.6](https://github.com/AIGNE-io/aigne-framework/compare/core-v1.18.5...core-v1.18.6) (2025-06-11)
 
 

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

@@ -1,6 +1,6 @@
 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 { Memory, MemoryAgent } from "../memory/memory.js";
 import type { MemoryRecorderInput } from "../memory/recorder.js";
@@ -594,7 +594,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 +622,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/cjs/agents/agent.js

@@ -38,6 +38,8 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FunctionAgent = exports.Agent = exports.agentOptionsSchema = void 0;
 exports.isEmptyChunk = isEmptyChunk;
+exports.isAgentResponseDelta = isAgentResponseDelta;
+exports.isAgentResponseProgress = isAgentResponseProgress;
 exports.textDelta = textDelta;
 exports.jsonDelta = jsonDelta;
 const index_js_1 = require("@aigne/platform-helpers/nodejs/index.js");
@@ -361,10 +363,11 @@ class Agent {
                     : (0, stream_utils_js_1.isAsyncGenerator)(response)
                         ? (0, stream_utils_js_1.asyncGeneratorToReadableStream)(response)
                         : (0, stream_utils_js_1.objectToAgentResponseStream)(response);
-                return this.checkResponseByGuideRails(message, (0, stream_utils_js_1.onAgentResponseStreamEnd)(stream, async (result) => {
-                    return await this.processAgentOutput(parsedInput, result, opts);
-                }, {
-                    errorCallback: async (error) => {
+                return this.checkResponseByGuideRails(message, (0, stream_utils_js_1.onAgentResponseStreamEnd)(stream, {
+                    onResult: async (result) => {
+                        return await this.processAgentOutput(parsedInput, result, opts);
+                    },
+                    onError: async (error) => {
                         return await this.processAgentError(message, error, opts);
                     },
                 }), opts);
@@ -464,14 +467,16 @@ class Agent {
             return output;
         const result = await output;
         if (result instanceof ReadableStream) {
-            return (0, stream_utils_js_1.onAgentResponseStreamEnd)(result, async (result) => {
-                const error = await this.runGuideRails(input, result, options);
-                if (error) {
-                    return {
-                        ...(await this.onGuideRailError(error)),
-                        $status: "GuideRailError",
-                    };
-                }
+            return (0, stream_utils_js_1.onAgentResponseStreamEnd)(result, {
+                onResult: async (result) => {
+                    const error = await this.runGuideRails(input, result, options);
+                    if (error) {
+                        return {
+                            ...(await this.onGuideRailError(error)),
+                            $status: "GuideRailError",
+                        };
+                    }
+                },
             });
         }
         const error = await this.runGuideRails(input, result, options);
@@ -585,7 +590,13 @@ exports.Agent = Agent;
  * @returns True if the chunk is empty
  */
 function isEmptyChunk(chunk) {
-    return (0, type_utils_js_1.isEmpty)(chunk.delta.json) && (0, type_utils_js_1.isEmpty)(chunk.delta.text);
+    return isAgentResponseDelta(chunk) && (0, type_utils_js_1.isEmpty)(chunk.delta.json) && (0, type_utils_js_1.isEmpty)(chunk.delta.text);
+}
+function isAgentResponseDelta(chunk) {
+    return "delta" in chunk;
+}
+function isAgentResponseProgress(chunk) {
+    return "progress" in chunk;
 }
 /**
  * Creates a text delta for streaming responses

package/lib/cjs/agents/ai-agent.js

@@ -191,8 +191,7 @@ class AIAgent extends agent_js_1.Agent {
         });
         const toolsMap = new Map(toolAgents?.map((i) => [i.name, i]));
         if (this.toolChoice === "router") {
-            yield* this._processRouter(input, model, modelInput, options, toolsMap);
-            return;
+            return yield* this._processRouter(input, model, modelInput, options, toolsMap);
         }
         const toolCallMessages = [];
         const outputKey = this.outputKey || prompt_builder_js_1.MESSAGE_KEY;
@@ -200,11 +199,13 @@ class AIAgent extends agent_js_1.Agent {
             const modelOutput = {};
             const stream = await options.context.invoke(model, { ...modelInput, messages: modelInput.messages.concat(toolCallMessages) }, { streaming: true });
             for await (const value of stream) {
-                if (value.delta.text?.text) {
-                    yield { delta: { text: { [outputKey]: value.delta.text.text } } };
-                }
-                if (value.delta.json) {
-                    Object.assign(modelOutput, value.delta.json);
+                if ((0, agent_js_1.isAgentResponseDelta)(value)) {
+                    if (value.delta.text?.text) {
+                        yield { delta: { text: { [outputKey]: value.delta.text.text } } };
+                    }
+                    if (value.delta.json) {
+                        Object.assign(modelOutput, value.delta.json);
+                    }
                 }
             }
             const { toolCalls, json, text } = modelOutput;
@@ -275,7 +276,7 @@ class AIAgent extends agent_js_1.Agent {
         if (!tool)
             throw new Error(`Tool not found: ${call.function.name}`);
         const stream = await options.context.invoke(tool, { ...call.function.arguments, ...input }, { streaming: true, sourceAgent: this });
-        yield* stream;
+        return yield* stream;
     }
 }
 exports.AIAgent = AIAgent;

package/lib/cjs/agents/team-agent.js

@@ -158,7 +158,7 @@ class TeamAgent extends agent_js_1.Agent {
             if (!done) {
                 tasks.set(index, read(index, reader));
             }
-            if (value) {
+            if (value && (0, agent_js_1.isAgentResponseDelta)(value)) {
                 let { delta: { text, ...delta }, } = value;
                 if (text) {
                     for (const key of Object.keys(text)) {

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

@@ -41,6 +41,7 @@ export type ContextEmitEventMap = {
  */
 export interface InvokeOptions<U extends UserContext = UserContext> extends Partial<Omit<AgentInvokeOptions<U>, "context">> {
     returnActiveAgent?: boolean;
+    returnProgressChunks?: boolean;
     disableTransfer?: boolean;
     sourceAgent?: Agent;
 }
@@ -53,6 +54,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;

package/lib/cjs/aigne/context.js

@@ -12,6 +12,7 @@ const agent_js_1 = require("../agents/agent.js");
 const types_js_1 = require("../agents/types.js");
 const user_agent_js_1 = require("../agents/user-agent.js");
 const prompt_builder_js_1 = require("../prompt/prompt-builder.js");
+const event_stream_js_1 = require("../utils/event-stream.js");
 const promise_js_1 = require("../utils/promise.js");
 const stream_utils_js_1 = require("../utils/stream-utils.js");
 const type_utils_js_1 = require("../utils/type-utils.js");
@@ -96,11 +97,9 @@ class AIGNEContext {
                 return output;
             }
             const activeAgentPromise = (0, promise_js_1.promiseWithResolvers)();
-            const stream = (0, stream_utils_js_1.onAgentResponseStreamEnd)((0, stream_utils_js_1.asyncGeneratorToReadableStream)(response), async ({ __activeAgent__: activeAgent }) => {
-                activeAgentPromise.resolve(activeAgent);
-            }, {
-                processChunk(chunk) {
-                    if (chunk.delta.json) {
+            const stream = (0, stream_utils_js_1.onAgentResponseStreamEnd)((0, stream_utils_js_1.asyncGeneratorToReadableStream)(response), {
+                onChunk(chunk) {
+                    if ((0, agent_js_1.isAgentResponseDelta)(chunk) && chunk.delta.json) {
                         return {
                             ...chunk,
                             delta: {
@@ -109,13 +108,18 @@ class AIGNEContext {
                             },
                         };
                     }
-                    return chunk;
+                },
+                onResult({ __activeAgent__: activeAgent }) {
+                    activeAgentPromise.resolve(activeAgent);
                 },
             });
+            const finalStream = !options.returnProgressChunks
+                ? stream
+                : (0, stream_utils_js_1.mergeReadableStreams)(stream, new event_stream_js_1.AgentResponseProgressStream(newContext));
             if (options.returnActiveAgent) {
-                return [stream, activeAgentPromise.promise];
+                return [finalStream, activeAgentPromise.promise];
             }
-            return stream;
+            return finalStream;
         });
     });
     publish = ((topic, payload, options) => {
@@ -171,7 +175,6 @@ class AIGNEContextShared {
         this.memories = overrides?.memories ?? [];
     }
     messageQueue;
-    // biome-ignore lint/suspicious/noExplicitAny: <explanation>
     events = new strict_event_emitter_1.Emitter();
     get model() {
         return this.parent?.model;
@@ -218,11 +221,13 @@ class AIGNEContextShared {
             }
             const stream = await activeAgent.invoke(input, { ...options, context, streaming: true });
             for await (const value of stream) {
-                if (value.delta.json) {
-                    value.delta.json = omitExistsProperties(result, value.delta.json);
-                    Object.assign(result, value.delta.json);
+                if ((0, agent_js_1.isAgentResponseDelta)(value)) {
+                    if (value.delta.json) {
+                        value.delta.json = omitExistsProperties(result, value.delta.json);
+                        Object.assign(result, value.delta.json);
+                    }
+                    delete value.delta.json?.[types_js_1.transferAgentOutputKey];
                 }
-                delete value.delta.json?.[types_js_1.transferAgentOutputKey];
                 if ((0, agent_js_1.isEmptyChunk)(value))
                     continue;
                 yield value;

package/lib/cjs/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/cjs/utils/event-stream.js

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AgentResponseStreamSSE = exports.AgentResponseStreamParser = exports.EventStreamParser = void 0;
+exports.AgentResponseProgressStream = exports.AgentResponseStreamSSE = exports.AgentResponseStreamParser = exports.EventStreamParser = void 0;
 const eventsource_parser_1 = require("eventsource-parser");
 const immer_1 = require("immer");
+const agent_js_1 = require("../agents/agent.js");
 const type_utils_js_1 = require("./type-utils.js");
 class EventStreamParser extends TransformStream {
     constructor() {
@@ -15,11 +16,16 @@ class EventStreamParser extends TransformStream {
                             controller.enqueue(new Error(`Parse response chunk json error: ${e.message} ${event.data}`));
                         });
                         if (json) {
-                            if (event.event === "error") {
-                                controller.enqueue(new Error(json.message));
-                            }
-                            else {
-                                controller.enqueue(json);
+                            switch (event.event) {
+                                case "error":
+                                    controller.enqueue(new Error(json.message));
+                                    break;
+                                default: {
+                                    if (!event.event)
+                                        controller.enqueue(json);
+                                    else
+                                        console.warn(`Unknown event type: ${event.event}`, event.data);
+                                }
                             }
                         }
                     },
@@ -42,25 +48,35 @@ class AgentResponseStreamParser extends TransformStream {
                     controller.terminate();
                     return;
                 }
-                this.json = (0, immer_1.produce)(this.json, (draft) => {
-                    if (chunk.delta.json)
-                        Object.assign(draft, chunk.delta.json);
-                    if (chunk.delta.text) {
-                        for (const [key, text] of Object.entries(chunk.delta.text)) {
-                            const original = draft[key];
-                            const t = (original || "") + (text || "");
-                            if (t)
-                                Object.assign(draft, { [key]: t });
+                if ((0, agent_js_1.isAgentResponseDelta)(chunk)) {
+                    this.json = (0, immer_1.produce)(this.json, (draft) => {
+                        if (chunk.delta.json)
+                            Object.assign(draft, chunk.delta.json);
+                        if (chunk.delta.text) {
+                            for (const [key, text] of Object.entries(chunk.delta.text)) {
+                                const original = draft[key];
+                                const t = (original || "") + (text || "");
+                                if (t)
+                                    Object.assign(draft, { [key]: t });
+                            }
                         }
+                    });
+                    controller.enqueue({
+                        ...chunk,
+                        delta: {
+                            ...chunk.delta,
+                            json: this.json,
+                        },
+                    });
+                }
+                else if ((0, agent_js_1.isAgentResponseProgress)(chunk)) {
+                    if (chunk.progress.event === "agentFailed") {
+                        const { name, message } = chunk.progress.error;
+                        chunk.progress.error = new Error(message);
+                        chunk.progress.error.name = name;
                     }
-                });
-                controller.enqueue({
-                    ...chunk,
-                    delta: {
-                        ...chunk.delta,
-                        json: this.json,
-                    },
-                });
+                    controller.enqueue(chunk);
+                }
             },
         });
     }
@@ -78,6 +94,14 @@ class AgentResponseStreamSSE extends ReadableStream {
                         controller.close();
                         return;
                     }
+                    if ((0, agent_js_1.isAgentResponseProgress)(value)) {
+                        if (value.progress.event === "agentFailed") {
+                            value.progress.error = {
+                                name: value.progress.error.name,
+                                message: value.progress.error.message,
+                            };
+                        }
+                    }
                     controller.enqueue(`data: ${JSON.stringify(value)}\n\n`);
                 }
                 catch (error) {
@@ -89,3 +113,44 @@ class AgentResponseStreamSSE extends ReadableStream {
     }
 }
 exports.AgentResponseStreamSSE = AgentResponseStreamSSE;
+class AgentResponseProgressStream extends ReadableStream {
+    constructor(context) {
+        super({
+            async start(controller) {
+                const writeEvent = (eventName, event) => {
+                    const progress = {
+                        ...event,
+                        event: eventName,
+                        agent: { name: event.agent.name },
+                    };
+                    controller.enqueue({ progress });
+                };
+                const close = () => {
+                    context.off("agentStarted", onAgentStarted);
+                    context.off("agentSucceed", onAgentSucceed);
+                    context.off("agentFailed", onAgentFailed);
+                    controller.close();
+                };
+                const onAgentStarted = (event) => {
+                    writeEvent("agentStarted", event);
+                };
+                const onAgentSucceed = (event) => {
+                    writeEvent("agentSucceed", event);
+                    if (event.contextId === context.id) {
+                        close();
+                    }
+                };
+                const onAgentFailed = (event) => {
+                    writeEvent("agentFailed", event);
+                    if (event.contextId === context.id) {
+                        close();
+                    }
+                };
+                context.on("agentStarted", onAgentStarted);
+                context.on("agentSucceed", onAgentSucceed);
+                context.on("agentFailed", onAgentFailed);
+            },
+        });
+    }
+}
+exports.AgentResponseProgressStream = AgentResponseProgressStream;

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

@@ -6,10 +6,11 @@ export declare function objectToAgentResponseStream<T extends Message>(json: 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 +18,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 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/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,7 @@ 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 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,7 @@ exports.isNotEmpty = isNotEmpty;
 exports.duplicates = duplicates;
 exports.remove = remove;
 exports.unique = unique;
+exports.omit = omit;
 exports.omitBy = omitBy;
 exports.orArrayToArray = orArrayToArray;
 exports.createAccessorArray = createAccessorArray;
@@ -73,6 +74,10 @@ 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 omitBy(obj, predicate) {
     return Object.fromEntries(Object.entries(obj).filter(([key, value]) => {
         const k = key;

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

@@ -1,6 +1,6 @@
 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 { Memory, MemoryAgent } from "../memory/memory.js";
 import type { MemoryRecorderInput } from "../memory/recorder.js";
@@ -594,7 +594,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 +622,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/aigne/context.d.ts

@@ -41,6 +41,7 @@ export type ContextEmitEventMap = {
  */
 export interface InvokeOptions<U extends UserContext = UserContext> extends Partial<Omit<AgentInvokeOptions<U>, "context">> {
     returnActiveAgent?: boolean;
+    returnProgressChunks?: boolean;
     disableTransfer?: boolean;
     sourceAgent?: Agent;
 }
@@ -53,6 +54,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;