@aigne/core 1.63.0-beta.11 → 1.63.0-beta.12

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## [1.63.0-beta.12](https://github.com/AIGNE-io/aigne-framework/compare/core-v1.63.0-beta.11...core-v1.63.0-beta.12) (2025-10-17)
+
+
+### Bug Fixes
+
+* custom queue instead of fastq to compatible with browser ([#640](https://github.com/AIGNE-io/aigne-framework/issues/640)) ([51e0f8f](https://github.com/AIGNE-io/aigne-framework/commit/51e0f8fdeaf26f2765f392218f04a2af4c0d2e1a))
+
 ## [1.63.0-beta.11](https://github.com/AIGNE-io/aigne-framework/compare/core-v1.63.0-beta.10...core-v1.63.0-beta.11) (2025-10-17)
 
 

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

@@ -1,14 +1,44 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AIAgent = exports.aiAgentOptionsSchema = exports.aiAgentToolChoiceSchema = exports.AIAgentToolChoice = exports.DEFAULT_OUTPUT_FILE_KEY = exports.DEFAULT_OUTPUT_KEY = void 0;
-const fastq_1 = __importDefault(require("fastq"));
 const zod_1 = require("zod");
 const prompt_builder_js_1 = require("../prompt/prompt-builder.js");
 const structured_stream_instructions_js_1 = require("../prompt/prompts/structured-stream-instructions.js");
 const template_js_1 = require("../prompt/template.js");
+const fastq = __importStar(require("../utils/queue.js"));
 const structured_stream_extractor_js_1 = require("../utils/structured-stream-extractor.js");
 const type_utils_js_1 = require("../utils/type-utils.js");
 const agent_js_1 = require("./agent.js");
@@ -319,7 +349,7 @@ class AIAgent extends agent_js_1.Agent {
                 }
                 const executedToolCalls = [];
                 let error;
-                const queue = fastq_1.default.promise(async ({ tool, call }) => {
+                const queue = fastq.promise(async ({ tool, call }) => {
                     try {
                         // NOTE: should pass both arguments (model generated) and input (user provided) to the tool
                         const output = await this.invokeSkill(tool, { ...input, ...call.function.arguments }, options).catch((error) => {

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

@@ -1,12 +1,45 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TeamAgent = exports.DEFAULT_REFLECTION_MAX_ITERATIONS = exports.ProcessMode = void 0;
 const node_assert_1 = __importDefault(require("node:assert"));
-const fastq_1 = __importDefault(require("fastq"));
 const immer_1 = require("immer");
+const fastq = __importStar(require("../utils/queue.js"));
 const stream_utils_js_1 = require("../utils/stream-utils.js");
 const type_utils_js_1 = require("../utils/type-utils.js");
 const agent_js_1 = require("./agent.js");
@@ -201,7 +234,7 @@ class TeamAgent extends agent_js_1.Agent {
         arr = Array.isArray(arr) ? [...arr] : (0, type_utils_js_1.isNil)(arr) ? [arr] : [];
         const results = new Array(arr.length);
         let error;
-        const queue = fastq_1.default.promise(async ({ item, index }) => {
+        const queue = fastq.promise(async ({ item, index }) => {
             try {
                 if (!(0, type_utils_js_1.isRecord)(item))
                     throw new TypeError(`Expected ${String(key)} to be an object, got ${typeof item}`);

package/lib/cjs/utils/queue.d.ts

@@ -0,0 +1,57 @@
+/** biome-ignore-all lint/style/noNonNullAssertion lint/complexity/useOptionalChain: <!> */
+declare namespace fastq {
+    type worker<C, T = any, R = any> = (this: C, task: T, cb: fastq.done<R>) => void;
+    type asyncWorker<C, T = any, R = any> = (this: C, task: T) => Promise<R>;
+    type done<R = any> = (err: Error | null, result?: R) => void;
+    type errorHandler<T = any> = (err: Error, task: T) => void;
+    interface queue<T = any, R = any> {
+        /** Add a task at the end of the queue. `done(err, result)` will be called when the task was processed. */
+        push(task: T, done?: done<R>): void;
+        /** Add a task at the beginning of the queue. `done(err, result)` will be called when the task was processed. */
+        unshift(task: T, done?: done<R>): void;
+        /** Pause the processing of tasks. Currently worked tasks are not stopped. */
+        pause(): any;
+        /** Resume the processing of tasks. */
+        resume(): any;
+        running(): number;
+        /** Returns `false` if there are tasks being processed or waiting to be processed. `true` otherwise. */
+        idle(): boolean;
+        /** Returns the number of tasks waiting to be processed (in the queue). */
+        length(): number;
+        /** Returns all the tasks be processed (in the queue). Returns empty array when there are no tasks */
+        getQueue(): T[];
+        /** Removes all tasks waiting to be processed, and reset `drain` to an empty function. */
+        kill(): any;
+        /** Same than `kill` but the `drain` function will be called before reset to empty. */
+        killAndDrain(): any;
+        /** Set a global error handler. `handler(err, task)` will be called each time a task is completed, `err` will be not null if the task has thrown an error. */
+        error(handler: errorHandler<T>): void;
+        /** Property that returns the number of concurrent tasks that could be executed in parallel. It can be altered at runtime. */
+        concurrency: number;
+        /** Property that returns `true` when the queue is in a paused state. */
+        paused: boolean;
+        /** Function that will be called when the last item from the queue has been processed by a worker. It can be altered at runtime. */
+        drain(): any;
+        /** Function that will be called when the last item from the queue has been assigned to a worker. It can be altered at runtime. */
+        empty: () => void;
+        /** Function that will be called when the queue hits the concurrency limit. It can be altered at runtime. */
+        saturated: () => void;
+    }
+    interface queueAsPromised<T = any, R = any> extends queue<T, R> {
+        /** Add a task at the end of the queue. The returned `Promise` will be fulfilled (rejected) when the task is completed successfully (unsuccessfully). */
+        push(task: T): Promise<R>;
+        /** Add a task at the beginning of the queue. The returned `Promise` will be fulfilled (rejected) when the task is completed successfully (unsuccessfully). */
+        unshift(task: T): Promise<R>;
+        /** Wait for the queue to be drained. The returned `Promise` will be resolved when all tasks in the queue have been processed by a worker. */
+        drained(): Promise<void>;
+    }
+}
+declare function fastq<C, T = any, R = any>(context: C, worker: fastq.worker<C, T, R>, _concurrency: number): fastq.queue<T, R>;
+declare function fastq<C, T = any, R = any>(worker: fastq.worker<C, T, R>, _concurrency: number): fastq.queue<T, R>;
+declare namespace fastq {
+    var promise: typeof queueAsPromised;
+}
+declare function queueAsPromised<C, T = any, R = any>(context: C, worker: fastq.asyncWorker<C, T, R>, _concurrency: number): fastq.queueAsPromised<T, R>;
+declare function queueAsPromised<C, T = any, R = any>(worker: fastq.asyncWorker<C, T, R>, _concurrency: number): fastq.queueAsPromised<T, R>;
+export default fastq;
+export declare const promise: typeof queueAsPromised;

package/lib/cjs/utils/queue.js

@@ -0,0 +1,318 @@
+"use strict";
+/** biome-ignore-all lint/style/noNonNullAssertion lint/complexity/useOptionalChain: <!> */
+// Cross-platform queue implementation compatible with Node.js and browser
+// Based on fastqueue library but implemented in TypeScript
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.promise = void 0;
+// Cross-platform nextTick implementation
+const nextTick = (() => {
+    if (typeof process !== "undefined" && process.nextTick) {
+        return process.nextTick;
+    }
+    if (typeof setImmediate !== "undefined") {
+        return setImmediate;
+    }
+    return (callback) => setTimeout(callback, 0);
+})();
+// Simple object pooling implementation to replace reusify
+function createObjectPool(factory) {
+    const pool = [];
+    return {
+        get() {
+            return pool.pop() || factory();
+        },
+        release(obj) {
+            pool.push(obj);
+        },
+    };
+}
+function noop() { }
+function createTask() {
+    const task = {
+        value: null,
+        callback: noop,
+        next: null,
+        release: noop,
+        context: null,
+        errorHandler: null,
+        worked: function worked(err, result) {
+            const callback = task.callback;
+            const errorHandler = task.errorHandler;
+            const val = task.value;
+            task.value = null;
+            task.callback = noop;
+            if (task.errorHandler && err) {
+                errorHandler(err, val);
+            }
+            callback.call(task.context, err, result);
+            task.release(task);
+        },
+    };
+    return task;
+}
+function fastq(contextOrWorker, workerOrConcurrency, _concurrency) {
+    let context = null;
+    let worker;
+    let concurrency;
+    if (typeof contextOrWorker === "function") {
+        context = null;
+        worker = contextOrWorker;
+        concurrency = workerOrConcurrency;
+    }
+    else {
+        context = contextOrWorker;
+        worker = workerOrConcurrency;
+        concurrency = _concurrency;
+    }
+    if (!(concurrency >= 1)) {
+        throw new Error("fastq concurrency must be equal to or greater than 1");
+    }
+    const cache = createObjectPool(() => createTask());
+    let queueHead = null;
+    let queueTail = null;
+    let _running = 0;
+    let errorHandler = null;
+    const self = {
+        push,
+        drain: noop,
+        saturated: noop,
+        pause,
+        paused: false,
+        get concurrency() {
+            return concurrency;
+        },
+        set concurrency(value) {
+            if (!(value >= 1)) {
+                throw new Error("fastq concurrency must be equal to or greater than 1");
+            }
+            concurrency = value;
+            if (self.paused)
+                return;
+            for (; queueHead && _running < concurrency;) {
+                _running++;
+                release();
+            }
+        },
+        running,
+        resume,
+        idle,
+        length,
+        getQueue,
+        unshift,
+        empty: noop,
+        kill,
+        killAndDrain,
+        error,
+    };
+    return self;
+    function running() {
+        return _running;
+    }
+    function pause() {
+        self.paused = true;
+    }
+    function length() {
+        let current = queueHead;
+        let counter = 0;
+        while (current) {
+            current = current.next;
+            counter++;
+        }
+        return counter;
+    }
+    function getQueue() {
+        let current = queueHead;
+        const tasks = [];
+        while (current) {
+            if (current.value !== null) {
+                tasks.push(current.value);
+            }
+            current = current.next;
+        }
+        return tasks;
+    }
+    function resume() {
+        if (!self.paused)
+            return;
+        self.paused = false;
+        for (; queueHead && _running < concurrency;) {
+            _running++;
+            release();
+        }
+    }
+    function idle() {
+        return _running === 0 && self.length() === 0;
+    }
+    function push(value, done) {
+        const current = cache.get();
+        current.context = context;
+        current.release = release;
+        current.value = value;
+        current.callback = done || noop;
+        current.errorHandler = errorHandler;
+        if (_running >= concurrency || self.paused) {
+            if (queueTail) {
+                queueTail.next = current;
+                queueTail = current;
+            }
+            else {
+                queueHead = current;
+                queueTail = current;
+                self.saturated();
+            }
+        }
+        else {
+            _running++;
+            worker.call(context, current.value, current.worked);
+        }
+    }
+    function unshift(value, done) {
+        const current = cache.get();
+        current.context = context;
+        current.release = release;
+        current.value = value;
+        current.callback = done || noop;
+        current.errorHandler = errorHandler;
+        if (_running >= concurrency || self.paused) {
+            if (queueHead) {
+                current.next = queueHead;
+                queueHead = current;
+            }
+            else {
+                queueHead = current;
+                queueTail = current;
+                self.saturated();
+            }
+        }
+        else {
+            _running++;
+            worker.call(context, current.value, current.worked);
+        }
+    }
+    function release(holder) {
+        if (holder) {
+            cache.release(holder);
+        }
+        const next = queueHead;
+        if (next) {
+            if (!self.paused) {
+                if (queueTail === queueHead) {
+                    queueTail = null;
+                }
+                queueHead = next.next;
+                next.next = null;
+                worker.call(context, next.value, next.worked);
+                if (queueTail === null) {
+                    self.empty();
+                }
+            }
+            else {
+                _running--;
+            }
+        }
+        else if (--_running === 0) {
+            self.drain();
+        }
+    }
+    function kill() {
+        queueHead = null;
+        queueTail = null;
+        self.drain = noop;
+    }
+    function killAndDrain() {
+        queueHead = null;
+        queueTail = null;
+        self.drain();
+        self.drain = noop;
+    }
+    function error(handler) {
+        errorHandler = handler;
+    }
+}
+function queueAsPromised(contextOrWorker, workerOrConcurrency, _concurrency) {
+    let context = null;
+    let worker;
+    let concurrency;
+    if (typeof contextOrWorker === "function") {
+        context = null;
+        worker = contextOrWorker;
+        concurrency = workerOrConcurrency;
+    }
+    else {
+        context = contextOrWorker;
+        worker = workerOrConcurrency;
+        concurrency = _concurrency;
+    }
+    function asyncWrapper(arg, cb) {
+        worker.call(context, arg).then((res) => cb(null, res), (err) => cb(err));
+    }
+    const queue = fastq(context, asyncWrapper, concurrency);
+    const pushCb = queue.push;
+    const unshiftCb = queue.unshift;
+    const promiseQueue = {
+        ...queue,
+        push,
+        unshift,
+        drained,
+    };
+    // Make sure drain property is properly connected
+    Object.defineProperty(promiseQueue, "drain", {
+        get: () => queue.drain,
+        set: (value) => {
+            queue.drain = value;
+        },
+    });
+    return promiseQueue;
+    function push(value) {
+        const p = new Promise((resolve, reject) => {
+            pushCb(value, (err, result) => {
+                if (err) {
+                    reject(err);
+                    return;
+                }
+                resolve(result);
+            });
+        });
+        // Fork the promise chain to prevent unhandled rejection
+        p.catch(noop);
+        return p;
+    }
+    function unshift(value) {
+        const p = new Promise((resolve, reject) => {
+            unshiftCb(value, (err, result) => {
+                if (err) {
+                    reject(err);
+                    return;
+                }
+                resolve(result);
+            });
+        });
+        // Fork the promise chain to prevent unhandled rejection
+        p.catch(noop);
+        return p;
+    }
+    function drained() {
+        return new Promise((resolve) => {
+            nextTick(() => {
+                if (queue.idle()) {
+                    resolve();
+                }
+                else {
+                    const previousDrain = queue.drain;
+                    queue.drain = () => {
+                        if (typeof previousDrain === "function" && previousDrain !== noop) {
+                            previousDrain();
+                        }
+                        resolve();
+                        queue.drain = previousDrain;
+                    };
+                }
+            });
+        });
+    }
+}
+// Add promise function to namespace
+fastq.promise = queueAsPromised;
+// Modern ESM exports
+exports.default = fastq;
+exports.promise = queueAsPromised;

package/lib/dts/utils/queue.d.ts

@@ -0,0 +1,57 @@
+/** biome-ignore-all lint/style/noNonNullAssertion lint/complexity/useOptionalChain: <!> */
+declare namespace fastq {
+    type worker<C, T = any, R = any> = (this: C, task: T, cb: fastq.done<R>) => void;
+    type asyncWorker<C, T = any, R = any> = (this: C, task: T) => Promise<R>;
+    type done<R = any> = (err: Error | null, result?: R) => void;
+    type errorHandler<T = any> = (err: Error, task: T) => void;
+    interface queue<T = any, R = any> {
+        /** Add a task at the end of the queue. `done(err, result)` will be called when the task was processed. */
+        push(task: T, done?: done<R>): void;
+        /** Add a task at the beginning of the queue. `done(err, result)` will be called when the task was processed. */
+        unshift(task: T, done?: done<R>): void;
+        /** Pause the processing of tasks. Currently worked tasks are not stopped. */
+        pause(): any;
+        /** Resume the processing of tasks. */
+        resume(): any;
+        running(): number;
+        /** Returns `false` if there are tasks being processed or waiting to be processed. `true` otherwise. */
+        idle(): boolean;
+        /** Returns the number of tasks waiting to be processed (in the queue). */
+        length(): number;
+        /** Returns all the tasks be processed (in the queue). Returns empty array when there are no tasks */
+        getQueue(): T[];
+        /** Removes all tasks waiting to be processed, and reset `drain` to an empty function. */
+        kill(): any;
+        /** Same than `kill` but the `drain` function will be called before reset to empty. */
+        killAndDrain(): any;
+        /** Set a global error handler. `handler(err, task)` will be called each time a task is completed, `err` will be not null if the task has thrown an error. */
+        error(handler: errorHandler<T>): void;
+        /** Property that returns the number of concurrent tasks that could be executed in parallel. It can be altered at runtime. */
+        concurrency: number;
+        /** Property that returns `true` when the queue is in a paused state. */
+        paused: boolean;
+        /** Function that will be called when the last item from the queue has been processed by a worker. It can be altered at runtime. */
+        drain(): any;
+        /** Function that will be called when the last item from the queue has been assigned to a worker. It can be altered at runtime. */
+        empty: () => void;
+        /** Function that will be called when the queue hits the concurrency limit. It can be altered at runtime. */
+        saturated: () => void;
+    }
+    interface queueAsPromised<T = any, R = any> extends queue<T, R> {
+        /** Add a task at the end of the queue. The returned `Promise` will be fulfilled (rejected) when the task is completed successfully (unsuccessfully). */
+        push(task: T): Promise<R>;
+        /** Add a task at the beginning of the queue. The returned `Promise` will be fulfilled (rejected) when the task is completed successfully (unsuccessfully). */
+        unshift(task: T): Promise<R>;
+        /** Wait for the queue to be drained. The returned `Promise` will be resolved when all tasks in the queue have been processed by a worker. */
+        drained(): Promise<void>;
+    }
+}
+declare function fastq<C, T = any, R = any>(context: C, worker: fastq.worker<C, T, R>, _concurrency: number): fastq.queue<T, R>;
+declare function fastq<C, T = any, R = any>(worker: fastq.worker<C, T, R>, _concurrency: number): fastq.queue<T, R>;
+declare namespace fastq {
+    var promise: typeof queueAsPromised;
+}
+declare function queueAsPromised<C, T = any, R = any>(context: C, worker: fastq.asyncWorker<C, T, R>, _concurrency: number): fastq.queueAsPromised<T, R>;
+declare function queueAsPromised<C, T = any, R = any>(worker: fastq.asyncWorker<C, T, R>, _concurrency: number): fastq.queueAsPromised<T, R>;
+export default fastq;
+export declare const promise: typeof queueAsPromised;

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

@@ -1,8 +1,8 @@
-import fastq from "fastq";
 import { z } from "zod";
 import { PromptBuilder } from "../prompt/prompt-builder.js";
 import { STRUCTURED_STREAM_INSTRUCTIONS } from "../prompt/prompts/structured-stream-instructions.js";
 import { AgentMessageTemplate, ToolMessageTemplate } from "../prompt/template.js";
+import * as fastq from "../utils/queue.js";
 import { ExtractMetadataTransform } from "../utils/structured-stream-extractor.js";
 import { checkArguments, isEmpty } from "../utils/type-utils.js";
 import { Agent, agentOptionsSchema, isAgentResponseDelta, } from "./agent.js";

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

@@ -1,6 +1,6 @@
 import assert from "node:assert";
-import fastq from "fastq";
 import { produce } from "immer";
+import * as fastq from "../utils/queue.js";
 import { mergeAgentResponseChunk } from "../utils/stream-utils.js";
 import { isEmpty, isNil, isRecord, omit } from "../utils/type-utils.js";
 import { Agent, agentProcessResultToObject, isAgentResponseDelta, } from "./agent.js";

package/lib/esm/utils/queue.d.ts

@@ -0,0 +1,57 @@
+/** biome-ignore-all lint/style/noNonNullAssertion lint/complexity/useOptionalChain: <!> */
+declare namespace fastq {
+    type worker<C, T = any, R = any> = (this: C, task: T, cb: fastq.done<R>) => void;
+    type asyncWorker<C, T = any, R = any> = (this: C, task: T) => Promise<R>;
+    type done<R = any> = (err: Error | null, result?: R) => void;
+    type errorHandler<T = any> = (err: Error, task: T) => void;
+    interface queue<T = any, R = any> {
+        /** Add a task at the end of the queue. `done(err, result)` will be called when the task was processed. */
+        push(task: T, done?: done<R>): void;
+        /** Add a task at the beginning of the queue. `done(err, result)` will be called when the task was processed. */
+        unshift(task: T, done?: done<R>): void;
+        /** Pause the processing of tasks. Currently worked tasks are not stopped. */
+        pause(): any;
+        /** Resume the processing of tasks. */
+        resume(): any;
+        running(): number;
+        /** Returns `false` if there are tasks being processed or waiting to be processed. `true` otherwise. */
+        idle(): boolean;
+        /** Returns the number of tasks waiting to be processed (in the queue). */
+        length(): number;
+        /** Returns all the tasks be processed (in the queue). Returns empty array when there are no tasks */
+        getQueue(): T[];
+        /** Removes all tasks waiting to be processed, and reset `drain` to an empty function. */
+        kill(): any;
+        /** Same than `kill` but the `drain` function will be called before reset to empty. */
+        killAndDrain(): any;
+        /** Set a global error handler. `handler(err, task)` will be called each time a task is completed, `err` will be not null if the task has thrown an error. */
+        error(handler: errorHandler<T>): void;
+        /** Property that returns the number of concurrent tasks that could be executed in parallel. It can be altered at runtime. */
+        concurrency: number;
+        /** Property that returns `true` when the queue is in a paused state. */
+        paused: boolean;
+        /** Function that will be called when the last item from the queue has been processed by a worker. It can be altered at runtime. */
+        drain(): any;
+        /** Function that will be called when the last item from the queue has been assigned to a worker. It can be altered at runtime. */
+        empty: () => void;
+        /** Function that will be called when the queue hits the concurrency limit. It can be altered at runtime. */
+        saturated: () => void;
+    }
+    interface queueAsPromised<T = any, R = any> extends queue<T, R> {
+        /** Add a task at the end of the queue. The returned `Promise` will be fulfilled (rejected) when the task is completed successfully (unsuccessfully). */
+        push(task: T): Promise<R>;
+        /** Add a task at the beginning of the queue. The returned `Promise` will be fulfilled (rejected) when the task is completed successfully (unsuccessfully). */
+        unshift(task: T): Promise<R>;
+        /** Wait for the queue to be drained. The returned `Promise` will be resolved when all tasks in the queue have been processed by a worker. */
+        drained(): Promise<void>;
+    }
+}
+declare function fastq<C, T = any, R = any>(context: C, worker: fastq.worker<C, T, R>, _concurrency: number): fastq.queue<T, R>;
+declare function fastq<C, T = any, R = any>(worker: fastq.worker<C, T, R>, _concurrency: number): fastq.queue<T, R>;
+declare namespace fastq {
+    var promise: typeof queueAsPromised;
+}
+declare function queueAsPromised<C, T = any, R = any>(context: C, worker: fastq.asyncWorker<C, T, R>, _concurrency: number): fastq.queueAsPromised<T, R>;
+declare function queueAsPromised<C, T = any, R = any>(worker: fastq.asyncWorker<C, T, R>, _concurrency: number): fastq.queueAsPromised<T, R>;
+export default fastq;
+export declare const promise: typeof queueAsPromised;

package/lib/esm/utils/queue.js

@@ -0,0 +1,315 @@
+/** biome-ignore-all lint/style/noNonNullAssertion lint/complexity/useOptionalChain: <!> */
+// Cross-platform queue implementation compatible with Node.js and browser
+// Based on fastqueue library but implemented in TypeScript
+// Cross-platform nextTick implementation
+const nextTick = (() => {
+    if (typeof process !== "undefined" && process.nextTick) {
+        return process.nextTick;
+    }
+    if (typeof setImmediate !== "undefined") {
+        return setImmediate;
+    }
+    return (callback) => setTimeout(callback, 0);
+})();
+// Simple object pooling implementation to replace reusify
+function createObjectPool(factory) {
+    const pool = [];
+    return {
+        get() {
+            return pool.pop() || factory();
+        },
+        release(obj) {
+            pool.push(obj);
+        },
+    };
+}
+function noop() { }
+function createTask() {
+    const task = {
+        value: null,
+        callback: noop,
+        next: null,
+        release: noop,
+        context: null,
+        errorHandler: null,
+        worked: function worked(err, result) {
+            const callback = task.callback;
+            const errorHandler = task.errorHandler;
+            const val = task.value;
+            task.value = null;
+            task.callback = noop;
+            if (task.errorHandler && err) {
+                errorHandler(err, val);
+            }
+            callback.call(task.context, err, result);
+            task.release(task);
+        },
+    };
+    return task;
+}
+function fastq(contextOrWorker, workerOrConcurrency, _concurrency) {
+    let context = null;
+    let worker;
+    let concurrency;
+    if (typeof contextOrWorker === "function") {
+        context = null;
+        worker = contextOrWorker;
+        concurrency = workerOrConcurrency;
+    }
+    else {
+        context = contextOrWorker;
+        worker = workerOrConcurrency;
+        concurrency = _concurrency;
+    }
+    if (!(concurrency >= 1)) {
+        throw new Error("fastq concurrency must be equal to or greater than 1");
+    }
+    const cache = createObjectPool(() => createTask());
+    let queueHead = null;
+    let queueTail = null;
+    let _running = 0;
+    let errorHandler = null;
+    const self = {
+        push,
+        drain: noop,
+        saturated: noop,
+        pause,
+        paused: false,
+        get concurrency() {
+            return concurrency;
+        },
+        set concurrency(value) {
+            if (!(value >= 1)) {
+                throw new Error("fastq concurrency must be equal to or greater than 1");
+            }
+            concurrency = value;
+            if (self.paused)
+                return;
+            for (; queueHead && _running < concurrency;) {
+                _running++;
+                release();
+            }
+        },
+        running,
+        resume,
+        idle,
+        length,
+        getQueue,
+        unshift,
+        empty: noop,
+        kill,
+        killAndDrain,
+        error,
+    };
+    return self;
+    function running() {
+        return _running;
+    }
+    function pause() {
+        self.paused = true;
+    }
+    function length() {
+        let current = queueHead;
+        let counter = 0;
+        while (current) {
+            current = current.next;
+            counter++;
+        }
+        return counter;
+    }
+    function getQueue() {
+        let current = queueHead;
+        const tasks = [];
+        while (current) {
+            if (current.value !== null) {
+                tasks.push(current.value);
+            }
+            current = current.next;
+        }
+        return tasks;
+    }
+    function resume() {
+        if (!self.paused)
+            return;
+        self.paused = false;
+        for (; queueHead && _running < concurrency;) {
+            _running++;
+            release();
+        }
+    }
+    function idle() {
+        return _running === 0 && self.length() === 0;
+    }
+    function push(value, done) {
+        const current = cache.get();
+        current.context = context;
+        current.release = release;
+        current.value = value;
+        current.callback = done || noop;
+        current.errorHandler = errorHandler;
+        if (_running >= concurrency || self.paused) {
+            if (queueTail) {
+                queueTail.next = current;
+                queueTail = current;
+            }
+            else {
+                queueHead = current;
+                queueTail = current;
+                self.saturated();
+            }
+        }
+        else {
+            _running++;
+            worker.call(context, current.value, current.worked);
+        }
+    }
+    function unshift(value, done) {
+        const current = cache.get();
+        current.context = context;
+        current.release = release;
+        current.value = value;
+        current.callback = done || noop;
+        current.errorHandler = errorHandler;
+        if (_running >= concurrency || self.paused) {
+            if (queueHead) {
+                current.next = queueHead;
+                queueHead = current;
+            }
+            else {
+                queueHead = current;
+                queueTail = current;
+                self.saturated();
+            }
+        }
+        else {
+            _running++;
+            worker.call(context, current.value, current.worked);
+        }
+    }
+    function release(holder) {
+        if (holder) {
+            cache.release(holder);
+        }
+        const next = queueHead;
+        if (next) {
+            if (!self.paused) {
+                if (queueTail === queueHead) {
+                    queueTail = null;
+                }
+                queueHead = next.next;
+                next.next = null;
+                worker.call(context, next.value, next.worked);
+                if (queueTail === null) {
+                    self.empty();
+                }
+            }
+            else {
+                _running--;
+            }
+        }
+        else if (--_running === 0) {
+            self.drain();
+        }
+    }
+    function kill() {
+        queueHead = null;
+        queueTail = null;
+        self.drain = noop;
+    }
+    function killAndDrain() {
+        queueHead = null;
+        queueTail = null;
+        self.drain();
+        self.drain = noop;
+    }
+    function error(handler) {
+        errorHandler = handler;
+    }
+}
+function queueAsPromised(contextOrWorker, workerOrConcurrency, _concurrency) {
+    let context = null;
+    let worker;
+    let concurrency;
+    if (typeof contextOrWorker === "function") {
+        context = null;
+        worker = contextOrWorker;
+        concurrency = workerOrConcurrency;
+    }
+    else {
+        context = contextOrWorker;
+        worker = workerOrConcurrency;
+        concurrency = _concurrency;
+    }
+    function asyncWrapper(arg, cb) {
+        worker.call(context, arg).then((res) => cb(null, res), (err) => cb(err));
+    }
+    const queue = fastq(context, asyncWrapper, concurrency);
+    const pushCb = queue.push;
+    const unshiftCb = queue.unshift;
+    const promiseQueue = {
+        ...queue,
+        push,
+        unshift,
+        drained,
+    };
+    // Make sure drain property is properly connected
+    Object.defineProperty(promiseQueue, "drain", {
+        get: () => queue.drain,
+        set: (value) => {
+            queue.drain = value;
+        },
+    });
+    return promiseQueue;
+    function push(value) {
+        const p = new Promise((resolve, reject) => {
+            pushCb(value, (err, result) => {
+                if (err) {
+                    reject(err);
+                    return;
+                }
+                resolve(result);
+            });
+        });
+        // Fork the promise chain to prevent unhandled rejection
+        p.catch(noop);
+        return p;
+    }
+    function unshift(value) {
+        const p = new Promise((resolve, reject) => {
+            unshiftCb(value, (err, result) => {
+                if (err) {
+                    reject(err);
+                    return;
+                }
+                resolve(result);
+            });
+        });
+        // Fork the promise chain to prevent unhandled rejection
+        p.catch(noop);
+        return p;
+    }
+    function drained() {
+        return new Promise((resolve) => {
+            nextTick(() => {
+                if (queue.idle()) {
+                    resolve();
+                }
+                else {
+                    const previousDrain = queue.drain;
+                    queue.drain = () => {
+                        if (typeof previousDrain === "function" && previousDrain !== noop) {
+                            previousDrain();
+                        }
+                        resolve();
+                        queue.drain = previousDrain;
+                    };
+                }
+            });
+        });
+    }
+}
+// Add promise function to namespace
+fastq.promise = queueAsPromised;
+// Modern ESM exports
+export default fastq;
+export const promise = queueAsPromised;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aigne/core",
-  "version": "1.63.0-beta.11",
+  "version": "1.63.0-beta.12",
   "description": "The functional core of agentic AI",
   "publishConfig": {
     "access": "public"
@@ -77,7 +77,6 @@
     "debug": "^4.4.3",
     "eventsource-parser": "^3.0.6",
     "fast-deep-equal": "^3.1.3",
-    "fastq": "^1.19.1",
     "immer": "^10.1.3",
     "is-network-error": "^1.2.0",
     "jaison": "^2.0.2",
@@ -93,8 +92,8 @@
     "zod-from-json-schema": "^0.0.5",
     "zod-to-json-schema": "^3.24.6",
     "@aigne/afs": "^1.1.0-beta",
-    "@aigne/platform-helpers": "^0.6.3",
-    "@aigne/observability-api": "^0.11.2-beta.5"
+    "@aigne/observability-api": "^0.11.2-beta.5",
+    "@aigne/platform-helpers": "^0.6.3"
   },
   "devDependencies": {
     "@types/bun": "^1.2.22",