@aigne/core 1.1.0-beta.3 → 1.1.0-beta.5

package/CHANGELOG.md

@@ -1,3 +1,14 @@
+## 1.1.0-beta.5 (2025-3-13)
+
+- feat: support chat history in PromptBuilder
+- feat: add `prompts` for MCPAgent to consume prompts from MCP server
+- chore: add sqlite-mcp-server example
+- test: add more unit test cases
+
+## 1.1.0-beta.4 (2025-3-12)
+
+- feat: support run puppeteer example chat loop in terminal
+
 ## 1.1.0-beta.3 (2025-3-11)
 
 - chore: set module type for core package

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

@@ -19,6 +19,7 @@ export interface AgentOptions<I extends AgentInput = AgentInput, O extends Agent
     }>;
     includeInputInOutput?: boolean;
     tools?: (Agent | FunctionAgentFn)[];
+    disableLogging?: boolean;
 }
 export declare class Agent<I extends AgentInput = AgentInput, O extends AgentOutput = AgentOutput> extends EventEmitter {
     static from<I extends AgentInput = AgentInput, O extends AgentOutput = AgentOutput>(options: AgentOptions<I, O>): Agent<I, O>;
@@ -37,6 +38,7 @@ export declare class Agent<I extends AgentInput = AgentInput, O extends AgentOut
     readonly tools: Agent<AgentInput, AgentOutput>[] & {
         [key: string]: Agent<AgentInput, AgentOutput>;
     };
+    private disableLogging?;
     addTool<I extends AgentInput, O extends AgentOutput>(tool: Agent<I, O> | FunctionAgentFn<I, O>): void;
     get isCallable(): boolean;
     call(input: I | string, context?: Context): Promise<O>;

package/lib/cjs/agents/agent.js

@@ -8,6 +8,7 @@ const node_events_1 = __importDefault(require("node:events"));
 const zod_1 = require("zod");
 const prompt_builder_1 = require("../prompt/prompt-builder");
 const logger_1 = require("../utils/logger");
+const type_utils_1 = require("../utils/type-utils");
 const types_1 = require("./types");
 class Agent extends node_events_1.default {
     static from(options) {
@@ -26,6 +27,7 @@ class Agent extends node_events_1.default {
         this.publishTopic = options.publishTopic;
         if (options.tools?.length)
             this.tools.push(...options.tools.map(functionToAgent));
+        this.disableLogging = options.disableLogging;
     }
     name;
     description;
@@ -34,9 +36,8 @@ class Agent extends node_events_1.default {
     includeInputInOutput;
     subscribeTopic;
     publishTopic;
-    tools = new Proxy([], {
-        get: (t, p, r) => Reflect.get(t, p, r) ?? t.find((t) => t.name === p),
-    });
+    tools = (0, type_utils_1.createAccessorArray)([], (arr, name) => arr.find((t) => t.name === name));
+    disableLogging;
     addTool(tool) {
         this.tools.push(typeof tool === "function" ? functionToAgent(tool) : tool);
     }
@@ -48,19 +49,11 @@ class Agent extends node_events_1.default {
             throw new Error("Agent must implement process method");
         const _input = typeof input === "string" ? (0, prompt_builder_1.userInput)(input) : input;
         const parsedInput = this.inputSchema.passthrough().parse(_input);
-        logger_1.logger.debug(`Call agent ${this.name} start`, parsedInput);
-        const output = await this.process(parsedInput, context);
-        const parsedOutput = this.outputSchema.passthrough().parse(output);
-        const finalOutput = this.includeInputInOutput
-            ? { ...parsedInput, ...parsedOutput }
-            : parsedOutput;
-        logger_1.logger.debug(`Call agent ${this.name} successfully`, {
-            ...finalOutput,
-            ...(finalOutput[types_1.transferAgentOutputKey]
-                ? { [types_1.transferAgentOutputKey]: finalOutput[types_1.transferAgentOutputKey].agent.name }
-                : {}),
+        const result = this.process(parsedInput, context).then((output) => {
+            const parsedOutput = this.outputSchema.passthrough().parse(output);
+            return this.includeInputInOutput ? { ...parsedInput, ...parsedOutput } : parsedOutput;
         });
-        return finalOutput;
+        return logger_1.logger.debug.spinner(result, `Call agent ${this.name}`, (output) => logger_1.logger.debug("input: %O\noutput: %O", input, output), { disabled: this.disableLogging });
     }
     async shutdown() { }
 }

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

@@ -7,6 +7,8 @@ export interface AIAgentOptions<I extends AgentInput = AgentInput, O extends Age
     instructions?: string | PromptBuilder;
     outputKey?: string;
     toolChoice?: AIAgentToolChoice;
+    enableHistory?: boolean;
+    maxHistoryMessages?: number;
 }
 export type AIAgentToolChoice = "auto" | "none" | "required" | "router" | Agent;
 export declare class AIAgent<I extends AgentInput = AgentInput, O extends AgentOutput = AgentOutput> extends Agent<I, O> {
@@ -16,5 +18,7 @@ export declare class AIAgent<I extends AgentInput = AgentInput, O extends AgentO
     instructions: PromptBuilder;
     outputKey?: string;
     toolChoice?: AIAgentToolChoice;
+    enableHistory?: boolean;
+    maxHistoryMessages: number;
     process(input: I, context?: Context): Promise<O>;
 }

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

@@ -6,6 +6,7 @@ const template_1 = require("../prompt/template");
 const agent_1 = require("./agent");
 const types_1 = require("./types");
 const DEFAULT_OUTPUT_KEY = "text";
+const DEFAULT_MAX_HISTORY_MESSAGES = 10;
 class AIAgent extends agent_1.Agent {
     static from(options) {
         return new AIAgent(options);
@@ -19,27 +20,35 @@ class AIAgent extends agent_1.Agent {
                 : (options.instructions ?? new prompt_builder_1.PromptBuilder());
         this.outputKey = options.outputKey;
         this.toolChoice = options.toolChoice;
+        this.enableHistory = options.enableHistory;
+        this.maxHistoryMessages = options.maxHistoryMessages ?? DEFAULT_MAX_HISTORY_MESSAGES;
     }
     model;
     instructions;
     outputKey;
     toolChoice;
+    enableHistory;
+    maxHistoryMessages;
     async process(input, context) {
         const model = context?.model ?? this.model;
         if (!model)
             throw new Error("model is required to run AIAgent");
         let transferOutput;
-        const { toolAgents, ...modelInput } = await this.instructions.build({
+        const { toolAgents, messages, ...modelInput } = await this.instructions.build({
+            enableHistory: this.enableHistory,
+            maxHistoryMessages: this.maxHistoryMessages,
             agent: this,
             input,
             model,
             context,
         });
         const toolsMap = new Map(toolAgents?.map((i) => [i.name, i]));
+        const toolCallMessages = [];
         for (;;) {
-            const { text, json, toolCalls } = await model.call(modelInput, context);
+            const { text, json, toolCalls } = await model.call({ ...modelInput, messages: messages.concat(toolCallMessages) }, context);
             if (toolCalls?.length) {
                 const executedToolCalls = [];
+                // Execute tools
                 for (const call of toolCalls) {
                     const tool = toolsMap.get(call.function.name);
                     if (!tool)
@@ -53,21 +62,27 @@ class AIAgent extends agent_1.Agent {
                         executedToolCalls.push({ call, output });
                     }
                 }
-                if (this.toolChoice === "router") {
-                    const output = executedToolCalls[0]?.output;
-                    if (!output || executedToolCalls.length !== 1) {
-                        throw new Error("Router toolChoice requires exactly one tool to be executed");
-                    }
-                    return output;
-                }
                 // Continue LLM function calling loop if any tools were executed
                 if (executedToolCalls.length) {
-                    modelInput.messages.push(template_1.AgentMessageTemplate.from(executedToolCalls.map(({ call }) => call)).format());
-                    modelInput.messages.push(...executedToolCalls.map(({ call, output }) => template_1.ToolMessageTemplate.from(output, call.id).format()));
+                    toolCallMessages.push(template_1.AgentMessageTemplate.from(executedToolCalls.map(({ call }) => call)).format(), ...executedToolCalls.map(({ call, output }) => template_1.ToolMessageTemplate.from(output, call.id).format()));
+                    // Return the output of the first tool if the toolChoice is "router"
+                    if (this.toolChoice === "router") {
+                        const output = executedToolCalls[0]?.output;
+                        if (!output || executedToolCalls.length !== 1) {
+                            throw new Error("Router toolChoice requires exactly one tool to be executed");
+                        }
+                        return output;
+                    }
                     continue;
                 }
             }
             const result = {};
+            if (json) {
+                this.instructions.addHistory(template_1.AgentMessageTemplate.from(JSON.stringify(json)).format());
+            }
+            else if (text) {
+                this.instructions.addHistory(template_1.AgentMessageTemplate.from(text).format());
+            }
             if (modelInput.responseFormat?.type === "json_schema") {
                 Object.assign(result, json);
             }

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

@@ -1,8 +1,10 @@
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { type StdioServerParameters } from "@modelcontextprotocol/sdk/client/stdio.js";
+import type { CallToolResult, GetPromptResult } from "@modelcontextprotocol/sdk/types";
 import { Agent, type AgentInput, type AgentOptions, type AgentOutput } from "./agent";
 export interface MCPAgentOptions extends AgentOptions {
     client: Client;
+    prompts?: MCPPrompt[];
 }
 export type MCPServerOptions = SSEServerParameters | StdioServerParameters;
 export type SSEServerParameters = {
@@ -14,14 +16,24 @@ export declare class MCPAgent extends Agent {
     private static fromTransport;
     constructor(options: MCPAgentOptions);
     private client;
+    readonly prompts: MCPPrompt[] & {
+        [key: string]: MCPPrompt;
+    };
     shutdown(): Promise<void>;
 }
-export interface MCPToolOptions extends AgentOptions {
+export interface MCPToolBaseOptions<I extends AgentInput, O extends AgentOutput> extends AgentOptions<I, O> {
     client: Client;
 }
-export declare class MCPTool extends Agent {
-    constructor(options: MCPToolOptions);
-    private client;
-    private get mcpServer();
-    process(input: AgentInput): Promise<AgentOutput>;
+export declare abstract class MCPBase<I extends AgentInput, O extends AgentOutput> extends Agent<I, O> {
+    constructor(options: MCPToolBaseOptions<I, O>);
+    protected client: Client;
+    protected get mcpServer(): string | undefined;
+}
+export declare class MCPTool extends MCPBase<AgentInput, CallToolResult> {
+    process(input: AgentInput): Promise<CallToolResult>;
+}
+export declare class MCPPrompt extends MCPBase<{
+    [key: string]: string;
+}, GetPromptResult> {
+    process(input: AgentInput): Promise<GetPromptResult>;
 }

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

@@ -1,16 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MCPTool = exports.MCPAgent = void 0;
+exports.MCPPrompt = exports.MCPTool = exports.MCPBase = exports.MCPAgent = void 0;
 const index_js_1 = require("@modelcontextprotocol/sdk/client/index.js");
 const sse_js_1 = require("@modelcontextprotocol/sdk/client/sse.js");
 const stdio_js_1 = require("@modelcontextprotocol/sdk/client/stdio.js");
-const json_schema_to_zod_1 = require("@n8n/json-schema-to-zod");
-const zod_1 = require("zod");
 const logger_1 = require("../utils/logger");
+const mcp_utils_1 = require("../utils/mcp-utils");
+const type_utils_1 = require("../utils/type-utils");
 const agent_1 = require("./agent");
 const MCP_AGENT_CLIENT_NAME = "MCPAgent";
 const MCP_AGENT_CLIENT_VERSION = "0.0.1";
-const debug = logger_1.logger.base.extend("mcp-agent:debug", "/");
+const debug = logger_1.logger.base.extend("mcp");
 function isSSEServerParameters(options) {
     return "url" in options && typeof options.url === "string";
 }
@@ -24,7 +24,7 @@ class MCPAgent extends agent_1.Agent {
             return MCPAgent.fromTransport(transport);
         }
         if (isStdioServerParameters(options)) {
-            const transport = new stdio_js_1.StdioClientTransport(options);
+            const transport = new stdio_js_1.StdioClientTransport({ ...options, stderr: "pipe" });
             return MCPAgent.fromTransport(transport);
         }
         return new MCPAgent(options);
@@ -34,42 +34,36 @@ class MCPAgent extends agent_1.Agent {
             name: MCP_AGENT_CLIENT_NAME,
             version: MCP_AGENT_CLIENT_VERSION,
         });
-        debug(`Connecting to MCP server with transport ${transport.constructor.name}`);
-        await client.connect(transport);
-        debug(`Connected to MCP server with transport ${transport.constructor.name}`);
+        await debug.spinner(client.connect(transport), "Connecting to MCP server");
         const mcpServer = getMCPServerName(client);
-        debug(`Listing tools from ${mcpServer}`);
-        const { tools: mcpTools } = await client.listTools();
-        debug(`Listed tools from ${mcpServer}`, mcpTools.map((i) => i.name));
-        const tools = mcpTools.map((tool) => {
-            return new MCPTool({
-                client,
-                name: tool.name,
-                description: tool.description,
-                inputSchema: (0, json_schema_to_zod_1.jsonSchemaToZod)(tool.inputSchema),
-                outputSchema: zod_1.z
-                    .object({
-                    _meta: zod_1.z.record(zod_1.z.unknown()).optional(),
-                    content: zod_1.z.array(zod_1.z.record(zod_1.z.unknown())),
-                    isError: zod_1.z.boolean().optional(),
-                })
-                    .passthrough(),
-            });
-        });
-        return new MCPAgent({ client, tools });
+        const { tools: isToolsAvailable, prompts: isPromptsAvailable } = client.getServerCapabilities() ?? {};
+        const tools = isToolsAvailable
+            ? await debug
+                .spinner(client.listTools(), `Listing tools from ${mcpServer}`, ({ tools }) => debug("%O", tools))
+                .then(({ tools }) => tools.map((tool) => (0, mcp_utils_1.toolFromMCPTool)(client, tool)))
+            : undefined;
+        const prompts = isPromptsAvailable
+            ? await debug
+                .spinner(client.listPrompts(), `Listing prompts from ${mcpServer}`, ({ prompts }) => debug("%O", prompts))
+                .then(({ prompts }) => prompts.map((prompt) => (0, mcp_utils_1.promptFromMCPPrompt)(client, prompt)))
+            : undefined;
+        return new MCPAgent({ client, tools, prompts });
     }
     constructor(options) {
         super(options);
         this.client = options.client;
+        if (options.prompts?.length)
+            this.prompts.push(...options.prompts);
     }
     client;
+    prompts = (0, type_utils_1.createAccessorArray)([], (arr, name) => arr.find((i) => i.name === name));
     async shutdown() {
         super.shutdown();
         await this.client.close();
     }
 }
 exports.MCPAgent = MCPAgent;
-class MCPTool extends agent_1.Agent {
+class MCPBase extends agent_1.Agent {
     constructor(options) {
         super(options);
         this.client = options.client;
@@ -78,14 +72,22 @@ class MCPTool extends agent_1.Agent {
     get mcpServer() {
         return getMCPServerName(this.client);
     }
+}
+exports.MCPBase = MCPBase;
+class MCPTool extends MCPBase {
     async process(input) {
-        debug(`Start call tool ${this.name} from ${this.mcpServer} with input`, input);
-        const result = await this.client.callTool({ name: this.name, arguments: input });
-        debug(`End call tool ${this.name} from ${this.mcpServer} with result`, result);
+        const result = await debug.spinner(this.client.callTool({ name: this.name, arguments: input }), `Call tool ${this.name} from ${this.mcpServer}`, (output) => debug("input: %O\noutput: %O", input, output));
         return result;
     }
 }
 exports.MCPTool = MCPTool;
+class MCPPrompt extends MCPBase {
+    async process(input) {
+        const result = await debug.spinner(this.client.getPrompt({ name: this.name, arguments: input }), `Get prompt ${this.name} from ${this.mcpServer}`, (output) => debug("input: %O\noutput: %O", input, output));
+        return result;
+    }
+}
+exports.MCPPrompt = MCPPrompt;
 function getMCPServerName(client) {
     const info = client.getServerVersion();
     if (!info)

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

@@ -33,6 +33,7 @@ export declare class ExecutionEngine extends EventEmitter implements Context {
     private runChatLoop;
     private callAgent;
     shutdown(): Promise<void>;
+    private initProcessExitHandler;
 }
 export declare class UserAgent<I extends AgentInput = AgentInput, O extends AgentOutput = AgentOutput> extends Agent<I, O> {
     options: AgentOptions<I, O> & {

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

@@ -18,6 +18,7 @@ class ExecutionEngine extends node_events_1.default {
         this.tools = options?.tools ?? [];
         if (options?.agents?.length)
             this.addAgent(...options.agents);
+        this.initProcessExitHandler();
     }
     messageQueue = new message_queue_1.MessageQueue();
     model;
@@ -175,12 +176,17 @@ class ExecutionEngine extends node_events_1.default {
             await agent.shutdown();
         }
     }
+    initProcessExitHandler() {
+        const shutdownAndExit = () => this.shutdown().finally(() => process.exit(0));
+        process.on("SIGINT", shutdownAndExit);
+        process.on("exit", shutdownAndExit);
+    }
 }
 exports.ExecutionEngine = ExecutionEngine;
 class UserAgent extends agent_1.Agent {
     options;
     constructor(options) {
-        super(options);
+        super({ ...options, disableLogging: true });
         this.options = options;
     }
     process(input) {

package/lib/cjs/index.d.ts

@@ -8,3 +8,4 @@ export * from "./models/chat";
 export * from "./models/chat-openai";
 export * from "./prompt/prompt-builder";
 export * from "./prompt/template";
+export * from "./utils/run-chat-loop";

package/lib/cjs/index.js

@@ -24,3 +24,4 @@ __exportStar(require("./models/chat"), exports);
 __exportStar(require("./models/chat-openai"), exports);
 __exportStar(require("./prompt/prompt-builder"), exports);
 __exportStar(require("./prompt/template"), exports);
+__exportStar(require("./utils/run-chat-loop"), exports);

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

@@ -1,14 +1,18 @@
+import type { GetPromptResult } from "@modelcontextprotocol/sdk/types";
 import { Agent, type AgentInput } from "../agents/agent";
 import type { AIAgent } from "../agents/ai-agent";
 import type { Context } from "../execution-engine/context";
 import type { ChatModel, ChatModelInput, ChatModelInputMessage } from "../models/chat";
+import { ChatMessagesTemplate } from "./template";
 export declare const USER_INPUT_MESSAGE_KEY = "$user_input_message";
 export declare function userInput(message: string | object): AgentInput;
 export declare function addMessagesToInput(input: AgentInput, messages: ChatModelInputMessage[]): AgentInput;
 export interface PromptBuilderOptions {
-    instructions?: string;
+    instructions?: string | ChatMessagesTemplate;
 }
 export interface PromptBuilderBuildOptions {
+    enableHistory?: boolean;
+    maxHistoryMessages?: number;
     context?: Context;
     agent?: AIAgent;
     input?: AgentInput;
@@ -16,15 +20,19 @@ export interface PromptBuilderBuildOptions {
 }
 export declare class PromptBuilder {
     static from(instructions: string): PromptBuilder;
+    static from(instructions: GetPromptResult): PromptBuilder;
     static from(instructions: {
         path: string;
     }): Promise<PromptBuilder>;
     static from(instructions: string | {
         path: string;
-    }): PromptBuilder | Promise<PromptBuilder>;
+    } | GetPromptResult): PromptBuilder | Promise<PromptBuilder>;
     private static fromFile;
+    private static fromMCPPromptResult;
     constructor(options?: PromptBuilderOptions);
-    instructions?: string;
+    instructions?: string | ChatMessagesTemplate;
+    histories: ChatModelInputMessage[];
+    addHistory(...messages: ChatModelInputMessage[]): void;
     build(options: PromptBuilderBuildOptions): Promise<ChatModelInput & {
         toolAgents?: Agent[];
     }>;

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

@@ -7,6 +7,7 @@ exports.PromptBuilder = exports.USER_INPUT_MESSAGE_KEY = void 0;
 exports.userInput = userInput;
 exports.addMessagesToInput = addMessagesToInput;
 const promises_1 = require("node:fs/promises");
+const lodash_1 = require("lodash");
 const zod_1 = require("zod");
 const zod_to_json_schema_1 = __importDefault(require("zod-to-json-schema"));
 const agent_1 = require("../agents/agent");
@@ -36,19 +37,39 @@ function addMessagesToInput(input, messages) {
 }
 class PromptBuilder {
     static from(instructions) {
-        if (typeof instructions === "string") {
+        if (typeof instructions === "string")
             return new PromptBuilder({ instructions });
-        }
-        return PromptBuilder.fromFile(instructions.path);
+        if (isFromPromptResult(instructions))
+            return PromptBuilder.fromMCPPromptResult(instructions);
+        if (isFromPath(instructions))
+            return PromptBuilder.fromFile(instructions.path);
+        throw new Error(`Invalid instructions ${instructions}`);
     }
     static async fromFile(path) {
         const text = await (0, promises_1.readFile)(path, "utf-8");
         return PromptBuilder.from(text);
     }
+    static fromMCPPromptResult(result) {
+        return new PromptBuilder({
+            instructions: template_1.ChatMessagesTemplate.from(result.messages.map((i) => {
+                if (i.content.type !== "text")
+                    throw new Error(`Unsupported content type ${i.content.type}`);
+                if (i.role === "user")
+                    return template_1.UserMessageTemplate.from(i.content.text);
+                if (i.role === "assistant")
+                    return template_1.AgentMessageTemplate.from(i.content.text);
+                throw new Error(`Unsupported role ${i.role}`);
+            })),
+        });
+    }
     constructor(options) {
         this.instructions = options?.instructions;
     }
     instructions;
+    histories = [];
+    addHistory(...messages) {
+        this.histories.push(...messages);
+    }
     async build(options) {
         return {
             messages: this.buildMessages(options),
@@ -58,21 +79,35 @@ class PromptBuilder {
     }
     buildMessages(options) {
         const { input } = options;
-        const template = template_1.ChatMessagesTemplate.from([]);
-        if (this.instructions)
-            template.messages.push(template_1.SystemMessageTemplate.from(this.instructions));
+        const messages = (typeof this.instructions === "string"
+            ? template_1.ChatMessagesTemplate.from([template_1.SystemMessageTemplate.from(this.instructions)])
+            : this.instructions)?.format(options.input) ?? [];
+        if (options.enableHistory) {
+            messages.push(...(options.maxHistoryMessages
+                ? this.histories.slice(-options.maxHistoryMessages)
+                : this.histories));
+        }
+        const userMessages = [];
         const userInputMessage = input?.[exports.USER_INPUT_MESSAGE_KEY];
-        if (typeof userInputMessage === "string") {
-            template.messages.push(template_1.UserMessageTemplate.from(userInputMessage));
+        // Parse messages from the user input with the key $user_input_message
+        if (!(0, lodash_1.isNil)(userInputMessage)) {
+            if (typeof userInputMessage === "string") {
+                userMessages.push(template_1.UserMessageTemplate.from(userInputMessage).format());
+            }
+            else {
+                const messages = (0, template_1.parseChatMessages)(userInputMessage);
+                if (messages)
+                    userMessages.push(...messages.map((i) => i.format()));
+                else
+                    userMessages.push(template_1.UserMessageTemplate.from(JSON.stringify(userInputMessage)).format());
+            }
         }
-        else if (userInputMessage) {
-            const messages = (0, template_1.parseChatMessages)(userInputMessage);
-            if (messages)
-                template.messages.push(...messages);
-            else
-                template.messages.push(template_1.UserMessageTemplate.from(JSON.stringify(userInputMessage)));
+        if (userMessages.length) {
+            if (options.enableHistory)
+                this.addHistory(...userMessages);
+            messages.push(...userMessages);
         }
-        return template.format(input);
+        return messages;
     }
     buildResponseFormat(options) {
         const outputSchema = options.agent?.outputSchema;
@@ -135,6 +170,12 @@ class PromptBuilder {
     }
 }
 exports.PromptBuilder = PromptBuilder;
+function isFromPromptResult(value) {
+    return typeof value === "object" && "messages" in value && Array.isArray(value.messages);
+}
+function isFromPath(value) {
+    return typeof value === "object" && "path" in value && typeof value.path === "string";
+}
 function isEmptyObjectType(schema) {
     return schema instanceof zod_1.ZodObject && Object.keys(schema.shape).length === 0;
 }

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

@@ -1,6 +1,18 @@
-import debug from "debug";
-export declare const logger: {
-    base: debug.Debugger;
-    debug: debug.Debugger;
-    error: debug.Debugger;
+import debug, { type Debugger } from "debug";
+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>;
+export declare const logger: debug.Debug & {
+    debug: debug.Debug;
+    default: debug.Debug;
+} & {
+    globalSpinner: import("ora").Ora;
+    base: DebugWithSpinner;
+    debug: DebugWithSpinner;
+    spinner: typeof spinner;
 };
+export {};

package/lib/cjs/utils/logger.js

@@ -5,8 +5,79 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.logger = void 0;
 const debug_1 = __importDefault(require("debug"));
-exports.logger = {
-    base: (0, debug_1.default)("@aigne/core"),
-    debug: (0, debug_1.default)("@aigne/core:debug"),
-    error: (0, debug_1.default)("@aigne/core:error"),
+const ora_1 = __importDefault(require("ora"));
+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;
+}
+const globalSpinner = (0, ora_1.default)();
+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");
+exports.logger = Object.assign(debug_1.default, {
+    globalSpinner,
+    base,
+    debug: base.extend("core"),
+    spinner,
+});