@aigne/core 1.18.6 → 1.20.1

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,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/esm/utils/type-utils.js

@@ -58,6 +58,22 @@ 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 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;
+}
 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.20.1",
   "description": "AIGNE core library for building AI-powered applications",
   "publishConfig": {
     "access": "public"
@@ -81,7 +81,7 @@
     "yaml": "^2.7.1",
     "zod": "^3.24.4",
     "zod-to-json-schema": "^3.24.5",
-    "@aigne/platform-helpers": "^0.1.1"
+    "@aigne/platform-helpers": "^0.1.2"
   },
   "devDependencies": {
     "@types/bun": "^1.2.12",