vibesurf 0.1.22__py3-none-any.whl → 0.1.23__py3-none-any.whl

vibe_surf/tools/vibesurf_tools.py

@@ -8,8 +8,10 @@ import json
 import enum
 import base64
 import mimetypes
+from json_repair import repair_json
 from datetime import datetime
 from typing import Optional, Type, Callable, Dict, Any, Union, Awaitable, TypeVar
+from pathvalidate import sanitize_filename
 from pydantic import BaseModel
 from browser_use.tools.service import Controller, Tools, handle_browser_error
 import logging
@@ -18,18 +20,21 @@ from browser_use.utils import time_execution_sync
 from browser_use.filesystem.file_system import FileSystem
 from browser_use.browser import BrowserSession
 from browser_use.llm.base import BaseChatModel
-from browser_use.llm.messages import UserMessage, ContentPartTextParam, ContentPartImageParam, ImageURL
+from browser_use.llm.messages import UserMessage, ContentPartTextParam, ContentPartImageParam, ImageURL, \
+    AssistantMessage
 from browser_use.dom.service import EnhancedDOMTreeNode
 from browser_use.browser.views import BrowserError
 from browser_use.mcp.client import MCPClient
-
+from browser_use.tools.views import NoParamsAction
 from vibe_surf.browser.agent_browser_session import AgentBrowserSession
 from vibe_surf.tools.views import HoverAction, ExtractionAction, FileExtractionAction, BrowserUseAgentExecution, \
-    ReportWriterTask, TodoGenerateAction, TodoModifyAction, VibeSurfDoneAction
+    ReportWriterTask, TodoGenerateAction, TodoModifyAction, VibeSurfDoneAction, SkillSearchAction, SkillCrawlAction, \
+    SkillSummaryAction, SkillTakeScreenshotAction, SkillDeepResearchAction, SkillCodeAction
 from vibe_surf.tools.mcp_client import CustomMCPClient
 from vibe_surf.tools.file_system import CustomFileSystem
 from vibe_surf.browser.browser_manager import BrowserManager
-
+from vibe_surf.tools.vibesurf_registry import VibeSurfRegistry
+from bs4 import BeautifulSoup
 from vibe_surf.logger import get_logger
 
 logger = get_logger(__name__)
@@ -39,17 +44,961 @@ Context = TypeVar('Context')
 T = TypeVar('T', bound=BaseModel)
 
 
+def clean_html_basic(page_html_content, max_text_length=100):
+    soup = BeautifulSoup(page_html_content, 'html.parser')
+
+    for script in soup(["script", "style"]):
+        script.decompose()
+
+    from bs4 import Comment
+    comments = soup.findAll(text=lambda text: isinstance(text, Comment))
+    for comment in comments:
+        comment.extract()
+
+    for text_node in soup.find_all(string=True):
+        if text_node.parent.name not in ['script', 'style']:
+            clean_text = ' '.join(text_node.split())
+
+            if len(clean_text) > max_text_length:
+                clean_text = clean_text[:max_text_length].rstrip() + "..."
+
+            if clean_text != text_node:
+                text_node.replace_with(clean_text)
+
+    important_attrs = ['id', 'class', 'name', 'role', 'type',
+                       'colspan', 'rowspan', 'headers', 'scope',
+                       'href', 'src', 'alt', 'title']
+
+    for tag in soup.find_all():
+        attrs_to_keep = {}
+        for attr in list(tag.attrs.keys()):
+            if (attr in important_attrs or
+                    attr.startswith('data-') or
+                    attr.startswith('aria-')):
+                attrs_to_keep[attr] = tag.attrs[attr]
+        tag.attrs = attrs_to_keep
+
+    return str(soup)
+
+
+def get_sibling_position(node: EnhancedDOMTreeNode) -> int:
+    """Get the position of node among its siblings with the same tag"""
+    if not node.parent_node:
+        return 1
+
+    tag_name = node.tag_name
+    position = 1
+
+    # Find siblings with same tag name before this node
+    for sibling in node.parent_node.children:
+        if sibling == node:
+            break
+        if sibling.tag_name == tag_name:
+            position += 1
+
+    return position
+
+
+def extract_css_hints(node: EnhancedDOMTreeNode) -> dict:
+    """Extract CSS selector construction hints"""
+    hints = {}
+
+    if "id" in node.attributes:
+        hints["id"] = f"#{node.attributes['id']}"
+
+    if "class" in node.attributes:
+        classes = node.attributes["class"].split()
+        hints["class"] = f".{'.'.join(classes[:3])}"  # Limit class count
+
+    # Attribute selector hints
+    for attr in ["name", "data-testid", "type"]:
+        if attr in node.attributes:
+            hints[f"attr_{attr}"] = f"[{attr}='{node.attributes[attr]}']"
+
+    return hints
+
+
+def convert_selector_map_for_llm(selector_map) -> dict:
+    """
+    Convert complex selector_map to simplified format suitable for LLM understanding and JS code writing
+    """
+    simplified_elements = []
+
+    for element_index, node in selector_map.items():
+        if node.is_visible and node.element_index is not None:  # Only include visible interactive elements
+            element_info = {
+                "tag": node.tag_name,
+                "text": node.get_meaningful_text_for_llm()[:200],  # Limit text length
+
+                # Selector information - most needed for JS code
+                "selectors": {
+                    "xpath": node.xpath,
+                    "css_hints": extract_css_hints(node),  # Extract id, class etc
+                },
+
+                # Element semantics
+                "role": node.ax_node.role if node.ax_node else None,
+                "type": node.attributes.get("type"),
+                "aria_label": node.attributes.get("aria-label"),
+
+                # Key attributes
+                "attributes": {k: v for k, v in node.attributes.items()
+                               if k in ["id", "class", "name", "href", "src", "value", "placeholder", "data-testid"]},
+
+                # Interactivity
+                "is_clickable": node.snapshot_node.is_clickable if node.snapshot_node else False,
+                "is_input": node.tag_name.lower() in ["input", "textarea", "select"],
+
+                # Structure information
+                "parent_tag": node.parent_node.tag_name if node.parent_node else None,
+                "position_info": f"{node.tag_name}[{get_sibling_position(node)}]"
+            }
+            simplified_elements.append(element_info)
+
+    return {
+        "page_elements": simplified_elements,
+        "total_elements": len(simplified_elements)
+    }
+
+
 class VibeSurfTools:
     def __init__(self, exclude_actions: list[str] = [], mcp_server_config: Optional[Dict[str, Any]] = None):
-        self.registry = Registry(exclude_actions)
+        self.registry = VibeSurfRegistry(exclude_actions)
         self._register_file_actions()
         self._register_browser_use_agent()
         self._register_report_writer_agent()
         self._register_todo_actions()
         self._register_done_action()
+        self._register_skills()
         self.mcp_server_config = mcp_server_config
         self.mcp_clients: Dict[str, MCPClient] = {}
 
+    def _register_skills(self):
+        @self.registry.action(
+            'Skill: Advanced parallel search - analyze user intent and generate 5 different search tasks, perform parallel Google searches, and return top 10 most relevant results',
+            param_model=SkillSearchAction,
+        )
+        async def skill_search(
+                params: SkillSearchAction,
+                browser_manager: BrowserManager,
+                page_extraction_llm: BaseChatModel
+        ):
+            """
+            Skill: Advanced parallel search with LLM-generated search strategies
+            """
+            llm = page_extraction_llm
+            agent_ids = []
+            try:
+                if not llm:
+                    raise RuntimeError("LLM is required for skill_search")
+
+                # Step 1: Use LLM to analyze user intent and generate different search tasks
+                from datetime import datetime
+                analysis_prompt = f"""
+Analyze the user query and generate 5 different Google search strategies to comprehensively find relevant information.
+
+Current Time: {datetime.now().isoformat()}
+
+User Query: "{params.query}"
+
+Generate 5 different search queries that approach this topic from different angles. Each search should be:
+1. Specific and concrete (good for Google search)
+2. Different from the others (different perspectives/aspects)
+3. Likely to return valuable, unique information
+
+Return your response as a JSON array of 5 search query strings.
+Example format: ["query 1", "query 2", "query 3", "query 4", "query 5"]
+"""
+
+                from browser_use.llm.messages import SystemMessage, UserMessage
+                response = await llm.ainvoke([
+                    SystemMessage(content="You are an expert at generating comprehensive search strategies."),
+                    UserMessage(content=analysis_prompt)
+                ])
+
+                # Parse the search queries
+                import json
+                try:
+                    search_queries = json.loads(response.completion.strip())
+                    if not isinstance(search_queries, list):
+                        raise ValueError("Invalid search queries format")
+                    search_queries = search_queries[:5]
+                except (json.JSONDecodeError, ValueError):
+                    # Fallback to simple queries if parsing fails
+                    try:
+                        from json_repair import repair_json
+                        search_queries = repair_json(response.completion.strip())
+                    except Exception as e:
+                        search_queries = [
+                            params.query,
+                            f"{params.query} guide",
+                            f"{params.query} best practices",
+                            f"{params.query} examples",
+                            f"{params.query} latest news"
+                        ]
+
+                # Step 2: Create browser sessions for parallel searching
+                register_sessions = []
+
+                for i, query in enumerate(search_queries):
+                    agent_id = f"search_agent_{i + 1:03d}"
+                    register_sessions.append(
+                        browser_manager.register_agent(agent_id, target_id=None)
+                    )
+                    agent_ids.append(agent_id)
+
+                agent_browser_sessions = await asyncio.gather(*register_sessions)
+
+                # Step 3: Perform parallel Google searches
+                search_tasks = []
+                for i, (browser_session, query) in enumerate(zip(agent_browser_sessions, search_queries)):
+                    search_tasks.append(self._perform_google_search(browser_session, query, llm))
+
+                search_results = await asyncio.gather(*search_tasks, return_exceptions=True)
+
+                # Step 4: Aggregate and filter results
+                all_results = []
+                for i, result in enumerate(search_results):
+                    if isinstance(result, Exception):
+                        logger.error(f"Search task {i + 1} failed: {result}")
+                        continue
+                    if result:
+                        all_results.extend(result)
+
+                # Step 5: Use LLM to deduplicate and rank top 10 results
+                if all_results:
+                    ranking_prompt = f"""
+Given these search results for the query "{params.query}", please:
+1. Remove duplicates (same or very similar content)
+2. Rank by relevance and value to the user
+3. Select the TOP 10 most relevant and valuable results
+
+Search Results:
+{json.dumps(all_results, indent=2)}
+
+Return the top 10 results as a JSON array, with each result containing:
+- title: string
+- url: string
+- summary: string (brief description of why this result is valuable)
+
+Format: [{{"title": "...", "url": "...", "summary": "..."}}, ...]
+"""
+
+                    ranking_response = await llm.ainvoke([
+                        SystemMessage(
+                            content="You are an expert at evaluating and ranking search results for relevance and value."),
+                        UserMessage(content=ranking_prompt)
+                    ])
+
+                    try:
+                        top_results = json.loads(ranking_response.completion.strip())
+                        if not isinstance(top_results, list):
+                            raise ValueError("Invalid ranking results format")
+                    except (json.JSONDecodeError, ValueError):
+                        # Fallback to first 10 results if ranking fails
+                        top_results = all_results[:10]
+                else:
+                    top_results = []
+
+                # Format results for display
+                if top_results:
+                    results_text = f"🔍 Advanced Search Results for '{params.query}':\n\n"
+                    for i, result in enumerate(top_results[:10]):
+                        title = result.get('title', 'Unknown Title')
+                        url = result.get('url', 'No URL')
+                        summary = result.get('summary', 'No summary available')
+                        results_text += f"{i}. **{title}**\n   URL: {url}\n   Summary: {summary}\n\n"
+                else:
+                    results_text = f"No results found for query: {params.query}"
+
+                logger.info(f'🔍 Skill Search completed for: {params.query}')
+                return ActionResult(
+                    extracted_content=results_text,
+                    include_extracted_content_only_once=True,
+                    long_term_memory=f'Advanced search completed for: {params.query}, found {len(top_results)} relevant results',
+                )
+
+            except Exception as e:
+                logger.error(f'❌ Skill Search failed: {e}')
+                return ActionResult(error=f'Skill search failed: {str(e)}')
+            finally:
+                for i, agent_id in enumerate(agent_ids):
+                    await browser_manager.unregister_agent(agent_id, close_tabs=True)
+
+        @self.registry.action(
+            'Skill: Crawl a web page and extract structured information from a webpage with optional tab selection',
+            param_model=SkillCrawlAction,
+        )
+        async def skill_crawl(
+                params: SkillCrawlAction,
+                browser_manager: BrowserManager,
+                page_extraction_llm: BaseChatModel
+        ):
+            """
+            Skill: Extract structured content from current or specified webpage
+            """
+            llm = page_extraction_llm
+            try:
+                if not llm:
+                    raise RuntimeError("LLM is required for skill_crawl")
+
+                # Get browser session
+                browser_session = browser_manager.main_browser_session
+
+                # If tab_id is provided, switch to that tab
+                if params.tab_id:
+                    target_id = await browser_session.get_target_id_from_tab_id(params.tab_id)
+                    await browser_session.get_or_create_cdp_session(target_id, focus=True)
+
+                # Extract structured content using the existing method
+                extracted_content = await self._extract_structured_content(
+                    browser_session, params.query, llm
+                )
+
+                current_url = await browser_session.get_current_page_url()
+                result_text = f'### URL:{current_url}\n\n{extracted_content}'
+
+                # Handle memory storage
+                MAX_MEMORY_LENGTH = 1000
+                if len(result_text) < MAX_MEMORY_LENGTH:
+                    memory = result_text
+                    include_extracted_content_only_once = False
+                else:
+                    memory = f'Extracted structured content from {current_url} for query: {params.query}'
+                    include_extracted_content_only_once = True
+
+                logger.info(f'📄 Skill Crawl completed for: {current_url}')
+                return ActionResult(
+                    extracted_content=result_text,
+                    include_extracted_content_only_once=include_extracted_content_only_once,
+                    long_term_memory=memory,
+                )
+
+            except Exception as e:
+                logger.error(f'❌ Skill Crawl failed: {e}')
+                return ActionResult(error=f'Skill crawl failed: {str(e)}')
+
+        @self.registry.action(
+            'Skill: Summarize webpage content with optional tab selection',
+            param_model=SkillSummaryAction,
+        )
+        async def skill_summary(
+                params: SkillSummaryAction,
+                browser_manager: BrowserManager,
+                page_extraction_llm: BaseChatModel
+        ):
+            """
+            Skill: Summarize webpage content using LLM
+            """
+            llm = page_extraction_llm
+            try:
+                if not llm:
+                    raise RuntimeError("LLM is required for skill_summary")
+
+                # Get browser session
+                browser_session = browser_manager.main_browser_session
+
+                # If tab_id is provided, switch to that tab
+                if params.tab_id:
+                    target_id = await browser_session.get_target_id_from_tab_id(params.tab_id)
+                    await browser_session.get_or_create_cdp_session(target_id, focus=True)
+
+                # Extract and summarize content
+                summary = await self._extract_structured_content(
+                    browser_session, "Provide a comprehensive summary of this webpage", llm
+                )
+
+                current_url = await browser_session.get_current_page_url()
+                result_text = f'📝 Summary of {current_url}:\n\n{summary}'
+
+                # Handle memory storage
+                MAX_MEMORY_LENGTH = 1000
+                if len(result_text) < MAX_MEMORY_LENGTH:
+                    memory = result_text
+                    include_extracted_content_only_once = False
+                else:
+                    memory = f'Summarized webpage: {current_url}'
+                    include_extracted_content_only_once = True
+
+                logger.info(f'📝 Skill Summary completed for: {current_url}')
+                return ActionResult(
+                    extracted_content=result_text,
+                    include_extracted_content_only_once=include_extracted_content_only_once,
+                    long_term_memory=memory,
+                )
+
+            except Exception as e:
+                logger.error(f'❌ Skill Summary failed: {e}')
+                return ActionResult(error=f'Skill summary failed: {str(e)}')
+
+        @self.registry.action(
+            'Skill: Take screenshot of current page or specified tab',
+            param_model=SkillTakeScreenshotAction,
+        )
+        async def skill_screenshot(
+                params: SkillTakeScreenshotAction,
+                browser_manager: BrowserManager,
+                file_system: CustomFileSystem
+        ):
+            """
+            Skill: Take screenshot with optional tab selection
+            """
+            try:
+                # Get browser session
+                browser_session = browser_manager.main_browser_session
+
+                # If tab_id is provided, switch to that tab
+                if params.tab_id:
+                    target_id = await browser_session.get_target_id_from_tab_id(params.tab_id)
+                    await browser_session.get_or_create_cdp_session(target_id, focus=True)
+
+                # Take screenshot using browser session
+                screenshot = await browser_session.take_screenshot()
+
+                # Generate timestamp for filename
+                timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+
+                # Get file system directory path (Path type)
+                fs_dir = file_system.get_dir()
+
+                # Create screenshots directory if it doesn't exist
+                screenshots_dir = fs_dir / "screenshots"
+                screenshots_dir.mkdir(exist_ok=True)
+
+                # Save screenshot to file system
+                page_title = await browser_session.get_current_page_title()
+                from pathvalidate import sanitize_filename
+                page_title = sanitize_filename(page_title)
+                filename = f"{page_title}-{timestamp}.png"
+                filepath = screenshots_dir / filename
+
+                with open(filepath, "wb") as f:
+                    f.write(base64.b64decode(screenshot))
+
+                msg = f'📸 Screenshot saved to path: {str(filepath.relative_to(fs_dir))}'
+                logger.info(msg)
+                return ActionResult(
+                    extracted_content=msg,
+                    include_in_memory=True,
+                    long_term_memory=f'Screenshot saved to {str(filepath.relative_to(fs_dir))}',
+                )
+
+            except Exception as e:
+                error_msg = f'❌ Failed to take screenshot: {str(e)}'
+                logger.error(error_msg)
+                return ActionResult(error=error_msg)
+
+        @self.registry.action(
+            'Skill: Execute JavaScript code on webpage with optional tab selection - accepts functional requirements, code prompts, or code snippets that will be processed by LLM to generate proper executable JavaScript',
+            param_model=SkillCodeAction,
+        )
+        async def skill_code(
+                params: SkillCodeAction,
+                browser_manager: BrowserManager,
+                page_extraction_llm: BaseChatModel,
+        ):
+            """
+            Skill: Generate and execute JavaScript code from functional requirements or code prompts with iterative retry logic
+            """
+            MAX_ITERATIONS = 5
+
+            try:
+                if not page_extraction_llm:
+                    raise RuntimeError("LLM is required for skill_code")
+
+                # Get browser session
+                browser_session = browser_manager.main_browser_session
+
+                # If tab_id is provided, switch to that tab
+                if params.tab_id:
+                    target_id = await browser_session.get_target_id_from_tab_id(params.tab_id)
+                    await browser_session.get_or_create_cdp_session(target_id, focus=True)
+
+                # Get browser state and convert for LLM
+                # browser_state = await browser_session.get_browser_state_summary()
+                # web_page_description = browser_state.dom_state.llm_representation()
+
+                page_html_content = await browser_session.get_html_content()
+                web_page_html = clean_html_basic(page_html_content)
+                if len(web_page_html) > 30000:
+                    web_page_html = web_page_html[:24000] + "..." + web_page_html[-6000:]
+
+                # Get current page URL for context
+                current_url = await browser_session.get_current_page_url()
+
+                # Create base system prompt for JavaScript code generation
+                base_system_prompt = """You are an expert JavaScript developer specializing in browser automation and DOM manipulation.
+
+You will be given a functional requirement or code prompt, along with the current page's DOM structure information.
+Your task is to generate valid, executable JavaScript code that accomplishes the specified requirement.
+
+IMPORTANT GUIDELINES:
+This JavaScript code gets executed with Runtime.evaluate and 'returnByValue': True, 'awaitPromise': True
+
+SYNTAX RULES - FAILURE TO FOLLOW CAUSES "Uncaught at line 0" ERRORS:
+- ALWAYS wrap your code in IIFE: (function(){ ... })() or (async function(){ ... })() for async code
+- ALWAYS add try-catch blocks to prevent execution errors
+- ALWAYS use proper semicolons and valid JavaScript syntax
+- NEVER write multiline code without proper IIFE wrapping
+- ALWAYS validate elements exist before accessing them
+
+EXAMPLES:
+Use this tool when other tools do not work on the first try as expected or when a more general tool is needed, e.g. for filling a form all at once, hovering, dragging, extracting only links, extracting content from the page, press and hold, hovering, clicking on coordinates, zooming, use this if the user provides custom selectors which you can otherwise not interact with ....
+You can also use it to explore the website.
+- Write code to solve problems you could not solve with other tools.
+- Don't write comments in here, no human reads that.
+- Write only valid js code.
+- use this to e.g. extract + filter links, convert the page to json into the format you need etc...
+
+- limit the output otherwise your context will explode
+- think if you deal with special elements like iframes / shadow roots etc
+- Adopt your strategy for React Native Web, React, Angular, Vue, MUI pages etc.
+- e.g. with  synthetic events, keyboard simulation, shadow DOM, etc.
+
+PROPER SYNTAX EXAMPLES:
+CORRECT: (function(){ try { const el = document.querySelector('#id'); return el ? el.value : 'not found'; } catch(e) { return 'Error: ' + e.message; } })()
+CORRECT: (async function(){ try { await new Promise(r => setTimeout(r, 100)); return 'done'; } catch(e) { return 'Error: ' + e.message; } })()
+
+WRONG: const el = document.querySelector('#id'); el ? el.value : '';
+WRONG: document.querySelector('#id').value
+WRONG: Multiline code without IIFE wrapping
+
+SHADOW DOM ACCESS EXAMPLE:
+(function(){
+    try {
+        const hosts = document.querySelectorAll('*');
+        for (let host of hosts) {
+            if (host.shadowRoot) {
+                const el = host.shadowRoot.querySelector('#target');
+                if (el) return el.textContent;
+            }
+        }
+        return 'Not found';
+    } catch(e) {
+        return 'Error: ' + e.message;
+    }
+})()
+
+## Return values:
+- Async functions (with await, promises, timeouts) are automatically handled
+- Returns strings, numbers, booleans, and serialized objects/arrays
+- Use JSON.stringify() for complex objects: JSON.stringify(Array.from(document.querySelectorAll('a')).map(el => el.textContent.trim()))
+
+OUTPUT FORMAT:
+Return ONLY the JavaScript code, no explanations or markdown formatting."""
+
+                # Initialize message history for iterative prompting
+                from browser_use.llm.messages import SystemMessage, UserMessage
+                message_history = [SystemMessage(content=base_system_prompt)]
+
+                # Initial user prompt
+                initial_user_prompt = f"""Current Page URL: {current_url}
+
+USER REQUIREMENT: {params.code_requirement}
+
+Web Page Html Content:
+{web_page_html}
+
+Generate JavaScript code to fulfill the requirement:"""
+
+                message_history.append(UserMessage(content=initial_user_prompt))
+
+                # Get CDP session for JavaScript execution
+                cdp_session = await browser_session.get_or_create_cdp_session()
+
+                # Iterative code generation and execution
+                for iteration in range(1, MAX_ITERATIONS + 1):
+                    try:
+                        logger.info(f'🔄 Skill Code iteration {iteration}/{MAX_ITERATIONS}')
+
+                        # Generate JavaScript code using LLM with message history
+                        response = await asyncio.wait_for(
+                            page_extraction_llm.ainvoke(message_history),
+                            timeout=60.0,
+                        )
+
+                        generated_js_code = response.completion.strip()
+                        message_history.append(AssistantMessage(content=generated_js_code))
+
+                        # Clean up the generated code (remove markdown if present)
+                        if generated_js_code.startswith('```javascript'):
+                            generated_js_code = generated_js_code.replace('```javascript', '').replace('```',
+                                                                                                       '').strip()
+                        elif generated_js_code.startswith('```js'):
+                            generated_js_code = generated_js_code.replace('```js', '').replace('```', '').strip()
+                        elif generated_js_code.startswith('```'):
+                            generated_js_code = generated_js_code.replace('```', '').strip()
+
+                        # Execute the generated JavaScript code
+                        try:
+                            logger.info(generated_js_code)
+                            # Always use awaitPromise=True - it's ignored for non-promises
+                            result = await cdp_session.cdp_client.send.Runtime.evaluate(
+                                params={'expression': generated_js_code, 'returnByValue': True, 'awaitPromise': True},
+                                session_id=cdp_session.session_id,
+                            )
+
+                            logger.info(result)
+                            # Check for JavaScript execution errors
+                            if result.get('exceptionDetails'):
+                                exception = result['exceptionDetails']
+                                error_msg = f'JavaScript execution error: {exception.get("text", "Unknown error")}'
+                                if 'lineNumber' in exception:
+                                    error_msg += f' at line {exception["lineNumber"]}'
+
+                                # Add error feedback to message history for next iteration
+                                if iteration < MAX_ITERATIONS:
+                                    error_feedback = f"""The previous JavaScript code failed with error:
+{error_msg}
+
+Please fix the error and generate corrected JavaScript code:"""
+                                    message_history.append(UserMessage(content=error_feedback))
+                                    continue  # Try next iteration
+                                else:
+                                    # Final iteration, return error
+                                    msg = f'Requirement: {params.code_requirement}\n\nFinal Generated Code (Iteration {iteration}): {generated_js_code}\n\nError: {error_msg}'
+                                    logger.info(msg)
+                                    return ActionResult(error=msg)
+
+                            # Get the result data
+                            result_data = result.get('result', {})
+
+                            # Check for wasThrown flag (backup error detection)
+                            if result_data.get('wasThrown'):
+                                error_msg = 'JavaScript execution failed (wasThrown=true)'
+
+                                # Add error feedback to message history for next iteration
+                                if iteration < MAX_ITERATIONS:
+                                    error_feedback = f"""The previous JavaScript code failed with error:
+{error_msg}
+
+Please fix the error and generate corrected JavaScript code:"""
+                                    message_history.append(UserMessage(content=error_feedback))
+                                    continue  # Try next iteration
+                                else:
+                                    # Final iteration, return error
+                                    msg = f'Requirement: {params.code_requirement}\n\nFinal Generated Code (Iteration {iteration}): {generated_js_code}\n\nError: {error_msg}'
+                                    logger.info(msg)
+                                    return ActionResult(error=msg)
+
+                            # Get the actual value
+                            value = result_data.get('value')
+
+                            # Handle different value types
+                            if value is None:
+                                # Could be legitimate null/undefined result
+                                result_text = str(value) if 'value' in result_data else 'undefined'
+                            elif isinstance(value, (dict, list)):
+                                # Complex objects - should be serialized by returnByValue
+                                try:
+                                    result_text = json.dumps(value, ensure_ascii=False)
+                                except (TypeError, ValueError):
+                                    # Fallback for non-serializable objects
+                                    result_text = str(value)
+                            else:
+                                # Primitive values (string, number, boolean)
+                                result_text = str(value)
+
+                            # Check if result is empty or meaningless
+                            if (not result_text or
+                                    result_text.strip() in ['', 'null', 'undefined', '[]', '{}'] or
+                                    len(result_text.strip()) == 0):
+
+                                # Add empty result feedback to message history for next iteration
+                                if iteration < MAX_ITERATIONS:
+                                    empty_feedback = f"""The previous JavaScript code executed successfully but returned empty/meaningless result:
+Result: {result_text}
+
+The result is empty or not useful. Please generate improved JavaScript code that returns meaningful data:"""
+                                    message_history.append(UserMessage(content=empty_feedback))
+                                    continue  # Try next iteration
+                                else:
+                                    # Final iteration, return empty result with warning
+                                    msg = f'Requirement: {params.code_requirement}\n\nFinal Generated Code (Iteration {iteration}): {generated_js_code}\n\nWarning: Empty or meaningless result: {result_text}'
+                                    logger.info(msg)
+                                    return ActionResult(
+                                        extracted_content=msg,
+                                        long_term_memory=f'Generated JavaScript code (iteration {iteration}) for requirement: {params.code_requirement} - Empty result warning',
+                                    )
+
+                            # Apply length limit with better truncation
+                            if len(result_text) > 30000:
+                                result_text = result_text[:30000] + '\n... [Truncated after 30000 characters]'
+
+                            # Success! Return the result
+                            msg = f'Requirement: {params.code_requirement}\n\nGenerated Code (Iteration {iteration}): \n```javascript\n{generated_js_code}\n```\nResult: {result_text}'
+                            logger.info(f'✅ Skill Code succeeded on iteration {iteration}')
+
+                            return ActionResult(
+                                extracted_content=msg,
+                                long_term_memory=f'Generated and executed JavaScript code (iteration {iteration}) for requirement: {params.code_requirement}',
+                            )
+
+                        except Exception as e:
+                            # CDP communication or other system errors
+                            error_msg = f'Failed to execute JavaScript: {type(e).__name__}: {e}'
+
+                            # Add system error feedback to message history for next iteration
+                            if iteration < MAX_ITERATIONS:
+                                system_error_feedback = f"""The previous JavaScript code failed to execute due to system error:
+{error_msg}
+
+Please generate alternative JavaScript code that avoids this system error:"""
+                                message_history.append(UserMessage(content=system_error_feedback))
+                                continue  # Try next iteration
+                            else:
+                                # Final iteration, return system error
+                                error_msg = f'Requirement: {params.code_requirement}\n\nFinal Generated Code (Iteration {iteration}): {generated_js_code}\n\nError: {error_msg}'
+                                logger.info(error_msg)
+                                return ActionResult(error=error_msg)
+
+                    except Exception as e:
+                        # LLM generation error
+                        logger.error(f'❌ LLM generation failed on iteration {iteration}: {e}')
+                        if iteration == MAX_ITERATIONS:
+                            return ActionResult(
+                                error=f'LLM generation failed after {MAX_ITERATIONS} iterations: {str(e)}')
+                        continue  # Try next iteration with same message history
+
+                # Should not reach here, but just in case
+                return ActionResult(error=f'Skill code failed after {MAX_ITERATIONS} iterations')
+
+            except Exception as e:
+                logger.error(f'❌ Skill Code failed: {e}')
+                return ActionResult(error=f'Skill code failed: {str(e)}')
+
+        @self.registry.action(
+            'Skill: Deep research mode - Only return the guideline for deep research. Please follow the guideline to do real deep research actions.',
+            param_model=NoParamsAction,
+        )
+        async def skill_deep_research(
+                _: NoParamsAction,
+        ):
+            """
+            Skill: Deep research mode activation
+            """
+            research_prompt = f"""
+        🔬 **DEEP RESEARCH GUIDELINE**
+
+        To proceed with comprehensive research, please:
+
+        1. **Set up a detailed TODO list** for this research project that includes:
+           - Background research and context gathering
+           - Key questions to investigate
+           - Multiple source verification
+           - Data collection and analysis steps
+           - Report generation with proper citations
+
+        2. **Conduct systematic research** following these principles:
+           - Use multiple search strategies and sources
+           - Verify information across different platforms
+           - Document all sources with URLs for citation
+           - Take notes and screenshots of key findings
+           - Organize findings by themes or categories
+
+        3. **Generate a comprehensive report** that includes:
+           - Executive summary
+           - Detailed findings with analysis
+           - Proper citations and source references
+           - Supporting evidence (screenshots, quotes)
+           - Conclusions and recommendations
+           - Areas for further investigation
+
+        4. **Maintain research traceability** by:
+           - Recording all search queries used
+           - Saving important URLs and sources
+           - Including direct quotes with attribution
+           - Documenting methodology and approach
+
+        This deep research mode ensures thorough, traceable, and well-documented investigation of your topic with proper academic rigor and source citation.
+        """
+
+            return ActionResult(
+                extracted_content=research_prompt,
+                include_extracted_content_only_once=True,
+            )
+
+    async def _perform_google_search(self, browser_session, query: str, llm: BaseChatModel):
+        """Helper method to perform Google search and extract top 5 results"""
+        try:
+            # Navigate to Google search
+            search_url = f'https://www.google.com/search?q={query}&udm=14'
+            await browser_session.navigate_to_url(search_url, new_tab=False)
+
+            # Wait a moment for page to load
+            await asyncio.sleep(1)
+
+            # Extract structured content
+            extraction_query = f"""
+Extract the top 5 search results from this Google search page. For each result, provide:
+- title: The clickable title/headline
+- url: The website URL
+- summary: A brief description of what this result contains
+
+Return results as a JSON array: [{{"title": "...", "url": "...", "summary": "..."}}, ...]
+"""
+
+            results_text = await self._extract_structured_content(browser_session, extraction_query, llm)
+
+            # Try to parse JSON results
+            import json
+            try:
+                results = json.loads(results_text.strip())
+                if isinstance(results, list):
+                    return results[:5]  # Ensure max 5 results
+            except (json.JSONDecodeError, ValueError):
+                try:
+                    results = repair_json(results_text.strip())
+                    if isinstance(results, list):
+                        return results[:5]  # Ensure max 5 results
+                except Exception as e:
+                    logger.warning(f"Failed to parse JSON from search results: {results_text}")
+
+            # Fallback: return raw text as single result
+            current_url = await browser_session.get_current_page_url()
+            return [{
+                "title": f"Search results for: {query}",
+                "url": current_url,
+                "summary": results_text[:200] + "..." if len(results_text) > 200 else results_text
+            }]
+
+        except Exception as e:
+            logger.error(f"Google search failed for query '{query}': {e}")
+            return []
+
+    async def _extract_structured_content(self, browser_session, query: str, llm: BaseChatModel):
+        """Helper method to extract structured content from current page"""
+        MAX_CHAR_LIMIT = 30000
+
+        # Extract clean markdown using the existing method
+        try:
+            content, content_stats = await self.extract_clean_markdown(browser_session, extract_links=False)
+        except Exception as e:
+            raise RuntimeError(f'Could not extract clean markdown: {type(e).__name__}')
+
+        # Smart truncation with context preservation
+        if len(content) > MAX_CHAR_LIMIT:
+            # Try to truncate at a natural break point
+            truncate_at = MAX_CHAR_LIMIT
+            paragraph_break = content.rfind('\n\n', MAX_CHAR_LIMIT - 500, MAX_CHAR_LIMIT)
+            if paragraph_break > 0:
+                truncate_at = paragraph_break
+            else:
+                sentence_break = content.rfind('.', MAX_CHAR_LIMIT - 200, MAX_CHAR_LIMIT)
+                if sentence_break > 0:
+                    truncate_at = sentence_break + 1
+            content = content[:truncate_at]
+
+        system_prompt = """
+You are an expert at extracting data from the markdown of a webpage.
+
+<input>
+You will be given a query and the markdown of a webpage that has been filtered to remove noise and advertising content.
+</input>
+
+<instructions>
+- You are tasked to extract information from the webpage that is relevant to the query.
+- You should ONLY use the information available in the webpage to answer the query. Do not make up information or provide guess from your own knowledge.
+- If the information relevant to the query is not available in the page, your response should mention that.
+- If the query asks for all items, products, etc., make sure to directly list all of them.
+</instructions>
+
+<output>
+- Your output should present ALL the information relevant to the query in a concise way.
+- Do not answer in conversational format - directly output the relevant information or that the information is unavailable.
+</output>
+""".strip()
+
+        prompt = f'<query>\n{query}\n</query>\n\n<webpage_content>\n{content}\n</webpage_content>'
+
+        try:
+            from browser_use.llm.messages import SystemMessage, UserMessage
+            response = await asyncio.wait_for(
+                llm.ainvoke([SystemMessage(content=system_prompt), UserMessage(content=prompt)]),
+                timeout=120.0,
+            )
+            return response.completion
+        except Exception as e:
+            logger.debug(f'Error extracting content: {e}')
+            raise RuntimeError(str(e))
+
+    async def extract_clean_markdown(
+            self, browser_session: BrowserSession, extract_links: bool = True
+    ) -> tuple[str, dict[str, Any]]:
+        """Extract clean markdown from the current page."""
+        import re
+
+        # Get HTML content from current page
+        cdp_session = await browser_session.get_or_create_cdp_session()
+        try:
+            body_id = await cdp_session.cdp_client.send.DOM.getDocument(session_id=cdp_session.session_id)
+            page_html_result = await cdp_session.cdp_client.send.DOM.getOuterHTML(
+                params={'backendNodeId': body_id['root']['backendNodeId']}, session_id=cdp_session.session_id
+            )
+            page_html = page_html_result['outerHTML']
+            current_url = await browser_session.get_current_page_url()
+        except Exception as e:
+            raise RuntimeError(f"Couldn't extract page content: {e}")
+
+        original_html_length = len(page_html)
+
+        # Use html2text for clean markdown conversion
+        import html2text
+
+        h = html2text.HTML2Text()
+        h.ignore_links = not extract_links
+        h.ignore_images = True
+        h.ignore_emphasis = False
+        h.body_width = 0  # Don't wrap lines
+        h.unicode_snob = True
+        h.skip_internal_links = True
+        content = h.handle(page_html)
+
+        initial_markdown_length = len(content)
+
+        # Minimal cleanup - html2text already does most of the work
+        content = re.sub(r'%[0-9A-Fa-f]{2}', '', content)  # Remove any remaining URL encoding
+
+        # Apply light preprocessing to clean up excessive whitespace
+        content, chars_filtered = self._preprocess_markdown_content(content)
+
+        final_filtered_length = len(content)
+
+        # Content statistics
+        stats = {
+            'url': current_url,
+            'original_html_chars': original_html_length,
+            'initial_markdown_chars': initial_markdown_length,
+            'filtered_chars_removed': chars_filtered,
+            'final_filtered_chars': final_filtered_length,
+        }
+
+        return content, stats
+
+    def _preprocess_markdown_content(self, content: str, max_newlines: int = 3) -> tuple[str, int]:
+        """Light preprocessing of html2text output - minimal cleanup since html2text is already clean."""
+        import re
+
+        original_length = len(content)
+
+        # Compress consecutive newlines (4+ newlines become max_newlines)
+        content = re.sub(r'\n{4,}', '\n' * max_newlines, content)
+
+        # Remove lines that are only whitespace or very short (likely artifacts)
+        lines = content.split('\n')
+        filtered_lines = []
+        for line in lines:
+            stripped = line.strip()
+            # Keep lines with substantial content (html2text output is already clean)
+            if len(stripped) > 2:
+                filtered_lines.append(line)
+
+        content = '\n'.join(filtered_lines)
+        content = content.strip()
+
+        chars_filtered = original_length - len(content)
+        return content, chars_filtered
+
     def _register_browser_use_agent(self):
         @self.registry.action(
             'Execute browser_use agent tasks. Supports both single task execution (list length=1) and '