@aigne/core 1.1.0-beta.4 → 1.1.0-beta.6

package/CHANGELOG.md

@@ -1,3 +1,14 @@
+## 1.1.0-beta.6 (2025-3-13)
+
+- chore(examples): default enable mcp debug message for examples
+
+## 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

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) {
@@ -35,9 +36,7 @@ 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);
@@ -54,7 +53,7 @@ class Agent extends node_events_1.default {
             const parsedOutput = this.outputSchema.passthrough().parse(output);
             return this.includeInputInOutput ? { ...parsedInput, ...parsedOutput } : parsedOutput;
         });
-        return logger_1.logger.debug.spinner(result, `Call agent ${this.name}`, (output) => logger_1.logger.debug("%O", { input, output }), { disabled: this.disableLogging });
+        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,12 +1,12 @@
 "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";
@@ -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);
@@ -36,36 +36,34 @@ class MCPAgent extends agent_1.Agent {
         });
         await debug.spinner(client.connect(transport), "Connecting to MCP server");
         const mcpServer = getMCPServerName(client);
-        const { tools: mcpTools } = await debug.spinner(client.listTools(), `Listing tools from ${mcpServer}`, ({ tools }) => debug("%O", tools));
-        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;
@@ -74,12 +72,22 @@ class MCPTool extends agent_1.Agent {
     get mcpServer() {
         return getMCPServerName(this.client);
     }
+}
+exports.MCPBase = MCPBase;
+class MCPTool extends MCPBase {
     async process(input) {
-        const result = await debug.spinner(this.client.callTool({ name: this.name, arguments: input }), `Call tool ${this.name} from ${this.mcpServer}`, (output) => debug("%O", { input, output }));
+        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/index.d.ts

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

package/lib/cjs/index.js

@@ -24,4 +24,5 @@ __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/logger"), 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,4 +1,4 @@
-import { type Debugger } from "debug";
+import debug, { type Debugger } from "debug";
 interface DebugWithSpinner extends Debugger {
     spinner<T>(promise: Promise<T>, message?: string, callback?: (result: T) => void, options?: {
         disabled?: boolean;
@@ -6,7 +6,11 @@ interface DebugWithSpinner extends Debugger {
     extend: (namespace: string) => DebugWithSpinner;
 }
 declare function spinner<T>(promise: Promise<T>, message?: string, callback?: (result: T) => void): Promise<T>;
-export declare const logger: {
+export declare const logger: debug.Debug & {
+    debug: debug.Debug;
+    default: debug.Debug;
+} & {
+    globalSpinner: import("ora").Ora;
     base: DebugWithSpinner;
     debug: DebugWithSpinner;
     spinner: typeof spinner;

package/lib/cjs/utils/logger.js

@@ -33,35 +33,51 @@ function createDebugger(namespace) {
     return i;
 }
 const globalSpinner = (0, ora_1.default)();
+const globalSpinnerTasks = [];
 async function spinner(promise, message, callback) {
-    const { isSpinning, text } = globalSpinner;
-    try {
-        globalSpinner.start(message || " ");
-        const result = await promise;
-        if (message)
-            globalSpinner.succeed(message);
-        else
+    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, 100));
-        callback?.(result);
-        // NOTE: This is a workaround to make sure the spinner stops spinning before the next tick
-        await new Promise((resolve) => setTimeout(resolve, 100));
-        return result;
-    }
-    catch (error) {
-        globalSpinner.fail(message || " ");
-        throw error;
-    }
-    finally {
-        // Recover the spinner state
-        if (isSpinning)
-            globalSpinner.start(text || " ");
+        await new Promise((resolve) => setTimeout(resolve, 10));
+        if (task.status === "succeed")
+            task.callback?.(task.result);
     }
+    return promise;
 }
 const base = createDebugger("aigne");
-exports.logger = {
+exports.logger = Object.assign(debug_1.default, {
+    globalSpinner,
     base,
     debug: base.extend("core"),
     spinner,
-};
+});

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

@@ -0,0 +1,5 @@
+import type { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import type { ListPromptsResult, ListToolsResult } from "@modelcontextprotocol/sdk/types";
+import { MCPPrompt, MCPTool } from "../agents/mcp-agent";
+export declare function toolFromMCPTool(client: Client, tool: ListToolsResult["tools"][number]): MCPTool;
+export declare function promptFromMCPPrompt(client: Client, prompt: ListPromptsResult["prompts"][number]): MCPPrompt;

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

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toolFromMCPTool = toolFromMCPTool;
+exports.promptFromMCPPrompt = promptFromMCPPrompt;
+const json_schema_to_zod_1 = require("@n8n/json-schema-to-zod");
+const zod_1 = require("zod");
+const mcp_agent_1 = require("../agents/mcp-agent");
+function toolFromMCPTool(client, tool) {
+    return new mcp_agent_1.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(),
+    });
+}
+function promptFromMCPPrompt(client, prompt) {
+    return new mcp_agent_1.MCPPrompt({
+        client,
+        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: zod_1.z
+            .object({
+            description: zod_1.z.string().optional(),
+            messages: zod_1.z.array(zod_1.z.record(zod_1.z.unknown())),
+        })
+            .passthrough(),
+    });
+}

package/lib/cjs/utils/run-chat-loop.d.ts

@@ -1,8 +1,10 @@
-import type { AgentOutput } from "../agents/agent";
+import type { AgentInput, AgentOutput } from "../agents/agent";
 import type { UserAgent } from "../execution-engine";
 export interface ChatLoopOptions {
+    log?: typeof console.log;
+    initialCall?: AgentInput | string;
     welcome?: string;
     defaultQuestion?: string;
     onResponse?: (response: AgentOutput) => void;
 }
-export declare function runChatLoopInTerminal(userAgent: UserAgent, options?: ChatLoopOptions): Promise<void>;
+export declare function runChatLoopInTerminal(userAgent: UserAgent, { log, ...options }?: ChatLoopOptions): Promise<void>;