vibesurf 0.1.26__py3-none-any.whl → 0.2.6__py3-none-any.whl

vibe_surf/tools/vibesurf_tools.py

@@ -31,14 +31,19 @@ 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, SkillSearchAction, SkillCrawlAction, \
-    SkillSummaryAction, SkillTakeScreenshotAction, SkillDeepResearchAction, SkillCodeAction, SkillFinanceAction
+    SkillSummaryAction, SkillTakeScreenshotAction, SkillDeepResearchAction, SkillCodeAction, SkillFinanceAction, \
+    SkillXhsAction, SkillDouyinAction, SkillYoutubeAction, SkillWeiboAction, GrepContentAction, \
+    SearchToolAction, GetToolInfoAction, ExecuteExtraToolAction
 from vibe_surf.tools.finance_tools import FinanceDataRetriever, FinanceMarkdownFormatter, FinanceMethod
 from vibe_surf.tools.mcp_client import CustomMCPClient
+from vibe_surf.tools.composio_client import ComposioClient
 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
+from vibe_surf.tools.utils import clean_html_basic
+from vibe_surf.tools.utils import _extract_structured_content, _rank_search_results_with_llm, extract_file_content_with_llm
 
 logger = get_logger(__name__)
 
@@ -47,125 +52,9 @@ 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):
+    def __init__(self, exclude_actions: list[str] = [], mcp_server_config: Optional[Dict[str, Any]] = None,
+                 composio_client: ComposioClient = None):
         self.registry = VibeSurfRegistry(exclude_actions)
         self._register_file_actions()
         self._register_browser_use_agent()
@@ -173,12 +62,27 @@ class VibeSurfTools:
         self._register_todo_actions()
         self._register_done_action()
         self._register_skills()
+        self._register_extra_tools()
         self.mcp_server_config = mcp_server_config
         self.mcp_clients: Dict[str, MCPClient] = {}
+        self.composio_toolkits: Dict[str, Any] = {}
+        self.composio_client: ComposioClient = composio_client
+
+    def get_all_action_names(self, exclude_actions: Optional[list] = None) -> list[str]:
+        action_names = []
+        for action_name in self.registry.registry.actions:
+            add_flag = True
+            for ex_action_name in exclude_actions:
+                if action_name.startswith(ex_action_name) or ex_action_name in action_name:
+                    add_flag = False
+                    break
+            if add_flag:
+                action_names.append(action_name)
+        return action_names
 
     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',
+            'Advanced search',
             param_model=SkillSearchAction,
         )
         async def skill_search(
@@ -187,187 +91,109 @@ class VibeSurfTools:
                 page_extraction_llm: BaseChatModel
         ):
             """
-            Skill: Advanced parallel search with LLM-generated search strategies
+            Advanced search skill that uses Google AI model search as primary method,
+            with fallback to parallel search across all/news/videos tabs.
+            
+            Primary Method: Google AI model search (udm=50) with "show more" button click
+            Fallback Method: Parallel search across all, news, and videos tabs
+            
+            Args:
+                params: SkillSearchAction containing query and rank parameters
+                browser_manager: Browser manager for creating browser sessions
+                page_extraction_llm: LLM for ranking results when rank=True
+            
+            Returns:
+                ActionResult with formatted search results
             """
-            llm = page_extraction_llm
+            from vibe_surf.tools.utils import google_ai_model_search, fallback_parallel_search
+
             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
-                query_num = 6
-                from datetime import datetime
-                analysis_prompt = f"""
-Analyze the user query and generate 5 different Google search strategies to comprehensively find relevant information.
+                # Step 1: Try Google AI model search first (primary method)
+                logger.info(f'🔍 Starting Google AI model search for: {params.query}')
 
-Current Time: {datetime.now().isoformat()}
+                # Attempt Google AI model search with udm=50
+                ai_search_results = await google_ai_model_search(browser_manager, params.query, max_results=15)
 
-User Query: "{params.query}"
+                # Step 2: If AI search fails or returns insufficient results, use fallback method
+                if not ai_search_results or len(ai_search_results) == 0:
+                    logger.info(f'🔄 Google AI search returned no results, using fallback parallel search')
 
-Generate {query_num} 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 {query_num} search query strings.
-Example format: ["query 1", "query 2", "query 3", "query 4", "query 5", "query 6"]
-"""
-
-                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[:query_num]
-                except (json.JSONDecodeError, ValueError):
-                    # Fallback to simple queries if parsing fails
-                    try:
-                        from json_repair import repair_json
-                        search_queries_s = repair_json(response.completion.strip())
-                        search_queries = json.loads(search_queries_s)
-                        search_queries = search_queries[:query_num]
-                    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[:query_num]):
-                    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 4.5: Rule-based deduplication to reduce LLM processing load
-                # if all_results:
-                #     deduplicated_results = self._rule_based_deduplication(all_results)
-                #     logger.info(f"Rule-based deduplication: {len(all_results)} -> {len(deduplicated_results)} results")
-                # else:
-                #     deduplicated_results = []
-
-                # Step 5: Use LLM only for final ranking and selection (much smaller dataset now)
-                if all_results and len(all_results) > 10:
-                    # Only use LLM if we have more than 10 results to rank
-                    # Create indexed results for LLM prompt
-                    indexed_results = []
-                    for i, result in enumerate(all_results):
-                        indexed_results.append({
-                            "index": i,
-                            "title": result.get('title', 'Unknown Title'),
-                            "url": result.get('url', 'No URL'),
-                            "summary": result.get('summary', 'No summary available')
-                        })
-                    
-                    ranking_prompt = f"""
-Rank these search results for the query "{params.query}" by relevance and value.
-Select the TOP 10 most relevant and valuable results.
-
-Search Results ({len(indexed_results)} total):
-{json.dumps(indexed_results, indent=2, ensure_ascii=False)}
-
-Return ONLY the indices of the top 10 results as a JSON array of numbers.
-For example: [0, 5, 2, 8, 1, 9, 3, 7, 4, 6]
-
-Format: [index1, index2, index3, ...]
-"""
+                    # Use parallel search across all, news, and videos tabs
+                    fallback_results = await fallback_parallel_search(browser_manager, params.query, max_results=15)
+                    all_results = fallback_results
+                else:
+                    logger.info(f'✅ Google AI search found {len(ai_search_results)} results')
+                    all_results = ai_search_results
 
-                    ranking_response = await llm.ainvoke([
-                        SystemMessage(
-                            content="You are an expert at ranking search results for relevance and value. Return only the indices of the top results."),
-                        UserMessage(content=ranking_prompt)
-                    ])
+                # Step 3: Process results based on rank parameter
+                if params.rank and all_results and len(all_results) > 10:
+                    logger.info(f'🔄 Using LLM ranking for {len(all_results)} results')
 
-                    try:
-                        selected_indices = json.loads(ranking_response.completion.strip())
-                        if not isinstance(selected_indices, list):
-                            raise ValueError("Invalid ranking results format")
-                        # Ensure indices are valid and limit to 10
-                        valid_indices = [i for i in selected_indices if isinstance(i, int) and 0 <= i < len(all_results)][:10]
-                        if valid_indices:
-                            top_results = [all_results[i] for i in valid_indices]
-                        else:
-                            top_results = all_results[:10]
-                    except (json.JSONDecodeError, ValueError):
-                        try:
-                            selected_indices_s = repair_json(ranking_response.completion.strip())
-                            selected_indices = json.loads(selected_indices_s)
-                            if isinstance(selected_indices, list):
-                                valid_indices = [i for i in selected_indices if isinstance(i, int) and 0 <= i < len(all_results)][:10]
-                                if valid_indices:
-                                    top_results = [all_results[i] for i in valid_indices]
-                                else:
-                                    top_results = all_results[:10]
-                            else:
-                                top_results = all_results[:10]
-                        except Exception:
-                            # Fallback to first 10 results
-                            top_results = all_results[:10]
-                elif all_results:
-                    # If we have 10 or fewer results, skip LLM ranking
-                    top_results = all_results[:10]
-                    logger.info(f"Skipping LLM ranking for {len(all_results)} results (≤10)")
+                    if not page_extraction_llm:
+                        logger.warning("LLM not available for ranking, returning unranked results")
+                        top_results = all_results[:15]
+                    else:
+                        # Use LLM ranking when rank=True and we have many results
+                        top_results = await _rank_search_results_with_llm(
+                            all_results, params.query, page_extraction_llm
+                        )
+                elif params.rank and all_results and len(all_results) <= 10:
+                    logger.info(f'⭐ Skipping LLM ranking for {len(all_results)} results (≤10)')
+                    top_results = all_results
                 else:
-                    top_results = []
+                    # When rank=False, return results from different tabs (5 each from all, news, videos)
+                    if hasattr(all_results, '__iter__') and all_results:
+                        # Group results by source_tab if available, otherwise take first 15
+                        tab_groups = {'all': [], 'news': [], 'videos': [], 'other': []}
+
+                        for result in all_results:
+                            source_tab = result.get('source_tab', 'other')
+                            tab_groups[source_tab].append(result)
+
+                        # Take up to 5 results from each tab
+                        top_results = []
+                        for tab_name in ['all', 'news', 'videos', 'other']:
+                            top_results.extend(tab_groups[tab_name][:5])
+
+                        # If we don't have enough results from tabs, take the first 15 overall
+                        if len(top_results) < 15:
+                            top_results = all_results[:15]
+                    else:
+                        top_results = all_results[:15] if all_results else []
 
-                # Format results for display
+                # Step 4: 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]):
+                    results_text = f"🔍 Search Results for '{params.query}':\n\n"
+                    for i, result in enumerate(top_results):
                         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"
+                        summary = result.get('summary', 'No description available')
+
+                        results_text += f"{i + 1}. **{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}')
+                logger.info(f'🔍 Skill Search completed for: {params.query}, found {len(top_results)} results')
                 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',
+                    long_term_memory=f'Search completed for: {params.query}, found {len(top_results)} relevant results using {"AI model search" if ai_search_results else "fallback search"}'
                 )
 
             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)
+                # Clean up browser sessions
+                for agent_id in agent_ids:
+                    try:
+                        await browser_manager.unregister_agent(agent_id, close_tabs=True)
+                    except Exception as cleanup_error:
+                        logger.warning(f"Failed to cleanup agent {agent_id}: {cleanup_error}")
 
         @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(
@@ -387,13 +213,22 @@ Format: [index1, index2, index3, ...]
                 browser_session = browser_manager.main_browser_session
 
                 # If tab_id is provided, switch to that tab
+                target_id = None
                 if params.tab_id:
                     target_id = await browser_session.get_target_id_from_tab_id(params.tab_id)
+                    url = await browser_session.get_current_page_url()
+                    current_target_id = None
+                    current_url = None
+                    if browser_session._dom_watchdog and browser_session._dom_watchdog.enhanced_dom_tree:
+                        current_target_id = browser_session._dom_watchdog.enhanced_dom_tree.target_id
+                        current_url = browser_session._dom_watchdog.enhanced_dom_tree.current_url
+                    if current_target_id != target_id or url != current_url:
+                        browser_session._dom_watchdog.clear_cache()
                     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
+                extracted_content = await _extract_structured_content(
+                    browser_session, params.query, llm, target_id=target_id
                 )
 
                 current_url = await browser_session.get_current_page_url()
@@ -420,7 +255,7 @@ Format: [index1, index2, index3, ...]
                 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(
@@ -440,13 +275,22 @@ Format: [index1, index2, index3, ...]
                 browser_session = browser_manager.main_browser_session
 
                 # If tab_id is provided, switch to that tab
+                target_id = None
                 if params.tab_id:
                     target_id = await browser_session.get_target_id_from_tab_id(params.tab_id)
+                    url = await browser_session.get_current_page_url()
+                    current_target_id = None
+                    current_url = None
+                    if browser_session._dom_watchdog and browser_session._dom_watchdog.enhanced_dom_tree:
+                        current_target_id = browser_session._dom_watchdog.enhanced_dom_tree.target_id
+                        current_url = browser_session._dom_watchdog.enhanced_dom_tree.current_url
+                    if current_target_id != target_id or url != current_url:
+                        browser_session._dom_watchdog.clear_cache()
                     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
+                summary = await _extract_structured_content(
+                    browser_session, "Provide a comprehensive summary of this webpage", llm, target_id=target_id
                 )
 
                 current_url = await browser_session.get_current_page_url()
@@ -473,7 +317,7 @@ Format: [index1, index2, index3, ...]
                 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(
@@ -494,7 +338,7 @@ Format: [index1, index2, index3, ...]
                     await browser_session.get_or_create_cdp_session(target_id, focus=True)
 
                 # Take screenshot using browser session
-                screenshot = await browser_session.take_screenshot()
+                screenshot_bytes = await browser_session.take_screenshot()
 
                 # Generate timestamp for filename
                 timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
@@ -514,9 +358,9 @@ Format: [index1, index2, index3, ...]
                 filepath = screenshots_dir / filename
 
                 with open(filepath, "wb") as f:
-                    f.write(base64.b64decode(screenshot))
+                    f.write(screenshot_bytes)
 
-                msg = f'📸 Screenshot saved to path: {str(filepath.relative_to(fs_dir))}'
+                msg = f'📸 Screenshot saved to path: [{filename}]({str(filepath.relative_to(fs_dir))})'
                 logger.info(msg)
                 return ActionResult(
                     extracted_content=msg,
@@ -530,7 +374,7 @@ Format: [index1, index2, index3, ...]
                 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',
+            'Execute JavaScript code on webpage',
             param_model=SkillCodeAction,
         )
         async def skill_code(
@@ -555,261 +399,23 @@ Format: [index1, index2, index3, ...]
                     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,
-                            )
+                from vibe_surf.tools.utils import generate_java_script_code
 
-                            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, indent=2)
-                                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'Generated Code (Iteration {iteration}): \n```javascript\n{generated_js_code}\n```\nResult:\n```json\n {result_text}\n```\n'
-                            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')
+                success, execute_result, js_code = await generate_java_script_code(params.code_requirement,
+                                                                                   page_extraction_llm, browser_session,
+                                                                                   MAX_ITERATIONS=5)
+                msg = f'```javascript\n{js_code}\n```\nResult:\n```json\n {execute_result}\n```\n'
+                if success:
+                    return ActionResult(extracted_content=msg)
+                else:
+                    return ActionResult(error=msg)
 
             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.',
+            'Return the guideline for deep research. Please follow the guideline to do real deep research actions.',
             param_model=NoParamsAction,
         )
         async def skill_deep_research(
@@ -860,7 +466,7 @@ Please generate alternative JavaScript code that avoids this system error:"""
             )
 
         @self.registry.action(
-            'Skill: Get comprehensive financial data for stocks - retrieve company information, historical prices, news, earnings, dividends, analyst recommendations and other financial data using Yahoo Finance. Available methods include: get_info (company info), get_history (price history), get_news (latest news), get_dividends (dividend history), get_earnings (earnings data), get_recommendations (analyst recommendations), get_balance_sheet (balance sheet data), get_income_stmt (income statement), get_cashflow (cash flow statement), get_fast_info (quick stats), get_institutional_holders (institutional ownership), get_major_holders (major shareholders), get_sustainability (ESG data), get_upgrades_downgrades (analyst upgrades/downgrades), and more. If no methods specified, defaults to get_info.',
+            'Get comprehensive financial data for stocks - retrieve company information, historical prices, news, earnings, dividends, analyst recommendations and other financial data using Yahoo Finance.',
             param_model=SkillFinanceAction,
         )
         async def skill_finance(
@@ -896,7 +502,7 @@ Please generate alternative JavaScript code that avoids this system error:"""
             try:
                 # Default to get_info if no methods specified
                 methods = params.methods if params.methods else [FinanceMethod.GET_INFO]
-                
+
                 # Convert string methods to FinanceMethod enum if needed
                 if methods and isinstance(methods[0], str):
                     try:
@@ -906,13 +512,13 @@ Please generate alternative JavaScript code that avoids this system error:"""
                         return ActionResult(
                             error=f'Invalid method in {methods}. Available methods: {available_methods}'
                         )
-                
+
                 # Create data retriever with symbol
                 retriever = FinanceDataRetriever(params.symbol)
-                
+
                 # Convert FinanceMethod enum values to strings for the retriever
                 method_strings = [method.value for method in methods]
-                
+
                 # Retrieve financial data
                 financial_data = retriever.get_finance_data(
                     methods=method_strings,
@@ -922,429 +528,684 @@ Please generate alternative JavaScript code that avoids this system error:"""
                     interval=getattr(params, 'interval', '1d'),
                     num_news=getattr(params, 'num_news', 5)
                 )
-                
+
                 # Format as markdown using the static method
                 markdown_content = FinanceMarkdownFormatter.format_finance_data(
                     symbol=params.symbol,
                     results=financial_data,
                     methods=method_strings
                 )
-                
+
                 method_names = [method.value for method in methods]
                 logger.info(f'💹 Comprehensive finance data retrieved for {params.symbol} with methods: {method_names}')
-                
+
                 return ActionResult(
                     extracted_content=markdown_content,
                     include_extracted_content_only_once=True,
                     long_term_memory=f'Retrieved comprehensive financial data for {params.symbol} using methods: {", ".join(method_names)}',
                 )
-                
+
             except Exception as e:
                 error_msg = f'❌ Failed to retrieve financial data for {params.symbol}: {str(e)}'
                 logger.error(error_msg)
-                return ActionResult(error=error_msg)
-
+                return ActionResult(error=error_msg, extracted_content=error_msg)
 
-    async def _extract_google_results_rule_based(self, browser_session):
-        """Rule-based extraction of Google search results using JavaScript"""
-        try:
-            cdp_session = await browser_session.get_or_create_cdp_session()
-            
-            # JavaScript code to extract Google search results using DOM selectors
-            js_extraction_code = """
-(function() {
-    try {
-        const results = [];
-        
-        // Multiple selector strategies for different Google layouts
-        const selectors = [
-            'div[data-sokoban-container] div[data-sokoban-feature]', // Standard results
-            'div.g:not(.g-blk)', // Classic results container
-            '.tF2Cxc', // Modern result container
-            'div[data-ved] h3', // Result titles
-        ];
-        
-        let resultElements = [];
-        
-        // Try each selector until we find results
-        for (const selector of selectors) {
-            const elements = document.querySelectorAll(selector);
-            if (elements.length > 0) {
-                resultElements = Array.from(elements).slice(0, 10); // Get up to 10 results
-                break;
-            }
-        }
-        
-        // If no results found with specific selectors, try broader search
-        if (resultElements.length === 0) {
-            // Look for any divs containing h3 elements (likely search results)
-            const h3Elements = document.querySelectorAll('h3');
-            resultElements = Array.from(h3Elements)
-                .map(h3 => h3.closest('div'))
-                .filter(div => div && div.querySelector('a[href]'))
-                .slice(0, 10);
-        }
-        
-        for (let i = 0; i < Math.min(resultElements.length, 10); i++) {
-            const element = resultElements[i];
-            
-            // Extract title
-            let title = '';
-            const titleSelectors = ['h3', '[role="heading"]', 'a > span', '.LC20lb'];
-            for (const sel of titleSelectors) {
-                const titleEl = element.querySelector(sel);
-                if (titleEl && titleEl.textContent.trim()) {
-                    title = titleEl.textContent.trim();
-                    break;
-                }
-            }
-            
-            // Extract URL
-            let url = '';
-            const linkSelectors = ['a[href^="http"]', 'a[href^="/url?q="]', 'a[href]'];
-            for (const sel of linkSelectors) {
-                const linkEl = element.querySelector(sel);
-                if (linkEl && linkEl.href) {
-                    url = linkEl.href;
-                    // Clean Google redirect URLs
-                    if (url.includes('/url?q=')) {
-                        const urlMatch = url.match(/[?&]q=([^&]*)/);
-                        if (urlMatch) {
-                            url = decodeURIComponent(urlMatch[1]);
-                        }
-                    }
-                    break;
-                }
-            }
-            
-            // Extract summary/description
-            let summary = '';
-            const summarySelectors = [
-                '.VwiC3b', // Description text
-                '.yXK7lf', // Snippet text
-                '[data-content-feature="1"] span',
-                '.s', // Classic description
-                'span:not(:has(a))'
-            ];
-            for (const sel of summarySelectors) {
-                const summaryEl = element.querySelector(sel);
-                if (summaryEl && summaryEl.textContent.trim() && summaryEl.textContent.length > 10) {
-                    summary = summaryEl.textContent.trim();
-                    break;
-                }
-            }
-            
-            // Only add if we have at least title or URL
-            if (title || url) {
-                results.push({
-                    title: title || 'No title',
-                    url: url || 'No URL',
-                    summary: summary || 'No description available'
-                });
-            }
-        }
-        
-        return JSON.stringify(results);
-        
-    } catch (e) {
-        return JSON.stringify([{
-            title: 'Error extracting results',
-            url: window.location.href,
-            summary: 'JavaScript extraction failed: ' + e.message
-        }]);
-    }
-})()
-"""
-            
-            # Execute JavaScript to extract results
-            result = await cdp_session.cdp_client.send.Runtime.evaluate(
-                params={'expression': js_extraction_code, 'returnByValue': True, 'awaitPromise': True},
-                session_id=cdp_session.session_id,
-            )
-            
-            if result.get('exceptionDetails'):
-                logger.warning(f"JavaScript extraction failed: {result['exceptionDetails']}")
-                return []
-            
-            result_data = result.get('result', {})
-            value = result_data.get('value', '[]')
+        @self.registry.action(
+            '',
+            param_model=SkillXhsAction,
+        )
+        async def skill_xhs(
+                params: SkillXhsAction,
+                browser_manager: BrowserManager,
+                file_system: CustomFileSystem
+        ):
+            """
+            Skill: Xiaohongshu API integration
             
+            Available methods:
+            - search_content_by_keyword: Search content by keyword with sorting options
+            - fetch_content_details: Get detailed information about specific content
+            - fetch_all_content_comments: Get all comments for specific content
+            - get_user_profile: Get user profile information
+            - fetch_all_user_content: Get all content posted by a user
+            - get_home_recommendations: Get homepage recommended content
+            """
             try:
-                extracted_results = json.loads(value)
-                return extracted_results if isinstance(extracted_results, list) else []
-            except (json.JSONDecodeError, ValueError):
-                logger.warning(f"Failed to parse extraction results: {value}")
-                return []
-                
-        except Exception as e:
-            logger.error(f"Rule-based extraction failed: {e}")
-            return []
+                from vibe_surf.tools.website_api.xhs.client import XiaoHongShuApiClient
 
-    async def _perform_google_search(self, browser_session, query: str, llm: BaseChatModel):
-        """Helper method to perform Google search and extract top 5 results using rule-based extraction"""
-        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(2)
-
-            # Use rule-based extraction first (much faster than LLM)
-            search_ret_len = 10
-            results = await self._extract_google_results_rule_based(browser_session)
-            if results and len(results) > 0:
-                # Rule-based extraction succeeded
-                logger.debug(f"Rule-based extraction found {len(results)} results for query: {query}")
-                return results[:search_ret_len]  # Return top 6 results
-            
-            # Fallback to LLM extraction if rule-based fails
-            logger.warning(f"Rule-based extraction failed for query '{query}', falling back to LLM")
-            
-            extraction_query = f"""
-Extract the top {search_ret_len} 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
+                # Initialize client
+                xhs_client = XiaoHongShuApiClient(browser_session=browser_manager.main_browser_session)
+                await xhs_client.setup()
+
+                # Parse params JSON string
+                import json
+                from json_repair import repair_json
+                try:
+                    method_params = json.loads(params.params)
+                except json.JSONDecodeError:
+                    method_params = json.loads(repair_json(params.params))
+
+                # Execute the requested method
+                result = None
+                if params.method == "search_content_by_keyword":
+                    result = await xhs_client.search_content_by_keyword(**method_params)
+                elif params.method == "fetch_content_details":
+                    result = await xhs_client.fetch_content_details(**method_params)
+                elif params.method == "fetch_all_content_comments":
+                    result = await xhs_client.fetch_all_content_comments(**method_params)
+                elif params.method == "get_user_profile":
+                    result = await xhs_client.get_user_profile(**method_params)
+                elif params.method == "fetch_all_user_content":
+                    result = await xhs_client.fetch_all_user_content(**method_params)
+                elif params.method == "get_home_recommendations":
+                    result = await xhs_client.get_home_recommendations()
+                else:
+                    return ActionResult(error=f"Unknown method: {params.method}")
 
-Return results as a JSON array: [{{"title": "...", "url": "...", "summary": "..."}}, ...]
-"""
+                # Save result to file
+                timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+                filename = f"xhs_{params.method}_{timestamp}.json"
+                filepath = file_system.get_dir() / "data" / filename
+                filepath.parent.mkdir(exist_ok=True)
+
+                with open(filepath, "w", encoding="utf-8") as f:
+                    json.dump(result, f, ensure_ascii=False, indent=2)
+
+                # Format result as markdown
+                if isinstance(result, list):
+                    display_count = min(5, len(result))
+                    md_content = f"## Xiaohongshu {params.method.replace('_', ' ').title()}\n\n"
+                    md_content += f"Showing {display_count} of {len(result)} results:\n\n"
+                    for i, item in enumerate(result[:display_count]):
+                        md_content += f"### Result {i + 1}\n"
+                        for key, value in item.items():
+                            if not value:
+                                continue
+                            if isinstance(value, str) and len(value) > 200:
+                                md_content += f"- **{key}**: {value[:200]}...\n"
+                            else:
+                                md_content += f"- **{key}**: {value}\n"
+                        md_content += "\n"
+                else:
+                    md_content = f"## Xiaohongshu {params.method.replace('_', ' ').title()}\n\n"
+                    for key, value in result.items():
+                        if isinstance(value, str) and len(value) > 200:
+                            md_content += f"- **{key}**: {value[:200]}...\n"
+                        else:
+                            md_content += f"- **{key}**: {value}\n"
+                    md_content += "\n"
+
+                # Add file path to markdown
+                relative_path = str(filepath.relative_to(file_system.get_dir()))
+                md_content += f"\n> 📁 Full data saved to: [{filename}]({relative_path})\n"
+                md_content += f"> 💡 Click the link above to view all results.\n"
+
+                logger.info(f'📕 Xiaohongshu data retrieved with method: {params.method}')
+
+                # Close client
+                await xhs_client.close()
+
+                return ActionResult(
+                    extracted_content=md_content
+                )
 
-            results_text = await self._extract_structured_content(browser_session, extraction_query, llm)
+            except Exception as e:
+                error_msg = f'❌ Failed to retrieve Xiaohongshu data: {str(e)}'
+                logger.error(error_msg)
+                return ActionResult(error=error_msg, extracted_content=error_msg)
 
-            # Try to parse JSON results
+        @self.registry.action(
+            '',
+            param_model=SkillWeiboAction,
+        )
+        async def skill_weibo(
+                params: SkillWeiboAction,
+                browser_manager: BrowserManager,
+                file_system: CustomFileSystem
+        ):
+            """
+            Skill: Weibo API integration
+            
+            Available methods:
+            - search_posts_by_keyword: Search posts by keyword with sorting options
+            - get_post_detail: Get detailed information about specific post
+            - get_all_post_comments: Get all comments for specific post
+            - get_user_info: Get user profile information
+            - get_all_user_posts: Get all posts by a user
+            - get_hot_posts: Get hot posts
+            - get_trending_list: Get trending list
+            """
             try:
-                results = json.loads(results_text.strip())
-                if isinstance(results, list):
-                    return results[:search_ret_len]  # Ensure max 5 results
-            except (json.JSONDecodeError, ValueError):
+                from vibe_surf.tools.website_api.weibo.client import WeiboApiClient
+
+                # Initialize client
+                wb_client = WeiboApiClient(browser_session=browser_manager.main_browser_session)
+                await wb_client.setup()
+
+                # Parse params JSON string
+                import json
+                from json_repair import repair_json
                 try:
-                    results = repair_json(results_text.strip())
-                    if isinstance(results, list):
-                        return results[:search_ret_len]  # Ensure max 5 results
-                except Exception as e:
-                    logger.warning(f"Failed to parse JSON from LLM search results: {results_text}")
+                    method_params = json.loads(params.params)
+                except json.JSONDecodeError:
+                    method_params = json.loads(repair_json(params.params))
+
+                # Execute the requested method
+                result = None
+                if params.method == "search_posts_by_keyword":
+                    result = await wb_client.search_posts_by_keyword(**method_params)
+                elif params.method == "get_post_detail":
+                    result = await wb_client.get_post_detail(**method_params)
+                elif params.method == "get_all_post_comments":
+                    result = await wb_client.get_all_post_comments(**method_params)
+                elif params.method == "get_user_info":
+                    result = await wb_client.get_user_info(**method_params)
+                elif params.method == "get_all_user_posts":
+                    result = await wb_client.get_all_user_posts(**method_params)
+                elif params.method == "get_hot_posts":
+                    result = await wb_client.get_hot_posts()
+                elif params.method == "get_trending_posts":
+                    result = await wb_client.get_trending_posts()
+                else:
+                    return ActionResult(error=f"Unknown method: {params.method}")
 
-            # 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
-            }]
+                # Save result to file
+                timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+                filename = f"weibo_{params.method}_{timestamp}.json"
+                filepath = file_system.get_dir() / "data" / filename
+                filepath.parent.mkdir(exist_ok=True)
+
+                with open(filepath, "w", encoding="utf-8") as f:
+                    json.dump(result, f, ensure_ascii=False, indent=2)
+                # Format result as markdown
+                if isinstance(result, list):
+                    display_count = min(5, len(result))
+                    md_content = f"## Weibo {params.method.replace('_', ' ').title()}\n\n"
+                    md_content += f"Showing {display_count} of {len(result)} results:\n\n"
+                    for i, item in enumerate(result[:display_count]):
+                        md_content += f"### Result {i + 1}\n"
+                        for key, value in item.items():
+                            if not value:
+                                continue
+                            if isinstance(value, str) and len(value) > 200:
+                                md_content += f"- **{key}**: {value[:200]}...\n"
+                            else:
+                                md_content += f"- **{key}**: {value}\n"
+                        md_content += "\n"
+                else:
+                    md_content = f"## Weibo {params.method.replace('_', ' ').title()}\n\n"
+                    for key, value in result.items():
+                        if isinstance(value, str) and len(value) > 200:
+                            md_content += f"- **{key}**: {value[:200]}...\n"
+                        else:
+                            md_content += f"- **{key}**: {value}\n"
+                    md_content += "\n"
 
-        except Exception as e:
-            logger.error(f"Google search failed for query '{query}': {e}")
-            return []
+                # Add file path to markdown
+                relative_path = str(filepath.relative_to(file_system.get_dir()))
+                md_content += f"\n> 📁 Full data saved to: [{filename}]({relative_path})\n"
+                md_content += f"> 💡 Click the link above to view all results.\n"
 
-    def _rule_based_deduplication(self, results):
-        """Rule-based deduplication to reduce dataset before LLM processing"""
-        if not results:
-            return []
-        
-        deduplicated = []
-        seen_urls = set()
-        seen_titles = set()
-        
-        for result in results:
-            url = result.get('url', '').strip()
-            title = result.get('title', '').strip().lower()
-            
-            # Skip results with missing essential data
-            if not url or not title or url == 'No URL' or title == 'no title':
-                continue
-            
-            # Normalize URL for comparison (remove fragments, query params for deduplication)
-            normalized_url = url.split('#')[0].split('?')[0].lower()
-            
-            # Check for duplicate URLs
-            if normalized_url in seen_urls:
-                continue
-            
-            # Check for very similar titles (basic similarity)
-            title_normalized = ''.join(c for c in title if c.isalnum()).lower()
-            if len(title_normalized) > 10:  # Only check titles with substantial content
-                similar_found = False
-                for seen_title in seen_titles:
-                    # Simple similarity check: if 80% of characters match
-                    if len(title_normalized) > 0 and len(seen_title) > 0:
-                        common_chars = sum(1 for c in title_normalized if c in seen_title)
-                        similarity = common_chars / max(len(title_normalized), len(seen_title))
-                        if similarity > 0.8:
-                            similar_found = True
-                            break
-                
-                if similar_found:
-                    continue
-            
-            # Add to deduplicated results
-            seen_urls.add(normalized_url)
-            seen_titles.add(title_normalized)
-            deduplicated.append(result)
-        
-        # Sort by relevance indicators (prioritize results with longer summaries, non-generic titles)
-        def relevance_score(result):
-            score = 0
-            title = result.get('title', '')
-            summary = result.get('summary', '')
-            
-            # Longer summaries are typically more informative
-            score += min(len(summary), 200) / 10
-            
-            # Non-generic titles score higher
-            generic_terms = ['search results', 'no title', 'error', 'loading']
-            if not any(term in title.lower() for term in generic_terms):
-                score += 10
-            
-            # Prefer results with actual descriptions
-            if summary and summary != 'No description available' and len(summary) > 20:
-                score += 5
-                
-            return score
-        
-        deduplicated.sort(key=relevance_score, reverse=True)
-        return deduplicated
+                logger.info(f'🐦 Weibo data retrieved with method: {params.method}')
 
-    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
+                # Close client
+                await wb_client.close()
 
-        # 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]
+                return ActionResult(
+                    extracted_content=md_content
+                )
 
-        system_prompt = """
-You are an expert at extracting data from the markdown of a webpage.
+            except Exception as e:
+                import traceback
+                traceback.print_exc()
+                error_msg = f'❌ Failed to retrieve Weibo data: {str(e)}. \nMost likely you are not login, please go to: [Weibo login page](https://passport.weibo.com/sso/signin?entry=miniblog&source=miniblog) and login.'
+                logger.error(error_msg)
+                return ActionResult(error=error_msg, extracted_content=error_msg)
 
-<input>
-You will be given a query and the markdown of a webpage that has been filtered to remove noise and advertising content.
-</input>
+        @self.registry.action(
+            '',
+            param_model=SkillDouyinAction,
+        )
+        async def skill_douyin(
+                params: SkillDouyinAction,
+                browser_manager: BrowserManager,
+                file_system: CustomFileSystem
+        ):
+            """
+            Skill: Douyin API integration
+            
+            Available methods:
+            - search_content_by_keyword: Search content by keyword with filtering options
+            - fetch_video_details: Get detailed information about specific video
+            - fetch_all_video_comments: Get all comments for specific video
+            - fetch_user_info: Get user profile information
+            - fetch_all_user_videos: Get all videos by a user
+            """
+            try:
+                from vibe_surf.tools.website_api.douyin.client import DouyinApiClient
 
-<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>
+                # Initialize client
+                dy_client = DouyinApiClient(browser_session=browser_manager.main_browser_session)
+                await dy_client.setup()
 
-<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()
+                # Parse params JSON string
+                import json
+                from json_repair import repair_json
+                try:
+                    method_params = json.loads(params.params)
+                except json.JSONDecodeError:
+                    method_params = json.loads(repair_json(params.params))
+
+                # Execute the requested method
+                result = None
+                if params.method == "search_content_by_keyword":
+                    result = await dy_client.search_content_by_keyword(**method_params)
+                elif params.method == "fetch_video_details":
+                    result = await dy_client.fetch_video_details(**method_params)
+                elif params.method == "fetch_all_video_comments":
+                    result = await dy_client.fetch_all_video_comments(**method_params)
+                elif params.method == "fetch_user_info":
+                    result = await dy_client.fetch_user_info(**method_params)
+                elif params.method == "fetch_all_user_videos":
+                    result = await dy_client.fetch_all_user_videos(**method_params)
+                else:
+                    return ActionResult(error=f"Unknown method: {params.method}")
 
-        prompt = f'<query>\n{query}\n</query>\n\n<webpage_content>\n{content}\n</webpage_content>'
+                # Save result to file
+                timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+                filename = f"douyin_{params.method}_{timestamp}.json"
+                filepath = file_system.get_dir() / "data" / filename
+                filepath.parent.mkdir(exist_ok=True)
+
+                with open(filepath, "w", encoding="utf-8") as f:
+                    json.dump(result, f, ensure_ascii=False, indent=2)
+
+                # Format result as markdown
+                if isinstance(result, list):
+                    display_count = min(5, len(result))
+                    md_content = f"## Douyin {params.method.replace('_', ' ').title()}\n\n"
+                    md_content += f"Showing {display_count} of {len(result)} results:\n\n"
+                    for i, item in enumerate(result[:display_count]):
+                        md_content += f"### Result {i + 1}\n"
+                        for key, value in item.items():
+                            if not value:
+                                continue
+                            if isinstance(value, str) and len(value) > 200:
+                                md_content += f"- **{key}**: {value[:200]}...\n"
+                            else:
+                                md_content += f"- **{key}**: {value}\n"
+                        md_content += "\n"
+                else:
+                    md_content = f"## Douyin {params.method.replace('_', ' ').title()}\n\n"
+                    for key, value in result.items():
+                        if isinstance(value, str) and len(value) > 200:
+                            md_content += f"- **{key}**: {value[:200]}...\n"
+                        else:
+                            md_content += f"- **{key}**: {value}\n"
+                    md_content += "\n"
 
-        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))
+                # Add file path to markdown
+                relative_path = str(filepath.relative_to(file_system.get_dir()))
+                md_content += f"\n> 📁 Full data saved to: [{filename}]({relative_path})\n"
+                md_content += f"> 💡 Click the link above to view all results.\n"
 
-    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
+                logger.info(f'🎵 Douyin data retrieved with method: {params.method}')
 
-        # 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}")
+                # Close client
+                await dy_client.close()
 
-        original_html_length = len(page_html)
+                return ActionResult(
+                    extracted_content=md_content
+                )
 
-        # Use html2text for clean markdown conversion
-        import html2text
+            except Exception as e:
+                error_msg = f'❌ Failed to retrieve Douyin data: {str(e)}'
+                logger.error(error_msg)
+                return ActionResult(error=error_msg, extracted_content=error_msg)
 
-        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)
+        @self.registry.action(
+            """YouTube API - If users want to know the specific content of this video, please use get_video_transcript to get detailed video content first.""",
+            param_model=SkillYoutubeAction,
+        )
+        async def skill_youtube(
+                params: SkillYoutubeAction,
+                browser_manager: BrowserManager,
+                file_system: CustomFileSystem
+        ):
+            """
+            Skill: YouTube API integration
+            
+            Available methods:
+            - search_videos: Search videos by keyword
+            - get_video_details: Get detailed information about specific video
+            - get_video_comments: Get comments for specific video
+            - get_channel_info: Get channel information
+            - get_channel_videos: Get videos from specific channel
+            - get_trending_videos: Get trending videos
+            - get_video_transcript: Get video transcript in multiple languages
+            """
+            try:
+                from vibe_surf.tools.website_api.youtube.client import YouTubeApiClient
 
-        initial_markdown_length = len(content)
+                # Initialize client
+                yt_client = YouTubeApiClient(browser_session=browser_manager.main_browser_session)
+                await yt_client.setup()
 
-        # Minimal cleanup - html2text already does most of the work
-        content = re.sub(r'%[0-9A-Fa-f]{2}', '', content)  # Remove any remaining URL encoding
+                # Parse params JSON string
+                import json
+                from json_repair import repair_json
+                try:
+                    method_params = json.loads(params.params)
+                except json.JSONDecodeError:
+                    method_params = json.loads(repair_json(params.params))
+
+                # Execute the requested method
+                result = None
+                if params.method == "search_videos":
+                    result = await yt_client.search_videos(**method_params)
+                elif params.method == "get_video_details":
+                    result = await yt_client.get_video_details(**method_params)
+                elif params.method == "get_video_comments":
+                    result = await yt_client.get_video_comments(**method_params)
+                elif params.method == "get_channel_info":
+                    result = await yt_client.get_channel_info(**method_params)
+                elif params.method == "get_channel_videos":
+                    result = await yt_client.get_channel_videos(**method_params)
+                elif params.method == "get_trending_videos":
+                    result = await yt_client.get_trending_videos()
+                elif params.method == "get_video_transcript":
+                    result = await yt_client.get_video_transcript(**method_params)
+                else:
+                    return ActionResult(error=f"Unknown method: {params.method}")
 
-        # Apply light preprocessing to clean up excessive whitespace
-        content, chars_filtered = self._preprocess_markdown_content(content)
+                # Save result to file
+                timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+                filename = f"youtube_{params.method}_{timestamp}.json"
+                filepath = file_system.get_dir() / "data" / filename
+                filepath.parent.mkdir(exist_ok=True)
+
+                with open(filepath, "w", encoding="utf-8") as f:
+                    json.dump(result, f, ensure_ascii=False, indent=2)
+
+                # Format result as markdown
+                if isinstance(result, list):
+                    display_count = min(5, len(result))
+                    md_content = f"## YouTube {params.method.replace('_', ' ').title()}\n\n"
+                    md_content += f"Showing {display_count} of {len(result)} results:\n\n"
+                    for i, item in enumerate(result[:display_count]):
+                        md_content += f"### Result {i + 1}\n"
+                        for key, value in item.items():
+                            if not value:
+                                continue
+                            if isinstance(value, str) and len(value) > 200:
+                                md_content += f"- **{key}**: {value[:200]}...\n"
+                            else:
+                                md_content += f"- **{key}**: {value}\n"
+                        md_content += "\n"
+                else:
+                    md_content = f"## YouTube {params.method.replace('_', ' ').title()}\n\n"
+                    for key, value in result.items():
+                        if isinstance(value, str) and len(value) > 200:
+                            md_content += f"- **{key}**: {value[:200]}...\n"
+                        else:
+                            md_content += f"- **{key}**: {value}\n"
+                    md_content += "\n"
 
-        final_filtered_length = len(content)
+                # Add file path to markdown
+                relative_path = str(filepath.relative_to(file_system.get_dir()))
+                md_content += f"\n> 📁 Full data saved to: [{filename}]({relative_path})\n"
+                md_content += f"> 💡 Click the link above to view all results.\n"
 
-        # 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,
-        }
+                logger.info(f'🎬 YouTube data retrieved with method: {params.method}')
 
-        return content, stats
+                # Close client
+                await yt_client.close()
 
-    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
+                return ActionResult(
+                    extracted_content=md_content
+                )
 
-        original_length = len(content)
+            except Exception as e:
+                error_msg = f'❌ Failed to retrieve YouTube data: {str(e)}'
+                logger.error(error_msg)
+                return ActionResult(error=error_msg, extracted_content=error_msg)
 
-        # Compress consecutive newlines (4+ newlines become max_newlines)
-        content = re.sub(r'\n{4,}', '\n' * max_newlines, content)
+    def _register_extra_tools(self):
+        """
+        Register extra tools for dynamic toolkit and MCP tool access
+        """
+        
+        @self.registry.action(
+            'Get all available toolkit types from both Composio and MCP clients',
+            param_model=NoParamsAction,
+        )
+        async def get_all_toolkit_types():
+            """
+            Get all toolkit types available in composio_toolkits and mcp_clients
+            
+            Returns:
+                ActionResult with list of all toolkit type names
+            """
+            try:
+                toolkit_types = []
+                
+                # Add Composio toolkit types
+                if self.composio_toolkits:
+                    toolkit_types.extend(list(self.composio_toolkits.keys()))
+                
+                # Add MCP client types
+                if self.mcp_clients:
+                    toolkit_types.extend(list(self.mcp_clients.keys()))
+                
+                result_text = f"Available toolkit types ({len(toolkit_types)} total):\n\n"
+                
+                # Group by type
+                composio_types = list(self.composio_toolkits.keys()) if self.composio_toolkits else []
+                mcp_types = list(self.mcp_clients.keys()) if self.mcp_clients else []
+                
+                if composio_types:
+                    result_text += f"**Composio Toolkits ({len(composio_types)}):**\n"
+                    for toolkit in composio_types:
+                        result_text += f"- {toolkit}\n"
+                    result_text += "\n"
+                
+                if mcp_types:
+                    result_text += f"**MCP Clients ({len(mcp_types)}):**\n"
+                    for client in mcp_types:
+                        result_text += f"- {client}\n"
+                    result_text += "\n"
+                
+                if not toolkit_types:
+                    result_text = "No toolkit types available. Please register Composio toolkits or MCP clients first."
+                
+                logger.info(f'📋 Retrieved {len(toolkit_types)} toolkit types')
+                return ActionResult(
+                    extracted_content=result_text,
+                )
+                
+            except Exception as e:
+                logger.error(f'❌ Failed to get toolkit types: {e}')
+                return ActionResult(error=f'Failed to get toolkit types: {str(e)}')
 
-        # 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)
+        @self.registry.action(
+            'Search tools within a specific toolkit type by name and description filters',
+            param_model=SearchToolAction,
+        )
+        async def search_tool(params: SearchToolAction):
+            """
+            Search tools by toolkit type and filters
+            
+            Args:
+                params: SearchToolAction containing toolkit_type and filters
+                
+            Returns:
+                ActionResult with matching tools and their descriptions
+            """
+            try:
+                toolkit_type = params.toolkit_type
+                filters = [f.lower() for f in params.filters]
+                
+                matching_tools = []
+                
+                # Search in registry actions with prefixes
+                for action_name, action in self.registry.registry.actions.items():
+                    # Check if this action belongs to the specified toolkit type
+                    if toolkit_type in self.composio_toolkits and action_name.startswith(f"cpo.{toolkit_type}."):
+                        # Get tool description from param_model
+                        try:
+                            param_dict = action.param_model.model_json_schema()
+                            description = param_dict.get('description', action_name)
+                        except:
+                            description = action_name
+                        
+                        # Check if any filter matches tool name or description
+                        search_text = f"{action_name} {description}".lower()
+                        if any(filter_term in search_text for filter_term in filters):
+                            matching_tools.append({
+                                'tool_name': action_name,
+                                'description': description
+                            })
+                    
+                    elif toolkit_type in self.mcp_clients and action_name.startswith(f"mcp.{toolkit_type}."):
+                        # Get tool description from param_model
+                        try:
+                            param_dict = action.param_model.model_json_schema()
+                            description = param_dict.get('description', action_name)
+                        except:
+                            description = action_name
+                        
+                        # Check if any filter matches tool name or description
+                        search_text = f"{action_name} {description}".lower()
+                        if any(filter_term in search_text for filter_term in filters):
+                            matching_tools.append({
+                                'tool_name': action_name,
+                                'description': description
+                            })
+                
+                # Format results
+                if matching_tools:
+                    result_text = f"Found {len(matching_tools)} tools in '{toolkit_type}' matching filters {params.filters}:\n\n"
+                    for i, tool in enumerate(matching_tools, 1):
+                        result_text += f"{i}. **{tool['tool_name']}**\n"
+                        result_text += f"   Description: {tool['description']}\n\n"
+                else:
+                    result_text = f"No tools found in '{toolkit_type}' matching filters {params.filters}"
+                
+                logger.info(f'🔍 Found {len(matching_tools)} tools in {toolkit_type} matching filters')
+                return ActionResult(
+                    extracted_content=result_text,
+                    include_extracted_content_only_once=True,
+                    long_term_memory=f'Found {len(matching_tools)} tools in {toolkit_type} matching filters: {", ".join(params.filters)}'
+                )
+                
+            except Exception as e:
+                logger.error(f'❌ Failed to search tools: {e}')
+                return ActionResult(error=f'Failed to search tools: {str(e)}')
 
-        content = '\n'.join(filtered_lines)
-        content = content.strip()
+        @self.registry.action(
+            'Get detailed information about a specific tool including its parameters',
+            param_model=GetToolInfoAction,
+        )
+        async def get_tool_info(params: GetToolInfoAction):
+            """
+            Get tool information including parameter model
+            
+            Args:
+                params: GetToolInfoAction containing tool_name
+                
+            Returns:
+                ActionResult with tool parameter information
+            """
+            try:
+                tool_name = params.tool_name
+                
+                if tool_name not in self.registry.registry.actions:
+                    return ActionResult(error=f'Tool "{tool_name}" not found in registry')
+                
+                action = self.registry.registry.actions[tool_name]
+                
+                # Convert param_model to dict
+                try:
+                    param_dict = action.param_model.model_json_schema()
+                    result_text = json.dumps(param_dict, indent=2, ensure_ascii=False)
+                except Exception as e:
+                    result_text = f"Tool: {tool_name}\nError getting parameter info: {str(e)}"
+                
+                logger.info(f'ℹ️ Retrieved tool info for: {tool_name}')
+                return ActionResult(
+                    extracted_content=f"```json\n{result_text}\n```"
+                )
+                
+            except Exception as e:
+                logger.error(f'❌ Failed to get tool info: {e}')
+                return ActionResult(error=f'Failed to get tool info: {str(e)}')
 
-        chars_filtered = original_length - len(content)
-        return content, chars_filtered
+        @self.registry.action(
+            'Execute a specific extra tool with provided parameters',
+            param_model=ExecuteExtraToolAction,
+        )
+        async def execute_extra_tool(
+                params: ExecuteExtraToolAction,
+                browser_manager: BrowserManager,
+                page_extraction_llm: BaseChatModel,
+                file_system: CustomFileSystem
+        ):
+            """
+            Execute an extra tool with given parameters
+            
+            Args:
+                params: ExecuteExtraToolAction containing tool_name and tool_params
+                browser_manager: Browser manager instance
+                page_extraction_llm: LLM instance
+                file_system: File system instance
+                
+            Returns:
+                ActionResult from the executed tool
+            """
+            try:
+                tool_name = params.tool_name
+                
+                if tool_name not in self.registry.registry.actions:
+                    return ActionResult(error=f'Tool "{tool_name}" not found in registry')
+                
+                # Parse tool parameters
+                try:
+                    tool_params_dict = json.loads(params.tool_params)
+                except json.JSONDecodeError:
+                    try:
+                        tool_params_dict = json.loads(repair_json(params.tool_params))
+                    except Exception as e:
+                        return ActionResult(error=f'Failed to parse tool parameters: {str(e)}')
+                
+                # Get the action
+                action = self.registry.registry.actions[tool_name]
+                
+                # Create special context (same as in act method)
+                special_context = {
+                    'browser_manager': browser_manager,
+                    'page_extraction_llm': page_extraction_llm,
+                    'file_system': file_system,
+                }
+                
+                # Validate parameters
+                try:
+                    validated_params = action.param_model(**tool_params_dict)
+                except Exception as e:
+                    return ActionResult(error=f'Invalid parameters {tool_params_dict} for action {tool_name}: {type(e)}: {e}')
+                
+                # Execute the tool
+                result = await action.function(params=validated_params, **special_context)
+                
+                logger.info(f'🔧 Successfully executed extra tool: {tool_name}')
+                return result
+                
+            except Exception as e:
+                logger.error(f'❌ Failed to execute extra tool: {e}')
+                return ActionResult(error=f'Failed to execute extra tool: {str(e)}')
 
     def _register_browser_use_agent(self):
         @self.registry.action(
-            'Execute browser_use agent tasks. Supports both single task execution (list length=1) and '
-            'parallel execution of multiple tasks for improved efficiency. '
-            'Accepts a list of tasks where each task can specify a tab_id (optional), '
-            'task description (focusing on goals and expected returns), and task_files (optional). '
-            'Browser_use agent has strong planning and execution capabilities, only needs task descriptions and desired outcomes.',
+            'Execute browser_use agent tasks. Please specify a tab id to an agent, if you want to let agent work on this tab.',
             param_model=BrowserUseAgentExecution,
         )
         async def execute_browser_use_agent(
@@ -1368,8 +1229,7 @@ You will be given a query and the markdown of a webpage that has been filtered t
 
     def _register_report_writer_agent(self):
         @self.registry.action(
-            'Execute report writer agent to generate HTML reports. '
-            'Task should describe report requirements, goals, insights observed, and any hints or tips for generating the report.',
+            'Execute report writer agent to generate HTML reports. ',
             param_model=ReportWriterTask,
         )
         async def execute_report_writer_agent(
@@ -1568,7 +1428,7 @@ You will be given a query and the markdown of a webpage that has been filtered t
 
     def _register_file_actions(self):
         @self.registry.action(
-            'Replace old_str with new_str in file_name. old_str must exactly match the string to replace in original text. Recommended tool to mark completed items in todo.md or change specific contents in a file.'
+            ''
         )
         async def replace_file_str(file_name: str, old_str: str, new_str: str, file_system: CustomFileSystem):
             result = await file_system.replace_file_str(file_name, old_str, new_str)
@@ -1624,71 +1484,13 @@ You will be given a query and the markdown of a webpage that has been filtered t
                 if not os.path.exists(full_file_path):
                     full_file_path = os.path.join(str(file_system.get_dir()), file_path)
 
-                # Determine if file is an image based on MIME type
-                mime_type, _ = mimetypes.guess_type(file_path)
-                is_image = mime_type and mime_type.startswith('image/')
-
-                if is_image:
-                    # Handle image files with LLM vision
-                    try:
-                        # Read image file and encode to base64
-                        with open(full_file_path, 'rb') as image_file:
-                            image_data = image_file.read()
-                            image_base64 = base64.b64encode(image_data).decode('utf-8')
-
-                        # Create content parts similar to the user's example
-                        content_parts: list[ContentPartTextParam | ContentPartImageParam] = [
-                            ContentPartTextParam(text=f"Query: {params.query}")
-                        ]
-
-                        # Add the image
-                        content_parts.append(
-                            ContentPartImageParam(
-                                image_url=ImageURL(
-                                    url=f'data:{mime_type};base64,{image_base64}',
-                                    media_type=mime_type,
-                                    detail='high',
-                                ),
-                            )
-                        )
-
-                        # Create user message and invoke LLM
-                        user_message = UserMessage(content=content_parts, cache=True)
-                        response = await asyncio.wait_for(
-                            page_extraction_llm.ainvoke([user_message]),
-                            timeout=120.0,
-                        )
-
-                        extracted_content = f'File: {file_path}\nQuery: {params.query}\nExtracted Content:\n{response.completion}'
-
-                    except Exception as e:
-                        raise Exception(f'Failed to process image file {file_path}: {str(e)}')
-
-                else:
-                    # Handle non-image files by reading content
-                    try:
-                        file_content = await file_system.read_file(full_file_path, external_file=True)
-
-                        # Create a simple prompt for text extraction
-                        prompt = f"""Extract the requested information from this file content.
-
-        Query: {params.query}
-
-        File: {file_path}
-        File Content:
-        {file_content}
-
-        Provide the extracted information in a clear, structured format."""
-
-                        response = await asyncio.wait_for(
-                            page_extraction_llm.ainvoke([UserMessage(content=prompt)]),
-                            timeout=120.0,
-                        )
-
-                        extracted_content = f'File: {file_path}\nQuery: {params.query}\nExtracted Content:\n{response.completion}'
-
-                    except Exception as e:
-                        raise Exception(f'Failed to read file {file_path}: {str(e)}')
+                # Use the utility function to extract content from file
+                extracted_content = await extract_file_content_with_llm(
+                    file_path=file_path,
+                    query=params.query,
+                    llm=page_extraction_llm,
+                    file_system=file_system
+                )
 
                 # Handle memory storage
                 if len(extracted_content) < 1000:
@@ -1713,7 +1515,7 @@ You will be given a query and the markdown of a webpage that has been filtered t
                 raise RuntimeError(str(e))
 
         @self.registry.action(
-            'Write or append content to file_path in file system. Allowed extensions are .md, .txt, .json, .csv, .pdf. For .pdf files, write the content in markdown format and it will automatically be converted to a properly formatted PDF document.'
+            ''
         )
         async def write_file(
                 file_path: str,
@@ -1735,7 +1537,7 @@ You will be given a query and the markdown of a webpage that has been filtered t
             return ActionResult(extracted_content=result, long_term_memory=result)
 
         @self.registry.action(
-            'Copy a file to the FileSystem. Set external_src=True to copy from external file(absolute path)to FileSystem, False to copy within FileSystem.'
+            'Set external_src=True to copy from external file(absolute path)to FileSystem, False to copy within FileSystem.'
         )
         async def copy_file(src_file_path: str, dst_file_path: str, file_system: CustomFileSystem,
                             external_src: bool = False):
@@ -1792,7 +1594,7 @@ You will be given a query and the markdown of a webpage that has been filtered t
             )
 
         @self.registry.action(
-            'List contents of a directory within the FileSystem. Use empty string "" or "." to list the root data_dir, or provide relative path for subdirectory.'
+            'List a directory within the FileSystem. Use empty string "" or "." to list the root FileSystem, or provide relative path for subdirectory.'
         )
         async def list_directory(directory_path: str, file_system: CustomFileSystem):
             result = await file_system.list_directory(directory_path)
@@ -1803,6 +1605,143 @@ You will be given a query and the markdown of a webpage that has been filtered t
                 long_term_memory=result,
             )
 
+        @self.registry.action(
+            'search for query or keywords and return surrounding context',
+            param_model=GrepContentAction,
+        )
+        async def grep_content_from_file(
+                params: GrepContentAction,
+                page_extraction_llm: BaseChatModel,
+                file_system: CustomFileSystem,
+        ):
+            try:
+                # Get file path
+                file_path = params.file_path
+                full_file_path = file_path
+                # Check if file exists
+                if not os.path.exists(full_file_path):
+                    full_file_path = os.path.join(str(file_system.get_dir()), file_path)
+
+                # Determine if file is an image based on MIME type
+                mime_type, _ = mimetypes.guess_type(file_path)
+                is_image = mime_type and mime_type.startswith('image/')
+
+                if is_image:
+                    # Handle image files with LLM vision for OCR
+                    try:
+                        # Read image file and encode to base64
+                        with open(full_file_path, 'rb') as image_file:
+                            image_data = image_file.read()
+                            image_base64 = base64.b64encode(image_data).decode('utf-8')
+
+                        # Create content parts for OCR
+                        content_parts: list[ContentPartTextParam | ContentPartImageParam] = [
+                            ContentPartTextParam(
+                                text="Please extract all text content from this image for search purposes. Return only the extracted text, no additional explanations.")
+                        ]
+
+                        # Add the image
+                        content_parts.append(
+                            ContentPartImageParam(
+                                image_url=ImageURL(
+                                    url=f'data:{mime_type};base64,{image_base64}',
+                                    media_type=mime_type,
+                                    detail='high',
+                                ),
+                            )
+                        )
+
+                        # Create user message and invoke LLM for OCR
+                        user_message = UserMessage(content=content_parts, cache=True)
+                        response = await asyncio.wait_for(
+                            page_extraction_llm.ainvoke([user_message]),
+                            timeout=120.0,
+                        )
+
+                        file_content = response.completion
+
+                    except Exception as e:
+                        raise Exception(f'Failed to process image file {file_path} for OCR: {str(e)}')
+
+                else:
+                    # Handle non-image files by reading content
+                    try:
+                        file_content = await file_system.read_file(full_file_path, external_file=True)
+                    except Exception as e:
+                        raise Exception(f'Failed to read file {file_path}: {str(e)}')
+
+                # Perform grep search
+                search_query = params.query.lower()
+                context_chars = params.context_chars
+
+                # Find all matches with context
+                matches = []
+                content_lower = file_content.lower()
+                search_start = 0
+
+                while True:
+                    match_pos = content_lower.find(search_query, search_start)
+                    if match_pos == -1:
+                        break
+
+                    # Calculate context boundaries
+                    start_pos = max(0, match_pos - context_chars)
+                    end_pos = min(len(file_content), match_pos + len(search_query) + context_chars)
+
+                    # Extract context with the match
+                    context_before = file_content[start_pos:match_pos]
+                    matched_text = file_content[match_pos:match_pos + len(search_query)]
+                    context_after = file_content[match_pos + len(search_query):end_pos]
+
+                    # Add ellipsis if truncated
+                    if start_pos > 0:
+                        context_before = "..." + context_before
+                    if end_pos < len(file_content):
+                        context_after = context_after + "..."
+
+                    matches.append({
+                        'context_before': context_before,
+                        'matched_text': matched_text,
+                        'context_after': context_after,
+                        'position': match_pos
+                    })
+
+                    search_start = match_pos + 1
+
+                # Format results
+                if not matches:
+                    extracted_content = f'File: {file_path}\nQuery: "{params.query}"\nResult: No matches found'
+                else:
+                    result_text = f'File: {file_path}\nQuery: "{params.query}"\nFound {len(matches)} match(es):\n\n'
+
+                    for i, match in enumerate(matches, 1):
+                        result_text += f"Match {i} (position: {match['position']}):\n"
+                        result_text += f"{match['context_before']}[{match['matched_text']}]{match['context_after']}\n\n"
+
+                    extracted_content = result_text.strip()
+
+                # Handle memory storage
+                if len(extracted_content) < 1000:
+                    memory = extracted_content
+                    include_extracted_content_only_once = False
+                else:
+                    save_result = await file_system.save_extracted_content(extracted_content)
+                    memory = (
+                        f'Grep search completed in file {file_path} for query: {params.query}\nFound {len(matches)} match(es)\nContent saved to file system: {save_result}'
+                    )
+                    include_extracted_content_only_once = True
+
+                logger.info(f'🔍 Grep search completed in file: {file_path}, found {len(matches)} match(es)')
+                return ActionResult(
+                    extracted_content=extracted_content,
+                    include_extracted_content_only_once=include_extracted_content_only_once,
+                    long_term_memory=memory,
+                )
+
+            except Exception as e:
+                logger.debug(f'Error grep searching content from file: {e}')
+                raise RuntimeError(str(e))
+
         @self.registry.action(
             'Create a directory within the FileSystem.'
         )
@@ -1898,6 +1837,72 @@ You will be given a query and the markdown of a webpage that has been filtered t
         self.mcp_clients.clear()
         logger.info('All MCP clients unregistered and disconnected')
 
+    async def register_composio_clients(self, composio_instance: Optional[Any] = None,
+                                        toolkit_tools_dict: Optional[Dict[str, Any]] = None):
+        """
+        Register Composio tools to the registry.
+        
+        Args:
+            composio_instance: Composio instance (optional, can be None initially)
+            toolkit_tools_dict: Dict of toolkit_slug -> tools list
+        """
+        try:
+            # Initialize Composio client if not exists
+            if self.composio_client is None:
+                self.composio_client = ComposioClient(composio_instance=composio_instance)
+            else:
+                # Update the composio instance
+                self.composio_client.update_composio_instance(composio_instance)
+            self.composio_toolkits = toolkit_tools_dict
+            # Register tools if we have both instance and toolkit tools
+            if composio_instance and toolkit_tools_dict:
+                await self.composio_client.register_to_tools(
+                    tools=self,
+                    toolkit_tools_dict=toolkit_tools_dict,
+                    prefix="cpo."
+                )
+                logger.info(f'Successfully registered Composio tools from {len(toolkit_tools_dict)} toolkits')
+            elif not composio_instance:
+                logger.info("Composio client initialized without instance - will register tools later")
+            elif not toolkit_tools_dict:
+                logger.info("Composio client initialized without toolkit tools - will register tools later")
+
+        except Exception as e:
+            logger.error(f'Failed to register Composio clients: {str(e)}')
+
+    async def unregister_composio_clients(self):
+        """
+        Unregister all Composio tools from the registry.
+        """
+        try:
+            if self.composio_client:
+                self.composio_client.unregister_all_tools(self)
+                logger.info('All Composio tools unregistered')
+            self.composio_toolkits.clear()
+        except Exception as e:
+            logger.error(f'Failed to unregister Composio clients: {str(e)}')
+
+    async def update_composio_tools(self, composio_instance: Optional[Any] = None,
+                                    toolkit_tools_dict: Optional[Dict[str, Any]] = None):
+        """
+        Update Composio tools by unregistering old ones and registering new ones.
+        
+        Args:
+            composio_instance: Composio instance
+            toolkit_tools_dict: Dict of toolkit_slug -> tools list
+        """
+        try:
+            # Unregister existing tools
+            await self.unregister_composio_clients()
+
+            # Register new tools
+            await self.register_composio_clients(composio_instance, toolkit_tools_dict)
+            self.composio_toolkits = toolkit_tools_dict
+            logger.info('Composio tools updated successfully')
+
+        except Exception as e:
+            logger.error(f'Failed to update Composio tools: {str(e)}')
+
     @time_execution_sync('--act')
     async def act(
             self,