n8n-nodes-smart-browser-automation 1.6.24 → 1.6.26

package/dist/nodes/SmartBrowserAutomation/BrowserSessionManager.js

@@ -85,70 +85,82 @@ class BrowserSessionManager {
                 throw new Error(`Invalid CDP Endpoint: "${trimmedCdp}". CDP Endpoint must be a ws(s) URL (e.g. ws://localhost:9222 or wss://.../devtools/...).`);
             }
         }
-        // Only initialize if not already done or config changed
-        if (this.isInitialized &&
+        // Check checks if we are already initialized with the same config
+        // BUT if we are using CDP, we want to ensure we call the connect tool again
+        // to make sure the browser session is active (referencing user request).
+        const isConfigMatch = this.isInitialized &&
             this.config.mcpEndpoint === mcpEndpoint &&
             this.config.useCDP === useCDP &&
-            this.config.cdpEndpoint === cdpEndpoint) {
+            this.config.cdpEndpoint === cdpEndpoint;
+        if (isConfigMatch && !useCDP) {
+            // For non-CDP (standard MCP tools), we can safely return cached tools
             return this.tools;
         }
-        // Close existing session if config changed
-        if (this.mcpClient) {
-            await this.close();
-        }
-        // Initialize MCP client
-        this.mcpClient = new index_js_1.Client({ name: 'n8n-browser-automation', version: '1.0.0' }, { capabilities: {} });
-        // Determine transport based on endpoint type
-        const isUrl = trimmedMcpEndpoint.startsWith('http://') || trimmedMcpEndpoint.startsWith('https://');
-        let urlIsSse = false;
-        if (isUrl) {
-            try {
-                urlIsSse = /(^|\/)sse\/?(\?|#|$)/i.test(mcpUrlObj.pathname);
-            }
-            catch (e) {
-                // Should be caught by parseUrl above, but just in case
-                throw new Error(`Invalid MCP Endpoint path: "${trimmedMcpEndpoint}".`);
-            }
-        }
-        if (isUrl) {
-            if (urlIsSse) {
-                // Connect via SSE
-                const { SSEClientTransport } = await Promise.resolve().then(() => __importStar(require('@modelcontextprotocol/sdk/client/sse.js')));
-                this.transport = new SSEClientTransport(new URL(trimmedMcpEndpoint)); // Safe because we parsed it above
-            }
-            else {
-                // Connect via Streamable HTTP
-                const { StreamableHTTPClientTransport } = await Promise.resolve().then(() => __importStar(require('@modelcontextprotocol/sdk/client/streamableHttp.js')));
-                this.transport = new StreamableHTTPClientTransport(new URL(trimmedMcpEndpoint)); // Safe because we parsed it above
+        // If config changed, or strict strict re-connect is needed (though we try to reuse client if endpoint is same)
+        if (this.config.mcpEndpoint !== mcpEndpoint || !this.mcpClient) {
+            // Full re-initialization needed
+            if (this.mcpClient) {
+                await this.close();
             }
+            this.isInitialized = false;
         }
         else {
-            // Connect via Stdio (lazy import so environments that only use SSE don't need stdio deps)
-            const { StdioClientTransport } = await Promise.resolve().then(() => __importStar(require('@modelcontextprotocol/sdk/client/stdio.js')));
-            this.transport = new StdioClientTransport({
-                command: 'node',
-                args: [mcpEndpoint],
-                env: {
-                    ...process.env,
-                    ...(useCDP && cdpEndpoint ? { CDP_URL: cdpEndpoint } : {}),
-                },
-            });
+            // MCP endpoint is same, just need to re-run tools logic (like CDP connect)
+            // We can skip client creation
         }
-        try {
-            await this.mcpClient.connect(this.transport);
-            // Stability delay for HTTP connections to ensure session is fully open
-            // Remote servers often need a moment to register the session before accepting POST calls
+        if (!this.mcpClient) {
+            // Initialize MCP client
+            this.mcpClient = new index_js_1.Client({ name: 'n8n-browser-automation', version: '1.0.0' }, { capabilities: {} });
+            // Determine transport based on endpoint type
+            const isUrl = trimmedMcpEndpoint.startsWith('http://') || trimmedMcpEndpoint.startsWith('https://');
+            let urlIsSse = false;
             if (isUrl) {
-                if (process.env.NODE_ENV !== 'production') {
-                    console.log(`[MCP] Connected to ${trimmedMcpEndpoint}. Waiting for session stabilization...`);
+                try {
+                    urlIsSse = /(^|\/)sse\/?(\?|#|$)/i.test(mcpUrlObj.pathname);
+                }
+                catch (e) {
+                    throw new Error(`Invalid MCP Endpoint path: "${trimmedMcpEndpoint}".`);
                 }
-                await new Promise(resolve => setTimeout(resolve, 2000));
             }
-        }
-        catch (error) {
-            this.isInitialized = false;
-            const transportType = isUrl ? (urlIsSse ? 'SSE' : 'Streamable HTTP') : 'Stdio';
-            throw new Error(`Failed to connect to MCP server via ${transportType} at ${trimmedMcpEndpoint}. Error: ${error.message}`);
+            if (isUrl) {
+                if (urlIsSse) {
+                    // Connect via SSE
+                    const { SSEClientTransport } = await Promise.resolve().then(() => __importStar(require('@modelcontextprotocol/sdk/client/sse.js')));
+                    this.transport = new SSEClientTransport(new URL(trimmedMcpEndpoint)); // Safe because we parsed it above
+                }
+                else {
+                    // Connect via Streamable HTTP
+                    const { StreamableHTTPClientTransport } = await Promise.resolve().then(() => __importStar(require('@modelcontextprotocol/sdk/client/streamableHttp.js')));
+                    this.transport = new StreamableHTTPClientTransport(new URL(trimmedMcpEndpoint)); // Safe because we parsed it above
+                }
+            }
+            else {
+                // Connect via Stdio (lazy import so environments that only use SSE don't need stdio deps)
+                const { StdioClientTransport } = await Promise.resolve().then(() => __importStar(require('@modelcontextprotocol/sdk/client/stdio.js')));
+                this.transport = new StdioClientTransport({
+                    command: 'node',
+                    args: [mcpEndpoint],
+                    env: {
+                        ...process.env,
+                        ...(useCDP && cdpEndpoint ? { CDP_URL: cdpEndpoint } : {}),
+                    },
+                });
+            }
+            try {
+                await this.mcpClient.connect(this.transport);
+                // Stability delay for HTTP connections to ensure session is fully open
+                if (isUrl) {
+                    if (process.env.NODE_ENV !== 'production') {
+                        console.log(`[MCP] Connected to ${trimmedMcpEndpoint}. Waiting for session stabilization...`);
+                    }
+                    await new Promise(resolve => setTimeout(resolve, 2000));
+                }
+            }
+            catch (error) {
+                this.isInitialized = false;
+                const transportType = isUrl ? (urlIsSse ? 'SSE' : 'Streamable HTTP') : 'Stdio';
+                throw new Error(`Failed to connect to MCP server via ${transportType} at ${trimmedMcpEndpoint}. Error: ${error.message}`);
+            }
         }
         this.isInitialized = true;
         this.config = { mcpEndpoint, useCDP, cdpEndpoint };

package/dist/nodes/SmartBrowserAutomation/SmartBrowserAutomation.node.js

@@ -1,12 +1,9 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SmartBrowserAutomation = void 0;
 const n8n_workflow_1 = require("n8n-workflow");
-const BrowserSessionManager_1 = __importDefault(require("./BrowserSessionManager"));
 const jsonSchemaToZod_1 = require("./jsonSchemaToZod");
+const McpConnection_1 = require("./utils/McpConnection");
 class SmartBrowserAutomation {
     description = {
         displayName: 'Smart Browser Automation',
@@ -97,9 +94,18 @@ class SmartBrowserAutomation {
             async getAvailableTools() {
                 try {
                     const credentials = await this.getCredentials('smartBrowserAutomationApi');
-                    const sessionManager = BrowserSessionManager_1.default.getInstance();
-                    await sessionManager.initialize(credentials.mcpEndpoint, false, '');
-                    const tools = await sessionManager.listTools();
+                    // Removed sessionManager usage
+                    // Use temporary config for listing options
+                    const config = {
+                        mcpEndpoint: (credentials.mcpEndpoint || '').trim(),
+                        browserMode: credentials.browserMode,
+                    };
+                    const { client, mcpTools, error } = await (0, McpConnection_1.connectAndGetTools)(this, config);
+                    if (error)
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), error.message);
+                    // Close immediately as we just need list
+                    await client.close();
+                    const tools = mcpTools;
                     return tools.map((tool) => ({
                         name: tool.name.split('_').map((s) => s.charAt(0).toUpperCase() + s.slice(1)).join(' '),
                         value: tool.name,
@@ -118,13 +124,25 @@ class SmartBrowserAutomation {
         const items = this.getInputData();
         const returnData = [];
         const credentials = await this.getCredentials('smartBrowserAutomationApi');
-        const sessionManager = BrowserSessionManager_1.default.getInstance();
         const operation = this.getNodeParameter('operation', 0);
         // Handle List Tools operation
         if (operation === 'listTools') {
             try {
-                await sessionManager.initialize(credentials.mcpEndpoint, false, '');
-                const tools = await sessionManager.listTools();
+                // Use new McpConnection logic
+                const mcpOverride = this.getNodeParameter('mcpEndpointOverride', 0, '');
+                const cdpOverride = this.getNodeParameter('cdpOverride', 0, '');
+                const browserMode = credentials.browserMode;
+                const config = {
+                    mcpEndpoint: (mcpOverride || credentials.mcpEndpoint || '').trim(),
+                    browserMode: browserMode,
+                    cdpEndpoint: (cdpOverride || credentials.cdpEndpoint || '').trim(),
+                };
+                const { client, mcpTools, error } = await (0, McpConnection_1.connectAndGetTools)(this, config);
+                if (error)
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), error.message);
+                // Close client after listing since this is just a listing operation
+                await client.close();
+                const tools = mcpTools;
                 returnData.push({
                     json: {
                         tools: tools.map((tool) => ({
@@ -191,10 +209,19 @@ class SmartBrowserAutomation {
         }
         try {
             // Initialize session if not ready
-            if (!sessionManager.isReady()) {
-                const cdpUrl = cdpOverride || credentials.cdpEndpoint || '';
-                await sessionManager.initialize(credentials.mcpEndpoint, !!cdpUrl, cdpUrl);
-            }
+            // Connect via McpConnection
+            const mcpOverride = this.getNodeParameter('mcpEndpointOverride', 0, '');
+            const browserMode = credentials.browserMode; // from credentials
+            // We might need to handle CDP Override if it's passed in tool params (legacy)
+            const cdpUrl = cdpOverride || credentials.cdpEndpoint || '';
+            const config = {
+                mcpEndpoint: (mcpOverride || credentials.mcpEndpoint || '').trim(),
+                browserMode: browserMode,
+                cdpEndpoint: cdpUrl.trim(),
+            };
+            const { client, mcpTools, error } = await (0, McpConnection_1.connectAndGetTools)(this, config);
+            if (error)
+                throw new n8n_workflow_1.NodeOperationError(this.getNode(), error.message);
             // Ensure toolParams is an object
             if (typeof toolParams !== 'object' ||
                 toolParams === null ||
@@ -207,9 +234,15 @@ class SmartBrowserAutomation {
                 if (!endpoint) {
                     throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'CDP endpoint is required. Provide it in tool parameters or CDP Endpoint Override field.');
                 }
-                // Reinitialize with new CDP endpoint
-                await sessionManager.close();
-                await sessionManager.initialize(credentials.mcpEndpoint, true, endpoint);
+                // Reinitialize with new CDP endpoint - Create new client
+                await client.close(); // Close existing listing client
+                const newConfig = { ...config, cdpEndpoint: endpoint };
+                const { client: newClient, error: connError } = await (0, McpConnection_1.connectAndGetTools)(this, newConfig);
+                if (connError) {
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Failed to reconnect with new CDP endpoint: ${connError.message}`);
+                }
+                // We just verify connection here via ListTools or similar implicitly done by connectAndGetTools
+                await newClient.close();
                 returnData.push({
                     json: {
                         result: {
@@ -221,7 +254,7 @@ class SmartBrowserAutomation {
                 return [returnData];
             }
             // Validate tool exists before executing
-            const availableTools = await sessionManager.listTools();
+            const availableTools = mcpTools;
             const selectedTool = availableTools.find((tool) => tool.name === toolName);
             const toolExists = Boolean(selectedTool);
             if (!toolExists) {
@@ -240,7 +273,11 @@ class SmartBrowserAutomation {
                 }
             }
             // Execute the tool via MCP
-            const result = await sessionManager.callTool(toolName, toolParams);
+            const result = await client.callTool({
+                name: toolName,
+                arguments: toolParams
+            });
+            await client.close();
             returnData.push({
                 json: { result },
             });

package/dist/nodes/SmartBrowserAutomation/SmartBrowserAutomationTools.node.js

@@ -1,80 +1,11 @@
 "use strict";
 /* eslint-disable n8n-nodes-base/node-class-description-inputs-wrong-regular-node */
 /* eslint-disable n8n-nodes-base/node-class-description-outputs-wrong */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SmartBrowserAutomationTools = void 0;
 const n8n_workflow_1 = require("n8n-workflow");
-const BrowserSessionManager_1 = __importDefault(require("./BrowserSessionManager"));
-const jsonSchemaToZod_1 = require("./jsonSchemaToZod");
-async function importDynamicStructuredTool() {
-    try {
-        return await Promise.resolve().then(() => __importStar(require('langchain/tools')));
-    }
-    catch {
-        // Some n8n installations ship a langchain build where subpath exports differ.
-        return await Promise.resolve().then(() => __importStar(require('@langchain/core/tools')));
-    }
-}
-async function importToolkitBase() {
-    // n8n uses Toolkit from @langchain/classic/agents internally.
-    return await Promise.resolve().then(() => __importStar(require('@langchain/classic/agents')));
-}
-function formatMcpToolResult(result) {
-    if (result === null || result === undefined)
-        return '';
-    if (typeof result === 'string')
-        return result;
-    const content = result?.content;
-    if (Array.isArray(content)) {
-        const texts = content
-            .map((c) => (c?.type === 'text' ? String(c?.text ?? '') : ''))
-            .filter((t) => t.length > 0);
-        if (texts.length)
-            return texts.join('\n');
-    }
-    try {
-        return JSON.stringify(result);
-    }
-    catch {
-        return String(result);
-    }
-}
+const McpUtils_1 = require("./utils/McpUtils");
+const McpConnection_1 = require("./utils/McpConnection");
 class SmartBrowserAutomationTools {
     description = {
         displayName: 'Smart Browser Automation Tools',
@@ -117,122 +48,93 @@ class SmartBrowserAutomationTools {
     async supplyData(itemIndex) {
         const node = this.getNode();
         const credentials = await this.getCredentials('smartBrowserAutomationApi');
-        const sessionManager = BrowserSessionManager_1.default.getInstance();
         const mcpOverride = this.getNodeParameter('mcpEndpointOverride', itemIndex, '');
         const cdpOverride = this.getNodeParameter('cdpOverride', itemIndex, '');
-        const useCDP = credentials.browserMode === 'cdp';
-        const cdpUrl = (cdpOverride || credentials.cdpEndpoint || '').trim();
-        const mcpEndpoint = (mcpOverride || credentials.mcpEndpoint || '').trim();
-        if (!mcpEndpoint) {
-            throw new n8n_workflow_1.NodeOperationError(node, 'MCP Endpoint is required in credentials', {
-                itemIndex,
-                description: 'Configure MCP Endpoint in Smart Browser Automation credentials (e.g. http://localhost:3000 or https://host/sse)',
-            });
-        }
-        // Basic pre-validation so users see a clear error in the UI
-        if (!/^[a-zA-Z][a-zA-Z0-9+.-]*:/.test(mcpEndpoint)) {
-            throw new n8n_workflow_1.NodeOperationError(node, `MCP Endpoint looks incomplete: "${mcpEndpoint}" (add http:// or https://)`, { itemIndex });
-        }
-        try {
-            await sessionManager.initialize(mcpEndpoint, useCDP, useCDP ? cdpUrl : undefined);
+        const browserMode = credentials.browserMode;
+        const useCDP = browserMode === 'cdp';
+        const config = {
+            mcpEndpoint: (mcpOverride || credentials.mcpEndpoint || '').trim(),
+            browserMode: browserMode,
+            cdpEndpoint: (cdpOverride || credentials.cdpEndpoint || '').trim(),
+            timeout: 60000 // Default timeout
+        };
+        if (!config.mcpEndpoint) {
+            throw new n8n_workflow_1.NodeOperationError(node, 'MCP Endpoint is required in credentials', { itemIndex });
         }
-        catch (error) {
-            const e = error;
-            const mode = useCDP ? 'cdp' : 'launch';
-            const details = `mcp=${mcpEndpoint} | mode=${mode}${useCDP ? ` | cdp=${cdpUrl || 'unset'}` : ''}`;
-            throw new n8n_workflow_1.NodeOperationError(node, `Failed to connect to MCP. ${details}. Original error: ${e.message}`, {
-                itemIndex,
-                description: details,
-            });
+        // Connect to MCP Server
+        const { client, mcpTools, error } = await (0, McpConnection_1.connectAndGetTools)(this, config);
+        if (error) {
+            throw new n8n_workflow_1.NodeOperationError(node, error.message, { itemIndex });
         }
-        const mcpTools = await sessionManager.listTools();
-        if (!mcpTools.length) {
+        if (!mcpTools?.length) {
             throw new n8n_workflow_1.NodeOperationError(node, 'MCP Server returned no tools', { itemIndex });
         }
-        // Emit a debug item on the Main output so users can see endpoints and tool list in the UI
+        // *** Smart Browser Automation Specific Logic ***
+        // If we are in CDP mode, we MUST ensure the connection is established immediately.
+        // We call 'browser_connect_cdp' now, during initialization.
+        if (useCDP) {
+            const connectToolName = 'browser_connect_cdp';
+            const connectTool = mcpTools.find(t => t.name === connectToolName);
+            if (connectTool && config.cdpEndpoint) {
+                try {
+                    console.log(`[Init] Auto-connecting to CDP: ${config.cdpEndpoint}`);
+                    const connectResult = await client.callTool({
+                        name: connectToolName,
+                        arguments: { endpoint: config.cdpEndpoint }
+                    });
+                    if (connectResult.isError) {
+                        throw new n8n_workflow_1.NodeOperationError(node, `CDP Connection failed: ${JSON.stringify(connectResult)}`, { itemIndex });
+                    }
+                    console.log(`[Init] Connected successfully.`);
+                }
+                catch (connErr) {
+                    throw new n8n_workflow_1.NodeOperationError(node, `Failed to auto-connect to CDP: ${connErr.message}`, { itemIndex });
+                }
+            }
+            else if (!config.cdpEndpoint) {
+                throw new n8n_workflow_1.NodeOperationError(node, 'CDP Endpoint is missing for CDP mode connection.', { itemIndex });
+            }
+        }
+        // Filter out the connect tool so the AI doesn't see it
+        const exposedTools = mcpTools.filter(t => t.name !== 'browser_connect_cdp');
+        // Debug Output
         const debugJson = {
-            mcpEndpoint,
-            browserMode: credentials.browserMode,
-            cdpEndpoint: useCDP ? cdpUrl : undefined,
-            toolCount: mcpTools.length,
-            tools: mcpTools.map((t) => ({
+            mcpEndpoint: config.mcpEndpoint,
+            browserMode: config.browserMode,
+            cdpEndpoint: config.cdpEndpoint,
+            initializationMode: 'strict_cdp_connect',
+            toolCount: exposedTools.length,
+            tools: exposedTools.map((t) => ({
                 name: t.name,
                 description: t.description ?? '',
             })),
         };
+        // Using 'this.addOutputData' as per recent fix
         this.addOutputData(n8n_workflow_1.NodeConnectionTypes.Main, 0, [[{ json: debugJson }]]);
-        const { DynamicStructuredTool } = await importDynamicStructuredTool();
-        const { Toolkit } = await importToolkitBase();
-        const ctx = this;
-        const tools = await Promise.all(mcpTools.map(async (tool) => {
-            const schema = await (0, jsonSchemaToZod_1.jsonSchemaToZod)(tool.inputSchema);
-            const toolName = tool.name;
-            const toolDescription = (tool.description ?? '');
-            return new DynamicStructuredTool({
-                name: toolName,
-                description: toolDescription,
-                schema,
-                func: async (args) => {
-                    // Make tool calls visible in n8n execution UI
-                    const input = {
-                        tool: toolName,
-                        arguments: args,
-                    };
-                    let runIndex = 0;
-                    try {
-                        runIndex = ctx.getNextRunIndex?.() ?? 0;
-                    }
-                    catch { }
-                    const { index } = ctx.addInputData(n8n_workflow_1.NodeConnectionTypes.AiTool, [[{ json: input }]], runIndex);
-                    try {
-                        console.log(`[AI Agent] Executing tool ${toolName} with args:`, JSON.stringify(args));
-                        const result = await sessionManager.callTool(toolName, args);
-                        const output = { tool: toolName, result };
-                        // Ensure the output is an array of INodeExecutionData
-                        const executionData = [[{ json: output }]];
-                        ctx.addOutputData(n8n_workflow_1.NodeConnectionTypes.AiTool, index, executionData);
-                        return formatMcpToolResult(result);
-                    }
-                    catch (e) {
-                        const errorMsg = e.message || String(e);
-                        console.error(`[AI Agent] Tool ${toolName} failed:`, errorMsg);
-                        // Fix: properly format error for addOutputData
-                        const errorOutput = [[{
-                                    json: {
-                                        tool: toolName,
-                                        error: errorMsg,
-                                        stack: e.stack
-                                    }
-                                }]];
-                        // Safely attempt to report error to UI
-                        try {
-                            ctx.addOutputData(n8n_workflow_1.NodeConnectionTypes.AiTool, index, errorOutput);
-                        }
-                        catch (addError) {
-                            console.error('[AI Agent] Failed to add error output:', addError);
-                        }
-                        // Re-throw so the AI Agent knows it failed
-                        throw e;
-                    }
-                },
-                metadata: { isFromToolkit: true },
-            });
+        // Create LangChain Tools
+        // Map MCP tools to DynamicStructuredTools using the official utility pattern
+        const dynamicTools = await Promise.all(exposedTools.map(async (tool) => {
+            return await (0, McpUtils_1.mcpToolToDynamicTool)(tool, (0, McpUtils_1.createCallTool)(tool.name, client, 60000, (errorMessage) => {
+                // Error callback similar to official implementation
+                const errorNode = new n8n_workflow_1.NodeOperationError(node, errorMessage, { itemIndex });
+                // We need to report this error on the AiTool output if possible, 
+                // or maybe just log it since the createCallTool helper handles return values.
+                // The official node uses void this.addOutputData(...)
+                try {
+                    this.addOutputData(n8n_workflow_1.NodeConnectionTypes.AiTool, itemIndex, errorNode);
+                }
+                catch (e) {
+                    console.error('Failed to report error to AiTool output', e);
+                }
+            }));
         }));
-        class SmartBrowserAutomationToolkit extends Toolkit {
-            _tools;
-            constructor(_tools) {
-                super();
-                this._tools = _tools;
-            }
-            getTools() {
-                return this._tools;
-            }
-        }
+        const toolkit = new McpUtils_1.McpToolkit(dynamicTools);
+        // Return the toolkit and the cleanup function
         return {
-            response: new SmartBrowserAutomationToolkit(tools),
+            response: toolkit,
             closeFunction: async () => {
-                // Called by n8n when Agent execution finishes
-                await sessionManager.close();
+                console.log('[Cleanup] Closing MCP Client');
+                await client.close();
             },
         };
     }

package/dist/nodes/SmartBrowserAutomation/utils/McpConnection.d.ts

@@ -0,0 +1,18 @@
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { type ISupplyDataFunctions, type IExecuteFunctions } from 'n8n-workflow';
+import { type McpTool } from './McpUtils';
+export interface McpConfig {
+    mcpEndpoint: string;
+    browserMode: string;
+    cdpEndpoint?: string;
+    transportType?: 'sse' | 'stdio';
+    timeout?: number;
+}
+export declare function connectAndGetTools(_ctx: ISupplyDataFunctions | IExecuteFunctions, config: McpConfig): Promise<{
+    client: Client;
+    mcpTools: McpTool[];
+    error?: {
+        error: string;
+        message: string;
+    };
+}>;

package/dist/nodes/SmartBrowserAutomation/utils/McpConnection.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.connectAndGetTools = connectAndGetTools;
+const index_js_1 = require("@modelcontextprotocol/sdk/client/index.js");
+const sse_js_1 = require("@modelcontextprotocol/sdk/client/sse.js");
+const streamableHttp_js_1 = require("@modelcontextprotocol/sdk/client/streamableHttp.js");
+const stdio_js_1 = require("@modelcontextprotocol/sdk/client/stdio.js");
+async function connectAndGetTools(_ctx, config) {
+    let client;
+    let Transport;
+    try {
+        const mcpEndpoint = config.mcpEndpoint.trim();
+        const isUrl = mcpEndpoint.startsWith('http://') || mcpEndpoint.startsWith('https://');
+        if (isUrl) {
+            // Check for SSE
+            let urlIsSse = false;
+            try {
+                const url = new URL(mcpEndpoint);
+                urlIsSse = /(^|\/)sse\/?(\?|#|$)/i.test(url.pathname);
+            }
+            catch (e) {
+                return {
+                    client: null,
+                    mcpTools: [],
+                    error: { error: 'Invalid URL', message: `Invalid MCP Endpoint URL: ${mcpEndpoint}` }
+                };
+            }
+            if (urlIsSse) {
+                Transport = new sse_js_1.SSEClientTransport(new URL(mcpEndpoint));
+            }
+            else {
+                Transport = new streamableHttp_js_1.StreamableHTTPClientTransport(new URL(mcpEndpoint));
+            }
+        }
+        else {
+            // Stdio
+            Transport = new stdio_js_1.StdioClientTransport({
+                command: 'node',
+                args: [mcpEndpoint],
+                // Pass env if needed, including CDP_URL if we want the server to pick it up via env
+                env: {
+                    ...process.env,
+                    ...(config.cdpEndpoint ? { CDP_URL: config.cdpEndpoint } : {}),
+                },
+            });
+        }
+        client = new index_js_1.Client({ name: 'n8n-smart-browser-automation', version: '1.0.0' }, { capabilities: {} });
+        await client.connect(Transport);
+        // List tools
+        const result = await client.listTools();
+        const tools = (result.tools || []);
+        return { client, mcpTools: tools };
+    }
+    catch (err) {
+        return {
+            client: null,
+            mcpTools: [],
+            error: { error: 'Connection Failed', message: err.message || String(err) }
+        };
+    }
+}

package/dist/nodes/SmartBrowserAutomation/utils/McpUtils.d.ts

@@ -0,0 +1,23 @@
+import { DynamicStructuredTool } from '@langchain/core/tools';
+import type { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { Toolkit } from '@langchain/classic/agents';
+import { type IDataObject } from 'n8n-workflow';
+export type McpToolIncludeMode = 'all' | 'selected' | 'except';
+export interface McpTool {
+    name: string;
+    description?: string;
+    inputSchema?: any;
+}
+export declare function getSelectedTools({ mode, includeTools, excludeTools, tools, }: {
+    mode: McpToolIncludeMode;
+    includeTools?: string[];
+    excludeTools?: string[];
+    tools: McpTool[];
+}): McpTool[];
+export declare const getErrorDescriptionFromToolCall: (result: unknown) => string | undefined;
+export declare const createCallTool: (name: string, client: Client, timeout: number, onError: (error: string) => void) => (args: IDataObject) => Promise<{} | null>;
+export declare function mcpToolToDynamicTool(tool: McpTool, onCallTool: (args: any) => Promise<any>): Promise<DynamicStructuredTool>;
+export declare class McpToolkit extends Toolkit {
+    tools: DynamicStructuredTool[];
+    constructor(tools: DynamicStructuredTool[]);
+}

package/dist/nodes/SmartBrowserAutomation/utils/McpUtils.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.McpToolkit = exports.createCallTool = exports.getErrorDescriptionFromToolCall = void 0;
+exports.getSelectedTools = getSelectedTools;
+exports.mcpToolToDynamicTool = mcpToolToDynamicTool;
+const tools_1 = require("@langchain/core/tools");
+const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
+const agents_1 = require("@langchain/classic/agents");
+const zod_1 = require("zod");
+const jsonSchemaToZod_1 = require("../jsonSchemaToZod");
+function getSelectedTools({ mode, includeTools, excludeTools, tools, }) {
+    switch (mode) {
+        case 'selected': {
+            if (!includeTools?.length)
+                return tools;
+            const include = new Set(includeTools);
+            return tools.filter((tool) => include.has(tool.name));
+        }
+        case 'except': {
+            const except = new Set(excludeTools ?? []);
+            return tools.filter((tool) => !except.has(tool.name));
+        }
+        case 'all':
+        default:
+            return tools;
+    }
+}
+const getErrorDescriptionFromToolCall = (result) => {
+    if (result && typeof result === 'object') {
+        if ('content' in result && Array.isArray(result.content)) {
+            const errorMessage = result.content.find((content) => content && typeof content === 'object' && typeof content.text === 'string')?.text;
+            return errorMessage;
+        }
+        else if ('toolResult' in result && typeof result.toolResult === 'string') {
+            return result.toolResult;
+        }
+        if ('message' in result && typeof result.message === 'string') {
+            return result.message;
+        }
+    }
+    return undefined;
+};
+exports.getErrorDescriptionFromToolCall = getErrorDescriptionFromToolCall;
+const createCallTool = (name, client, timeout, onError) => async (args) => {
+    let result;
+    function handleError(error) {
+        const errorDescription = (0, exports.getErrorDescriptionFromToolCall)(error) ?? `Failed to execute tool "${name}"`;
+        onError(errorDescription);
+        return errorDescription;
+    }
+    try {
+        result = await client.callTool({ name, arguments: args }, types_js_1.CompatibilityCallToolResultSchema, {
+            timeout,
+        });
+    }
+    catch (error) {
+        return handleError(error);
+    }
+    if (result.isError) {
+        return handleError(result);
+    }
+    if (result.toolResult !== undefined) {
+        return result.toolResult;
+    }
+    if (result.content !== undefined) {
+        return result.content;
+    }
+    return result;
+};
+exports.createCallTool = createCallTool;
+async function mcpToolToDynamicTool(tool, onCallTool) {
+    // Use our existing jsonSchemaToZod implementation
+    const rawSchema = await (0, jsonSchemaToZod_1.jsonSchemaToZod)(tool.inputSchema);
+    // Ensure we always have an object schema for structured tools
+    const objectSchema = rawSchema instanceof zod_1.z.ZodObject ? rawSchema : zod_1.z.object({ value: rawSchema });
+    return new tools_1.DynamicStructuredTool({
+        name: tool.name,
+        description: tool.description ?? '',
+        schema: objectSchema,
+        func: onCallTool,
+        metadata: { isFromToolkit: true },
+    });
+}
+class McpToolkit extends agents_1.Toolkit {
+    tools;
+    constructor(tools) {
+        super();
+        this.tools = tools;
+    }
+}
+exports.McpToolkit = McpToolkit;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "n8n-nodes-smart-browser-automation",
-  "version": "1.6.24",
+  "version": "1.6.26",
   "description": "n8n node for AI-driven browser automation using MCP",
   "keywords": [
     "n8n-community-node-package",