brave-real-browser-mcp-server 2.41.11 → 2.41.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brave-real-browser-mcp-server",
-  "version": "2.41.11",
+  "version": "2.41.12",
   "description": "MCP Server for Brave Real Browser - Puppeteer with Brave Browser, Stealth Mode, Ad Blocker, and Turnstile Auto-Solver for undetectable web automation.",
   "main": "lib/cjs/index.js",
   "module": "lib/esm/index.mjs",
@@ -74,7 +74,7 @@
   "license": "ISC",
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.25.3",
-    "brave-real-puppeteer-core": "^24.37.1-brave.10",
+    "brave-real-puppeteer-core": "^24.37.1-brave.11",
     "ghost-cursor": "^1.4.2",
     "puppeteer-extra": "^3.3.6",
     "puppeteer-extra-plugin-stealth": "^2.11.2",

package/packages/brave-real-blocker/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brave-real-blocker",
-  "version": "1.17.11",
+  "version": "1.17.12",
   "description": "Advanced uBlock Origin management and stealth features for Brave Real Browser",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
@@ -64,7 +64,7 @@
     "@types/adm-zip": "^0.5.5",
     "@types/fs-extra": "^11.0.4",
     "@types/node": "^20.0.0",
-    "brave-real-puppeteer-core": "^24.37.1-brave.10",
+    "brave-real-puppeteer-core": "^24.37.1-brave.11",
     "mocha": "^10.4.0",
     "puppeteer-core": ">=24.0.0",
     "sinon": "^17.0.1",

package/packages/brave-real-launcher/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brave-real-launcher",
-  "version": "1.23.11",
+  "version": "1.23.12",
   "description": "Launch Brave Browser with ease from node. Based on chrome-launcher with Brave-specific support.",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
@@ -54,7 +54,7 @@
     "typescript": "^5.0.0"
   },
   "dependencies": {
-    "brave-real-blocker": "^1.17.11",
+    "brave-real-blocker": "^1.17.12",
     "escape-string-regexp": "^5.0.0",
     "is-wsl": "^3.1.0",
     "which": "^6.0.0"

package/packages/brave-real-playwright-core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brave-real-playwright-core",
-  "version": "1.59.11",
+  "version": "1.59.12",
   "description": "Brave-optimized Playwright Core (v1.57.0) with comprehensive stealth patches and error stack sanitization",
   "keywords": [
     "playwright",

package/packages/brave-real-puppeteer-core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brave-real-puppeteer-core",
-  "version": "24.37.1-brave.10",
+  "version": "24.37.1-brave.11",
   "description": "🦁 Brave Real-World Optimized Puppeteer & Playwright Core with 1-5ms ultra-fast timing, 50+ professional stealth features, intelligent browser auto-detection, and 100% bot detection bypass. Features cross-platform Brave browser integration, comprehensive anti-detection, and breakthrough performance improvements.",
   "keywords": [
     "automation",
@@ -134,13 +134,13 @@
     "test-version": "node ./scripts/test-version-management.js"
   },
   "dependencies": {
-    "brave-real-launcher": "^1.23.11",
+    "brave-real-launcher": "^1.23.12",
     "get-east-asian-width": "^1.4.0",
     "yargs": "^18.0.0"
   },
   "optionalDependencies": {
-    "playwright-core": "^1.58.2",
-    "puppeteer-core": "^24.37.2"
+    "playwright-core": "^1.58.1",
+    "puppeteer-core": "^24.37.1"
   },
   "devDependencies": {
     "test": "^3.3.0"

package/src/lsp/capabilities/diagnostics.js

@@ -12,38 +12,38 @@ function getDiagnostics(document, tools, lang, maxDiagnostics = 100) {
   const text = document.getText();
   const lines = text.split('\n');
   const diagnostics = [];
-  
+
   // State tracking
   let browserInitialized = false;
   let browserClosed = false;
   let currentPage = null;
   let networkRecording = false;
-  
+
   // Tool categories
   const browserRequiredTools = [
     'navigate', 'get_content', 'wait', 'click', 'type', 'solve_captcha',
     'random_scroll', 'find_element', 'save_content_as_markdown', 'search_regex',
     'extract_json', 'scrape_meta_tags', 'press_key', 'deep_analysis',
     'network_recorder', 'link_harvester', 'cookie_manager', 'iframe_handler',
-    'stream_extractor', 'js_scrape', 'execute_js', 'player_api_hook', 'form_automator',
+    'stream_extractor', 'js_scrape', 'execute_js', 'player_api_hook',
     'redirect_tracer', 'file_downloader'
   ];
-  
+
   const pageRequiredTools = [
     'get_content', 'click', 'type', 'random_scroll', 'find_element',
     'save_content_as_markdown', 'search_regex', 'extract_json', 'scrape_meta_tags',
     'deep_analysis', 'link_harvester', 'iframe_handler', 'stream_extractor',
-    'js_scrape', 'execute_js', 'player_api_hook', 'form_automator', 'press_key'
+    'js_scrape', 'execute_js', 'player_api_hook', 'press_key'
   ];
-  
+
   // Parse all tool calls with their parameters
   const toolCalls = parseAllToolCalls(text, lines, tools);
-  
+
   for (const call of toolCalls) {
     if (diagnostics.length >= maxDiagnostics) break;
-    
+
     const tool = tools.find(t => t.name === call.name);
-    
+
     // 1. Unknown tool check
     if (!tool) {
       diagnostics.push({
@@ -56,7 +56,7 @@ function getDiagnostics(document, tools, lang, maxDiagnostics = 100) {
       });
       continue;
     }
-    
+
     // 2. Browser state tracking
     if (call.name === 'browser_init') {
       if (browserInitialized && !browserClosed) {
@@ -71,7 +71,7 @@ function getDiagnostics(document, tools, lang, maxDiagnostics = 100) {
       browserInitialized = true;
       browserClosed = false;
     }
-    
+
     if (call.name === 'browser_close') {
       if (!browserInitialized) {
         diagnostics.push({
@@ -85,11 +85,11 @@ function getDiagnostics(document, tools, lang, maxDiagnostics = 100) {
       browserClosed = true;
       currentPage = null;
     }
-    
+
     if (call.name === 'navigate') {
       currentPage = call.params?.url || 'page';
     }
-    
+
     // 3. Browser required check
     if (browserRequiredTools.includes(call.name) && !browserInitialized) {
       diagnostics.push({
@@ -100,7 +100,7 @@ function getDiagnostics(document, tools, lang, maxDiagnostics = 100) {
         code: 'browser-not-init'
       });
     }
-    
+
     // 4. Browser closed check
     if (browserRequiredTools.includes(call.name) && browserClosed) {
       diagnostics.push({
@@ -111,7 +111,7 @@ function getDiagnostics(document, tools, lang, maxDiagnostics = 100) {
         code: 'browser-closed'
       });
     }
-    
+
     // 5. Page required check (navigate must be called first)
     if (pageRequiredTools.includes(call.name) && !currentPage && browserInitialized) {
       diagnostics.push({
@@ -122,7 +122,7 @@ function getDiagnostics(document, tools, lang, maxDiagnostics = 100) {
         code: 'no-page-loaded'
       });
     }
-    
+
     // 6. Network recorder state
     if (call.name === 'network_recorder') {
       if (call.params?.action === 'start') {
@@ -140,7 +140,7 @@ function getDiagnostics(document, tools, lang, maxDiagnostics = 100) {
         networkRecording = false;
       }
     }
-    
+
     // 7. Required parameters check
     if (tool.inputSchema?.required) {
       for (const reqParam of tool.inputSchema.required) {
@@ -156,12 +156,12 @@ function getDiagnostics(document, tools, lang, maxDiagnostics = 100) {
         }
       }
     }
-    
+
     // 8. Parameter validation
     if (call.params && tool.inputSchema?.properties) {
       for (const [paramName, paramValue] of Object.entries(call.params)) {
         const schema = tool.inputSchema.properties[paramName];
-        
+
         // Unknown parameter
         if (!schema) {
           diagnostics.push({
@@ -174,7 +174,7 @@ function getDiagnostics(document, tools, lang, maxDiagnostics = 100) {
           });
           continue;
         }
-        
+
         // Type validation
         const typeError = validateParamType(paramValue, schema, paramName);
         if (typeError) {
@@ -186,7 +186,7 @@ function getDiagnostics(document, tools, lang, maxDiagnostics = 100) {
             code: 'type-error'
           });
         }
-        
+
         // Enum validation
         if (schema.enum && !schema.enum.includes(paramValue)) {
           diagnostics.push({
@@ -197,7 +197,7 @@ function getDiagnostics(document, tools, lang, maxDiagnostics = 100) {
             code: 'invalid-enum'
           });
         }
-        
+
         // URL validation
         if (paramName === 'url' && typeof paramValue === 'string') {
           const urlError = validateUrl(paramValue);
@@ -211,7 +211,7 @@ function getDiagnostics(document, tools, lang, maxDiagnostics = 100) {
             });
           }
         }
-        
+
         // Selector validation
         if (paramName === 'selector' && typeof paramValue === 'string') {
           const selectorError = validateSelector(paramValue);
@@ -225,7 +225,7 @@ function getDiagnostics(document, tools, lang, maxDiagnostics = 100) {
             });
           }
         }
-        
+
         // Timeout validation
         if (paramName === 'timeout' && typeof paramValue === 'number') {
           if (paramValue < 0) {
@@ -246,7 +246,7 @@ function getDiagnostics(document, tools, lang, maxDiagnostics = 100) {
             });
           }
         }
-        
+
         // Delay validation
         if (paramName === 'delay' && typeof paramValue === 'number') {
           if (paramValue < 0) {
@@ -269,7 +269,7 @@ function getDiagnostics(document, tools, lang, maxDiagnostics = 100) {
         }
       }
     }
-    
+
     // 9. Tool-specific validations
     if (call.name === 'type' && call.params?.text === '') {
       diagnostics.push({
@@ -280,7 +280,7 @@ function getDiagnostics(document, tools, lang, maxDiagnostics = 100) {
         code: 'empty-text'
       });
     }
-    
+
     if (call.name === 'wait' && call.params?.type === 'timeout') {
       const waitValue = parseInt(call.params?.value);
       if (waitValue > 30000) {
@@ -293,7 +293,7 @@ function getDiagnostics(document, tools, lang, maxDiagnostics = 100) {
         });
       }
     }
-    
+
     if (call.name === 'execute_js' && call.params?.code) {
       const jsCode = call.params.code;
       if (jsCode.includes('eval(') || jsCode.includes('Function(')) {
@@ -306,7 +306,7 @@ function getDiagnostics(document, tools, lang, maxDiagnostics = 100) {
         });
       }
     }
-    
+
     if (call.name === 'file_downloader' && call.params?.directory) {
       const dir = call.params.directory;
       if (dir.includes('..') || dir.startsWith('/')) {
@@ -320,7 +320,7 @@ function getDiagnostics(document, tools, lang, maxDiagnostics = 100) {
       }
     }
   }
-  
+
   // 10. Document-level checks
   if (browserInitialized && !browserClosed) {
     diagnostics.push({
@@ -331,7 +331,7 @@ function getDiagnostics(document, tools, lang, maxDiagnostics = 100) {
       code: 'missing-cleanup'
     });
   }
-  
+
   if (networkRecording) {
     diagnostics.push({
       severity: DiagnosticSeverity.Information,
@@ -341,7 +341,7 @@ function getDiagnostics(document, tools, lang, maxDiagnostics = 100) {
       code: 'network-not-stopped'
     });
   }
-  
+
   // 11. Check for duplicate tool calls (potential bugs)
   const navigateCalls = toolCalls.filter(c => c.name === 'navigate');
   if (navigateCalls.length > 5) {
@@ -353,7 +353,7 @@ function getDiagnostics(document, tools, lang, maxDiagnostics = 100) {
       code: 'many-navigates'
     });
   }
-  
+
   return diagnostics.slice(0, maxDiagnostics);
 }
 
@@ -364,15 +364,15 @@ function parseAllToolCalls(text, lines, tools) {
   const calls = [];
   const toolNames = tools.map(t => t.name);
   const toolRegex = new RegExp(`(${toolNames.join('|')})\\s*\\(\\s*(\\{[^}]*\\})?`, 'g');
-  
+
   for (let lineNum = 0; lineNum < lines.length; lineNum++) {
     const line = lines[lineNum];
     let match;
-    
+
     while ((match = toolRegex.exec(line)) !== null) {
       const name = match[1];
       const paramsStr = match[2];
-      
+
       calls.push({
         name,
         params: paramsStr ? parseParams(paramsStr) : null,
@@ -383,10 +383,10 @@ function parseAllToolCalls(text, lines, tools) {
         }
       });
     }
-    
+
     toolRegex.lastIndex = 0;
   }
-  
+
   return calls;
 }
 
@@ -401,7 +401,7 @@ function parseParams(paramsStr) {
       .replace(/(\w+)\s*:/g, '"$1":')
       .replace(/,\s*}/g, '}')
       .replace(/\n/g, ' ');
-    
+
     return JSON.parse(jsonStr);
   } catch (e) {
     return null;
@@ -414,7 +414,7 @@ function parseParams(paramsStr) {
 function validateParamType(value, schema, paramName) {
   const expectedType = schema.type;
   const actualType = typeof value;
-  
+
   if (expectedType === 'string' && actualType !== 'string') {
     return `Parameter ${paramName}: Expected string, got ${actualType}`;
   }
@@ -430,7 +430,7 @@ function validateParamType(value, schema, paramName) {
   if (expectedType === 'object' && (actualType !== 'object' || value === null || Array.isArray(value))) {
     return `Parameter ${paramName}: Expected object, got ${actualType}`;
   }
-  
+
   return null;
 }
 
@@ -441,7 +441,7 @@ function validateUrl(url) {
   if (!url || url.trim() === '') {
     return 'URL cannot be empty';
   }
-  
+
   try {
     const parsed = new URL(url);
     if (!['http:', 'https:'].includes(parsed.protocol)) {
@@ -450,7 +450,7 @@ function validateUrl(url) {
   } catch (e) {
     return 'Invalid URL format. Example: https://example.com';
   }
-  
+
   return null;
 }
 
@@ -461,20 +461,20 @@ function validateSelector(selector) {
   if (!selector || selector.trim() === '') {
     return 'Selector cannot be empty';
   }
-  
+
   // Check for common mistakes
   if (selector.includes('  ')) {
     return 'Selector contains multiple consecutive spaces';
   }
-  
+
   if (/^[0-9]/.test(selector) && !selector.startsWith('[')) {
     return 'Selector cannot start with a number (unless in attribute selector)';
   }
-  
+
   // Check balanced brackets
   const brackets = { '[': ']', '(': ')' };
   const stack = [];
-  
+
   for (const char of selector) {
     if (char in brackets) {
       stack.push(brackets[char]);
@@ -484,16 +484,16 @@ function validateSelector(selector) {
       }
     }
   }
-  
+
   if (stack.length > 0) {
     return 'Unclosed bracket in selector';
   }
-  
+
   // Check for empty attribute selector
   if (selector.includes('[]')) {
     return 'Empty attribute selector []';
   }
-  
+
   return null;
 }
 
@@ -502,7 +502,7 @@ function validateSelector(selector) {
  */
 function findSimilarTools(name, tools) {
   const lowerName = name.toLowerCase();
-  
+
   return tools
     .map(t => ({
       name: t.name,
@@ -520,14 +520,14 @@ function findSimilarTools(name, tools) {
 function calculateSimilarity(s1, s2) {
   const longer = s1.length > s2.length ? s1 : s2;
   const shorter = s1.length > s2.length ? s2 : s1;
-  
+
   if (longer.length === 0) return 1.0;
-  
+
   // Quick check for common prefix
   if (longer.startsWith(shorter) || shorter.startsWith(longer.substring(0, 3))) {
     return 0.8;
   }
-  
+
   // Levenshtein distance
   const costs = [];
   for (let i = 0; i <= s1.length; i++) {
@@ -546,7 +546,7 @@ function calculateSimilarity(s1, s2) {
     }
     if (i > 0) costs[s2.length] = lastValue;
   }
-  
+
   return (longer.length - costs[s2.length]) / longer.length;
 }
 

package/src/lsp/languages/en.js

@@ -21,7 +21,7 @@ module.exports = {
     click: { label: 'Click Element', detail: 'Click with human-like behavior', documentation: 'Clicks on an element using ghost-cursor.', parameters: { selector: 'Element selector', humanLike: 'Use realistic movement', clickCount: 'Number of clicks', delay: 'Click delay' } },
     type: { label: 'Type Text', detail: 'Type into input field', documentation: 'Types text with realistic keystroke delays.', parameters: { selector: 'Input selector', text: 'Text to type', delay: 'Keystroke delay', clear: 'Clear first' } },
     browser_close: { label: 'Close Browser', detail: 'Close and cleanup', documentation: 'Closes the browser.', parameters: { force: 'Force close' } },
-    solve_captcha: { label: 'Solve CAPTCHA', detail: 'Auto-solve CAPTCHAs', documentation: 'Automatically solves Turnstile, reCAPTCHA, hCaptcha.', parameters: { type: 'CAPTCHA type', timeout: 'Max solve time' } },
+    solve_captcha: { label: 'Solve CAPTCHA + Form', detail: 'Auto-solve + Fill forms', documentation: 'Solves CAPTCHAs and fills forms with AI field matching.', parameters: { type: 'CAPTCHA type', timeout: 'Max time', formData: 'Form data', submit: 'Submit form' } },
     random_scroll: { label: 'Random Scroll', detail: 'Human-like scrolling', documentation: 'Scrolls with human-like behavior.', parameters: { direction: 'Scroll direction', amount: 'Scroll amount', smooth: 'Smooth scrolling' } },
     find_element: { label: 'Find Element', detail: 'Locate elements', documentation: 'Finds elements by selector/xpath/text.', parameters: { selector: 'CSS selector', xpath: 'XPath', text: 'Text content', multiple: 'Return all' } },
     save_content_as_markdown: { label: 'Save as Markdown', detail: 'Export to MD', documentation: 'Saves page as Markdown file.', parameters: { filename: 'Output filename', selector: 'Content selector', includeImages: 'Include images', includeMeta: 'Include meta' } },
@@ -40,8 +40,7 @@ module.exports = {
     stream_extractor: { label: 'Extract Streams', detail: 'Get video/audio', documentation: 'Extracts stream URLs.', parameters: { types: 'Stream types', quality: 'Quality' } },
     js_scrape: { label: 'JS Scrape', detail: 'Scrape JS content', documentation: 'Scrapes JS-rendered content.', parameters: { selector: 'CSS selector', waitForJS: 'Wait for JS', timeout: 'Max wait' } },
     execute_js: { label: 'Execute JS', detail: 'Run JavaScript', documentation: 'Executes custom JavaScript.', parameters: { code: 'JS code', returnValue: 'Return result' } },
-    player_api_hook: { label: 'Player API Hook', detail: 'Video player control', documentation: 'Hooks into video players.', parameters: { playerType: 'Player type', action: 'Action' } },
-    form_automator: { label: 'Automate Form', detail: 'Fill and submit', documentation: 'Auto-fills and submits forms.', parameters: { selector: 'Form selector', data: 'Form data', submit: 'Submit', humanLike: 'Human delays' } }
+    player_api_hook: { label: 'Player API Hook', detail: 'Video player control', documentation: 'Hooks into video players.', parameters: { playerType: 'Player type', action: 'Action' } }
   },
   diagnostics: {
     browserNotInit: 'Browser not initialized. Call browser_init first.',

package/src/lsp/languages/hi.js

@@ -11,7 +11,7 @@ module.exports = {
     click: { label: 'क्लिक करें', detail: 'मानव-जैसा क्लिक', documentation: 'ghost-cursor से क्लिक करता है।', parameters: { selector: 'एलीमेंट selector', humanLike: 'वास्तविक मूवमेंट', clickCount: 'क्लिक संख्या', delay: 'देरी' } },
     type: { label: 'टाइप करें', detail: 'इनपुट में टाइप', documentation: 'वास्तविक कीस्ट्रोक के साथ टाइप करता है।', parameters: { selector: 'इनपुट selector', text: 'टेक्स्ट', delay: 'कीस्ट्रोक देरी', clear: 'पहले साफ करें' } },
     browser_close: { label: 'ब्राउज़र बंद करें', detail: 'बंद और क्लीनअप', documentation: 'ब्राउज़र बंद करता है।', parameters: { force: 'फोर्स क्लोज़' } },
-    solve_captcha: { label: 'CAPTCHA हल करें', detail: 'ऑटो-सॉल्व', documentation: 'Turnstile, reCAPTCHA हल करता है।', parameters: { type: 'CAPTCHA प्रकार', timeout: 'अधिकतम समय' } },
+    solve_captcha: { label: 'CAPTCHA + फॉर्म', detail: 'ऑटो-सॉल्व + फॉर्म भरें', documentation: 'CAPTCHA हल करता है और फॉर्म भी भरता है।', parameters: { type: 'CAPTCHA प्रकार', timeout: 'अधिकतम समय', formData: 'फॉर्म डेटा', submit: 'सबमिट करें' } },
     random_scroll: { label: 'रैंडम स्क्रॉल', detail: 'मानव-जैसा स्क्रॉल', documentation: 'रैंडम स्क्रॉल करता है।', parameters: { direction: 'दिशा', amount: 'मात्रा', smooth: 'स्मूथ' } },
     find_element: { label: 'एलीमेंट खोजें', detail: 'पेज पर खोजें', documentation: 'selector/xpath से खोजता है।', parameters: { selector: 'CSS selector', xpath: 'XPath', text: 'टेक्स्ट', multiple: 'सभी लौटाएं' } },
     save_content_as_markdown: { label: 'MD में सेव', detail: 'Markdown एक्सपोर्ट', documentation: 'Markdown फाइल में सेव करता है।', parameters: { filename: 'फाइलनेम', selector: 'कंटेंट selector', includeImages: 'इमेज शामिल', includeMeta: 'मेटा शामिल' } },
@@ -30,8 +30,7 @@ module.exports = {
     stream_extractor: { label: 'स्ट्रीम निकालें', detail: 'वीडियो/ऑडियो URL', documentation: 'स्ट्रीम URLs निकालता है।', parameters: { types: 'प्रकार', quality: 'क्वालिटी' } },
     js_scrape: { label: 'JS स्क्रैप', detail: 'JS कंटेंट', documentation: 'JS-रेंडर्ड कंटेंट।', parameters: { selector: 'selector', waitForJS: 'JS इंतजार', timeout: 'अधिकतम' } },
     execute_js: { label: 'JS चलाएं', detail: 'JavaScript रन', documentation: 'कस्टम JS चलाता है।', parameters: { code: 'कोड', returnValue: 'रिज़ल्ट लौटाएं' } },
-    player_api_hook: { label: 'Player Hook', detail: 'वीडियो प्लेयर', documentation: 'प्लेयर में हुक करता है।', parameters: { playerType: 'प्लेयर', action: 'एक्शन' } },
-    form_automator: { label: 'फॉर्म ऑटोमेट', detail: 'फॉर्म भरें', documentation: 'फॉर्म भरता और सबमिट करता है।', parameters: { selector: 'फॉर्म selector', data: 'डेटा', submit: 'सबमिट', humanLike: 'मानव देरी' } }
+    player_api_hook: { label: 'Player Hook', detail: 'वीडियो प्लेयर', documentation: 'प्लेयर में हुक करता है।', parameters: { playerType: 'प्लेयर', action: 'एक्शन' } }
   },
   diagnostics: {
     browserNotInit: 'ब्राउज़र इनिशियलाइज़ नहीं। पहले browser_init करें।',

package/src/mcp/handlers.js

@@ -240,93 +240,242 @@ const decoders = {
  * Tool Handlers Object
  */
 const handlers = {
-  // 0. Smart Form Filler (NEW - Universal Form Automation)
-  async smart_form_filler(params = {}) {
-    const { page } = requireBrowser();
-    const {
-      formData = {},
-      validateBeforeSubmit = true,
-      humanLike = true,
-      submitAfter = false,
-      submitSelector = 'button[type="submit"], input[type="submit"], .btn-primary',
-      solveCaptcha = false,
-      captchaOptions = {}
-    } = params;
+  // ═══════════════════════════════════════════════════════════════
+  // HELPER: Full Page Analyzer - Detect ALL inputs on page
+  // ═══════════════════════════════════════════════════════════════
+  async _analyzeFullPage(page) {
+    return await page.evaluate(() => {
+      const inputs = [];
+      const allInputs = document.querySelectorAll('input, textarea, select');
+
+      allInputs.forEach((el, index) => {
+        if (el.type === 'hidden' || el.offsetParent === null) return;
+
+        // Find associated label
+        let label = '';
+        if (el.id) {
+          const labelEl = document.querySelector(`label[for="${el.id}"]`);
+          if (labelEl) label = labelEl.textContent.trim();
+        }
+        if (!label) {
+          const parent = el.closest('label, .form-group, .field');
+          if (parent) label = parent.textContent?.split('\n')[0]?.trim() || '';
+        }
+
+        inputs.push({
+          index,
+          tag: el.tagName.toLowerCase(),
+          type: el.type || 'text',
+          name: el.name || '',
+          id: el.id || '',
+          placeholder: el.placeholder || '',
+          label: label,
+          required: el.required,
+          value: el.value || '',
+          selector: el.id ? `#${el.id}` : (el.name ? `[name="${el.name}"]` : `input[type="${el.type}"]:nth-of-type(${index + 1})`)
+        });
+      });
 
-    notifyProgress('smart_form_filler', 'started', '🤖 Universal form automation started');
+      // Detect captcha elements
+      const captcha = {
+        image: document.querySelector('img[src*="captcha"], img[id*="captcha"], .captcha-image')?.src || null,
+        input: document.querySelector('input[name*="captcha"], input[id*="captcha"]')?.id || null
+      };
 
-    try {
-      // Load universal form analyzer
-      const formAnalyzer = require('../../lib/universal-form-analyzer');
+      // Detect submit button
+      const submitBtn = document.querySelector('button[type="submit"], input[type="submit"], button.submit');
 
-      // Step 1: Analyze forms on page
-      notifyProgress('smart_form_filler', 'progress', '🔍 Analyzing page forms...');
-      const forms = await formAnalyzer.analyzeAllForms(page);
+      return {
+        inputs,
+        captcha,
+        submitButton: submitBtn ? (submitBtn.id ? `#${submitBtn.id}` : 'button[type="submit"]') : null,
+        totalInputs: inputs.length
+      };
+    });
+  },
 
-      if (forms.length === 0) {
-        return { success: false, error: 'No forms found on page' };
-      }
+  // ═══════════════════════════════════════════════════════════════
+  // HELPER: Fill form fields with Sequential Tab Navigation
+  // ═══════════════════════════════════════════════════════════════
+  async _fillFormFields(page, formData, formSelector, humanLike = true, aiMatch = true) {
+    const targetForm = formSelector || 'form';
+    const fields = Object.keys(formData || {});
+    let filledCount = 0;
+    const filledFields = [];
+    const unfilledFields = [];
 
-      notifyProgress('smart_form_filler', 'progress', `Found ${forms.length} form(s) with ${forms[0].fields.length} fields`);
+    // First, analyze the full page
+    const pageInfo = await this._analyzeFullPage(page);
+    notifyProgress('solve_captcha', 'progress', `🔍 Page analyzed: ${pageInfo.totalInputs} inputs found`);
 
-      // Step 2: Fill form with smart field matching
-      const result = await formAnalyzer.fillForm(page, formData, {
-        validateBeforeSubmit,
-        humanLike,
-        submitAfter: false, // We'll handle submit separately
-      });
+    for (const [field, value] of Object.entries(formData || {})) {
+      // Enhanced AI Field Matching - uses pageInfo for better matching
+      let bestMatch = null;
+      let bestScore = 0;
 
-      if (!result.success) {
-        notifyProgress('smart_form_filler', 'error', result.error);
-        return result;
+      for (const input of pageInfo.inputs) {
+        let score = 0;
+        const fieldLower = field.toLowerCase();
+
+        // Exact matches
+        if (input.name.toLowerCase() === fieldLower) score = 100;
+        else if (input.id.toLowerCase() === fieldLower) score = 95;
+        // Partial matches
+        else if (input.name.toLowerCase().includes(fieldLower)) score = 80;
+        else if (input.id.toLowerCase().includes(fieldLower)) score = 75;
+        else if (input.placeholder.toLowerCase().includes(fieldLower)) score = 70;
+        else if (input.label.toLowerCase().includes(fieldLower)) score = 65;
+        // Type-based matching
+        else if (fieldLower.includes('email') && input.type === 'email') score = 60;
+        else if (fieldLower.includes('pass') && input.type === 'password') score = 60;
+        else if (fieldLower.includes('phone') && input.type === 'tel') score = 60;
+
+        if (score > bestScore) {
+          bestScore = score;
+          bestMatch = input;
+        }
       }
 
-      notifyProgress('smart_form_filler', 'progress', `✅ Filled ${result.filledFields.length} fields`);
+      if (!bestMatch || bestScore < 50) {
+        unfilledFields.push(field);
+        continue;
+      }
 
-      // Step 3: Solve CAPTCHA if requested
-      if (solveCaptcha) {
-        notifyProgress('smart_form_filler', 'progress', '🔓 Solving CAPTCHA...');
-        const captchaResult = await handlers.solve_captcha(captchaOptions);
-        
-        if (!captchaResult.success) {
-          return {
-            success: false,
-            error: 'CAPTCHA solving failed',
-            captchaError: captchaResult.error,
-            filledFields: result.filledFields
-          };
+      try {
+        const element = await page.$(bestMatch.selector);
+        if (!element) {
+          unfilledFields.push(field);
+          continue;
         }
 
-        notifyProgress('smart_form_filler', 'progress', `✅ CAPTCHA solved: ${captchaResult.text}`);
+        // Focus element first (human-like)
+        await element.focus();
+        await new Promise(r => setTimeout(r, 100 + Math.random() * 150));
+
+        if (bestMatch.tag === 'select') {
+          // Smart Select
+          await page.evaluate((sel, val) => {
+            const el = document.querySelector(sel);
+            if (!el) return;
+            el.value = val;
+            if (el.value !== val) {
+              for (const opt of el.options) {
+                if (opt.text.toLowerCase().includes(val.toLowerCase())) {
+                  el.value = opt.value;
+                  break;
+                }
+              }
+            }
+            el.dispatchEvent(new Event('change', { bubbles: true }));
+          }, bestMatch.selector, String(value));
+        } else if (bestMatch.type === 'checkbox' || bestMatch.type === 'radio') {
+          if (value) await element.click();
+        } else {
+          // Text input - clear and type with human behavior
+          await element.click({ clickCount: 3 });
+          await page.keyboard.press('Backspace');
+          await new Promise(r => setTimeout(r, 50));
+
+          if (humanLike) {
+            // Human-like typing with variable delays
+            for (let i = 0; i < String(value).length; i++) {
+              const char = String(value)[i];
+              await page.keyboard.type(char);
+              // Variable delay based on character type
+              const delay = char === ' ' ? 80 : (30 + Math.random() * 70);
+              await new Promise(r => setTimeout(r, delay));
+            }
+          } else {
+            await page.type(bestMatch.selector, String(value));
+          }
+        }
+
+        // Tab to next field (human-like navigation)
+        if (humanLike) {
+          await new Promise(r => setTimeout(r, 100 + Math.random() * 200));
+          await page.keyboard.press('Tab');
+          await new Promise(r => setTimeout(r, 50));
+        }
+
+        filledCount++;
+        filledFields.push({ field, selector: bestMatch.selector, matchScore: bestScore });
+        notifyProgress('solve_captcha', 'progress', `📝 Filled: ${field} (score: ${bestScore})`, { field, filledCount });
+      } catch (e) {
+        unfilledFields.push(field);
       }
+    }
 
-      // Step 4: Submit if requested
-      if (submitAfter) {
-        notifyProgress('smart_form_filler', 'progress', '📤 Submitting form...');
-        try {
-          await page.click(submitSelector);
-          await new Promise(r => setTimeout(r, 2000)); // Wait for submission
-        } catch (submitErr) {
-          notifyProgress('smart_form_filler', 'error', `Submit failed: ${submitErr.message}`);
+    return {
+      success: filledCount > 0,
+      filledCount,
+      filledFields,
+      unfilledFields,
+      totalFields: fields.length,
+      pageInfo
+    };
+  },
+
+  // ═══════════════════════════════════════════════════════════════
+  // HELPER: Pre-Submit Validation - Check all required fields filled
+  // ═══════════════════════════════════════════════════════════════
+  async _validateBeforeSubmit(page) {
+    return await page.evaluate(() => {
+      const errors = [];
+      const requiredFields = document.querySelectorAll('[required], .required input');
+
+      requiredFields.forEach(field => {
+        if (!field.value || field.value.trim() === '') {
+          const label = field.name || field.id || field.placeholder || 'Unknown';
+          errors.push({ field: label, error: 'Required field is empty' });
+        }
+      });
+
+      // Check for visible error messages
+      const errorMsgs = document.querySelectorAll('.error, .error-message, .invalid-feedback, [class*="error"]');
+      errorMsgs.forEach(el => {
+        if (el.offsetParent !== null && el.textContent.trim()) {
+          errors.push({ field: 'form', error: el.textContent.trim() });
         }
+      });
+
+      return { valid: errors.length === 0, errors };
+    });
+  },
+
+  // ═══════════════════════════════════════════════════════════════
+  // HELPER: Post-Submit Error Detection
+  // ═══════════════════════════════════════════════════════════════
+  async _detectPostSubmitErrors(page) {
+    await new Promise(r => setTimeout(r, 1500)); // Wait for page response
+
+    return await page.evaluate(() => {
+      const errors = [];
+
+      // Check for error messages
+      const errorSelectors = [
+        '.error', '.error-message', '.alert-danger', '.invalid',
+        '[class*="error"]', '[class*="invalid"]', '.captcha-error'
+      ];
+
+      for (const sel of errorSelectors) {
+        document.querySelectorAll(sel).forEach(el => {
+          if (el.offsetParent !== null && el.textContent.trim()) {
+            errors.push(el.textContent.trim());
+          }
+        });
       }
 
-      notifyProgress('smart_form_filler', 'completed', `Form automation completed successfully`);
+      // Check if captcha input is still visible (might indicate wrong captcha)
+      const captchaInput = document.querySelector('input[name*="captcha"], input[id*="captcha"]');
+      if (captchaInput && captchaInput.offsetParent !== null && !captchaInput.value) {
+        errors.push('Captcha may have failed - input is empty');
+      }
 
       return {
-        success: true,
-        formsAnalyzed: forms.length,
-        fieldsDetected: forms[0].fields.length,
-        fieldsFilled: result.filledFields.length,
-        filledFields: result.filledFields,
-        captchaSolved: solveCaptcha,
-        submitted: submitAfter
+        hasErrors: errors.length > 0,
+        errors: [...new Set(errors)].slice(0, 5) // Unique errors, max 5
       };
-
-    } catch (error) {
-      notifyProgress('smart_form_filler', 'error', error.message);
-      return { success: false, error: error.message };
-    }
+    });
   },
 
   // 1. Browser Init
@@ -354,6 +503,26 @@ const handlers = {
     pageInstance = result.page;
     blockerInstance = result.blocker;
 
+    // ═══════════════════════════════════════════════════════════════
+    // GLOBAL DIALOG HANDLER - Auto-accept all dialogs (alerts/confirms/prompts)
+    // This prevents browser from getting stuck on JavaScript dialogs
+    // ═══════════════════════════════════════════════════════════════
+    pageInstance.on('dialog', async (dialog) => {
+      const dialogType = dialog.type();
+      const dialogMessage = dialog.message();
+      
+      notifyProgress('browser_init', 'progress', 
+        `🔔 Auto-accepting ${dialogType}: ${dialogMessage.substring(0, 100)}...`);
+      
+      try {
+        await dialog.accept();
+        notifyProgress('browser_init', 'progress', `✅ Dialog accepted: ${dialogType}`);
+      } catch (e) {
+        // Dialog might already be handled
+        console.error(`Dialog handling error: ${e.message}`);
+      }
+    });
+
     const pid = browserInstance.process()?.pid;
 
     notifyProgress('browser_init', 'completed', `Browser started (PID: ${pid})`, {
@@ -528,26 +697,54 @@ const handlers = {
   // 5. Click
   async click(params) {
     const { page } = requireBrowser();
-    const { selector, humanLike = true, clickCount = 1, delay = 0 } = params;
+    const { selector, humanLike = true, clickCount = 1, delay = 0, autoAcceptDialogs = true } = params;
 
     notifyProgress('click', 'started', `Clicking: ${selector}`);
 
-    if (humanLike) {
+    // Auto-handle dialogs (alerts, confirms, prompts) to prevent blocking
+    let dialogHandled = false;
+    const dialogHandler = async (dialog) => {
+      dialogHandled = true;
+      const type = dialog.type();
+      const message = dialog.message();
+      notifyProgress('click', 'progress', `🔔 Auto-accepting ${type}: ${message.substring(0, 50)}...`);
       try {
-        const { createCursor } = require('ghost-cursor');
-        const cursor = createCursor(page);
-        await cursor.click(selector);
-        notifyProgress('click', 'progress', 'Used human-like cursor movement');
+        await dialog.accept();
       } catch (e) {
-        await page.click(selector, { clickCount, delay });
+        // Ignore if already handled by global handler
       }
-    } else {
-      await page.click(selector, { clickCount, delay });
+    };
+
+    if (autoAcceptDialogs) {
+      page.on('dialog', dialogHandler);
     }
 
-    notifyProgress('click', 'completed', `Clicked: ${selector}`, { selector, humanLike });
+    try {
+      if (humanLike) {
+        try {
+          const { createCursor } = require('ghost-cursor');
+          const cursor = createCursor(page);
+          await cursor.click(selector);
+          notifyProgress('click', 'progress', 'Used human-like cursor movement');
+        } catch (e) {
+          await page.click(selector, { clickCount, delay });
+        }
+      } else {
+        await page.click(selector, { clickCount, delay });
+      }
+
+      // Small wait to allow dialogs to appear and be handled
+      await new Promise(r => setTimeout(r, 300));
 
-    return { success: true, selector, clicked: true };
+      notifyProgress('click', 'completed', `Clicked: ${selector}${dialogHandled ? ' (dialog auto-accepted)' : ''}`, { selector, humanLike, dialogHandled });
+
+      return { success: true, selector, clicked: true, dialogHandled };
+    } finally {
+      // Remove dialog handler to prevent memory leaks
+      if (autoAcceptDialogs) {
+        page.off('dialog', dialogHandler);
+      }
+    }
   },
 
   // 6. Type
@@ -596,7 +793,7 @@ const handlers = {
     return { success: true, message: 'Browser closed' };
   },
 
-  // 8. Solve Captcha (Enhanced with OCR + Page Analysis + 100% Accuracy)
+  // 8. Solve Captcha (MERGED with form_automator - handles both CAPTCHA and form automation)
   async solve_captcha(params = {}) {
     const { page } = requireBrowser();
     const {
@@ -614,9 +811,24 @@ const handlers = {
       analyzeFirst = true,     // Analyze page before solving
       verifyBeforeSubmit = true, // Verify captcha looks correct before typing
       autoRetry = true,        // Auto-retry until success
+      // MERGED: Form automation options (from form_automator)
+      formData,                // Form field data to fill
+      formSelector,            // Form selector (auto-detect if not provided)
+      submit = false,          // Auto-submit after filling
+      humanLike = true,        // Human-like typing delays
+      aiMatch = true,          // AI matches fields even if names differ
     } = params;
 
-    notifyProgress('solve_captcha', 'started', `🎯 100% Accuracy Mode: Solving ${type} captcha...`);
+    // ═══════════════════════════════════════════════════════════════
+    // STEP 0: FORM AUTOMATION (if formData is provided)
+    // ═══════════════════════════════════════════════════════════════
+    let formResult = null;
+    if (formData && Object.keys(formData).length > 0) {
+      notifyProgress('solve_captcha', 'started', `📋 Smart Form + Captcha Mode: Filling ${Object.keys(formData).length} fields...`);
+      formResult = await this._fillFormFields(page, formData, formSelector, humanLike, aiMatch);
+    } else {
+      notifyProgress('solve_captcha', 'started', `🎯 100% Accuracy Mode: Solving ${type} captcha...`);
+    }
 
     // ═══════════════════════════════════════════════════════════════
     // STEP 1: ANALYZE PAGE (if enabled)
@@ -813,6 +1025,26 @@ const handlers = {
 
               notifyProgress('solve_captcha', 'completed', `✅ 100% VERIFIED: "${finalText}" (${result.confidence.toFixed(0)}%)`);
 
+              // MERGED: Handle form submission if requested
+              if (submit) {
+                notifyProgress('solve_captcha', 'progress', '🚀 Submitting form...');
+                const submitResult = await this._submitForm(page);
+                return {
+                  success: true,
+                  type: 'ocr',
+                  text: finalText,
+                  originalText: result.text,
+                  confidence: result.confidence,
+                  attempts,
+                  filled: true,
+                  pageAnalysis: analyzeFirst ? pageAnalysis : null,
+                  verified: true,
+                  formResult,
+                  submitted: submitResult.success,
+                  submitMessage: submitResult.message
+                };
+              }
+
               return {
                 success: true,
                 type: 'ocr',
@@ -823,6 +1055,7 @@ const handlers = {
                 filled: true,
                 pageAnalysis: analyzeFirst ? pageAnalysis : null,
                 verified: true,
+                formResult,
               };
             } catch (typeErr) {
               notifyProgress('solve_captcha', 'error', `Type error: ${typeErr.message}`);
@@ -839,6 +1072,7 @@ const handlers = {
               filled: false,
               pageAnalysis: pageAnalysis,
               verified: true,
+              formResult,
             };
           }
         }
@@ -850,11 +1084,12 @@ const handlers = {
           error: `Failed after ${attempts} attempts`,
           lastResult,
           pageAnalysis,
+          formResult,
         };
 
       } catch (err) {
         notifyProgress('solve_captcha', 'error', `OCR error: ${err.message}`);
-        return { success: false, error: err.message, type: 'ocr' };
+        return { success: false, error: err.message, type: 'ocr', formResult };
       }
     }
 
@@ -872,7 +1107,22 @@ const handlers = {
 
       if (turnstileToken) {
         notifyProgress('solve_captcha', 'completed', `Captcha solved after ${attempts} checks`, { type: 'turnstile', attempts });
-        return { success: true, type: 'turnstile', solved: true };
+
+        // MERGED: Handle form submission if requested
+        if (submit) {
+          notifyProgress('solve_captcha', 'progress', '🚀 Submitting form...');
+          const submitResult = await this._submitForm(page);
+          return {
+            success: true,
+            type: 'turnstile',
+            solved: true,
+            formResult,
+            submitted: submitResult.success,
+            submitMessage: submitResult.message
+          };
+        }
+
+        return { success: true, type: 'turnstile', solved: true, formResult };
       }
 
       if (attempts % 10 === 0) {
@@ -883,7 +1133,78 @@ const handlers = {
     }
 
     notifyProgress('solve_captcha', 'error', 'Captcha solving timeout');
-    return { success: false, error: 'Captcha solving timeout' };
+    return { success: false, error: 'Captcha solving timeout', formResult };
+  },
+
+  // HELPER: Submit form with smart detection, validation, and error handling
+  async _submitForm(page, validateFirst = true, maxRetries = 1) {
+    try {
+      // Pre-submit validation
+      if (validateFirst) {
+        const validation = await this._validateBeforeSubmit(page);
+        if (!validation.valid) {
+          notifyProgress('solve_captcha', 'warn', `⚠️ Validation failed: ${validation.errors.length} issue(s)`);
+          return { success: false, message: 'Pre-submit validation failed', errors: validation.errors };
+        }
+        notifyProgress('solve_captcha', 'progress', '✅ Pre-submit validation passed');
+      }
+
+      const submitSelector = await page.evaluate(() => {
+        const buttons = Array.from(document.querySelectorAll('button, input[type="submit"], input[type="button"], a.btn'));
+        const candidates = buttons.filter(b => {
+          const text = (b.innerText || b.value || '').toLowerCase();
+          return text.includes('submit') || text.includes('go') || text.includes('search') ||
+            text.includes('view') || text.includes('login') || text.includes('sign in') ||
+            text.includes('register') || text.includes('send');
+        });
+        const best = candidates.find(b => b.offsetParent !== null);
+        if (best) {
+          return best.id ? `#${best.id}` : (best.name ? `[name="${best.name}"]` : 'button[type="submit"]');
+        }
+        // Fallback to any submit button
+        const fallback = document.querySelector('button[type="submit"], input[type="submit"]');
+        return fallback ? (fallback.id ? `#${fallback.id}` : 'button[type="submit"]') : null;
+      });
+
+      if (!submitSelector) {
+        notifyProgress('solve_captcha', 'warn', '⚠️ Could not auto-detect submit button');
+        return { success: false, message: 'Could not auto-detect submit button' };
+      }
+
+      // Click submit button with human-like behavior
+      try {
+        const { createCursor } = require('ghost-cursor');
+        const cursor = createCursor(page);
+        await cursor.click(submitSelector);
+      } catch (e) {
+        await page.click(submitSelector);
+      }
+
+      // Wait for response
+      try {
+        await page.waitForNavigation({ timeout: 5000, waitUntil: 'domcontentloaded' });
+        notifyProgress('solve_captcha', 'completed', '✅ Form submitted and navigation complete');
+        return { success: true, message: 'Form submitted and navigation complete', navigated: true };
+      } catch (e) {
+        // No navigation - check for errors on same page
+        const postErrors = await this._detectPostSubmitErrors(page);
+
+        if (postErrors.hasErrors) {
+          notifyProgress('solve_captcha', 'warn', `⚠️ Submit detected errors: ${postErrors.errors[0]}`);
+          return {
+            success: false,
+            message: 'Form submitted but errors detected',
+            errors: postErrors.errors,
+            needsRetry: postErrors.errors.some(e => e.toLowerCase().includes('captcha'))
+          };
+        }
+
+        notifyProgress('solve_captcha', 'completed', '✅ Form submitted (no navigation detected)');
+        return { success: true, message: 'Form submitted (no navigation detected)', navigated: false };
+      }
+    } catch (error) {
+      return { success: false, message: error.message };
+    }
   },
 
 

package/src/shared/tools.js

@@ -1,12 +1,13 @@
 /**
  * Brave Real Browser MCP Server - Shared Tool Definitions
  * 
- * OPTIMIZED: 23 tools (merged from 28)
+ * OPTIMIZED: 22 tools (merged from 28)
  * 
  * Merges Applied:
  * - iframe_handler + stream_extractor + player_api_hook → media_extractor
  * - get_content + js_scrape → get_content (enhanced)
  * - search_regex + extract_json + scrape_meta_tags → extract_data
+ * - solve_captcha + form_automator → solve_captcha (enhanced)
  * 
  * New Features:
  * - URL/Base64/AES Decoders built into media_extractor
@@ -125,6 +126,7 @@ const TOOLS = [
         selector: { type: 'string', description: 'CSS selector (AI auto-heals if element not found)' },
         humanLike: { type: 'boolean', default: true, description: 'Ghost cursor human movement' },
         aiHeal: { type: 'boolean', default: true, description: 'Auto-find alternative selector if broken' },
+        autoAcceptDialogs: { type: 'boolean', default: true, description: 'Auto-accept alerts/confirms to prevent blocking' },
         retries: { type: 'number', default: 3 },
         clickCount: { type: 'number', default: 1 },
         delay: { type: 'number', default: 0 }
@@ -173,34 +175,42 @@ const TOOLS = [
     }
   },
 
-  // 8. Solve Captcha (Enhanced with OCR for text captchas)
+  // 8. Solve Captcha (MERGED with form_automator - Enhanced with OCR + Form Automation)
   {
     name: 'solve_captcha',
     emoji: '🔓',
-    description: 'Auto-solve CAPTCHA with AI (Turnstile, reCAPTCHA, hCaptcha, Text/Image OCR)',
-    descriptionHindi: 'CAPTCHA हल करना (AI + OCR powered)',
+    description: 'Auto-solve CAPTCHA with AI + Smart Form Automation (Turnstile, reCAPTCHA, hCaptcha, Text/Image OCR)',
+    descriptionHindi: 'CAPTCHA हल करना + फॉर्म भरना (AI + OCR powered)',
     category: 'interaction',
     requiresBrowser: true,
     requiresPage: true,
     inputSchema: {
       type: 'object',
       properties: {
-        type: { 
-          type: 'string', 
-          enum: ['turnstile', 'recaptcha', 'hcaptcha', 'text', 'image', 'auto'], 
+        // === CAPTCHA OPTIONS ===
+        type: {
+          type: 'string',
+          enum: ['turnstile', 'recaptcha', 'hcaptcha', 'text', 'image', 'auto'],
           default: 'auto',
           description: 'Captcha type: turnstile/recaptcha/hcaptcha (JS-based), text/image (OCR-based), auto (detect)'
         },
         timeout: { type: 'number', default: 30000 },
         aiMode: { type: 'boolean', default: true, description: 'Use AI vision for complex CAPTCHAs' },
-        // OCR-specific options for text/image captchas
         captchaSelector: { type: 'string', description: 'CSS selector for captcha image (required for text/image type)' },
         inputSelector: { type: 'string', description: 'CSS selector for input field to fill result' },
         refreshSelector: { type: 'string', description: 'CSS selector for captcha refresh button' },
         lang: { type: 'string', default: 'eng', description: 'OCR language: eng, hin, eng+hin' },
         expectedLength: { type: 'number', description: 'Expected captcha text length' },
         allowedChars: { type: 'string', description: 'Allowed characters in captcha' },
-        maxRetries: { type: 'number', default: 3, description: 'Max refresh attempts for OCR' }
+        maxRetries: { type: 'number', default: 3, description: 'Max refresh attempts for OCR' },
+
+        // === FORM AUTOMATION OPTIONS (merged from form_automator) ===
+        formData: { type: 'object', description: 'Form field data to fill (AI matches fields automatically)' },
+        formSelector: { type: 'string', description: 'Form selector (AI auto-detects if not provided)' },
+        submit: { type: 'boolean', default: false, description: 'Auto-submit form after filling and captcha solving' },
+        humanLike: { type: 'boolean', default: true, description: 'Human-like typing with random delays' },
+        aiMatch: { type: 'boolean', default: true, description: 'AI matches fields even if names differ' },
+        aiValidate: { type: 'boolean', default: true, description: 'AI validates form before submission' }
       }
     }
   },
@@ -483,10 +493,10 @@ const TOOLS = [
     inputSchema: {
       type: 'object',
       properties: {
-        action: { 
-          type: 'string', 
-          enum: ['extract', 'list_iframes', 'switch_iframe', 'player_control', 'decode_url', 'batch_extract'], 
-          default: 'extract' 
+        action: {
+          type: 'string',
+          enum: ['extract', 'list_iframes', 'switch_iframe', 'player_control', 'decode_url', 'batch_extract'],
+          default: 'extract'
         },
         // For extraction
         types: { type: 'array', items: { type: 'string' }, default: ['all'], description: 'video, audio, hls, dash, download, iframes' },
@@ -530,30 +540,6 @@ const TOOLS = [
       },
       required: ['code']
     }
-  },
-
-  // 23. Form Automator
-  {
-    name: 'form_automator',
-    emoji: '📋',
-    description: 'Smart form automation with AI field detection and validation',
-    descriptionHindi: 'फॉर्म भरना (AI detection)',
-    category: 'interaction',
-    requiresBrowser: true,
-    requiresPage: true,
-    inputSchema: {
-      type: 'object',
-      properties: {
-        selector: { type: 'string', description: 'Form selector (AI auto-detects if not provided)' },
-        data: { type: 'object', description: 'Field data (AI matches fields if names differ)' },
-        submit: { type: 'boolean', default: false },
-        humanLike: { type: 'boolean', default: true },
-        aiMatch: { type: 'boolean', default: true, description: 'AI matches fields even if names differ' },
-        aiValidate: { type: 'boolean', default: true, description: 'AI validates form before submission' },
-        captcha: { type: 'boolean', default: true, description: 'Auto-solve CAPTCHA if present' }
-      },
-      required: ['data']
-    }
   }
 ];
 
@@ -586,9 +572,9 @@ const TOOL_DISPLAY = TOOLS.map(t => ({
   category: t.category
 }));
 
-module.exports = { 
-  TOOLS, 
-  TOOL_DISPLAY, 
+module.exports = {
+  TOOLS,
+  TOOL_DISPLAY,
   CATEGORIES,
   getToolByName,
   getToolsByCategory,