@aigne/core 1.72.0 → 1.74.0-beta

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

@@ -1,60 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.sortHooks = sortHooks;
-exports.mapCliAgent = mapCliAgent;
-exports.findCliAgent = findCliAgent;
-exports.isAgent = isAgent;
-const priorities = ["high", "medium", "low"];
-function sortHooks(hooks) {
-    return hooks
-        .slice(0)
-        .sort(({ priority: a = "low" }, { priority: b = "low" }) => a === b ? 0 : priorities.indexOf(a) - priorities.indexOf(b));
-}
-function mapCliAgent({ agent, agents, ...input }, transform) {
-    return {
-        ...input,
-        agent: agent ? transform(agent) : undefined,
-        agents: agents?.map((item) => mapCliAgent(item, transform)),
-    };
-}
-function findCliAgent(cli, parent, name) {
-    if (parent === "*")
-        return findCliAgentRecursive(cli, name);
-    let currentAgents = cli.agents ?? [];
-    for (const name of parent) {
-        const found = currentAgents.find((i) => (i.name || i.agent?.name) === name);
-        if (!found)
-            throw new Error(`Agent ${name} not found in parent path ${parent.join(" -> ")}`);
-        if (found.agents)
-            currentAgents = found.agents;
-        else
-            currentAgents = [];
-    }
-    return currentAgents.find((i) => (i.name || i.agent?.name) === name)?.agent;
-}
-function findCliAgentRecursive(agents, name) {
-    if (agents.chat?.name === name) {
-        return agents.chat;
-    }
-    if (agents.agents) {
-        const queue = [...agents.agents];
-        while (queue.length > 0) {
-            const c = queue.shift();
-            if (!c)
-                break;
-            if ((c.name || c.agent?.name) === name) {
-                return c.agent;
-            }
-            if (c.agents) {
-                queue.push(...c.agents);
-            }
-        }
-    }
-    return undefined;
-}
-function isAgent(obj) {
-    return (obj &&
-        typeof obj.name === "string" &&
-        typeof obj.invoke === "function" &&
-        typeof obj.process === "function");
-}

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

@@ -1,7 +0,0 @@
-export type CamelCase<S extends string> = S extends `${infer P1}_${infer P2}${infer P3}` ? `${P1}${Uppercase<P2>}${CamelCase<P3>}` : S;
-export type CamelizeObject<T, S = false> = {
-    [K in keyof T as Uncapitalize<CamelCase<string & K>>]: T[K] extends Date ? T[K] : T[K] extends RegExp ? T[K] : T[K] extends Array<infer U> ? U extends object | undefined ? Array<CamelizeObject<U>> : T[K] : T[K] extends object | undefined ? S extends true ? T[K] : CamelizeObject<T[K]> : T[K];
-};
-export type Camelize<T, S = false> = T extends Array<infer U> ? Array<CamelizeObject<U, S>> : CamelizeObject<T, S>;
-export declare function camelize<T, S extends boolean = false>(obj: T, shallow?: S): T extends string ? string : Camelize<T, S>;
-export declare function snakelize<T, S extends boolean = false>(obj: T, shallow?: S): T extends string ? string : any;

package/lib/cjs/utils/camelize.js

@@ -1,38 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.camelize = camelize;
-exports.snakelize = snakelize;
-function camelize(obj, shallow) {
-    return typeof obj === "string" ? camelCase(obj) : walk(obj, shallow, camelCase);
-}
-function snakelize(obj, shallow) {
-    return typeof obj === "string" ? snakeCase(obj) : walk(obj, shallow, snakeCase);
-}
-function camelCase(key) {
-    key = key.replace(/[_.-](\w|$)/g, (_, char) => char.toUpperCase());
-    key = key.charAt(0).toLowerCase() + key.slice(1);
-    return key;
-}
-function snakeCase(key) {
-    return key.replace(/([a-z])([A-Z])/g, "$1_$2").toLowerCase();
-}
-function walk(obj, shallow = false, transform) {
-    if (!obj || typeof obj !== "object")
-        return obj;
-    if (obj instanceof Date || obj instanceof RegExp)
-        return obj;
-    if (Array.isArray(obj))
-        return obj.map((v) => {
-            if (!shallow) {
-                return walk(v, shallow, transform);
-            }
-            if (typeof v === "object")
-                return walk(v, shallow, transform);
-            return v;
-        });
-    return Object.keys(obj).reduce((res, key) => {
-        const newKey = transform(key);
-        res[newKey] = shallow ? obj[key] : walk(obj[key], shallow, transform);
-        return res;
-    }, {});
-}

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

@@ -1,15 +0,0 @@
-import { type AgentResponseChunk, type AgentResponseProgress, type AgentResponseStream, type Message } from "../agents/agent.js";
-import type { Context } from "../aigne/context.js";
-export declare class EventStreamParser<T> extends TransformStream<string, T | Error> {
-    constructor();
-}
-export declare class AgentResponseStreamParser<O extends Message> extends TransformStream<AgentResponseChunk<O> | Error, AgentResponseChunk<O>> {
-    private json;
-    constructor();
-}
-export declare class AgentResponseStreamSSE<O extends Message> extends ReadableStream<string> {
-    constructor(stream: AgentResponseStream<O>);
-}
-export declare class AgentResponseProgressStream extends ReadableStream<AgentResponseProgress> {
-    constructor(context: Context);
-}

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

@@ -1,158 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AgentResponseProgressStream = exports.AgentResponseStreamSSE = exports.AgentResponseStreamParser = exports.EventStreamParser = void 0;
-const eventsource_parser_1 = require("eventsource-parser");
-const immer_1 = require("immer");
-const agent_js_1 = require("../agents/agent.js");
-const type_utils_js_1 = require("./type-utils.js");
-(0, immer_1.setAutoFreeze)(false);
-class EventStreamParser extends TransformStream {
-    constructor() {
-        let parser;
-        super({
-            start(controller) {
-                parser = (0, eventsource_parser_1.createParser)({
-                    onEvent: (event) => {
-                        const json = (0, type_utils_js_1.tryOrThrow)(() => JSON.parse(event.data), (e) => {
-                            controller.enqueue(new Error(`Parse response chunk json error: ${e.message} ${event.data}`));
-                        });
-                        if (json) {
-                            switch (event.event) {
-                                case "error":
-                                    controller.enqueue(new Error(json.message));
-                                    break;
-                                default: {
-                                    if (!event.event)
-                                        controller.enqueue(json);
-                                    else
-                                        console.warn(`Unknown event type: ${event.event}`, event.data);
-                                }
-                            }
-                        }
-                    },
-                });
-            },
-            transform(chunk) {
-                parser?.feed(chunk);
-            },
-        });
-    }
-}
-exports.EventStreamParser = EventStreamParser;
-class AgentResponseStreamParser extends TransformStream {
-    json = {};
-    constructor() {
-        super({
-            transform: (chunk, controller) => {
-                if (chunk instanceof Error) {
-                    controller.error(chunk);
-                    controller.terminate();
-                    return;
-                }
-                if ((0, agent_js_1.isAgentResponseDelta)(chunk)) {
-                    this.json = (0, immer_1.produce)(this.json, (draft) => {
-                        if (chunk.delta.json)
-                            Object.assign(draft, chunk.delta.json);
-                        if (chunk.delta.text) {
-                            for (const [key, text] of Object.entries(chunk.delta.text)) {
-                                const original = draft[key];
-                                const t = (original || "") + (text || "");
-                                if (t)
-                                    Object.assign(draft, { [key]: t });
-                            }
-                        }
-                    });
-                    controller.enqueue({
-                        ...chunk,
-                        delta: {
-                            ...chunk.delta,
-                            json: this.json,
-                        },
-                    });
-                }
-                else if ((0, agent_js_1.isAgentResponseProgress)(chunk)) {
-                    if (chunk.progress.event === "agentFailed") {
-                        const { name, message } = chunk.progress.error;
-                        chunk.progress.error = new Error(message);
-                        chunk.progress.error.name = name;
-                    }
-                    controller.enqueue(chunk);
-                }
-            },
-        });
-    }
-}
-exports.AgentResponseStreamParser = AgentResponseStreamParser;
-class AgentResponseStreamSSE extends ReadableStream {
-    constructor(stream) {
-        let reader;
-        super({
-            async pull(controller) {
-                reader ??= stream.getReader();
-                try {
-                    const { value, done } = await reader.read();
-                    if (done) {
-                        controller.close();
-                        return;
-                    }
-                    if ((0, agent_js_1.isAgentResponseProgress)(value)) {
-                        if (value.progress.event === "agentFailed") {
-                            value.progress.error = {
-                                name: value.progress.error.name,
-                                message: value.progress.error.message,
-                            };
-                        }
-                    }
-                    controller.enqueue(`data: ${JSON.stringify(value)}\n\n`);
-                }
-                catch (error) {
-                    controller.enqueue(`event: error\ndata: ${JSON.stringify({ message: error.message })}\n\n`);
-                    controller.close();
-                }
-            },
-        });
-    }
-}
-exports.AgentResponseStreamSSE = AgentResponseStreamSSE;
-class AgentResponseProgressStream extends ReadableStream {
-    constructor(context) {
-        super({
-            async start(controller) {
-                const writeEvent = (eventName, event) => {
-                    const progress = {
-                        ...event,
-                        event: eventName,
-                        agent: { name: event.agent.name },
-                    };
-                    controller.enqueue({ progress });
-                };
-                const close = () => {
-                    context.off("agentStarted", onAgentStarted);
-                    context.off("agentSucceed", onAgentSucceed);
-                    context.off("agentFailed", onAgentFailed);
-                    controller.close();
-                };
-                const onAgentStarted = async (event) => {
-                    const taskTitle = await event.agent.renderTaskTitle(event.input);
-                    writeEvent("agentStarted", { ...event, taskTitle });
-                };
-                const onAgentSucceed = (event) => {
-                    writeEvent("agentSucceed", event);
-                    if (event.contextId === context.id) {
-                        close();
-                    }
-                };
-                const onAgentFailed = (event) => {
-                    writeEvent("agentFailed", event);
-                    if (event.contextId === context.id) {
-                        close();
-                    }
-                };
-                context.on("agentStarted", onAgentStarted);
-                context.on("agentSucceed", onAgentSucceed);
-                context.on("agentFailed", onAgentFailed);
-            },
-        });
-    }
-}
-exports.AgentResponseProgressStream = AgentResponseProgressStream;

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

@@ -1,4 +0,0 @@
-export declare function fetch(input: RequestInfo, init?: RequestInit & {
-    timeout?: number;
-    skipResponseCheck?: boolean;
-}): Promise<Response>;

package/lib/cjs/utils/fetch.js

@@ -1,36 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.fetch = fetch;
-const TIMEOUT = (process.env.TIMEOUT && parseInt(process.env.TIMEOUT, 10)) || 8e3; // default timeout 8 seconds
-async function fetch(input, init) {
-    const url = typeof input === "string" ? input : input instanceof URL ? input.toString() : input.url;
-    const timeout = init?.timeout || TIMEOUT;
-    const controller = timeout ? new AbortController() : undefined;
-    const timeoutId = controller
-        ? setTimeout(() => controller.abort(new Error(`Timeout after ${timeout}ms`)), timeout)
-        : undefined;
-    try {
-        const response = await globalThis
-            .fetch(input, {
-            ...init,
-            signal: controller?.signal,
-        })
-            .catch((error) => {
-            throw new Error(`Fetch ${url} error: ${error.message}`);
-        });
-        // Clear the timeout if the fetch completes successfully
-        clearTimeout(timeoutId);
-        if (!init?.skipResponseCheck && !response.ok) {
-            const text = await response.text().catch(() => "");
-            throw new Error(`Fetch ${url} error: ${response.status} ${response.statusText} ${text}`);
-        }
-        const json = response.json.bind(response);
-        response.json = () => json().catch((error) => {
-            throw new Error(`Parse JSON from ${url} error: ${error.message}`);
-        });
-        return response;
-    }
-    finally {
-        clearTimeout(timeoutId);
-    }
-}

package/lib/cjs/utils/json-schema.d.ts

@@ -1,15 +0,0 @@
-import { type ZodType, z } from "zod";
-import type { Message } from "../agents/agent.js";
-export declare function outputSchemaToResponseFormatSchema(agentOutput: ZodType<Message>): Record<string, unknown>;
-export declare function parseJSON(json: string): any;
-/**
- * Ensure that the union array has at least 1 item.
- * NOTE: the zod union requires at least 2 items (just type definition, not runtime behavior)
- * so we need to ensure that the union has at least 1 item.
- * @param union - The union array
- * @returns The union array with at least 1 item (but the type is at least 2 items for z.union)
- */
-export declare function ensureZodUnionArray<T extends z.ZodType>(union: T[]): [T, T, ...T[]];
-export declare function isZodSchema(schema: ZodType): schema is ZodType;
-export declare const wrapAutoParseJsonSchema: <T extends ZodType>(schema: T) => T;
-export declare function getZodObjectKeys(schema: ZodType): string[];

package/lib/cjs/utils/json-schema.js

@@ -1,123 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.wrapAutoParseJsonSchema = void 0;
-exports.outputSchemaToResponseFormatSchema = outputSchemaToResponseFormatSchema;
-exports.parseJSON = parseJSON;
-exports.ensureZodUnionArray = ensureZodUnionArray;
-exports.isZodSchema = isZodSchema;
-exports.getZodObjectKeys = getZodObjectKeys;
-const zod_1 = require("zod");
-const zod_to_json_schema_1 = require("zod-to-json-schema");
-const json_utils_js_1 = require("./json-utils.js");
-const logger_js_1 = require("./logger.js");
-const type_utils_js_1 = require("./type-utils.js");
-function outputSchemaToResponseFormatSchema(agentOutput) {
-    return convertNullableToOptional(setAdditionPropertiesDeep((0, zod_to_json_schema_1.zodToJsonSchema)(agentOutput), false))[0];
-}
-function setAdditionPropertiesDeep(schema, additionalProperties) {
-    if (Array.isArray(schema)) {
-        return schema.map((s) => setAdditionPropertiesDeep(s, additionalProperties));
-    }
-    if (schema !== null && typeof schema === "object" && !Array.isArray(schema)) {
-        return Object.entries(schema).reduce((acc, [key, value]) => {
-            acc[key] = setAdditionPropertiesDeep(value, additionalProperties);
-            if (acc.type === "object") {
-                acc.additionalProperties = additionalProperties;
-            }
-            return acc;
-        }, {});
-    }
-    return schema;
-}
-function parseJSON(json) {
-    try {
-        return JSON.parse(json);
-    }
-    catch (error) {
-        logger_js_1.logger.error("Failed to parse JSON", { json, error });
-        throw error;
-    }
-}
-/**
- * Ensure that the union array has at least 1 item.
- * NOTE: the zod union requires at least 2 items (just type definition, not runtime behavior)
- * so we need to ensure that the union has at least 1 item.
- * @param union - The union array
- * @returns The union array with at least 1 item (but the type is at least 2 items for z.union)
- */
-function ensureZodUnionArray(union) {
-    if (!(union.length >= 1)) {
-        throw new Error(`Union must have at least 1 item, but got ${union.length}`);
-    }
-    return union;
-}
-function isZodSchema(schema) {
-    if (!schema || typeof schema !== "object")
-        return false;
-    return typeof schema.parse === "function" && typeof schema.safeParse === "function";
-}
-function convertNullableToOptional(schema) {
-    if (!(0, type_utils_js_1.isRecord)(schema))
-        return [schema, false];
-    if (schema.type === "object" && "properties" in schema && (0, type_utils_js_1.isRecord)(schema.properties)) {
-        const optionalProperties = [];
-        const properties = Object.fromEntries(Object.entries(schema.properties).map(([key, value]) => {
-            const [property, optional] = convertNullableToOptional(value);
-            if (optional)
-                optionalProperties.push(key);
-            return [key, property];
-        }));
-        const currentRequired = "required" in schema && Array.isArray(schema.required) ? schema.required : [];
-        const required = currentRequired.filter((key) => !optionalProperties.includes(key));
-        return [{ ...schema, properties, required }, false];
-    }
-    if (schema.type === "array" && "items" in schema && (0, type_utils_js_1.isRecord)(schema.items)) {
-        const [items, _] = convertNullableToOptional(schema.items);
-        return [{ ...schema, items }, false];
-    }
-    if (Array.isArray(schema.type)) {
-        if (schema.type.includes("null") && schema.type.length === 2) {
-            return [
-                {
-                    ...schema,
-                    type: schema.type.filter((t) => t !== "null")[0],
-                },
-                true,
-            ];
-        }
-    }
-    if (Array.isArray(schema.anyOf)) {
-        const anyOf = schema.anyOf.filter((i) => (0, type_utils_js_1.isRecord)(i) && i.type !== "null" && !("not" in i && (0, type_utils_js_1.isEmpty)(i.not)));
-        const optional = anyOf.length !== schema.anyOf.length;
-        if (anyOf.length === 1)
-            return [convertNullableToOptional(anyOf[0])[0], optional];
-    }
-    return [schema, false];
-}
-const wrapJsonParse = (schema) => {
-    return zod_1.z.preprocess((val) => (typeof val === "string" ? (0, json_utils_js_1.safeParseJSON)(val) : val), schema);
-};
-const wrapAutoParseJsonSchema = (schema) => {
-    if (schema instanceof zod_1.z.ZodNullable)
-        return zod_1.z.nullable((0, exports.wrapAutoParseJsonSchema)(schema._def.innerType));
-    if (schema instanceof zod_1.z.ZodOptional)
-        return zod_1.z.optional((0, exports.wrapAutoParseJsonSchema)(schema._def.innerType));
-    if (schema instanceof zod_1.z.ZodObject) {
-        const newSchema = schema.extend(Object.fromEntries(Object.entries(schema.shape).map(([key, value]) => [
-            key,
-            (0, exports.wrapAutoParseJsonSchema)(value),
-        ])));
-        return wrapJsonParse(newSchema);
-    }
-    if (schema instanceof zod_1.z.ZodArray) {
-        schema._def.type = (0, exports.wrapAutoParseJsonSchema)(schema._def.type);
-        return wrapJsonParse(schema);
-    }
-    return schema;
-};
-exports.wrapAutoParseJsonSchema = wrapAutoParseJsonSchema;
-function getZodObjectKeys(schema) {
-    if ("shape" in schema && schema.shape)
-        return Object.keys(schema.shape);
-    return [];
-}

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

@@ -1,24 +0,0 @@
-/**
- * Safely parses JSON text using jaison library which handles malformed JSON better than JSON.parse
- *
- * @param text - The text to parse as JSON
- * @returns Parsed JSON object or null if parsing fails
- *
- * @example
- * ```typescript
- * const result = safeParseJSON('{"key": "value"}');
- * console.log(result); // { key: "value" }
- *
- * const malformed = safeParseJSON('{"key": "value"'); // Missing closing brace
- * console.log(malformed); // null
- * ```
- */
-export declare function safeParseJSON(text: string): any;
-/**
- * Safely stringifies a value to JSON, handling errors gracefully
- *
- * @param value - The value to stringify
- * @param space - Optional spacing for pretty printing
- * @returns JSON string or null if stringification fails
- */
-export declare function safeStringifyJSON(value: any, space?: number): string | null;

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

@@ -1,48 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.safeParseJSON = safeParseJSON;
-exports.safeStringifyJSON = safeStringifyJSON;
-const jaison_1 = __importDefault(require("jaison"));
-/**
- * Safely parses JSON text using jaison library which handles malformed JSON better than JSON.parse
- *
- * @param text - The text to parse as JSON
- * @returns Parsed JSON object or null if parsing fails
- *
- * @example
- * ```typescript
- * const result = safeParseJSON('{"key": "value"}');
- * console.log(result); // { key: "value" }
- *
- * const malformed = safeParseJSON('{"key": "value"'); // Missing closing brace
- * console.log(malformed); // null
- * ```
- */
-function safeParseJSON(text) {
-    if (!text)
-        return null;
-    try {
-        return (0, jaison_1.default)(text);
-    }
-    catch {
-        return null;
-    }
-}
-/**
- * Safely stringifies a value to JSON, handling errors gracefully
- *
- * @param value - The value to stringify
- * @param space - Optional spacing for pretty printing
- * @returns JSON string or null if stringification fails
- */
-function safeStringifyJSON(value, space) {
-    try {
-        return JSON.stringify(value, null, space);
-    }
-    catch {
-        return null;
-    }
-}

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

@@ -1,39 +0,0 @@
-export declare enum LogLevel {
-    SILENT = "silent",
-    ERROR = "error",
-    WARN = "warn",
-    INFO = "info",
-    DEBUG = "debug"
-}
-export declare function getLevelFromEnv(ns: string): LogLevel | undefined;
-export declare class Logger {
-    options: {
-        level: LogLevel;
-        ns: string;
-    };
-    constructor(options: {
-        level: LogLevel;
-        ns: string;
-    });
-    level: LogLevel;
-    private debugLogger;
-    private infoLogger;
-    private warnLogger;
-    private errorLogger;
-    logMessage: {
-        (...data: any[]): void;
-        (...data: any[]): void;
-        (message?: any, ...optionalParams: any[]): void;
-    };
-    logError: {
-        (...data: any[]): void;
-        (...data: any[]): void;
-        (message?: any, ...optionalParams: any[]): void;
-    };
-    debug(message: string, ...args: unknown[]): void;
-    info(message: string, ...args: unknown[]): void;
-    warn(message: string, ...args: unknown[]): void;
-    error(message: string, ...args: unknown[]): void;
-    enabled(level: LogLevel): boolean;
-}
-export declare const logger: Logger;

package/lib/cjs/utils/logger.js

@@ -1,81 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.logger = exports.Logger = exports.LogLevel = void 0;
-exports.getLevelFromEnv = getLevelFromEnv;
-const index_js_1 = require("@aigne/platform-helpers/nodejs/index.js");
-const debug_1 = __importDefault(require("debug"));
-var LogLevel;
-(function (LogLevel) {
-    LogLevel["SILENT"] = "silent";
-    LogLevel["ERROR"] = "error";
-    LogLevel["WARN"] = "warn";
-    LogLevel["INFO"] = "info";
-    LogLevel["DEBUG"] = "debug";
-})(LogLevel || (exports.LogLevel = LogLevel = {}));
-const levels = Object.values(LogLevel);
-function getLevelFromEnv(ns) {
-    for (const level of [...levels].reverse()) {
-        if (debug_1.default.enabled(`${ns}:${level}`)) {
-            return level;
-        }
-    }
-}
-class Logger {
-    options;
-    constructor(options) {
-        this.options = options;
-        this.debugLogger = (0, debug_1.default)(`${options.ns}:${LogLevel.DEBUG}`);
-        this.infoLogger = (0, debug_1.default)(`${options.ns}:${LogLevel.INFO}`);
-        this.warnLogger = (0, debug_1.default)(`${options.ns}:${LogLevel.WARN}`);
-        this.errorLogger = (0, debug_1.default)(`${options.ns}:${LogLevel.ERROR}`);
-        this.level = getLevelFromEnv(options.ns) || options.level;
-        for (const logger of [this.debugLogger, this.infoLogger, this.warnLogger]) {
-            // @ts-ignore
-            logger.useColors = index_js_1.nodejs.isStdoutATTY;
-            logger.enabled = true;
-            logger.log = (...args) => this.logMessage(...args);
-        }
-        this.errorLogger.log = (...args) => this.logError(...args);
-        // @ts-ignore
-        this.errorLogger.useColors = index_js_1.nodejs.isStderrATTY;
-        this.errorLogger.enabled = true;
-    }
-    level;
-    debugLogger;
-    infoLogger;
-    warnLogger;
-    errorLogger;
-    logMessage = console.log;
-    logError = console.error;
-    debug(message, ...args) {
-        if (this.enabled(LogLevel.DEBUG)) {
-            this.debugLogger(message, ...args);
-        }
-    }
-    info(message, ...args) {
-        if (this.enabled(LogLevel.INFO)) {
-            this.infoLogger(message, ...args);
-        }
-    }
-    warn(message, ...args) {
-        if (this.enabled(LogLevel.WARN)) {
-            this.warnLogger(message, ...args);
-        }
-    }
-    error(message, ...args) {
-        if (this.enabled(LogLevel.ERROR)) {
-            this.errorLogger(message, ...args);
-        }
-    }
-    enabled(level) {
-        return levels.indexOf(this.level) >= levels.indexOf(level);
-    }
-}
-exports.Logger = Logger;
-exports.logger = new Logger({
-    ns: "aigne:core",
-    level: LogLevel.SILENT,
-});

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

@@ -1,5 +0,0 @@
-import { type ListPromptsResult, type ListResourcesResult, type ListResourceTemplatesResult, type ListToolsResult } from "@modelcontextprotocol/sdk/types.js";
-import { type MCPBaseOptions, MCPPrompt, MCPResource, MCPTool } from "../agents/mcp-agent.js";
-export declare function toolFromMCPTool(tool: ListToolsResult["tools"][number], options: MCPBaseOptions): MCPTool;
-export declare function promptFromMCPPrompt(prompt: ListPromptsResult["prompts"][number], options: MCPBaseOptions): MCPPrompt;
-export declare function resourceFromMCPResource(resource: ListResourcesResult["resources"][number] | ListResourceTemplatesResult["resourceTemplates"][number], options: MCPBaseOptions): MCPResource;