@aigne/core 1.18.5 → 1.19.0

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

@@ -1,14 +1,16 @@
 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>;
@@ -16,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,6 +1,7 @@
 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) {
     return new ReadableStream({
         pull(controller) {
@@ -10,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;
 }
@@ -70,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({
@@ -79,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;
@@ -98,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);
             }
         },
     });
@@ -179,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.5",
+  "version": "1.19.0",
   "description": "AIGNE core library for building AI-powered applications",
   "publishConfig": {
     "access": "public"