@aigne/core 1.18.6 → 1.19.0

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

@@ -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/dts/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/esm/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/esm/agents/agent.js

@@ -319,10 +319,11 @@ export class Agent {
                     : isAsyncGenerator(response)
                         ? asyncGeneratorToReadableStream(response)
                         : objectToAgentResponseStream(response);
-                return this.checkResponseByGuideRails(message, onAgentResponseStreamEnd(stream, async (result) => {
-                    return await this.processAgentOutput(parsedInput, result, opts);
-                }, {
-                    errorCallback: async (error) => {
+                return this.checkResponseByGuideRails(message, onAgentResponseStreamEnd(stream, {
+                    onResult: async (result) => {
+                        return await this.processAgentOutput(parsedInput, result, opts);
+                    },
+                    onError: async (error) => {
                         return await this.processAgentError(message, error, opts);
                     },
                 }), opts);
@@ -422,14 +423,16 @@ export class Agent {
             return output;
         const result = await output;
         if (result instanceof ReadableStream) {
-            return onAgentResponseStreamEnd(result, async (result) => {
-                const error = await this.runGuideRails(input, result, options);
-                if (error) {
-                    return {
-                        ...(await this.onGuideRailError(error)),
-                        $status: "GuideRailError",
-                    };
-                }
+            return 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);
@@ -542,7 +545,13 @@ export class Agent {
  * @returns True if the chunk is empty
  */
 export function isEmptyChunk(chunk) {
-    return isEmpty(chunk.delta.json) && isEmpty(chunk.delta.text);
+    return isAgentResponseDelta(chunk) && isEmpty(chunk.delta.json) && isEmpty(chunk.delta.text);
+}
+export function isAgentResponseDelta(chunk) {
+    return "delta" in chunk;
+}
+export function isAgentResponseProgress(chunk) {
+    return "progress" in chunk;
 }
 /**
  * Creates a text delta for streaming responses

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

@@ -2,7 +2,7 @@ import { z } from "zod";
 import { MESSAGE_KEY, PromptBuilder } from "../prompt/prompt-builder.js";
 import { AgentMessageTemplate, ToolMessageTemplate } from "../prompt/template.js";
 import { checkArguments, isEmpty } from "../utils/type-utils.js";
-import { Agent, agentOptionsSchema, } from "./agent.js";
+import { Agent, agentOptionsSchema, isAgentResponseDelta, } from "./agent.js";
 import { ChatModel, } from "./chat-model.js";
 import { isTransferAgentOutput } from "./types.js";
 /**
@@ -188,8 +188,7 @@ export class AIAgent extends 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 || MESSAGE_KEY;
@@ -197,11 +196,13 @@ export class AIAgent extends 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 (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;
@@ -272,6 +273,6 @@ export class AIAgent extends 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;
     }
 }

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

@@ -1,6 +1,6 @@
 import { mergeAgentResponseChunk } from "../utils/stream-utils.js";
 import { isEmpty } from "../utils/type-utils.js";
-import { Agent, } from "./agent.js";
+import { Agent, isAgentResponseDelta, } from "./agent.js";
 /**
  * Defines the processing modes available for a TeamAgent.
  *
@@ -155,7 +155,7 @@ export class TeamAgent extends Agent {
             if (!done) {
                 tasks.set(index, read(index, reader));
             }
-            if (value) {
+            if (value && isAgentResponseDelta(value)) {
                 let { delta: { text, ...delta }, } = value;
                 if (text) {
                     for (const key of Object.keys(text)) {

package/lib/esm/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/esm/aigne/context.js

@@ -2,12 +2,13 @@ import equal from "fast-deep-equal";
 import { Emitter } from "strict-event-emitter";
 import { v7 } from "uuid";
 import { z } from "zod";
-import { Agent, isEmptyChunk, } from "../agents/agent.js";
+import { Agent, isAgentResponseDelta, isEmptyChunk, } from "../agents/agent.js";
 import { isTransferAgentOutput, transferAgentOutputKey, } from "../agents/types.js";
 import { UserAgent } from "../agents/user-agent.js";
 import { createMessage } from "../prompt/prompt-builder.js";
+import { AgentResponseProgressStream } from "../utils/event-stream.js";
 import { promiseWithResolvers } from "../utils/promise.js";
-import { agentResponseStreamToObject, asyncGeneratorToReadableStream, onAgentResponseStreamEnd, } from "../utils/stream-utils.js";
+import { agentResponseStreamToObject, asyncGeneratorToReadableStream, mergeReadableStreams, onAgentResponseStreamEnd, } from "../utils/stream-utils.js";
 import { checkArguments, isEmpty, isNil, omitBy, } from "../utils/type-utils.js";
 import { MessageQueue, toMessagePayload, } from "./message-queue.js";
 import { newEmptyContextUsage } from "./usage.js";
@@ -90,11 +91,9 @@ export class AIGNEContext {
                 return output;
             }
             const activeAgentPromise = promiseWithResolvers();
-            const stream = onAgentResponseStreamEnd(asyncGeneratorToReadableStream(response), async ({ __activeAgent__: activeAgent }) => {
-                activeAgentPromise.resolve(activeAgent);
-            }, {
-                processChunk(chunk) {
-                    if (chunk.delta.json) {
+            const stream = onAgentResponseStreamEnd(asyncGeneratorToReadableStream(response), {
+                onChunk(chunk) {
+                    if (isAgentResponseDelta(chunk) && chunk.delta.json) {
                         return {
                             ...chunk,
                             delta: {
@@ -103,13 +102,18 @@ export class AIGNEContext {
                             },
                         };
                     }
-                    return chunk;
+                },
+                onResult({ __activeAgent__: activeAgent }) {
+                    activeAgentPromise.resolve(activeAgent);
                 },
             });
+            const finalStream = !options.returnProgressChunks
+                ? stream
+                : mergeReadableStreams(stream, new AgentResponseProgressStream(newContext));
             if (options.returnActiveAgent) {
-                return [stream, activeAgentPromise.promise];
+                return [finalStream, activeAgentPromise.promise];
             }
-            return stream;
+            return finalStream;
         });
     });
     publish = ((topic, payload, options) => {
@@ -164,7 +168,6 @@ class AIGNEContextShared {
         this.memories = overrides?.memories ?? [];
     }
     messageQueue;
-    // biome-ignore lint/suspicious/noExplicitAny: <explanation>
     events = new Emitter();
     get model() {
         return this.parent?.model;
@@ -211,11 +214,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 (isAgentResponseDelta(value)) {
+                    if (value.delta.json) {
+                        value.delta.json = omitExistsProperties(result, value.delta.json);
+                        Object.assign(result, value.delta.json);
+                    }
+                    delete value.delta.json?.[transferAgentOutputKey];
                 }
-                delete value.delta.json?.[transferAgentOutputKey];
                 if (isEmptyChunk(value))
                     continue;
                 yield value;

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

@@ -1,5 +1,6 @@
 import { createParser } from "eventsource-parser";
 import { produce } from "immer";
+import { isAgentResponseDelta, isAgentResponseProgress, } from "../agents/agent.js";
 import { tryOrThrow } from "./type-utils.js";
 export class EventStreamParser extends TransformStream {
     constructor() {
@@ -12,11 +13,16 @@ export 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);
+                                }
                             }
                         }
                     },
@@ -38,25 +44,35 @@ export class AgentResponseStreamParser extends TransformStream {
                     controller.terminate();
                     return;
                 }
-                this.json = 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 (isAgentResponseDelta(chunk)) {
+                    this.json = 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 (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);
+                }
             },
         });
     }
@@ -73,6 +89,14 @@ export class AgentResponseStreamSSE extends ReadableStream {
                         controller.close();
                         return;
                     }
+                    if (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) {
@@ -83,3 +107,43 @@ export class AgentResponseStreamSSE extends ReadableStream {
         });
     }
 }
+export 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);
+            },
+        });
+    }
+}

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

@@ -1,5 +1,5 @@
 import equal from "fast-deep-equal";
-import { isEmptyChunk, } from "../agents/agent.js";
+import { isAgentResponseDelta, isEmptyChunk, } from "../agents/agent.js";
 import { omitBy } from "./type-utils.js";
 import "./stream-polyfill.js";
 export function objectToAgentResponseStream(json) {
@@ -11,16 +11,18 @@ export function objectToAgentResponseStream(json) {
     });
 }
 export 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 (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, omitBy(chunk.delta.json, (v) => v === undefined));
         }
-    }
-    if (chunk.delta.json) {
-        Object.assign(output, omitBy(chunk.delta.json, (v) => v === undefined));
     }
     return output;
 }
@@ -71,7 +73,7 @@ export function asyncGeneratorToReadableStream(generator) {
         },
     });
 }
-export function onAgentResponseStreamEnd(stream, callback, options) {
+export function onAgentResponseStreamEnd(stream, options) {
     const json = {};
     const reader = stream.getReader();
     return new ReadableStream({
@@ -80,18 +82,17 @@ export 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 && !equal(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 (!isEmptyChunk(chunk)) {
                         controller.enqueue(chunk);
                         break;
@@ -99,7 +100,7 @@ export function onAgentResponseStreamEnd(stream, callback, options) {
                 }
             }
             catch (error) {
-                controller.error((await options?.errorCallback?.(error)) ?? error);
+                controller.error((await options?.onError?.(error)) ?? error);
             }
         },
     });
@@ -180,3 +181,34 @@ export function toReadableStream(stream) {
 export async function readAllString(stream) {
     return (await readableStreamToArray((stream instanceof ReadableStream ? stream : toReadableStream(stream)).pipeThrough(new TextDecoderStream()))).join("");
 }
+export 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/esm/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/esm/utils/type-utils.js

@@ -58,6 +58,10 @@ export function unique(arr, key = (item) => item) {
         return true;
     });
 }
+export function omit(obj, ...keys) {
+    const flattenedKeys = new Set(keys.flat());
+    return Object.fromEntries(Object.entries(obj).filter(([key]) => !flattenedKeys.has(key)));
+}
 export function omitBy(obj, predicate) {
     return Object.fromEntries(Object.entries(obj).filter(([key, value]) => {
         const k = key;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aigne/core",
-  "version": "1.18.6",
+  "version": "1.19.0",
   "description": "AIGNE core library for building AI-powered applications",
   "publishConfig": {
     "access": "public"