@aigne/core 1.8.0 → 1.10.0

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

@@ -0,0 +1,144 @@
+import equal from "fast-deep-equal";
+import { omitBy } from "./type-utils.js";
+export function objectToAgentResponseStream(json) {
+    return new ReadableStream({
+        start(controller) {
+            controller.enqueue({ delta: { json } });
+            controller.close();
+        },
+    });
+}
+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 (chunk.delta.json) {
+        Object.assign(output, omitBy(chunk.delta.json, (v) => v === undefined));
+    }
+    return output;
+}
+export async function agentResponseStreamToObject(stream) {
+    const json = {};
+    if (stream instanceof ReadableStream) {
+        for await (const value of readableStreamToAsyncIterator(stream)) {
+            mergeAgentResponseChunk(json, value);
+        }
+    }
+    else {
+        for (;;) {
+            const chunk = await stream.next();
+            if (chunk.value) {
+                if (chunk.done) {
+                    Object.assign(json, chunk.value);
+                }
+                else {
+                    mergeAgentResponseChunk(json, chunk.value);
+                }
+            }
+            if (chunk.done)
+                break;
+        }
+    }
+    return json;
+}
+export function asyncGeneratorToReadableStream(generator) {
+    return new ReadableStream({
+        async start(controller) {
+            try {
+                for (;;) {
+                    const chunk = await generator.next();
+                    if (chunk.value) {
+                        if (chunk.done) {
+                            controller.enqueue({ delta: { json: chunk.value } });
+                        }
+                        else {
+                            controller.enqueue(chunk.value);
+                        }
+                    }
+                    if (chunk.done)
+                        break;
+                }
+            }
+            catch (error) {
+                controller.error(error);
+            }
+            finally {
+                controller.close();
+            }
+        },
+    });
+}
+export function onAgentResponseStreamEnd(stream, callback, options) {
+    return new ReadableStream({
+        async start(controller) {
+            try {
+                const json = {};
+                for await (const value of readableStreamToAsyncIterator(stream)) {
+                    const chunk = options?.processChunk ? options.processChunk(value) : value;
+                    controller.enqueue(chunk);
+                    mergeAgentResponseChunk(json, value);
+                }
+                const result = await callback(json);
+                if (result && !equal(result, json)) {
+                    let chunk = { delta: { json: result } };
+                    if (options?.processChunk)
+                        chunk = options.processChunk(chunk);
+                    controller.enqueue(chunk);
+                }
+            }
+            catch (error) {
+                controller.error(options?.errorCallback?.(error) ?? error);
+            }
+            finally {
+                controller.close();
+            }
+        },
+    });
+}
+export function isAsyncGenerator(value) {
+    return typeof value === "object" && value !== null && Symbol.asyncIterator in value;
+}
+export async function* arrayToAgentProcessAsyncGenerator(chunks, result) {
+    for (const chunk of chunks) {
+        if (chunk instanceof Error)
+            throw chunk;
+        yield chunk;
+    }
+    if (result !== undefined)
+        return result;
+}
+export function arrayToAgentResponseStream(chunks) {
+    return new ReadableStream({
+        start(controller) {
+            for (const chunk of chunks) {
+                if (chunk instanceof Error) {
+                    controller.error(chunk);
+                    return;
+                }
+                controller.enqueue(chunk);
+            }
+            controller.close();
+        },
+    });
+}
+export async function readableStreamToArray(stream) {
+    const result = [];
+    for await (const value of readableStreamToAsyncIterator(stream)) {
+        result.push(value);
+    }
+    return result;
+}
+export async function* readableStreamToAsyncIterator(stream) {
+    const reader = stream.getReader();
+    while (true) {
+        const { value, done } = await reader.read();
+        if (done)
+            break;
+        yield value;
+    }
+}

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

@@ -7,9 +7,10 @@ export declare function isEmpty(obj: unknown): boolean;
 export declare function isNonNullable<T>(value: T): value is NonNullable<T>;
 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 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[] & {
     [key: string]: T;
 };
-export declare function checkArguments<T>(prefix: string, schema: ZodType<T>, args: T): void;
+export declare function checkArguments<T>(prefix: string, schema: ZodType<T>, args: T): T;
 export declare function tryOrThrow<P extends PromiseOrValue<unknown>>(fn: () => P, error: string | Error | ((error: Error) => Error)): P;

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

@@ -31,6 +31,12 @@ export function duplicates(arr, key = (item) => item) {
     }
     return Array.from(duplicates);
 }
+export function omitBy(obj, predicate) {
+    return Object.fromEntries(Object.entries(obj).filter(([key, value]) => {
+        const k = key;
+        return !predicate(value, k);
+    }));
+}
 export function orArrayToArray(value) {
     if (isNil(value))
         return [];
@@ -43,7 +49,7 @@ export function createAccessorArray(array, accessor) {
 }
 export function checkArguments(prefix, schema, args) {
     try {
-        schema.parse(args, {
+        return schema.parse(args, {
             errorMap: (issue, ctx) => {
                 if (issue.code === "invalid_union") {
                     // handle all issues that are not invalid_type

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aigne/core",
-  "version": "1.8.0",
+  "version": "1.10.0",
   "description": "AIGNE core library for building AI-powered applications",
   "publishConfig": {
     "access": "public"
@@ -66,6 +66,7 @@
     "@modelcontextprotocol/sdk": "^1.9.0",
     "@types/debug": "^4.1.12",
     "debug": "^4.4.0",
+    "fast-deep-equal": "^3.1.3",
     "inquirer": "^12.5.2",
     "mustache": "^4.2.0",
     "nanoid": "^5.1.5",