n8n-nodes-agnicwallet 1.0.6 → 1.0.8

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

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

package/dist/nodes/AgnicAI/AgnicAI.node.js

@@ -0,0 +1,422 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgnicAI = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+class AgnicAI {
+    constructor() {
+        this.description = {
+            displayName: "AgnicAI",
+            name: "agnicAI",
+            group: ["transform"],
+            version: 1.0,
+            description: "Access various language models through AgnicPay AI Gateway with X402 payment support. Use this node in regular workflows to call AI models.",
+            defaults: {
+                name: "AgnicAI",
+            },
+            icon: "file:AgnicAI.png",
+            inputs: [n8n_workflow_1.NodeConnectionTypes.Main],
+            outputs: [n8n_workflow_1.NodeConnectionTypes.Main],
+            credentials: [
+                {
+                    name: "agnicWalletOAuth2Api",
+                    required: false,
+                    displayOptions: {
+                        show: {
+                            authentication: ["oAuth2"],
+                        },
+                    },
+                },
+                {
+                    name: "agnicWalletApi",
+                    required: false,
+                    displayOptions: {
+                        show: {
+                            authentication: ["apiKey"],
+                        },
+                    },
+                },
+            ],
+            properties: [
+                {
+                    displayName: "Authentication",
+                    name: "authentication",
+                    type: "options",
+                    options: [
+                        {
+                            name: "OAuth2",
+                            value: "oAuth2",
+                            description: "Recommended: Connect your account",
+                        },
+                        {
+                            name: "API Key",
+                            value: "apiKey",
+                            description: "For CI/CD or programmatic access",
+                        },
+                    ],
+                    default: "oAuth2",
+                    description: "How to authenticate with AgnicWallet",
+                },
+                {
+                    displayName: "Model",
+                    name: "model",
+                    type: "options",
+                    typeOptions: {
+                        allowCustomValues: true,
+                    },
+                    options: [
+                        {
+                            name: "Simple (GPT-4o Mini)",
+                            value: "openai/gpt-4o-mini",
+                            description: "Simple and fast default option - GPT-4o Mini",
+                        },
+                        {
+                            name: "OpenAI - GPT-4o",
+                            value: "openai/gpt-4o",
+                            description: "OpenAI's latest GPT-4o model",
+                        },
+                        {
+                            name: "OpenAI - GPT-4o Mini",
+                            value: "openai/gpt-4o-mini",
+                            description: "Fast and efficient GPT-4o Mini",
+                        },
+                        {
+                            name: "OpenAI - GPT-4 Turbo",
+                            value: "openai/gpt-4-turbo",
+                            description: "GPT-4 Turbo with extended context",
+                        },
+                        {
+                            name: "OpenAI - GPT-4",
+                            value: "openai/gpt-4",
+                            description: "OpenAI GPT-4",
+                        },
+                        {
+                            name: "OpenAI - GPT-3.5 Turbo",
+                            value: "openai/gpt-3.5-turbo",
+                            description: "Fast GPT-3.5 Turbo model",
+                        },
+                        {
+                            name: "Anthropic - Claude 3.5 Sonnet",
+                            value: "anthropic/claude-3.5-sonnet",
+                            description: "Anthropic's Claude 3.5 Sonnet",
+                        },
+                        {
+                            name: "Anthropic - Claude 3 Opus",
+                            value: "anthropic/claude-3-opus",
+                            description: "Anthropic's Claude 3 Opus",
+                        },
+                        {
+                            name: "Anthropic - Claude 3 Sonnet",
+                            value: "anthropic/claude-3-sonnet",
+                            description: "Anthropic's Claude 3 Sonnet",
+                        },
+                        {
+                            name: "Anthropic - Claude 3 Haiku",
+                            value: "anthropic/claude-3-haiku",
+                            description: "Fast Claude 3 Haiku model",
+                        },
+                        {
+                            name: "Google - Gemini Pro 1.5",
+                            value: "google/gemini-pro-1.5",
+                            description: "Google Gemini Pro 1.5",
+                        },
+                        {
+                            name: "Google - Gemini Pro",
+                            value: "google/gemini-pro",
+                            description: "Google Gemini Pro",
+                        },
+                        {
+                            name: "Google - Gemini Flash 1.5",
+                            value: "google/gemini-flash-1.5",
+                            description: "Fast Gemini Flash 1.5",
+                        },
+                        {
+                            name: "Meta - Llama 3.1 405B",
+                            value: "meta-llama/llama-3.1-405b-instruct",
+                            description: "Meta Llama 3.1 405B Instruct",
+                        },
+                        {
+                            name: "Meta - Llama 3.1 70B",
+                            value: "meta-llama/llama-3.1-70b-instruct",
+                            description: "Meta Llama 3.1 70B Instruct",
+                        },
+                        {
+                            name: "Meta - Llama 3 70B",
+                            value: "meta-llama/llama-3-70b-instruct",
+                            description: "Meta Llama 3 70B Instruct",
+                        },
+                        {
+                            name: "Mistral AI - Mistral Large",
+                            value: "mistralai/mistral-large",
+                            description: "Mistral AI Large model",
+                        },
+                        {
+                            name: "Mistral AI - Mixtral 8x7B",
+                            value: "mistralai/mixtral-8x7b-instruct",
+                            description: "Mistral Mixtral 8x7B Instruct",
+                        },
+                        {
+                            name: "Mistral AI - Mistral 7B",
+                            value: "mistralai/mistral-7b-instruct",
+                            description: "Mistral 7B Instruct",
+                        },
+                        {
+                            name: "Cohere - Command R+",
+                            value: "cohere/command-r-plus",
+                            description: "Cohere Command R+",
+                        },
+                        {
+                            name: "Perplexity - Sonar",
+                            value: "perplexity/sonar",
+                            description: "Perplexity Sonar model",
+                        },
+                        {
+                            name: "xAI - Grok Beta",
+                            value: "x-ai/grok-beta",
+                            description: "xAI Grok Beta",
+                        },
+                    ],
+                    default: "openai/gpt-4o-mini",
+                    description: "Select a model or type any OpenRouter model ID. See https://openrouter.ai/models for all available models. Examples: 'openai/gpt-4o', 'anthropic/claude-3.5-sonnet', 'google/gemini-pro-1.5'",
+                },
+                {
+                    displayName: "Messages",
+                    name: "messages",
+                    type: "fixedCollection",
+                    typeOptions: {
+                        multipleValues: true,
+                    },
+                    default: {},
+                    options: [
+                        {
+                            name: "message",
+                            displayName: "Message",
+                            values: [
+                                {
+                                    displayName: "Role",
+                                    name: "role",
+                                    type: "options",
+                                    options: [
+                                        {
+                                            name: "System",
+                                            value: "system",
+                                            description: "System message to set behavior",
+                                        },
+                                        {
+                                            name: "User",
+                                            value: "user",
+                                            description: "User message",
+                                        },
+                                        {
+                                            name: "Assistant",
+                                            value: "assistant",
+                                            description: "Assistant message (for conversation history)",
+                                        },
+                                    ],
+                                    default: "user",
+                                    description: "The role of the message",
+                                },
+                                {
+                                    displayName: "Content",
+                                    name: "content",
+                                    type: "string",
+                                    default: "",
+                                    typeOptions: {
+                                        rows: 4,
+                                    },
+                                    description: "The content of the message",
+                                },
+                            ],
+                        },
+                    ],
+                    description: "The messages to send to the model",
+                },
+                {
+                    displayName: "Options",
+                    name: "options",
+                    type: "collection",
+                    placeholder: "Add Option",
+                    default: {},
+                    options: [
+                        {
+                            displayName: "Temperature",
+                            name: "temperature",
+                            type: "number",
+                            typeOptions: {
+                                minValue: 0,
+                                maxValue: 2,
+                                numberStepSize: 0.1,
+                            },
+                            default: 1,
+                            description: "Controls randomness. Lower values make output more deterministic",
+                        },
+                        {
+                            displayName: "Max Tokens",
+                            name: "max_tokens",
+                            type: "number",
+                            typeOptions: {
+                                minValue: 1,
+                            },
+                            default: 2048,
+                            description: "Maximum number of tokens to generate",
+                        },
+                        {
+                            displayName: "Top P",
+                            name: "top_p",
+                            type: "number",
+                            typeOptions: {
+                                minValue: 0,
+                                maxValue: 1,
+                                numberStepSize: 0.1,
+                            },
+                            default: 1,
+                            description: "Nucleus sampling: consider tokens with top_p probability mass",
+                        },
+                        {
+                            displayName: "Frequency Penalty",
+                            name: "frequency_penalty",
+                            type: "number",
+                            typeOptions: {
+                                minValue: -2,
+                                maxValue: 2,
+                                numberStepSize: 0.1,
+                            },
+                            default: 0,
+                            description: "Penalize tokens based on their frequency in the text so far",
+                        },
+                        {
+                            displayName: "Presence Penalty",
+                            name: "presence_penalty",
+                            type: "number",
+                            typeOptions: {
+                                minValue: -2,
+                                maxValue: 2,
+                                numberStepSize: 0.1,
+                            },
+                            default: 0,
+                            description: "Penalize tokens based on whether they appear in the text so far",
+                        },
+                    ],
+                    description: "Additional options for the chat completion",
+                },
+            ],
+        };
+    }
+    async execute() {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+        const items = this.getInputData();
+        const returnData = [];
+        for (let itemIndex = 0; itemIndex < items.length; itemIndex++) {
+            try {
+                // Get authentication type
+                const authentication = this.getNodeParameter("authentication", itemIndex);
+                // Get authentication header
+                let authHeader;
+                if (authentication === "oAuth2") {
+                    // OAuth2 authentication
+                    const credentials = (await this.getCredentials("agnicWalletOAuth2Api", itemIndex));
+                    authHeader = `Bearer ${String(credentials.oauthTokenData.access_token)}`;
+                }
+                else {
+                    // API Key authentication
+                    const credentials = await this.getCredentials("agnicWalletApi", itemIndex);
+                    const { apiToken } = credentials;
+                    authHeader = `Bearer ${String(apiToken)}`;
+                }
+                // Get model parameter (supports both dropdown selection and custom input)
+                const modelParam = this.getNodeParameter("model", itemIndex);
+                const model = modelParam === null || modelParam === void 0 ? void 0 : modelParam.trim();
+                if (!model || model === "") {
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), "Model must be specified. Enter an OpenRouter model ID (e.g., 'openai/gpt-4o' or 'anthropic/claude-3.5-sonnet'). See https://openrouter.ai/models for all available models.", { itemIndex });
+                }
+                // Get messages
+                const messagesConfig = this.getNodeParameter("messages", itemIndex, {});
+                if (!messagesConfig.message || messagesConfig.message.length === 0) {
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), "At least one message is required", { itemIndex });
+                }
+                const messages = messagesConfig.message.map((msg) => ({
+                    role: msg.role,
+                    content: msg.content,
+                }));
+                // Get options
+                const options = this.getNodeParameter("options", itemIndex, {});
+                // Build request body
+                const requestBody = {
+                    model: model.trim(),
+                    messages,
+                };
+                if (options.temperature !== undefined) {
+                    requestBody.temperature = options.temperature;
+                }
+                if (options.max_tokens !== undefined) {
+                    requestBody.max_tokens = options.max_tokens;
+                }
+                if (options.top_p !== undefined) {
+                    requestBody.top_p = options.top_p;
+                }
+                if (options.frequency_penalty !== undefined) {
+                    requestBody.frequency_penalty = options.frequency_penalty;
+                }
+                if (options.presence_penalty !== undefined) {
+                    requestBody.presence_penalty = options.presence_penalty;
+                }
+                // Make request to AgnicPay AI Gateway
+                const apiUrl = "https://api.agnicpay.xyz/v1/chat/completions";
+                (_a = this.logger) === null || _a === void 0 ? void 0 : _a.info(`[AgnicAI] Calling AgnicPay AI Gateway with model: ${model}`);
+                const response = await this.helpers.httpRequest({
+                    method: "POST",
+                    url: apiUrl,
+                    headers: {
+                        "Content-Type": "application/json",
+                        Authorization: authHeader,
+                    },
+                    body: requestBody,
+                    json: true,
+                });
+                // Format response
+                const formattedResponse = {
+                    ...response,
+                    content: ((_d = (_c = (_b = response.choices) === null || _b === void 0 ? void 0 : _b[0]) === null || _c === void 0 ? void 0 : _c.message) === null || _d === void 0 ? void 0 : _d.content) ||
+                        ((_f = (_e = response.choices) === null || _e === void 0 ? void 0 : _e[0]) === null || _f === void 0 ? void 0 : _f.text) ||
+                        response.content,
+                    role: ((_j = (_h = (_g = response.choices) === null || _g === void 0 ? void 0 : _g[0]) === null || _h === void 0 ? void 0 : _h.message) === null || _j === void 0 ? void 0 : _j.role) || "assistant",
+                };
+                returnData.push({
+                    json: formattedResponse,
+                    pairedItem: {
+                        item: itemIndex,
+                    },
+                });
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
+                // Extract more detailed error information if available
+                let detailedError = errorMessage;
+                if (error && typeof error === "object" && "response" in error) {
+                    const responseError = error;
+                    if ((_k = responseError.response) === null || _k === void 0 ? void 0 : _k.body) {
+                        detailedError = JSON.stringify(responseError.response.body);
+                    }
+                    else if ((_l = responseError.response) === null || _l === void 0 ? void 0 : _l.statusCode) {
+                        detailedError = `HTTP ${responseError.response.statusCode}: ${errorMessage}`;
+                    }
+                }
+                if (this.continueOnFail()) {
+                    returnData.push({
+                        json: {
+                            error: detailedError,
+                        },
+                        pairedItem: {
+                            item: itemIndex,
+                        },
+                    });
+                    continue;
+                }
+                throw new n8n_workflow_1.NodeOperationError(this.getNode(), detailedError, {
+                    itemIndex,
+                });
+            }
+        }
+        return [returnData];
+    }
+}
+exports.AgnicAI = AgnicAI;

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

@@ -0,0 +1,12 @@
+import { INodeType, INodeTypeDescription, ISupplyDataFunctions, SupplyData } from "n8n-workflow";
+/**
+ * AgnicAI Chat Model Node for n8n
+ *
+ * Uses LangChain's ChatOpenAI class with AgnicPay's OpenAI-compatible endpoint.
+ * This approach is identical to how n8n's built-in OpenAI Chat Model works,
+ * just pointing to AgnicPay's AI Gateway instead.
+ */
+export declare class AgnicAILanguageModel implements INodeType {
+    description: INodeTypeDescription;
+    supplyData(this: ISupplyDataFunctions, itemIndex: number): Promise<SupplyData>;
+}

package/dist/nodes/AgnicAILanguageModel/AgnicAILanguageModel.node.js

@@ -0,0 +1,365 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgnicAILanguageModel = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const openai_1 = require("@langchain/openai");
+const base_1 = require("@langchain/core/callbacks/base");
+/**
+ * Custom LLM Tracing callback for AgnicAI
+ * This enables the spinning indicator and AI Agent logging
+ * Mirrors n8n's internal N8nLlmTracing implementation
+ */
+class AgnicLlmTracing extends base_1.BaseCallbackHandler {
+    constructor(executionFunctions) {
+        super();
+        this.name = "AgnicLlmTracing";
+        // This flag makes LangChain wait for handlers before continuing
+        this.awaitHandlers = true;
+        this.connectionType = n8n_workflow_1.NodeConnectionTypes.AiLanguageModel;
+        this.runsMap = {};
+        this.executionFunctions = executionFunctions;
+    }
+    async handleLLMStart(llm, prompts, runId) {
+        const options = llm.kwargs || llm;
+        // Add input data to n8n's execution context
+        // This triggers the spinning indicator
+        const { index } = this.executionFunctions.addInputData(this.connectionType, [[{ json: { messages: prompts, options } }]]);
+        this.runsMap[runId] = {
+            index,
+            options,
+            messages: prompts,
+        };
+        // Log AI event for the AI Agent's log panel
+        this.logAiEvent("ai-llm-generated-output-started", {
+            messages: prompts,
+            options,
+        });
+    }
+    async handleLLMEnd(output, runId) {
+        var _a;
+        const runDetails = (_a = this.runsMap[runId]) !== null && _a !== void 0 ? _a : { index: 0 };
+        // Parse the response
+        const generations = output.generations.map((gen) => gen.map((g) => ({ text: g.text, generationInfo: g.generationInfo })));
+        const response = {
+            generations,
+            llmOutput: output.llmOutput,
+        };
+        // Add output data to n8n's execution context
+        // This stops the spinning indicator and shows success
+        this.executionFunctions.addOutputData(this.connectionType, runDetails.index, [[{ json: response }]]);
+        // Log AI event for the AI Agent's log panel
+        this.logAiEvent("ai-llm-generated-output", {
+            messages: runDetails.messages,
+            options: runDetails.options,
+            response,
+        });
+    }
+    async handleLLMError(error, runId) {
+        var _a;
+        const runDetails = (_a = this.runsMap[runId]) !== null && _a !== void 0 ? _a : { index: 0 };
+        // Add error output
+        this.executionFunctions.addOutputData(this.connectionType, runDetails.index, new n8n_workflow_1.NodeOperationError(this.executionFunctions.getNode(), error, {
+            functionality: "configuration-node",
+        }));
+        // Log AI error event
+        this.logAiEvent("ai-llm-errored", {
+            error: error.message || String(error),
+            runId,
+        });
+    }
+    logAiEvent(event, data) {
+        var _a, _b;
+        try {
+            (_b = (_a = this.executionFunctions).logAiEvent) === null || _b === void 0 ? void 0 : _b.call(_a, event, data ? (0, n8n_workflow_1.jsonStringify)(data) : undefined);
+        }
+        catch {
+            // Silently ignore if logAiEvent is not available
+        }
+    }
+}
+/**
+ * AgnicAI Chat Model Node for n8n
+ *
+ * Uses LangChain's ChatOpenAI class with AgnicPay's OpenAI-compatible endpoint.
+ * This approach is identical to how n8n's built-in OpenAI Chat Model works,
+ * just pointing to AgnicPay's AI Gateway instead.
+ */
+class AgnicAILanguageModel {
+    constructor() {
+        this.description = {
+            displayName: "AgnicAI Chat Model",
+            name: "lmChatAgnicAI",
+            icon: "file:AgnicAILanguageModel.png",
+            group: ["transform"],
+            version: [1, 1.1],
+            description: "Chat model using AgnicPay AI Gateway with X402 payment support",
+            defaults: {
+                name: "AgnicAI Chat Model",
+            },
+            codex: {
+                categories: ["AI"],
+                subcategories: {
+                    AI: ["Language Models", "Root Nodes"],
+                    "Language Models": ["Chat Models (Recommended)"],
+                },
+                resources: {
+                    primaryDocumentation: [
+                        {
+                            url: "https://www.agnicpay.xyz/ai-gateway",
+                        },
+                    ],
+                },
+            },
+            inputs: [],
+            outputs: [n8n_workflow_1.NodeConnectionTypes.AiLanguageModel],
+            outputNames: ["Model"],
+            credentials: [
+                {
+                    name: "agnicWalletOAuth2Api",
+                    required: false,
+                    displayOptions: {
+                        show: {
+                            authentication: ["oAuth2"],
+                        },
+                    },
+                },
+                {
+                    name: "agnicWalletApi",
+                    required: false,
+                    displayOptions: {
+                        show: {
+                            authentication: ["apiKey"],
+                        },
+                    },
+                },
+            ],
+            properties: [
+                {
+                    displayName: "Authentication",
+                    name: "authentication",
+                    type: "options",
+                    options: [
+                        {
+                            name: "OAuth2",
+                            value: "oAuth2",
+                            description: "Recommended: Connect your account",
+                        },
+                        {
+                            name: "API Key",
+                            value: "apiKey",
+                            description: "For CI/CD or programmatic access",
+                        },
+                    ],
+                    default: "apiKey",
+                    description: "How to authenticate with AgnicWallet",
+                },
+                {
+                    displayName: "Model",
+                    name: "model",
+                    type: "options",
+                    typeOptions: {
+                        allowCustomValues: true,
+                    },
+                    options: [
+                        {
+                            name: "GPT-4o Mini (Fast & Affordable)",
+                            value: "openai/gpt-4o-mini",
+                        },
+                        {
+                            name: "GPT-4o (Best Quality)",
+                            value: "openai/gpt-4o",
+                        },
+                        {
+                            name: "GPT-4 Turbo",
+                            value: "openai/gpt-4-turbo",
+                        },
+                        {
+                            name: "GPT-3.5 Turbo",
+                            value: "openai/gpt-3.5-turbo",
+                        },
+                        {
+                            name: "Claude 3.5 Sonnet",
+                            value: "anthropic/claude-3.5-sonnet",
+                        },
+                        {
+                            name: "Claude 3 Opus",
+                            value: "anthropic/claude-3-opus",
+                        },
+                        {
+                            name: "Claude 3 Haiku",
+                            value: "anthropic/claude-3-haiku",
+                        },
+                        {
+                            name: "Gemini Pro 1.5",
+                            value: "google/gemini-pro-1.5",
+                        },
+                        {
+                            name: "Gemini Flash 1.5",
+                            value: "google/gemini-flash-1.5",
+                        },
+                        {
+                            name: "Llama 3.1 70B",
+                            value: "meta-llama/llama-3.1-70b-instruct",
+                        },
+                        {
+                            name: "Llama 3.1 8B",
+                            value: "meta-llama/llama-3.1-8b-instruct",
+                        },
+                        {
+                            name: "Mistral Large",
+                            value: "mistralai/mistral-large",
+                        },
+                        {
+                            name: "Mixtral 8x22B",
+                            value: "mistralai/mixtral-8x22b-instruct",
+                        },
+                        {
+                            name: "DeepSeek R1",
+                            value: "deepseek/deepseek-r1",
+                        },
+                        {
+                            name: "DeepSeek Chat",
+                            value: "deepseek/deepseek-chat",
+                        },
+                        {
+                            name: "Qwen 2.5 72B",
+                            value: "qwen/qwen-2.5-72b-instruct",
+                        },
+                    ],
+                    default: "openai/gpt-4o-mini",
+                    description: "Select a model or type a custom OpenRouter model ID. See https://openrouter.ai/models for all available models.",
+                },
+                {
+                    displayName: "Options",
+                    name: "options",
+                    type: "collection",
+                    placeholder: "Add Option",
+                    default: {},
+                    options: [
+                        {
+                            displayName: "Temperature",
+                            name: "temperature",
+                            type: "number",
+                            typeOptions: {
+                                minValue: 0,
+                                maxValue: 2,
+                                numberStepSize: 0.1,
+                            },
+                            default: 0.7,
+                            description: "Controls randomness: Lower = more focused and deterministic",
+                        },
+                        {
+                            displayName: "Max Tokens",
+                            name: "maxTokens",
+                            type: "number",
+                            typeOptions: {
+                                minValue: 1,
+                            },
+                            default: 2048,
+                            description: "Maximum number of tokens to generate",
+                        },
+                        {
+                            displayName: "Top P",
+                            name: "topP",
+                            type: "number",
+                            typeOptions: {
+                                minValue: 0,
+                                maxValue: 1,
+                                numberStepSize: 0.1,
+                            },
+                            default: 1,
+                            description: "Nucleus sampling: considers tokens with top_p probability mass",
+                        },
+                        {
+                            displayName: "Frequency Penalty",
+                            name: "frequencyPenalty",
+                            type: "number",
+                            typeOptions: {
+                                minValue: -2,
+                                maxValue: 2,
+                                numberStepSize: 0.1,
+                            },
+                            default: 0,
+                            description: "Penalizes new tokens based on frequency in text so far",
+                        },
+                        {
+                            displayName: "Presence Penalty",
+                            name: "presencePenalty",
+                            type: "number",
+                            typeOptions: {
+                                minValue: -2,
+                                maxValue: 2,
+                                numberStepSize: 0.1,
+                            },
+                            default: 0,
+                            description: "Penalizes new tokens based on presence in text so far",
+                        },
+                        {
+                            displayName: "Timeout",
+                            name: "timeout",
+                            type: "number",
+                            default: 60000,
+                            description: "Request timeout in milliseconds",
+                        },
+                    ],
+                },
+            ],
+        };
+    }
+    async supplyData(itemIndex) {
+        var _a, _b;
+        // Get authentication type and credentials
+        const authentication = this.getNodeParameter("authentication", itemIndex);
+        let apiKey;
+        try {
+            if (authentication === "oAuth2") {
+                const credentials = (await this.getCredentials("agnicWalletOAuth2Api", itemIndex));
+                apiKey = (_a = credentials.oauthTokenData) === null || _a === void 0 ? void 0 : _a.access_token;
+                if (!apiKey) {
+                    throw new Error("OAuth2 access token not found. Please reconnect your AgnicWallet account.");
+                }
+            }
+            else {
+                const credentials = await this.getCredentials("agnicWalletApi", itemIndex);
+                apiKey = credentials.apiToken;
+                if (!apiKey) {
+                    throw new Error("API Key not found. Please configure your AgnicWallet API credentials.");
+                }
+            }
+        }
+        catch (error) {
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Authentication failed: ${errorMsg}`, { itemIndex });
+        }
+        // Get model parameter
+        const model = this.getNodeParameter("model", itemIndex);
+        if (!(model === null || model === void 0 ? void 0 : model.trim())) {
+            throw new n8n_workflow_1.NodeOperationError(this.getNode(), "Model must be specified. Select from dropdown or enter a custom OpenRouter model ID.", { itemIndex });
+        }
+        // Get options
+        const options = this.getNodeParameter("options", itemIndex, {});
+        // Create ChatOpenAI instance pointing to AgnicPay's endpoint
+        // Pass our custom tracing callback to enable spinning indicator and logging
+        const chatModel = new openai_1.ChatOpenAI({
+            apiKey,
+            model: model.trim(),
+            temperature: options.temperature,
+            maxTokens: options.maxTokens,
+            topP: options.topP,
+            frequencyPenalty: options.frequencyPenalty,
+            presencePenalty: options.presencePenalty,
+            timeout: (_b = options.timeout) !== null && _b !== void 0 ? _b : 60000,
+            maxRetries: 2,
+            configuration: {
+                baseURL: "https://api.agnicpay.xyz/v1",
+            },
+            // Add our custom tracing callback for spinning indicator and AI Agent logging
+            callbacks: [new AgnicLlmTracing(this)],
+        });
+        // Return in the same format as n8n's built-in OpenAI Chat Model
+        return {
+            response: chatModel,
+        };
+    }
+}
+exports.AgnicAILanguageModel = AgnicAILanguageModel;

package/dist/nodes/AgnicAILanguageModel/AgnicAILanguageModel.svg

@@ -0,0 +1,6 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 60 60">
+  <rect width="60" height="60" fill="none"/>
+  <path d="M30 10 L50 25 L50 35 L30 50 L10 35 L10 25 Z" fill="#6366f1" stroke="#4f46e5" stroke-width="2"/>
+  <circle cx="30" cy="30" r="8" fill="#ffffff"/>
+  <path d="M25 30 L28 33 L35 26" stroke="#6366f1" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" fill="none"/>
+</svg>

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

@@ -0,0 +1,22 @@
+import { INodeType, INodeTypeDescription, ISupplyDataFunctions, IExecuteFunctions, SupplyData, INodeExecutionData } from "n8n-workflow";
+/**
+ * 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.
+ */
+export declare class AgnicMCPTool implements INodeType {
+    description: INodeTypeDescription;
+    /**
+     * Execute method for direct tool invocation.
+     * This is called when input data is passed directly to this node.
+     */
+    execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]>;
+    /**
+     * Supply MCP tools to AI Agent.
+     * This is the main method that provides tools to the AI Agent.
+     */
+    supplyData(this: ISupplyDataFunctions, itemIndex: number): Promise<SupplyData>;
+}

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

@@ -0,0 +1,370 @@
+"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 zod_1 = require("zod");
+const json_schema_to_zod_1 = require("@n8n/json-schema-to-zod");
+/**
+ * Minimal Toolkit interface compatible with n8n AI Agent
+ * This replaces the deprecated langchain/agents Toolkit to avoid version conflicts
+ */
+class AgnicMcpToolkit {
+    constructor(tools) {
+        this.tools = tools;
+        this.lc_namespace = ["langchain", "agents", "toolkits"];
+    }
+    getTools() {
+        return this.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.js

@@ -13,6 +13,7 @@ class X402HttpRequest {
             defaults: {
                 name: "AgnicWallet X402",
             },
+            icon: "file:X402HttpRequest.png",
             usableAsTool: true,
             inputs: ["main"],
             outputs: ["main"],

package/dist/nodes/X402HttpRequest/X402HttpRequest.svg

@@ -0,0 +1,19 @@
+<?xml version="1.0" standalone="no"?>
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 20010904//EN"
+ "http://www.w3.org/TR/2001/REC-SVG-20010904/DTD/svg10.dtd">
+<svg version="1.0" xmlns="http://www.w3.org/2000/svg"
+ width="44.000000pt" height="45.000000pt" viewBox="0 0 44.000000 45.000000"
+ preserveAspectRatio="xMidYMid meet">
+
+<g transform="translate(0.000000,45.000000) scale(0.100000,-0.100000)"
+fill="#000000" stroke="none">
+<path d="M175 380 l-39 -40 42 -43 42 -42 42 42 42 43 -39 40 c-21 22 -42 40
+-45 40 -3 0 -24 -18 -45 -40z"/>
+<path d="M55 260 l-39 -40 42 -43 42 -42 42 42 42 43 -39 40 c-21 22 -42 40
+-45 40 -3 0 -24 -18 -45 -40z"/>
+<path d="M295 260 l-39 -40 42 -43 42 -42 42 42 42 43 -39 40 c-21 22 -42 40
+-45 40 -3 0 -24 -18 -45 -40z"/>
+<path d="M175 140 l-39 -40 42 -43 42 -42 42 42 42 43 -39 40 c-21 22 -42 40
+-45 40 -3 0 -24 -18 -45 -40z"/>
+</g>
+</svg>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "n8n-nodes-agnicwallet",
-  "version": "1.0.6",
+  "version": "1.0.8",
   "description": "n8n community node for AgnicWallet - automated Web3 payments for X402 APIs",
   "keywords": [
     "n8n-community-node-package",
@@ -15,7 +15,10 @@
     "automation",
     "workflow",
     "base",
-    "solana"
+    "solana",
+    "mcp",
+    "model-context-protocol",
+    "ai-agent"
   ],
   "license": "MIT",
   "homepage": "https://github.com/agnicpay/n8n-X402-AgnicWallet#readme",
@@ -48,10 +51,20 @@
       "dist/credentials/AgnicWalletOAuth2Api.credentials.js"
     ],
     "nodes": [
-      "dist/nodes/X402HttpRequest/X402HttpRequest.node.js"
+      "dist/nodes/X402HttpRequest/X402HttpRequest.node.js",
+      "dist/nodes/AgnicAILanguageModel/AgnicAILanguageModel.node.js",
+      "dist/nodes/AgnicAI/AgnicAI.node.js",
+      "dist/nodes/AgnicMCPTool/AgnicMCPTool.node.js"
     ]
   },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.24.0",
+    "@n8n/json-schema-to-zod": "^1.6.0",
+    "zod": "^3.23.0"
+  },
   "devDependencies": {
+    "@langchain/core": "^0.3.68",
+    "@langchain/openai": "^0.6.16",
     "@types/node": "^20.10.0",
     "@typescript-eslint/parser": "^6.13.0",
     "eslint": "^8.54.0",
@@ -62,6 +75,7 @@
     "typescript": "^5.3.0"
   },
   "peerDependencies": {
+    "@langchain/core": ">=0.2.0",
     "n8n-workflow": "*"
   }
 }