n8n-nodes-agnicwallet 1.0.5 → 1.0.7

package/dist/nodes/AgnicMCPTool/AgnicMCPTool.node.js

@@ -0,0 +1,368 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgnicMCPTool = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const index_js_1 = require("@modelcontextprotocol/sdk/client/index.js");
+const streamableHttp_js_1 = require("@modelcontextprotocol/sdk/client/streamableHttp.js");
+const tools_1 = require("@langchain/core/tools");
+const agents_1 = require("langchain/agents");
+const zod_1 = require("zod");
+const json_schema_to_zod_1 = require("@n8n/json-schema-to-zod");
+/**
+ * Toolkit class that wraps MCP tools for n8n AI Agent
+ * Extends Toolkit from langchain/agents for proper serialization
+ */
+class AgnicMcpToolkit extends agents_1.Toolkit {
+    constructor(tools) {
+        super();
+        this.tools = tools;
+    }
+}
+// Pre-configured AgnicPay MCP endpoint (uses HTTP Streamable transport)
+const AGNIC_MCP_ENDPOINT = "https://mcp.agnicpay.xyz/sse";
+/**
+ * Convert JSON Schema to Zod schema using n8n's library
+ * Returns actual Zod schema objects (not strings)
+ */
+function convertJsonSchemaToZod(schema) {
+    if (!schema || typeof schema !== "object") {
+        return zod_1.z.object({});
+    }
+    try {
+        // @n8n/json-schema-to-zod returns actual Zod objects, not strings
+        const zodSchema = (0, json_schema_to_zod_1.jsonSchemaToZod)(schema);
+        // Ensure we return an object schema for structured tools
+        if (zodSchema instanceof zod_1.z.ZodObject) {
+            return zodSchema;
+        }
+        // Wrap non-object schemas in an object
+        return zod_1.z.object({ value: zodSchema });
+    }
+    catch {
+        // Fallback to empty object schema if conversion fails
+        return zod_1.z.object({});
+    }
+}
+/**
+ * Convert an MCP tool to a LangChain DynamicStructuredTool
+ */
+function mcpToolToDynamicTool(tool, callTool) {
+    // Convert JSON Schema to Zod schema using proper library
+    const zodSchema = convertJsonSchemaToZod(tool.inputSchema);
+    // Use type assertion to avoid deep type instantiation issues with DynamicStructuredTool
+    const toolConfig = {
+        name: tool.name,
+        description: tool.description || `MCP tool: ${tool.name}`,
+        schema: zodSchema,
+        func: async (input) => {
+            try {
+                const result = await callTool(tool.name, input);
+                if (typeof result === "string") {
+                    return result;
+                }
+                return JSON.stringify(result);
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                return `Error calling ${tool.name}: ${errorMessage}`;
+            }
+        },
+        // Required metadata for proper tool serialization in n8n
+        metadata: { isFromToolkit: true },
+    };
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return new tools_1.DynamicStructuredTool(toolConfig);
+}
+/**
+ * AgnicMCPTool - MCP Client for AgnicPay
+ *
+ * This is a supply-only AI tool node that connects to the AgnicPay MCP server
+ * and provides X402 payment tools to AI Agents via the MCP protocol.
+ *
+ * This node cannot be executed directly - it only supplies tools to AI Agents.
+ */
+class AgnicMCPTool {
+    constructor() {
+        this.description = {
+            displayName: "Agnic MCP Tool",
+            name: "agnicMcpTool",
+            icon: "file:AgnicMCPTool.png",
+            group: ["output"],
+            version: 1,
+            description: "MCP client for AgnicPay - X402 payment tools for AI Agents",
+            defaults: {
+                name: "Agnic MCP Tool",
+            },
+            // Supply-only AI tool configuration
+            inputs: [],
+            outputs: [{ type: n8n_workflow_1.NodeConnectionTypes.AiTool, displayName: "Tools" }],
+            codex: {
+                categories: ["AI"],
+                subcategories: {
+                    AI: ["Tools"],
+                },
+                resources: {
+                    primaryDocumentation: [
+                        {
+                            url: "https://www.agnicpay.xyz/mcp",
+                        },
+                    ],
+                },
+            },
+            credentials: [
+                {
+                    name: "agnicWalletOAuth2Api",
+                    required: false,
+                    displayOptions: {
+                        show: {
+                            authentication: ["oAuth2"],
+                        },
+                    },
+                },
+                {
+                    name: "agnicWalletApi",
+                    required: false,
+                    displayOptions: {
+                        show: {
+                            authentication: ["apiKey"],
+                        },
+                    },
+                },
+            ],
+            properties: [
+                {
+                    displayName: "Authentication",
+                    name: "authentication",
+                    type: "options",
+                    default: "apiKey",
+                    options: [
+                        {
+                            name: "OAuth2",
+                            value: "oAuth2",
+                            description: "Recommended: Connect your account",
+                        },
+                        {
+                            name: "API Key",
+                            value: "apiKey",
+                            description: "For CI/CD or programmatic access",
+                        },
+                    ],
+                    description: "How to authenticate with AgnicWallet",
+                },
+                {
+                    displayName: "Connects to AgnicPay MCP server. Tools are discovered automatically and include: make X402 API requests, check balance, view payment history, and discover APIs.",
+                    name: "notice",
+                    type: "notice",
+                    default: "",
+                },
+            ],
+        };
+    }
+    /**
+     * Execute method for direct tool invocation.
+     * This is called when input data is passed directly to this node.
+     */
+    async execute() {
+        var _a;
+        const node = this.getNode();
+        const items = this.getInputData();
+        const returnData = [];
+        // Get authentication
+        const authentication = this.getNodeParameter("authentication", 0);
+        let accessToken;
+        try {
+            if (authentication === "oAuth2") {
+                const creds = (await this.getCredentials("agnicWalletOAuth2Api"));
+                accessToken = (_a = creds === null || creds === void 0 ? void 0 : creds.oauthTokenData) === null || _a === void 0 ? void 0 : _a.access_token;
+            }
+            else {
+                const creds = (await this.getCredentials("agnicWalletApi"));
+                accessToken = creds === null || creds === void 0 ? void 0 : creds.apiToken;
+            }
+        }
+        catch {
+            throw new n8n_workflow_1.NodeOperationError(node, "Failed to load AgnicWallet credentials.");
+        }
+        if (!accessToken) {
+            throw new n8n_workflow_1.NodeOperationError(node, "Missing AgnicWallet authentication token.");
+        }
+        // Connect to MCP server
+        const transport = new streamableHttp_js_1.StreamableHTTPClientTransport(new URL(AGNIC_MCP_ENDPOINT), {
+            requestInit: { headers: { Authorization: `Bearer ${accessToken}` } },
+        });
+        const client = new index_js_1.Client({ name: "agnic-mcp-client", version: "1.0.0" }, { capabilities: {} });
+        try {
+            await client.connect(transport);
+            const toolsResult = await client.listTools();
+            const mcpTools = toolsResult.tools || [];
+            for (let itemIndex = 0; itemIndex < items.length; itemIndex++) {
+                const item = items[itemIndex];
+                // Expect input to have a 'tool' property with the tool name
+                if (!item.json.tool || typeof item.json.tool !== "string") {
+                    throw new n8n_workflow_1.NodeOperationError(node, "Tool name not found in item.json.tool", { itemIndex });
+                }
+                const toolName = item.json.tool;
+                const matchingTool = mcpTools.find((t) => t.name === toolName);
+                if (!matchingTool) {
+                    throw new n8n_workflow_1.NodeOperationError(node, `Tool "${toolName}" not found`, {
+                        itemIndex,
+                    });
+                }
+                // Extract tool arguments (everything except 'tool' property)
+                const { tool: _, ...toolArguments } = item.json;
+                const result = await client.callTool({
+                    name: toolName,
+                    arguments: toolArguments,
+                });
+                // Extract text content from result
+                let responseContent = result;
+                if (result.content && Array.isArray(result.content)) {
+                    const textContent = result.content.find((c) => c.type === "text");
+                    if (textContent && "text" in textContent) {
+                        responseContent = textContent.text;
+                    }
+                }
+                returnData.push({
+                    json: { response: responseContent },
+                    pairedItem: { item: itemIndex },
+                });
+            }
+        }
+        finally {
+            try {
+                await client.close();
+            }
+            catch {
+                // Ignore cleanup errors
+            }
+            try {
+                await transport.close();
+            }
+            catch {
+                // Ignore cleanup errors
+            }
+        }
+        return [returnData];
+    }
+    /**
+     * Supply MCP tools to AI Agent.
+     * This is the main method that provides tools to the AI Agent.
+     */
+    async supplyData(itemIndex) {
+        var _a;
+        // ─────────────────────────────────────────────
+        // Authentication
+        // ─────────────────────────────────────────────
+        const authentication = this.getNodeParameter("authentication", itemIndex);
+        let accessToken;
+        try {
+            if (authentication === "oAuth2") {
+                const creds = (await this.getCredentials("agnicWalletOAuth2Api", itemIndex));
+                accessToken = (_a = creds === null || creds === void 0 ? void 0 : creds.oauthTokenData) === null || _a === void 0 ? void 0 : _a.access_token;
+            }
+            else {
+                const creds = (await this.getCredentials("agnicWalletApi", itemIndex));
+                accessToken = creds === null || creds === void 0 ? void 0 : creds.apiToken;
+            }
+        }
+        catch (err) {
+            throw new n8n_workflow_1.NodeOperationError(this.getNode(), "Failed to load AgnicWallet credentials. Please configure your credentials.", { itemIndex });
+        }
+        if (!accessToken) {
+            throw new n8n_workflow_1.NodeOperationError(this.getNode(), "Missing AgnicWallet authentication token. Please check your credentials configuration.", { itemIndex });
+        }
+        // ─────────────────────────────────────────────
+        // MCP Client Setup
+        // ─────────────────────────────────────────────
+        let client;
+        let transport;
+        try {
+            // Create HTTP Streamable transport with authentication
+            // This transport uses POST requests and accepts both JSON and SSE responses
+            transport = new streamableHttp_js_1.StreamableHTTPClientTransport(new URL(AGNIC_MCP_ENDPOINT), {
+                requestInit: {
+                    headers: {
+                        Authorization: `Bearer ${accessToken}`,
+                    },
+                },
+            });
+            // Create MCP client
+            client = new index_js_1.Client({ name: "agnic-mcp-client", version: "1.0.0" }, { capabilities: {} });
+            // Connect to MCP server
+            await client.connect(transport);
+            // ─────────────────────────────────────────────
+            // Discover and wrap MCP tools
+            // ─────────────────────────────────────────────
+            const toolsResult = await client.listTools();
+            const mcpTools = toolsResult.tools || [];
+            if (mcpTools.length === 0) {
+                throw new n8n_workflow_1.NodeOperationError(this.getNode(), "No tools available from AgnicPay MCP server. Please check your authentication and try again.", { itemIndex });
+            }
+            // Create a tool caller function
+            const callTool = async (name, args) => {
+                if (!client) {
+                    throw new Error("MCP client is not connected");
+                }
+                const result = await client.callTool({
+                    name,
+                    arguments: args,
+                });
+                // Extract content from the result
+                if (result.content && Array.isArray(result.content)) {
+                    const textContent = result.content.find((c) => c.type === "text");
+                    if (textContent && "text" in textContent) {
+                        return textContent.text;
+                    }
+                }
+                return result;
+            };
+            // Convert MCP tools to LangChain DynamicStructuredTools
+            const langchainTools = mcpTools.map((tool) => mcpToolToDynamicTool(tool, callTool));
+            // Wrap tools in a Toolkit for n8n AI Agent compatibility
+            const toolkit = new AgnicMcpToolkit(langchainTools);
+            // Store references for cleanup
+            const clientRef = client;
+            const transportRef = transport;
+            // Return toolkit with cleanup function
+            return {
+                response: toolkit,
+                closeFunction: async () => {
+                    try {
+                        await clientRef.close();
+                    }
+                    catch {
+                        // Ignore cleanup errors
+                    }
+                    try {
+                        await transportRef.close();
+                    }
+                    catch {
+                        // Ignore cleanup errors
+                    }
+                },
+            };
+        }
+        catch (error) {
+            // Clean up on error
+            if (client) {
+                try {
+                    await client.close();
+                }
+                catch {
+                    // Ignore cleanup errors
+                }
+            }
+            if (transport) {
+                try {
+                    await transport.close();
+                }
+                catch {
+                    // Ignore cleanup errors
+                }
+            }
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Failed to connect to AgnicPay MCP server: ${errorMessage}`, { itemIndex });
+        }
+    }
+}
+exports.AgnicMCPTool = AgnicMCPTool;

package/dist/nodes/X402HttpRequest/X402HttpRequest.node.d.ts

@@ -1,4 +1,4 @@
-import { IExecuteFunctions, INodeExecutionData, INodeType, INodeTypeDescription } from 'n8n-workflow';
+import { IExecuteFunctions, INodeExecutionData, INodeType, INodeTypeDescription } from "n8n-workflow";
 export declare class X402HttpRequest implements INodeType {
     description: INodeTypeDescription;
     execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]>;