n8n-nodes-smart-browser-automation 1.6.4 → 1.6.6

package/README.md

@@ -54,13 +54,14 @@ Add new credentials for **Smart Browser Automation API**:
 
 ### Mode 1: AI Agent (Automatic)
 
-Use with n8n's **AI Agent** node to let AI decide which browser tools to use:
+Use with n8n's **AI Agent** node to let AI decide which browser tools to use.
 
-1. Add **Smart Browser Automation** node
-2. Select **Mode**: `AI Agent (Auto)`
-3. Operation: `Initialize Session`
-4. Connect to **AI Agent** node
-5. AI can now use all browser tools automatically
+Use the dedicated tool node so the agent can discover each MCP tool and its JSON-schema arguments:
+
+1. Add **Smart Browser Automation Tools** node
+2. Configure credentials (MCP endpoint + browser mode)
+3. Connect its **Tools** output to **AI Agent**
+4. The agent can now call MCP tools (e.g. `browser_navigate`, `browser_click`) with correct argument schemas
 
 **Example AI Agent Workflow**:
 ```

package/dist/nodes/SmartBrowserAutomation/BrowserSessionManager.d.ts

@@ -13,6 +13,7 @@ declare class BrowserSessionManager {
     private constructor();
     static getInstance(): BrowserSessionManager;
     initialize(mcpEndpoint: string, useCDP: boolean, cdpEndpoint?: string): Promise<MCPTool[]>;
+    private getAllTools;
     callTool(toolName: string, toolArgs?: any): Promise<any>;
     getTools(): MCPTool[];
     listTools(): Promise<MCPTool[]>;

package/dist/nodes/SmartBrowserAutomation/BrowserSessionManager.js

@@ -21,6 +21,7 @@ class BrowserSessionManager {
         // Only initialize if not already done or config changed
         if (this.isInitialized &&
             this.config.mcpEndpoint === mcpEndpoint &&
+            this.config.useCDP === useCDP &&
             this.config.cdpEndpoint === cdpEndpoint) {
             return this.tools;
         }
@@ -64,13 +65,42 @@ class BrowserSessionManager {
             throw new Error(`Failed to connect to MCP server via ${transportType} at ${mcpEndpoint}. Error: ${error.message}`);
         }
         this.isInitialized = true;
-        this.config = { mcpEndpoint, cdpEndpoint };
-        // Fetch available tools from MCP server
-        const toolsResponse = await this.mcpClient.listTools();
-        await this.mcpClient.callTool({ name: 'browser_connect_cdp', arguments: { endpoint: cdpEndpoint || '' } });
-        this.tools = toolsResponse.tools;
+        this.config = { mcpEndpoint, useCDP, cdpEndpoint };
+        // Fetch available tools from MCP server (handles pagination)
+        this.tools = await this.getAllTools();
+        // If requested, connect to an existing browser via CDP
+        if (useCDP) {
+            if (!cdpEndpoint || String(cdpEndpoint).trim() === '') {
+                throw new Error('CDP endpoint is required when Browser Mode is CDP Connection');
+            }
+            const hasConnectTool = this.tools.some((t) => t.name === 'browser_connect_cdp');
+            if (hasConnectTool) {
+                const result = await this.mcpClient.callTool({
+                    name: 'browser_connect_cdp',
+                    arguments: { endpoint: cdpEndpoint },
+                });
+                if (result?.isError) {
+                    throw new Error(`Failed to connect via CDP: ${JSON.stringify(result)}`);
+                }
+            }
+        }
         return this.tools;
     }
+    async getAllTools(cursor) {
+        if (!this.mcpClient) {
+            throw new Error('MCP client not initialized');
+        }
+        // SDK supports optional cursor param; keep it loosely typed for compatibility.
+        const response = await (cursor
+            ? this.mcpClient.listTools({ cursor })
+            : this.mcpClient.listTools());
+        const tools = (response?.tools ?? []);
+        const nextCursor = response?.nextCursor;
+        if (nextCursor) {
+            return tools.concat(await this.getAllTools(nextCursor));
+        }
+        return tools;
+    }
     async callTool(toolName, toolArgs) {
         if (!this.mcpClient || !this.isInitialized) {
             throw new Error('MCP client not initialized. Please configure credentials first.');
@@ -84,6 +114,9 @@ class BrowserSessionManager {
             });
             // Log the response for debugging
             console.log(`[MCP] Tool "${toolName}" response:`, JSON.stringify(result, null, 2));
+            if (result?.isError) {
+                throw new Error(typeof result?.toolResult === 'string' ? result.toolResult : `Tool returned error: ${JSON.stringify(result)}`);
+            }
             return result;
         }
         catch (error) {

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

@@ -6,6 +6,7 @@ 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");
 class SmartBrowserAutomation {
     description = {
         displayName: 'Smart Browser Automation',
@@ -142,74 +143,64 @@ class SmartBrowserAutomation {
         // Handle Execute Tool operation
         // Get CDP override or use from credentials
         const cdpOverride = this.getNodeParameter('cdpOverride', 0, '');
-        // Check if AI Agent sent Tool_Parameters in input
+        // Check if AI Agent sent tool name in input
         const inputData = items[0]?.json;
-        const aiToolParams = inputData?.Tool_Parameters;
-        const aiAction = inputData?.action;
-        // Determine tool name: prefer AI input, fallback to manual parameter
+        // Determine tool name and parameters
         let toolName;
-        // Check if Tool_Parameters has browser_action field
-        if (aiToolParams && typeof aiToolParams === 'object' && 'browser_action' in aiToolParams) {
-            const browserAction = aiToolParams.browser_action;
-            toolName = `browser_${browserAction}`;
-        }
-        else if (aiAction && typeof aiAction === 'string' && aiAction !== 'sendMessage') {
-            // AI Agent sent action like "click", "open", etc - map to browser tool
-            toolName = aiAction === 'open' ? 'browser_navigate' : `browser_${aiAction}`;
+        let toolParams;
+        // Check if this is from AI Agent (has 'tool' field in json)
+        if (inputData?.tool && typeof inputData.tool === 'string') {
+            // AI Agent execution - tool name is in item.json.tool
+            toolName = inputData.tool;
+            // Extract parameters by removing known n8n/AI fields
+            const { tool, action, chatInput, sessionId, toolCallId, name, id, arguments: args, ...rest } = inputData;
+            // Use 'arguments' field if present, otherwise use remaining fields
+            toolParams = args && typeof args === 'object' ? args : rest;
         }
         else {
-            // Manual mode or no AI action
+            // Manual execution - use node parameters
             toolName = this.getNodeParameter('toolName', 0);
-        }
-        try {
-            // Initialize session if not ready
-            if (!sessionManager.isReady()) {
-                const cdpUrl = cdpOverride || credentials.cdpEndpoint || '';
-                await sessionManager.initialize(credentials.mcpEndpoint, !!cdpUrl, cdpUrl);
-            }
-            // Handle tool execution
-            let toolParams;
             try {
-                // First check if AI Agent sent Tool_Parameters in input
-                if (aiToolParams && typeof aiToolParams === 'object') {
-                    toolParams = aiToolParams;
+                const rawParams = this.getNodeParameter('toolParameters', 0);
+                if (rawParams === undefined || rawParams === null) {
+                    toolParams = {};
                 }
-                else {
-                    // Fallback to manual toolParameters field
-                    const rawParams = this.getNodeParameter('toolParameters', 0);
-                    if (rawParams === undefined || rawParams === null) {
+                else if (typeof rawParams === 'string') {
+                    if (!rawParams || rawParams.trim() === '') {
                         toolParams = {};
                     }
-                    else if (typeof rawParams === 'string') {
-                        if (!rawParams || rawParams.trim() === '') {
-                            toolParams = {};
-                        }
-                        else {
-                            toolParams = JSON.parse(rawParams);
-                        }
-                    }
-                    else if (typeof rawParams === 'object') {
-                        toolParams = rawParams;
-                    }
                     else {
-                        try {
-                            toolParams = JSON.parse(JSON.stringify(rawParams));
-                        }
-                        catch (parseError) {
-                            throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Invalid parameter type: ${typeof rawParams}`);
-                        }
+                        toolParams = JSON.parse(rawParams);
                     }
                 }
-                // Ensure toolParams is an object
-                if (typeof toolParams !== 'object' ||
-                    toolParams === null ||
-                    Array.isArray(toolParams)) {
-                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Tool parameters must be a JSON object');
+                else if (typeof rawParams === 'object') {
+                    toolParams = rawParams;
+                }
+                else {
+                    try {
+                        toolParams = JSON.parse(JSON.stringify(rawParams));
+                    }
+                    catch (parseError) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Invalid parameter type: ${typeof rawParams}`);
+                    }
                 }
             }
             catch (error) {
                 throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Failed to parse tool parameters: ${error.message}. Make sure the parameters are valid JSON.`);
             }
+        }
+        try {
+            // Initialize session if not ready
+            if (!sessionManager.isReady()) {
+                const cdpUrl = cdpOverride || credentials.cdpEndpoint || '';
+                await sessionManager.initialize(credentials.mcpEndpoint, !!cdpUrl, cdpUrl);
+            }
+            // Ensure toolParams is an object
+            if (typeof toolParams !== 'object' ||
+                toolParams === null ||
+                Array.isArray(toolParams)) {
+                throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Tool parameters must be a JSON object');
+            }
             // Special handling for browser_connect_cdp
             if (toolName === 'browser_connect_cdp') {
                 const endpoint = toolParams.endpoint || cdpOverride || credentials.cdpEndpoint;
@@ -231,11 +222,23 @@ class SmartBrowserAutomation {
             }
             // Validate tool exists before executing
             const availableTools = await sessionManager.listTools();
-            const toolExists = availableTools.some((tool) => tool.name === toolName);
+            const selectedTool = availableTools.find((tool) => tool.name === toolName);
+            const toolExists = Boolean(selectedTool);
             if (!toolExists) {
                 const availableToolNames = availableTools.map((t) => t.name).join(', ');
                 throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Tool '${toolName}' does not exist. Available tools: ${availableToolNames}`);
             }
+            // Validate tool parameters against the MCP tool JSON schema (when provided)
+            if (selectedTool?.inputSchema) {
+                try {
+                    const schema = await (0, jsonSchemaToZod_1.jsonSchemaToZod)(selectedTool.inputSchema);
+                    schema.parse(toolParams);
+                }
+                catch (validationError) {
+                    const details = validationError?.issues ? JSON.stringify(validationError.issues) : validationError.message;
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Invalid tool parameters for '${toolName}'.`, { description: details });
+                }
+            }
             // Execute the tool via MCP
             const result = await sessionManager.callTool(toolName, toolParams);
             returnData.push({

package/dist/nodes/SmartBrowserAutomation/SmartBrowserAutomationTools.node.d.ts

@@ -0,0 +1,5 @@
+import { type INodeType, type INodeTypeDescription, type ISupplyDataFunctions, type SupplyData } from 'n8n-workflow';
+export declare class SmartBrowserAutomationTools implements INodeType {
+    description: INodeTypeDescription;
+    supplyData(this: ISupplyDataFunctions, itemIndex: number): Promise<SupplyData>;
+}

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

@@ -0,0 +1,121 @@
+"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");
+class SmartBrowserAutomationTools {
+    description = {
+        displayName: 'Smart Browser Automation Tools',
+        name: 'smartBrowserAutomationTools',
+        group: ['transform'],
+        version: 1,
+        description: 'Expose Smart Browser Automation MCP tools (with JSON-schema args) to AI Agents',
+        defaults: {
+            name: 'Browser Automation Tools',
+        },
+        inputs: [],
+        outputs: [{ type: n8n_workflow_1.NodeConnectionTypes.AiTool, displayName: 'Tools' }],
+        icon: 'file:smartBrowserAutomation.svg',
+        credentials: [
+            {
+                name: 'smartBrowserAutomationApi',
+                required: true,
+            },
+        ],
+        properties: [
+            {
+                displayName: 'CDP Endpoint Override',
+                name: 'cdpOverride',
+                type: 'string',
+                default: '',
+                placeholder: 'ws://localhost:9222',
+                description: 'Override the CDP endpoint from credentials (only used in CDP mode)',
+            },
+        ],
+    };
+    async supplyData(itemIndex) {
+        const node = this.getNode();
+        const credentials = await this.getCredentials('smartBrowserAutomationApi');
+        const sessionManager = BrowserSessionManager_1.default.getInstance();
+        const cdpOverride = this.getNodeParameter('cdpOverride', itemIndex, '');
+        const useCDP = credentials.browserMode === 'cdp';
+        const cdpUrl = (cdpOverride || credentials.cdpEndpoint || '').trim();
+        try {
+            await sessionManager.initialize(credentials.mcpEndpoint, useCDP, useCDP ? cdpUrl : undefined);
+        }
+        catch (error) {
+            throw new n8n_workflow_1.NodeOperationError(node, `Failed to connect to MCP server: ${error.message}`, {
+                itemIndex,
+            });
+        }
+        const mcpTools = await sessionManager.listTools();
+        if (!mcpTools.length) {
+            throw new n8n_workflow_1.NodeOperationError(node, 'MCP Server returned no tools', { itemIndex });
+        }
+        const { DynamicStructuredTool } = await Promise.resolve().then(() => __importStar(require('langchain/tools')));
+        const { Toolkit } = await Promise.resolve().then(() => __importStar(require('langchain/agents')));
+        const tools = await Promise.all(mcpTools.map(async (tool) => {
+            const schema = await (0, jsonSchemaToZod_1.jsonSchemaToZod)(tool.inputSchema);
+            return new DynamicStructuredTool({
+                name: tool.name,
+                description: tool.description ?? '',
+                schema,
+                func: async (args) => {
+                    return await sessionManager.callTool(tool.name, args);
+                },
+                metadata: { isFromToolkit: true },
+            });
+        }));
+        class SmartBrowserAutomationToolkit extends Toolkit {
+            tools;
+            constructor(tools) {
+                super();
+                this.tools = tools;
+            }
+        }
+        return {
+            response: new SmartBrowserAutomationToolkit(tools),
+            closeFunction: async () => await sessionManager.close(),
+        };
+    }
+}
+exports.SmartBrowserAutomationTools = SmartBrowserAutomationTools;

package/dist/nodes/SmartBrowserAutomation/jsonSchemaToZod.d.ts

@@ -0,0 +1,16 @@
+type JsonSchema = {
+    type?: string | string[];
+    properties?: Record<string, JsonSchema>;
+    required?: string[];
+    items?: JsonSchema;
+    enum?: Array<string | number | boolean | null>;
+    anyOf?: JsonSchema[];
+    oneOf?: JsonSchema[];
+    allOf?: JsonSchema[];
+    additionalProperties?: boolean | JsonSchema;
+    default?: unknown;
+    description?: string;
+    format?: string;
+};
+export type { JsonSchema };
+export declare function jsonSchemaToZod(schema: JsonSchema | undefined): Promise<any>;

package/dist/nodes/SmartBrowserAutomation/jsonSchemaToZod.js

@@ -0,0 +1,108 @@
+"use strict";
+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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.jsonSchemaToZod = jsonSchemaToZod;
+async function jsonSchemaToZod(schema) {
+    const { z } = await Promise.resolve().then(() => __importStar(require('zod')));
+    const toZod = (s) => {
+        if (!s)
+            return z.any();
+        if (Array.isArray(s.oneOf) && s.oneOf.length) {
+            return z.union(s.oneOf.map((x) => toZod(x)));
+        }
+        if (Array.isArray(s.anyOf) && s.anyOf.length) {
+            return z.union(s.anyOf.map((x) => toZod(x)));
+        }
+        if (Array.isArray(s.allOf) && s.allOf.length) {
+            return s.allOf.reduce((acc, cur) => acc.and(toZod(cur)), toZod(s.allOf[0]));
+        }
+        if (Array.isArray(s.enum) && s.enum.length) {
+            const values = s.enum;
+            const allStrings = values.every((v) => typeof v === 'string');
+            if (allStrings) {
+                return z.enum(values);
+            }
+            return z.union(values.map((v) => z.literal(v)));
+        }
+        const type = s.type;
+        const types = Array.isArray(type) ? type : type ? [type] : [];
+        const allowsNull = types.includes('null');
+        const effectiveTypes = types.filter((t) => t !== 'null');
+        let base;
+        switch (effectiveTypes[0]) {
+            case 'string':
+                base = z.string();
+                break;
+            case 'integer':
+                base = z.number().int();
+                break;
+            case 'number':
+                base = z.number();
+                break;
+            case 'boolean':
+                base = z.boolean();
+                break;
+            case 'array':
+                base = z.array(toZod(s.items));
+                break;
+            case 'object': {
+                const shape = {};
+                const props = s.properties ?? {};
+                const required = new Set(s.required ?? []);
+                for (const [key, value] of Object.entries(props)) {
+                    const zodProp = toZod(value);
+                    shape[key] = required.has(key) ? zodProp : zodProp.optional();
+                }
+                base = z.object(shape);
+                if (s.additionalProperties === false) {
+                    base = base.strict();
+                }
+                else if (s.additionalProperties && typeof s.additionalProperties === 'object') {
+                    base = base.catchall(toZod(s.additionalProperties));
+                }
+                else {
+                    base = base.passthrough();
+                }
+                break;
+            }
+            default:
+                base = z.any();
+        }
+        if (allowsNull)
+            base = base.nullable();
+        return base;
+    };
+    return toZod(schema);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "n8n-nodes-smart-browser-automation",
-  "version": "1.6.4",
+  "version": "1.6.6",
   "description": "n8n node for AI-driven browser automation using MCP",
   "keywords": [
     "n8n-community-node-package",
@@ -37,7 +37,8 @@
       "dist/credentials/SmartBrowserAutomationApi.credentials.js"
     ],
     "nodes": [
-      "dist/nodes/SmartBrowserAutomation/SmartBrowserAutomation.node.js"
+      "dist/nodes/SmartBrowserAutomation/SmartBrowserAutomation.node.js",
+      "dist/nodes/SmartBrowserAutomation/SmartBrowserAutomationTools.node.js"
     ]
   },
   "devDependencies": {
@@ -55,6 +56,7 @@
     "n8n-workflow": "*"
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.17.0"
+    "@modelcontextprotocol/sdk": "^1.17.0",
+    "zod": "^3.23.8"
   }
 }