@aigne/core 1.72.0 → 1.74.0-beta

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

@@ -1,52 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.toolFromMCPTool = toolFromMCPTool;
-exports.promptFromMCPPrompt = promptFromMCPPrompt;
-exports.resourceFromMCPResource = resourceFromMCPResource;
-const json_schema_to_zod_1 = require("@aigne/json-schema-to-zod");
-const uriTemplate_js_1 = require("@modelcontextprotocol/sdk/shared/uriTemplate.js");
-const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
-const zod_1 = require("zod");
-const mcp_agent_js_1 = require("../agents/mcp-agent.js");
-const type_utils_js_1 = require("./type-utils.js");
-function toolFromMCPTool(tool, options) {
-    return new mcp_agent_js_1.MCPTool({
-        ...options,
-        name: tool.name,
-        description: tool.description,
-        inputSchema: (0, type_utils_js_1.isEmpty)(tool.inputSchema.properties)
-            ? zod_1.z.object({})
-            : (0, json_schema_to_zod_1.jsonSchemaToZod)(tool.inputSchema),
-        outputSchema: types_js_1.CallToolResultSchema,
-    });
-}
-function promptFromMCPPrompt(prompt, options) {
-    return new mcp_agent_js_1.MCPPrompt({
-        ...options,
-        name: prompt.name,
-        description: prompt.description,
-        inputSchema: (0, json_schema_to_zod_1.jsonSchemaToZod)({
-            type: "object",
-            properties: prompt.arguments &&
-                Object.fromEntries(prompt.arguments.map((i) => [i.name, { type: "string", description: i.description }])),
-            required: prompt.arguments?.filter((i) => i.required).map((i) => i.name),
-        }),
-        outputSchema: types_js_1.GetPromptResultSchema,
-    });
-}
-function resourceFromMCPResource(resource, options) {
-    const [uri, variables] = isResourceTemplate(resource)
-        ? [resource.uriTemplate, new uriTemplate_js_1.UriTemplate(resource.uriTemplate).variableNames]
-        : [resource.uri, []];
-    return new mcp_agent_js_1.MCPResource({
-        ...options,
-        name: resource.name,
-        uri,
-        description: resource.description,
-        inputSchema: zod_1.z.object(Object.fromEntries(variables.map((i) => [i, zod_1.z.string()]))),
-        outputSchema: types_js_1.ReadResourceResultSchema,
-    });
-}
-function isResourceTemplate(resource) {
-    return "uriTemplate" in resource && typeof resource.uriTemplate === "string";
-}

package/lib/cjs/utils/model-utils.d.ts

@@ -1,3 +0,0 @@
-import type { ChatModelOutputUsage } from "../agents/chat-model.js";
-import type { Nullish } from "./type-utils.js";
-export declare function mergeUsage(...usages: Nullish<ChatModelOutputUsage>[]): ChatModelOutputUsage;

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

@@ -1,10 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.mergeUsage = mergeUsage;
-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/promise.d.ts

@@ -1,6 +0,0 @@
-export interface PromiseWithResolvers<T> {
-    promise: Promise<T>;
-    resolve: (value: T | PromiseLike<T>) => void;
-    reject: (reason?: unknown) => void;
-}
-export declare function promiseWithResolvers<T = void>(): PromiseWithResolvers<T>;

package/lib/cjs/utils/promise.js

@@ -1,12 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.promiseWithResolvers = promiseWithResolvers;
-function promiseWithResolvers() {
-    let resolve;
-    let reject;
-    const promise = new Promise((res, rej) => {
-        resolve = res;
-        reject = rej;
-    });
-    return { promise, resolve, reject };
-}

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

@@ -1,2 +0,0 @@
-export declare function getJsonOutputPrompt(schema: Record<string, unknown> | string): string;
-export declare function getJsonToolInputPrompt(schema: Record<string, unknown> | string): string;

package/lib/cjs/utils/prompts.js

@@ -1,22 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getJsonOutputPrompt = getJsonOutputPrompt;
-exports.getJsonToolInputPrompt = getJsonToolInputPrompt;
-function buildJsonPrompt(schema, firstLine) {
-    let prompt = firstLine;
-    if (typeof schema === "string") {
-        prompt += `\n<json_fields>\n${schema}\n</json_fields>`;
-    }
-    else {
-        prompt += `\n<json_fields>\n${JSON.stringify(schema)}\n</json_fields>`;
-    }
-    prompt +=
-        "\nDo not include any explanations, comments, or Markdown formatting (such as triple backticks). Return only the raw JSON.";
-    return prompt;
-}
-function getJsonOutputPrompt(schema) {
-    return buildJsonPrompt(schema, "Output must be a JSON object containing the following fields only.");
-}
-function getJsonToolInputPrompt(schema) {
-    return buildJsonPrompt(schema, "Tool input must be a JSON object containing the following fields only.");
-}

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

@@ -1,57 +0,0 @@
-/** 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

@@ -1,318 +0,0 @@
-"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/cjs/utils/role-utils.d.ts

@@ -1,31 +0,0 @@
-import type { Role } from "../agents/chat-model.js";
-/**
- * Standard role mapping for most chat model providers
- * Maps AIGNE framework roles to common provider role names
- */
-export declare const STANDARD_ROLE_MAP: {
-    [key in Role]: string;
-};
-/**
- * Creates a role mapper function for a specific provider
- *
- * @param roleMap - Custom role mapping for the provider
- * @returns Function that maps AIGNE roles to provider roles
- *
- * @example
- * ```typescript
- * // For standard providers (OpenAI, Anthropic, etc.)
- * const mapRole = createRoleMapper(STANDARD_ROLE_MAP);
- *
- * // For providers with different role names
- * const customMap = { ...STANDARD_ROLE_MAP, agent: "bot" };
- * const customMapper = createRoleMapper(customMap);
- * ```
- */
-export declare function createRoleMapper<T extends string>(roleMap: {
-    [key in Role]: T;
-}): (role: Role) => T;
-/**
- * Standard role mapper using the default role mapping
- */
-export declare const mapStandardRole: (role: Role) => string;

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

@@ -1,37 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.mapStandardRole = exports.STANDARD_ROLE_MAP = void 0;
-exports.createRoleMapper = createRoleMapper;
-/**
- * Standard role mapping for most chat model providers
- * Maps AIGNE framework roles to common provider role names
- */
-exports.STANDARD_ROLE_MAP = {
-    system: "system",
-    user: "user",
-    agent: "assistant",
-    tool: "tool",
-};
-/**
- * Creates a role mapper function for a specific provider
- *
- * @param roleMap - Custom role mapping for the provider
- * @returns Function that maps AIGNE roles to provider roles
- *
- * @example
- * ```typescript
- * // For standard providers (OpenAI, Anthropic, etc.)
- * const mapRole = createRoleMapper(STANDARD_ROLE_MAP);
- *
- * // For providers with different role names
- * const customMap = { ...STANDARD_ROLE_MAP, agent: "bot" };
- * const customMapper = createRoleMapper(customMap);
- * ```
- */
-function createRoleMapper(roleMap) {
-    return (role) => roleMap[role];
-}
-/**
- * Standard role mapper using the default role mapping
- */
-exports.mapStandardRole = createRoleMapper(exports.STANDARD_ROLE_MAP);

package/lib/cjs/utils/stream-polyfill.d.ts

@@ -1 +0,0 @@
-export {};

package/lib/cjs/utils/stream-polyfill.js

@@ -1,38 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-ReadableStream.prototype.values ??= function ({ preventCancel = false } = {}) {
-    const reader = this.getReader();
-    return {
-        async next() {
-            try {
-                const result = await reader.read();
-                if (result.done) {
-                    reader.releaseLock();
-                }
-                return result;
-            }
-            catch (e) {
-                reader.releaseLock();
-                throw e;
-            }
-        },
-        async return(value) {
-            if (!preventCancel) {
-                const cancelPromise = reader.cancel(value);
-                reader.releaseLock();
-                await cancelPromise;
-            }
-            else {
-                reader.releaseLock();
-            }
-            return { done: true, value };
-        },
-        [Symbol.asyncIterator]() {
-            return this;
-        },
-        async [Symbol.asyncDispose]() {
-            reader.releaseLock();
-        },
-    };
-};
-ReadableStream.prototype[Symbol.asyncIterator] ??= ReadableStream.prototype.values;

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

@@ -1,26 +0,0 @@
-import { type AgentProcessAsyncGenerator, type AgentResponseChunk, type AgentResponseStream, type Message } from "../agents/agent.js";
-import { type PromiseOrValue } from "./type-utils.js";
-import "./stream-polyfill.js";
-export declare function objectToAgentResponseStream<T extends Message>(json: T): AgentResponseStream<T>;
-export declare function mergeAgentResponseChunk<T extends Message>(output: T, chunk: AgentResponseChunk<T>): T;
-export declare function agentResponseStreamToObject<T extends Message>(stream: AgentResponseStream<T> | AgentProcessAsyncGenerator<T>): Promise<T>;
-export declare function asyncGeneratorToReadableStream<T extends Message>(generator: AgentProcessAsyncGenerator<T>): AgentResponseStream<T>;
-export declare function onAgentResponseStreamEnd<T extends Message>(stream: AgentResponseStream<T>, options?: {
-    onChunk?: (chunk: AgentResponseChunk<T>) => PromiseOrValue<AgentResponseChunk<T> | undefined | void>;
-    onResult?: (result: T) => PromiseOrValue<Partial<T> | undefined | void>;
-    onError?: (error: Error) => PromiseOrValue<Error>;
-}): AgentResponseStream<T>;
-export declare function isAsyncGenerator<T extends AsyncGenerator>(value: AsyncGenerator | unknown): value is T;
-export declare function arrayToAgentProcessAsyncGenerator<T extends Message>(chunks: (AgentResponseChunk<T> | Error)[], result?: Partial<T>): AgentProcessAsyncGenerator<T>;
-export declare function arrayToReadableStream<T>(chunks: (T | Error)[]): ReadableStream<T>;
-export declare function readableStreamToArray<T>(stream: ReadableStream<T>, options: {
-    catchError: true;
-}): Promise<(T | Error)[]>;
-export declare function readableStreamToArray<T>(stream: ReadableStream<T>, options?: {
-    catchError?: boolean;
-}): Promise<T[]>;
-export declare function stringToAgentResponseStream(str: string, key?: "text" | string): AgentResponseStream<Message>;
-export declare function toReadableStream(stream: NodeJS.ReadStream): ReadableStream<Uint8Array<ArrayBufferLike>>;
-export declare function readAllString(stream: NodeJS.ReadStream | ReadableStream): Promise<string>;
-export declare function mergeReadableStreams<T1, T2>(s1: ReadableStream<T1>, s2: ReadableStream<T2>): ReadableStream<T1 | T2>;
-export declare function mergeReadableStreams(...streams: (ReadableStream<any> | undefined)[]): ReadableStream<any>;