@aigne/core 1.5.1-2 → 1.7.0

package/lib/cjs/execution-engine/message-queue.d.ts

@@ -1,3 +1,4 @@
+import { EventEmitter } from "node:events";
 import type { Message } from "../agents/agent.js";
 import type { Context } from "./context.js";
 export declare const UserInputTopic = "UserInputTopic";
@@ -9,11 +10,10 @@ export interface MessagePayload {
     context: Context;
 }
 export type MessageQueueListener = (message: MessagePayload) => void;
-export type MessageRequest = MessagePayload;
 export type Unsubscribe = () => void;
 export declare class MessageQueue {
-    private events;
-    publish(topic: string | string[], message: MessageRequest): void;
+    events: EventEmitter<[never]>;
+    publish(topic: string | string[], payload: MessagePayload): void;
     error(error: Error): void;
     subscribe(topic: string, listener?: undefined): Promise<MessagePayload>;
     subscribe(topic: string, listener: MessageQueueListener): Unsubscribe;

package/lib/cjs/execution-engine/message-queue.js

@@ -2,20 +2,29 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MessageQueue = exports.UserOutputTopic = exports.UserInputTopic = void 0;
 const node_events_1 = require("node:events");
+const zod_1 = require("zod");
 const type_utils_js_1 = require("../utils/type-utils.js");
 exports.UserInputTopic = "UserInputTopic";
 exports.UserOutputTopic = "UserOutputTopic";
 class MessageQueue {
     events = new node_events_1.EventEmitter();
-    publish(topic, message) {
+    publish(topic, payload) {
+        (0, type_utils_js_1.checkArguments)("MessageQueue.publish", publishArgsSchema, {
+            topic,
+            payload,
+        });
         for (const t of (0, type_utils_js_1.orArrayToArray)(topic)) {
-            this.events.emit(t, message);
+            this.events.emit(t, payload);
         }
     }
     error(error) {
         this.events.emit("error", error);
     }
     subscribe(topic, listener) {
+        (0, type_utils_js_1.checkArguments)("MessageQueue.subscribe", subscribeArgsSchema, {
+            topic,
+            listener,
+        });
         if (!listener) {
             return new Promise((resolve, reject) => {
                 const unsubscribe1 = once(this.events, topic, (message) => {
@@ -31,6 +40,10 @@ class MessageQueue {
         return on(this.events, topic, listener);
     }
     unsubscribe(topic, listener) {
+        (0, type_utils_js_1.checkArguments)("MessageQueue.unsubscribe", unsubscribeArgsSchema, {
+            topic,
+            listener,
+        });
         this.events.off(topic, listener);
     }
 }
@@ -43,3 +56,20 @@ function once(events, event, listener) {
     events.once(event, listener);
     return () => events.off(event, listener);
 }
+const subscribeArgsSchema = zod_1.z.object({
+    topic: zod_1.z.string(),
+    listener: zod_1.z.function(zod_1.z.tuple([zod_1.z.any()]), zod_1.z.any()).optional(),
+});
+const unsubscribeArgsSchema = zod_1.z.object({
+    topic: zod_1.z.string(),
+    listener: zod_1.z.function(zod_1.z.tuple([zod_1.z.any()]), zod_1.z.any()),
+});
+const publishArgsSchema = zod_1.z.object({
+    topic: zod_1.z.union([zod_1.z.string(), zod_1.z.array(zod_1.z.string())]),
+    payload: zod_1.z.object({
+        role: zod_1.z.union([zod_1.z.literal("user"), zod_1.z.literal("agent")]),
+        source: zod_1.z.string().optional(),
+        message: zod_1.z.union([zod_1.z.string(), zod_1.z.record(zod_1.z.unknown())]),
+        context: zod_1.z.any(),
+    }),
+});

package/lib/cjs/execution-engine/usage.d.ts

@@ -0,0 +1,11 @@
+export interface ContextUsage {
+    inputTokens: number;
+    outputTokens: number;
+    agentCalls: number;
+}
+export declare function newEmptyContextUsage(): ContextUsage;
+export interface ContextLimits {
+    maxTokens?: number;
+    maxAgentCalls?: number;
+    timeout?: number;
+}

package/lib/cjs/execution-engine/usage.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.newEmptyContextUsage = newEmptyContextUsage;
+function newEmptyContextUsage() {
+    return {
+        inputTokens: 0,
+        outputTokens: 0,
+        agentCalls: 0,
+    };
+}

package/lib/{esm/loader/function-agent.d.ts → cjs/loader/agent-js.d.ts}

@@ -1,10 +1,6 @@
 import { type ZodObject, type ZodType, z } from "zod";
 import type { Message } from "../agents/agent.js";
-export declare function loadAgentFromJsFile(path: string, { import: _import }?: {
-    import?: (path: string) => Promise<{
-        default: unknown;
-    }>;
-}): Promise<{
+export declare function loadAgentFromJsFile(path: string): Promise<{
     name: string;
     fn: (args_0: Message) => Message;
     description?: string | undefined;

package/lib/cjs/loader/{function-agent.js → agent-js.js}

@@ -52,8 +52,8 @@ const agentJsFileSchema = zod_1.z.object({
         .transform((v) => (v ? (0, json_schema_to_zod_1.jsonSchemaToZod)(v) : undefined)),
     fn: zod_1.z.function(),
 });
-async function loadAgentFromJsFile(path, { import: _import } = {}) {
-    const { default: agent } = await (0, type_utils_js_1.tryOrThrow)(() => (_import ? _import(path) : Promise.resolve(`${path}`).then(s => __importStar(require(s)))), (error) => new Error(`Failed to load agent definition from ${path}: ${error.message}`));
+async function loadAgentFromJsFile(path) {
+    const { default: agent } = await (0, type_utils_js_1.tryOrThrow)(() => Promise.resolve(`${path}`).then(s => __importStar(require(s))), (error) => new Error(`Failed to load agent definition from ${path}: ${error.message}`));
     if (typeof agent !== "function") {
         throw new Error(`Agent file ${path} must export a default function, but got ${typeof agent}`);
     }

package/lib/cjs/loader/{ai-agent.d.ts → agent-yaml.d.ts}

@@ -1,8 +1,6 @@
-import { readFile } from "node:fs/promises";
 import { type ZodObject, type ZodType, z } from "zod";
-export declare function loadAgentFromYamlFile(path: string, { readFile: _readFile }?: {
-    readFile?: typeof readFile;
-}): Promise<{
+export declare function loadAgentFromYamlFile(path: string): Promise<{
+    type: "ai";
     name: string;
     description?: string | undefined;
     tools?: string[] | undefined;
@@ -18,4 +16,9 @@ export declare function loadAgentFromYamlFile(path: string, { readFile: _readFil
         [x: string]: any;
     }> | undefined;
     output_key?: string | undefined;
+} | {
+    type: "mcp";
+    url?: string | undefined;
+    command?: string | undefined;
+    args?: string[] | undefined;
 }>;

package/lib/cjs/loader/agent-yaml.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadAgentFromYamlFile = loadAgentFromYamlFile;
+const promises_1 = require("node:fs/promises");
+const json_schema_to_zod_1 = require("@aigne/json-schema-to-zod");
+const yaml_1 = require("yaml");
+const zod_1 = require("zod");
+const type_utils_js_1 = require("../utils/type-utils.js");
+const schema_js_1 = require("./schema.js");
+const agentFileSchema = zod_1.z.discriminatedUnion("type", [
+    zod_1.z.object({
+        type: zod_1.z.literal("ai"),
+        name: zod_1.z.string(),
+        description: zod_1.z
+            .string()
+            .nullish()
+            .transform((v) => v ?? undefined),
+        instructions: zod_1.z
+            .string()
+            .nullish()
+            .transform((v) => v ?? undefined),
+        input_schema: schema_js_1.inputOutputSchema
+            .nullish()
+            .transform((v) => (v ? (0, json_schema_to_zod_1.jsonSchemaToZod)(v) : undefined)),
+        output_schema: schema_js_1.inputOutputSchema
+            .nullish()
+            .transform((v) => (v ? (0, json_schema_to_zod_1.jsonSchemaToZod)(v) : undefined)),
+        output_key: zod_1.z
+            .string()
+            .nullish()
+            .transform((v) => v ?? undefined),
+        tools: zod_1.z
+            .array(zod_1.z.string())
+            .nullish()
+            .transform((v) => v ?? undefined),
+    }),
+    zod_1.z.object({
+        type: zod_1.z.literal("mcp"),
+        url: zod_1.z
+            .string()
+            .nullish()
+            .transform((v) => v ?? undefined),
+        command: zod_1.z
+            .string()
+            .nullish()
+            .transform((v) => v ?? undefined),
+        args: zod_1.z
+            .array(zod_1.z.string())
+            .nullish()
+            .transform((v) => v ?? undefined),
+    }),
+]);
+async function loadAgentFromYamlFile(path) {
+    const raw = await (0, type_utils_js_1.tryOrThrow)(() => (0, promises_1.readFile)(path, "utf8"), (error) => new Error(`Failed to load agent definition from ${path}: ${error.message}`));
+    const json = await (0, type_utils_js_1.tryOrThrow)(() => (0, yaml_1.parse)(raw), (error) => new Error(`Failed to parse agent definition from ${path}: ${error.message}`));
+    const agent = (0, type_utils_js_1.tryOrThrow)(() => agentFileSchema.parse({ ...json, type: json.type ?? "ai" }), (error) => new Error(`Failed to validate agent definition from ${path}: ${error.message}`));
+    return agent;
+}

package/lib/cjs/loader/index.d.ts

@@ -1,4 +1,3 @@
-import { readFile } from "node:fs/promises";
 import { type Agent } from "../agents/agent.js";
 import type { ChatModel } from "../models/chat-model.js";
 export interface LoadOptions {
@@ -8,15 +7,26 @@ export declare function load(options: LoadOptions): Promise<{
     model: ChatModel | undefined;
     agents: Agent<import("../agents/agent.js").Message, import("../agents/agent.js").Message>[];
     tools: Agent<import("../agents/agent.js").Message, import("../agents/agent.js").Message>[];
+    description?: string | null | undefined;
+    name?: string | null | undefined;
+    chat_model?: {
+        name?: string | null | undefined;
+        temperature?: number | null | undefined;
+        provider?: string | null | undefined;
+        top_p?: number | null | undefined;
+        frequent_penalty?: number | null | undefined;
+        presence_penalty?: number | null | undefined;
+    } | null | undefined;
 }>;
 export declare function loadAgent(path: string): Promise<Agent>;
-export declare function loadAIGNEFile(path: string, { readFile: _readFile }?: {
-    readFile?: typeof readFile;
-}): Promise<{
+export declare function loadAIGNEFile(path: string): Promise<{
+    description?: string | null | undefined;
     tools?: string[] | null | undefined;
+    name?: string | null | undefined;
     chat_model?: {
         name?: string | null | undefined;
         temperature?: number | null | undefined;
+        provider?: string | null | undefined;
         top_p?: number | null | undefined;
         frequent_penalty?: number | null | undefined;
         presence_penalty?: number | null | undefined;

package/lib/cjs/loader/index.js

@@ -9,19 +9,24 @@ const yaml_1 = require("yaml");
 const zod_1 = require("zod");
 const agent_js_1 = require("../agents/agent.js");
 const ai_agent_js_1 = require("../agents/ai-agent.js");
+const mcp_agent_js_1 = require("../agents/mcp-agent.js");
+const claude_chat_model_js_1 = require("../models/claude-chat-model.js");
 const openai_chat_model_js_1 = require("../models/openai-chat-model.js");
+const xai_chat_model_js_1 = require("../models/xai-chat-model.js");
 const type_utils_js_1 = require("../utils/type-utils.js");
-const ai_agent_js_2 = require("./ai-agent.js");
-const function_agent_js_1 = require("./function-agent.js");
-const AIGNE_FILE_NAME = "aigne.yaml";
+const agent_js_js_1 = require("./agent-js.js");
+const agent_yaml_js_1 = require("./agent-yaml.js");
+const DEFAULT_MODEL_PROVIDER = "openai";
+const AIGNE_FILE_NAME = ["aigne.yaml", "aigne.yml"];
 async function load(options) {
     const { path } = options;
-    const aigneFilePath = path.endsWith(AIGNE_FILE_NAME) ? path : (0, node_path_1.join)(path, AIGNE_FILE_NAME);
+    const aigneFilePath = await getAIGNEFilePath(path);
     const rootDir = (0, node_path_1.dirname)(aigneFilePath);
     const aigne = await loadAIGNEFile(aigneFilePath);
     const agents = await Promise.all((aigne.agents ?? []).map((filename) => loadAgent((0, node_path_1.join)(rootDir, filename))));
     const tools = await Promise.all((aigne.tools ?? []).map((filename) => loadAgent((0, node_path_1.join)(rootDir, filename))));
     return {
+        ...aigne,
         model: await loadModel(aigne.chat_model),
         agents,
         tools,
@@ -29,7 +34,7 @@ async function load(options) {
 }
 async function loadAgent(path) {
     if ((0, node_path_1.extname)(path) === ".js") {
-        const agent = await (0, function_agent_js_1.loadAgentFromJsFile)(path);
+        const agent = await (0, agent_js_js_1.loadAgentFromJsFile)(path);
         return agent_js_1.FunctionAgent.from({
             name: agent.name,
             description: agent.description,
@@ -39,16 +44,32 @@ async function loadAgent(path) {
         });
     }
     if ((0, node_path_1.extname)(path) === ".yaml" || (0, node_path_1.extname)(path) === ".yml") {
-        const agent = await (0, ai_agent_js_2.loadAgentFromYamlFile)(path);
-        return ai_agent_js_1.AIAgent.from({
-            name: agent.name,
-            description: agent.description,
-            instructions: agent.instructions,
-            inputSchema: agent.input_schema,
-            outputSchema: agent.output_schema,
-            outputKey: agent.output_key,
-            tools: await Promise.all((agent.tools ?? []).map((filename) => loadAgent((0, node_path_1.join)((0, node_path_1.dirname)(path), filename)))),
-        });
+        const agent = await (0, agent_yaml_js_1.loadAgentFromYamlFile)(path);
+        if (agent.type === "ai") {
+            return ai_agent_js_1.AIAgent.from({
+                name: agent.name,
+                description: agent.description,
+                instructions: agent.instructions,
+                inputSchema: agent.input_schema,
+                outputSchema: agent.output_schema,
+                outputKey: agent.output_key,
+                tools: await Promise.all((agent.tools ?? []).map((filename) => loadAgent((0, node_path_1.join)((0, node_path_1.dirname)(path), filename)))),
+            });
+        }
+        if (agent.type === "mcp") {
+            if (agent.url) {
+                return mcp_agent_js_1.MCPAgent.from({
+                    url: agent.url,
+                });
+            }
+            if (agent.command) {
+                return mcp_agent_js_1.MCPAgent.from({
+                    command: agent.command,
+                    args: agent.args,
+                });
+            }
+            throw new Error(`Missing url or command in mcp agent: ${path}`);
+        }
     }
     throw new Error(`Unsupported agent file type: ${path}`);
 }
@@ -62,17 +83,20 @@ async function loadModel(model) {
         frequencyPenalty: model.frequent_penalty ?? undefined,
         presencePenalty: model.presence_penalty ?? undefined,
     };
-    // TODO: add support for other models such as AutoChatModel, ClaudeChatModel, etc.
-    if (/^o1|gpt-/.test(model.name)) {
-        return new openai_chat_model_js_1.OpenAIChatModel(params);
-    }
-    throw new Error(`Unsupported model: ${model.name}`);
+    const availableModels = [openai_chat_model_js_1.OpenAIChatModel, claude_chat_model_js_1.ClaudeChatModel, xai_chat_model_js_1.XAIChatModel];
+    const M = availableModels.find((m) => m.name.toLowerCase().includes(model.provider || DEFAULT_MODEL_PROVIDER));
+    if (!M)
+        throw new Error(`Unsupported model: ${model.provider} ${model.name}`);
+    return new M(params);
 }
 const aigneFileSchema = zod_1.z.object({
+    name: zod_1.z.string().nullish(),
+    description: zod_1.z.string().nullish(),
     chat_model: zod_1.z
         .union([
         zod_1.z.string(),
         zod_1.z.object({
+            provider: zod_1.z.string().nullish(),
             name: zod_1.z.string().nullish(),
             temperature: zod_1.z.number().min(0).max(2).nullish(),
             top_p: zod_1.z.number().min(0).nullish(),
@@ -85,9 +109,20 @@ const aigneFileSchema = zod_1.z.object({
     agents: zod_1.z.array(zod_1.z.string()).nullish(),
     tools: zod_1.z.array(zod_1.z.string()).nullish(),
 });
-async function loadAIGNEFile(path, { readFile: _readFile = promises_1.readFile } = {}) {
-    const raw = await (0, type_utils_js_1.tryOrThrow)(() => _readFile(path, "utf8"), (error) => new Error(`Failed to load aigne.yaml from ${path}: ${error.message}`));
+async function loadAIGNEFile(path) {
+    const raw = await (0, type_utils_js_1.tryOrThrow)(() => (0, promises_1.readFile)(path, "utf8"), (error) => new Error(`Failed to load aigne.yaml from ${path}: ${error.message}`));
     const json = await (0, type_utils_js_1.tryOrThrow)(() => (0, yaml_1.parse)(raw), (error) => new Error(`Failed to parse aigne.yaml from ${path}: ${error.message}`));
     const agent = (0, type_utils_js_1.tryOrThrow)(() => aigneFileSchema.parse(json), (error) => new Error(`Failed to validate aigne.yaml from ${path}: ${error.message}`));
     return agent;
 }
+async function getAIGNEFilePath(path) {
+    const s = await (0, promises_1.stat)(path);
+    if (s.isDirectory()) {
+        for (const file of AIGNE_FILE_NAME) {
+            const filePath = (0, node_path_1.join)(path, file);
+            if ((await (0, promises_1.stat)(filePath)).isFile())
+                return filePath;
+        }
+    }
+    return path;
+}

package/lib/cjs/models/chat-model.d.ts

@@ -75,6 +75,7 @@ export interface ChatModelOutput extends Message {
     json?: object;
     toolCalls?: ChatModelOutputToolCall[];
     usage?: ChatModelOutputUsage;
+    model?: string;
 }
 export interface ChatModelOutputToolCall {
     id: string;
@@ -85,6 +86,6 @@ export interface ChatModelOutputToolCall {
     };
 }
 export interface ChatModelOutputUsage {
-    promptTokens: number;
-    completionTokens: number;
+    inputTokens: number;
+    outputTokens: number;
 }

package/lib/cjs/models/chat-model.js

@@ -13,7 +13,7 @@ class ChatModel extends agent_js_1.Agent {
     preprocess(input, context) {
         super.preprocess(input, context);
         const { limits, usage } = context;
-        const usedTokens = usage.completionTokens + usage.promptTokens;
+        const usedTokens = usage.outputTokens + usage.inputTokens;
         if (limits?.maxTokens && usedTokens >= limits.maxTokens) {
             throw new Error(`Exceeded max tokens ${usedTokens}/${limits.maxTokens}`);
         }
@@ -22,8 +22,8 @@ class ChatModel extends agent_js_1.Agent {
         super.postprocess(input, output, context);
         const { usage } = output;
         if (usage) {
-            context.usage.completionTokens += usage.completionTokens;
-            context.usage.promptTokens += usage.promptTokens;
+            context.usage.outputTokens += usage.outputTokens;
+            context.usage.inputTokens += usage.inputTokens;
         }
     }
 }
@@ -102,12 +102,13 @@ const chatModelOutputToolCallSchema = zod_1.z.object({
     }),
 });
 const chatModelOutputUsageSchema = zod_1.z.object({
-    promptTokens: zod_1.z.number(),
-    completionTokens: zod_1.z.number(),
+    inputTokens: zod_1.z.number(),
+    outputTokens: zod_1.z.number(),
 });
 const chatModelOutputSchema = zod_1.z.object({
     text: zod_1.z.string().optional(),
     json: zod_1.z.record(zod_1.z.unknown()).optional(),
     toolCalls: zod_1.z.array(chatModelOutputToolCallSchema).optional(),
     usage: chatModelOutputUsageSchema.optional(),
+    model: zod_1.z.string().optional(),
 });

package/lib/cjs/models/claude-chat-model.js

@@ -81,16 +81,18 @@ class ClaudeChatModel extends chat_model_js_1.ChatModel {
             let text = "";
             const toolCalls = [];
             let usage;
+            let model;
             for await (const chunk of stream) {
                 if (chunk.type === "message_start") {
+                    model ??= chunk.message.model;
                     const { input_tokens, output_tokens } = chunk.message.usage;
                     usage = {
-                        promptTokens: input_tokens,
-                        completionTokens: output_tokens,
+                        inputTokens: input_tokens,
+                        outputTokens: output_tokens,
                     };
                 }
                 if (chunk.type === "message_delta" && usage) {
-                    usage.completionTokens = chunk.usage.output_tokens;
+                    usage.outputTokens = chunk.usage.output_tokens;
                 }
                 logs.push(JSON.stringify(chunk));
                 // handle streaming text
@@ -115,7 +117,7 @@ class ClaudeChatModel extends chat_model_js_1.ChatModel {
                     call.args += chunk.delta.partial_json;
                 }
             }
-            const result = { usage, text };
+            const result = { usage, model, text };
             if (toolCalls.length) {
                 result.toolCalls = toolCalls
                     .map(({ args, ...c }) => ({
@@ -131,7 +133,7 @@ class ClaudeChatModel extends chat_model_js_1.ChatModel {
             return result;
         }
         catch (error) {
-            logger_js_1.logger.debug("Failed to process Claude stream", { error, logs });
+            logger_js_1.logger.core("Failed to process Claude stream", { error, logs });
             throw error;
         }
     }
@@ -160,9 +162,10 @@ class ClaudeChatModel extends chat_model_js_1.ChatModel {
             throw new Error("Json tool not found");
         return {
             json: jsonTool.input,
+            model: result.model,
             usage: {
-                promptTokens: result.usage.input_tokens,
-                completionTokens: result.usage.output_tokens,
+                inputTokens: result.usage.input_tokens,
+                outputTokens: result.usage.output_tokens,
             },
         };
     }

package/lib/cjs/models/openai-chat-model.js

@@ -78,8 +78,10 @@ class OpenAIChatModel extends chat_model_js_1.ChatModel {
         let text = "";
         const toolCalls = [];
         let usage;
+        let model;
         for await (const chunk of res) {
             const choice = chunk.choices?.[0];
+            model ??= chunk.model;
             if (choice?.delta.tool_calls?.length) {
                 for (const call of choice.delta.tool_calls) {
                     toolCalls[call.index] ??= {
@@ -101,13 +103,14 @@ class OpenAIChatModel extends chat_model_js_1.ChatModel {
                 text += choice.delta.content;
             if (chunk.usage) {
                 usage = {
-                    promptTokens: chunk.usage.prompt_tokens,
-                    completionTokens: chunk.usage.completion_tokens,
+                    inputTokens: chunk.usage.prompt_tokens,
+                    outputTokens: chunk.usage.completion_tokens,
                 };
             }
         }
         const result = {
             usage,
+            model,
         };
         if (input.responseFormat?.type === "json_schema" && text) {
             result.json = (0, json_schema_js_1.parseJSON)(text);

package/lib/cjs/prompt/prompt-builder.d.ts

@@ -7,7 +7,7 @@ import type { ChatModel, ChatModelInput } from "../models/chat-model.js";
 import { ChatMessagesTemplate } from "./template.js";
 export declare const MESSAGE_KEY = "$message";
 export declare const DEFAULT_MAX_HISTORY_MESSAGES = 10;
-export declare function createMessage(message: string | object): Message;
+export declare function createMessage<I extends Message>(message: string | I): I;
 export declare function getMessage(input: Message): string | undefined;
 export interface PromptBuilderOptions {
     instructions?: string | ChatMessagesTemplate;

package/lib/cjs/prompt/prompt-builder.js

@@ -12,7 +12,9 @@ const template_js_1 = require("./template.js");
 exports.MESSAGE_KEY = "$message";
 exports.DEFAULT_MAX_HISTORY_MESSAGES = 10;
 function createMessage(message) {
-    return { [exports.MESSAGE_KEY]: message };
+    return typeof message === "string"
+        ? { [exports.MESSAGE_KEY]: message }
+        : { ...message };
 }
 function getMessage(input) {
     const userInputMessage = input[exports.MESSAGE_KEY];

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

@@ -28,8 +28,8 @@ function parseJSON(json) {
         return JSON.parse(json);
     }
     catch (error) {
-        logger_js_1.logger.debug("Failed to parse JSON", { json, error });
-        throw new Error(`Failed to parse JSON ${error.message}`);
+        logger_js_1.logger.core("Failed to parse JSON", { json, error });
+        throw error;
     }
 }
 /**

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

@@ -1,20 +1,8 @@
-import debug, { type Debugger } from "debug";
-import type { Ora } from "ora";
-interface DebugWithSpinner extends Debugger {
-    spinner<T>(promise: Promise<T>, message?: string, callback?: (result: T) => void, options?: {
-        disabled?: boolean;
-    }): Promise<T>;
-    extend: (namespace: string) => DebugWithSpinner;
-}
-declare function spinner<T>(promise: Promise<T>, message?: string, callback?: (result: T) => void): Promise<T>;
+import debug from "debug";
 export declare const logger: debug.Debug & {
     debug: debug.Debug;
     default: debug.Debug;
 } & {
-    globalSpinner: Ora | undefined;
-    base: DebugWithSpinner;
-    debug: DebugWithSpinner;
-    spinner: typeof spinner;
-    setSpinner: (spinner: Ora) => void;
+    core: debug.Debugger;
+    mcp: debug.Debugger;
 };
-export {};

package/lib/cjs/utils/logger.js

@@ -5,82 +5,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.logger = void 0;
 const debug_1 = __importDefault(require("debug"));
-debug_1.default.log = (...args) => {
-    const { isSpinning } = globalSpinner ?? {};
-    if (isSpinning)
-        globalSpinner?.stop();
-    console.log(...args);
-    if (isSpinning)
-        globalSpinner?.start();
-};
-function createDebugger(namespace) {
-    const i = (0, debug_1.default)(namespace);
-    function overrideExtend(debug) {
-        const originalExtend = debug.extend;
-        debug.extend = (namespace) => {
-            const extended = originalExtend.call(debug, namespace);
-            overrideExtend(extended);
-            extended.spinner = async (promise, message, callback, options) => {
-                if (!extended.enabled || options?.disabled)
-                    return promise;
-                return spinner(promise, message, callback);
-            };
-            return extended;
-        };
-    }
-    overrideExtend(i);
-    return i;
-}
-let globalSpinner;
-const globalSpinnerTasks = [];
-async function spinner(promise, message, callback) {
-    const task = { promise, message, callback };
-    globalSpinnerTasks.push(task);
-    globalSpinner?.start(message || " ");
-    await promise
-        .then((result) => {
-        task.result = result;
-        task.status = "succeed";
-    })
-        .catch(() => {
-        task.status = "fail";
-    });
-    // Once the promise resolves or rejects, it updates the spinner status and processes
-    // all completed tasks in a Last-In-First-Out (LIFO) order.
-    for (;;) {
-        const task = globalSpinnerTasks.at(-1);
-        if (!task)
-            break;
-        // Recover spinner state for last running task
-        if (!task.status) {
-            globalSpinner?.start(task.message || " ");
-            break;
-        }
-        globalSpinnerTasks.pop();
-        if (task.message) {
-            if (task.status === "fail")
-                globalSpinner?.fail(task.message);
-            else
-                globalSpinner?.succeed(task.message);
-        }
-        else {
-            globalSpinner?.stop();
-        }
-        // NOTE: This is a workaround to make sure the spinner stops spinning before the next tick
-        await new Promise((resolve) => setTimeout(resolve, 10));
-        if (task.status === "succeed")
-            task.callback?.(task.result);
-    }
-    return promise;
-}
-const base = createDebugger("aigne");
+const base = (0, debug_1.default)("aigne");
 exports.logger = Object.assign(debug_1.default, {
-    globalSpinner,
-    base,
-    debug: base.extend("core"),
-    spinner,
-    setSpinner: (spinner) => {
-        globalSpinner = spinner;
-        exports.logger.globalSpinner = spinner;
-    },
+    core: base.extend("core"),
+    mcp: base.extend("mcp"),
 });