@aigne/core 1.63.0-beta.8 → 1.63.0

package/CHANGELOG.md

@@ -1,5 +1,53 @@
 # Changelog
 
+## [1.63.0](https://github.com/AIGNE-io/aigne-framework/compare/core-v1.63.0-beta.12...core-v1.63.0) (2025-10-19)
+
+
+### Dependencies
+
+* The following workspace dependencies were updated
+  * dependencies
+    * @aigne/afs bumped to 1.1.0
+    * @aigne/observability-api bumped to 0.11.2
+
+## [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)
+
+
+### Bug Fixes
+
+* **gemini:** implement retry mechanism for empty responses with structured output fallback ([#638](https://github.com/AIGNE-io/aigne-framework/issues/638)) ([d33c8bb](https://github.com/AIGNE-io/aigne-framework/commit/d33c8bb9711aadddef9687d6cf472a179cd8ed9c))
+
+## [1.63.0-beta.10](https://github.com/AIGNE-io/aigne-framework/compare/core-v1.63.0-beta.9...core-v1.63.0-beta.10) (2025-10-16)
+
+
+### Dependencies
+
+* The following workspace dependencies were updated
+  * dependencies
+    * @aigne/observability-api bumped to 0.11.2-beta.5
+
+## [1.63.0-beta.9](https://github.com/AIGNE-io/aigne-framework/compare/core-v1.63.0-beta.8...core-v1.63.0-beta.9) (2025-10-16)
+
+
+### Bug Fixes
+
+* allow custom user messages and prevent duplicate user content ([#632](https://github.com/AIGNE-io/aigne-framework/issues/632)) ([6c883b2](https://github.com/AIGNE-io/aigne-framework/commit/6c883b2d57a65e9b46232cece91fc6aa1de03aba))
+* **models:** auto retry when got emtpy response from gemini ([#636](https://github.com/AIGNE-io/aigne-framework/issues/636)) ([9367cef](https://github.com/AIGNE-io/aigne-framework/commit/9367cef49ea4c0c87b8a36b454deb2efaee6886f))
+
+
+### Dependencies
+
+* The following workspace dependencies were updated
+  * dependencies
+    * @aigne/observability-api bumped to 0.11.2-beta.4
+
 ## [1.63.0-beta.8](https://github.com/AIGNE-io/aigne-framework/compare/core-v1.63.0-beta.7...core-v1.63.0-beta.8) (2025-10-16)
 
 

package/lib/cjs/agents/agent.d.ts

@@ -20,7 +20,8 @@ export declare const DEFAULT_INPUT_ACTION_GET = "$get";
  */
 export interface Message extends Record<string, unknown> {
     $meta?: {
-        usage: ContextUsage;
+        usage?: ContextUsage;
+        [key: string]: unknown;
     };
 }
 /**

package/lib/cjs/agents/agent.js

@@ -451,7 +451,10 @@ class Agent {
                     (0, stream_utils_js_1.mergeAgentResponseChunk)(output, chunk);
                     yield chunk;
                 }
-                const result = await this.processAgentOutput(input, output, options);
+                let result = await this.processAgentOutput(input, output, options);
+                if (attempt > 0) {
+                    result = { ...result, $meta: { ...result.$meta, retries: attempt } };
+                }
                 if (result && !(0, fast_deep_equal_1.default)(result, output)) {
                     yield { delta: { json: result } };
                 }
@@ -461,7 +464,8 @@ class Agent {
             catch (error) {
                 if (this.retryOnError?.retries) {
                     const { retries, minTimeout = DEFAULT_RETRY_MIN_TIMEOUT, factor = DEFAULT_RETRY_FACTOR, randomize = false, shouldRetry, } = this.retryOnError;
-                    if (attempt++ < retries && (!shouldRetry || (await shouldRetry(error)))) {
+                    if (attempt < retries && (!shouldRetry || (await shouldRetry(error)))) {
+                        attempt++;
                         const timeout = minTimeout * factor ** (attempt - 1) * (randomize ? 1 + Math.random() : 1);
                         logger_js_1.logger.warn(`Agent ${this.name} attempt ${attempt} of ${retries} failed with error: ${error}. Retrying in ${timeout}ms...`);
                         await new Promise((resolve) => setTimeout(resolve, timeout));
@@ -469,8 +473,12 @@ class Agent {
                     }
                 }
                 const res = await this.processAgentError(input, error, options);
-                if (!res.retry)
-                    throw res.error ?? error;
+                if (!res.retry) {
+                    const e = res.error ?? error;
+                    if (attempt > 0)
+                        e.message += ` (after ${attempt + 1} retries)`;
+                    throw e;
+                }
             }
         }
     }

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/prompt/prompt-builder.js

@@ -87,9 +87,9 @@ class PromptBuilder {
         const { input } = options;
         const inputKey = options.agent?.inputKey;
         const message = inputKey && typeof input?.[inputKey] === "string" ? input[inputKey] : undefined;
-        const messages = (await (typeof this.instructions === "string"
+        const [messages, otherCustomMessages] = (0, type_utils_js_1.partition)((await (typeof this.instructions === "string"
             ? template_js_1.ChatMessagesTemplate.from([template_js_1.SystemMessageTemplate.from(this.instructions)])
-            : this.instructions)?.format(options.input, { workingDir: this.workingDir })) ?? [];
+            : this.instructions)?.format(options.input, { workingDir: this.workingDir })) ?? [], (i) => i.role === "system");
         const inputFileKey = options.agent?.inputFileKey;
         const files = (0, type_utils_js_1.flat)(inputFileKey
             ? (0, type_utils_js_1.checkArguments)("Check input files", (0, schema_js_1.optionalize)(model_js_1.fileUnionContentsSchema), input?.[inputFileKey])
@@ -102,7 +102,7 @@ class PromptBuilder {
             memories.push(...options.context.memories);
         }
         if (options.agent?.afs) {
-            messages.push(template_js_1.SystemMessageTemplate.from(await (0, afs_builtin_prompt_js_1.getAFSSystemPrompt)(options.agent.afs)));
+            messages.push(await template_js_1.SystemMessageTemplate.from(await (0, afs_builtin_prompt_js_1.getAFSSystemPrompt)(options.agent.afs)).format({}));
             if (options.agent.afsConfig?.injectHistory) {
                 const history = await options.agent.afs.list(afs_1.AFSHistory.Path, {
                     limit: options.agent.afsConfig.historyWindowSize || 10,
@@ -132,12 +132,21 @@ class PromptBuilder {
         }
         if (message || files.length) {
             const content = [];
-            if (message)
+            if (message &&
+                // avoid duplicate user messages: developer may have already included the message in the custom user messages
+                !otherCustomMessages.some((i) => i.role === "user" &&
+                    (typeof i.content === "string"
+                        ? i.content.includes(message)
+                        : i.content?.some((c) => c.type === "text" && c.text.includes(message))))) {
                 content.push({ type: "text", text: message });
+            }
             if (files.length)
                 content.push(...files);
-            messages.push({ role: "user", content });
+            if (content.length) {
+                messages.push({ role: "user", content });
+            }
         }
+        messages.push(...otherCustomMessages);
         return this.refineMessages(options, messages);
     }
     refineMessages(options, messages) {

package/lib/cjs/utils/model-utils.js

@@ -5,5 +5,6 @@ function mergeUsage(...usages) {
     return {
         inputTokens: usages.reduce((acc, usage) => (usage ? acc + usage.inputTokens : acc), 0),
         outputTokens: usages.reduce((acc, usage) => (usage ? acc + usage.outputTokens : acc), 0),
+        aigneHubCredits: usages.reduce((acc, usage) => (usage?.aigneHubCredits ? acc + usage.aigneHubCredits : acc), 0),
     };
 }

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/agents/agent.d.ts

@@ -20,7 +20,8 @@ export declare const DEFAULT_INPUT_ACTION_GET = "$get";
  */
 export interface Message extends Record<string, unknown> {
     $meta?: {
-        usage: ContextUsage;
+        usage?: ContextUsage;
+        [key: string]: unknown;
     };
 }
 /**

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/agent.d.ts

@@ -20,7 +20,8 @@ export declare const DEFAULT_INPUT_ACTION_GET = "$get";
  */
 export interface Message extends Record<string, unknown> {
     $meta?: {
-        usage: ContextUsage;
+        usage?: ContextUsage;
+        [key: string]: unknown;
     };
 }
 /**

package/lib/esm/agents/agent.js

@@ -403,7 +403,10 @@ export class Agent {
                     mergeAgentResponseChunk(output, chunk);
                     yield chunk;
                 }
-                const result = await this.processAgentOutput(input, output, options);
+                let result = await this.processAgentOutput(input, output, options);
+                if (attempt > 0) {
+                    result = { ...result, $meta: { ...result.$meta, retries: attempt } };
+                }
                 if (result && !equal(result, output)) {
                     yield { delta: { json: result } };
                 }
@@ -413,7 +416,8 @@ export class Agent {
             catch (error) {
                 if (this.retryOnError?.retries) {
                     const { retries, minTimeout = DEFAULT_RETRY_MIN_TIMEOUT, factor = DEFAULT_RETRY_FACTOR, randomize = false, shouldRetry, } = this.retryOnError;
-                    if (attempt++ < retries && (!shouldRetry || (await shouldRetry(error)))) {
+                    if (attempt < retries && (!shouldRetry || (await shouldRetry(error)))) {
+                        attempt++;
                         const timeout = minTimeout * factor ** (attempt - 1) * (randomize ? 1 + Math.random() : 1);
                         logger.warn(`Agent ${this.name} attempt ${attempt} of ${retries} failed with error: ${error}. Retrying in ${timeout}ms...`);
                         await new Promise((resolve) => setTimeout(resolve, timeout));
@@ -421,8 +425,12 @@ export class Agent {
                     }
                 }
                 const res = await this.processAgentError(input, error, options);
-                if (!res.retry)
-                    throw res.error ?? error;
+                if (!res.retry) {
+                    const e = res.error ?? error;
+                    if (attempt > 0)
+                        e.message += ` (after ${attempt + 1} retries)`;
+                    throw e;
+                }
             }
         }
     }

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/prompt/prompt-builder.js

@@ -84,9 +84,9 @@ export class PromptBuilder {
         const { input } = options;
         const inputKey = options.agent?.inputKey;
         const message = inputKey && typeof input?.[inputKey] === "string" ? input[inputKey] : undefined;
-        const messages = (await (typeof this.instructions === "string"
+        const [messages, otherCustomMessages] = partition((await (typeof this.instructions === "string"
             ? ChatMessagesTemplate.from([SystemMessageTemplate.from(this.instructions)])
-            : this.instructions)?.format(options.input, { workingDir: this.workingDir })) ?? [];
+            : this.instructions)?.format(options.input, { workingDir: this.workingDir })) ?? [], (i) => i.role === "system");
         const inputFileKey = options.agent?.inputFileKey;
         const files = flat(inputFileKey
             ? checkArguments("Check input files", optionalize(fileUnionContentsSchema), input?.[inputFileKey])
@@ -99,7 +99,7 @@ export class PromptBuilder {
             memories.push(...options.context.memories);
         }
         if (options.agent?.afs) {
-            messages.push(SystemMessageTemplate.from(await getAFSSystemPrompt(options.agent.afs)));
+            messages.push(await SystemMessageTemplate.from(await getAFSSystemPrompt(options.agent.afs)).format({}));
             if (options.agent.afsConfig?.injectHistory) {
                 const history = await options.agent.afs.list(AFSHistory.Path, {
                     limit: options.agent.afsConfig.historyWindowSize || 10,
@@ -129,12 +129,21 @@ export class PromptBuilder {
         }
         if (message || files.length) {
             const content = [];
-            if (message)
+            if (message &&
+                // avoid duplicate user messages: developer may have already included the message in the custom user messages
+                !otherCustomMessages.some((i) => i.role === "user" &&
+                    (typeof i.content === "string"
+                        ? i.content.includes(message)
+                        : i.content?.some((c) => c.type === "text" && c.text.includes(message))))) {
                 content.push({ type: "text", text: message });
+            }
             if (files.length)
                 content.push(...files);
-            messages.push({ role: "user", content });
+            if (content.length) {
+                messages.push({ role: "user", content });
+            }
         }
+        messages.push(...otherCustomMessages);
         return this.refineMessages(options, messages);
     }
     refineMessages(options, messages) {

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

@@ -2,5 +2,6 @@ export function mergeUsage(...usages) {
     return {
         inputTokens: usages.reduce((acc, usage) => (usage ? acc + usage.inputTokens : acc), 0),
         outputTokens: usages.reduce((acc, usage) => (usage ? acc + usage.outputTokens : acc), 0),
+        aigneHubCredits: usages.reduce((acc, usage) => (usage?.aigneHubCredits ? acc + usage.aigneHubCredits : acc), 0),
     };
 }

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.8",
+  "version": "1.63.0",
   "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",
@@ -92,9 +91,9 @@
     "zod": "^3.25.67",
     "zod-from-json-schema": "^0.0.5",
     "zod-to-json-schema": "^3.24.6",
-    "@aigne/platform-helpers": "^0.6.3",
-    "@aigne/afs": "^1.1.0-beta",
-    "@aigne/observability-api": "^0.11.2-beta.3"
+    "@aigne/afs": "^1.1.0",
+    "@aigne/observability-api": "^0.11.2",
+    "@aigne/platform-helpers": "^0.6.3"
   },
   "devDependencies": {
     "@types/bun": "^1.2.22",