vibesurf 0.1.43__py3-none-any.whl → 0.2.9a2__py3-none-any.whl

vibe_surf/tools/vibesurf_tools.py

@@ -32,7 +32,8 @@ 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, \
-    SkillXhsAction, SkillDouyinAction, SkillYoutubeAction, SkillWeiboAction, GrepContentAction
+    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
@@ -42,6 +43,7 @@ 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__)
 
@@ -60,13 +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(
-            'parallel search',
+            'Advanced search',
             param_model=SkillSearchAction,
         )
         async def skill_search(
@@ -75,186 +91,106 @@ 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: Try Google AI model search first (primary method)
+                logger.info(f'🔍 Starting Google AI model search for: {params.query}')
 
-                # 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.
+                # Attempt Google AI model search with udm=50
+                ai_search_results = await google_ai_model_search(browser_manager, params.query, max_results=15)
 
-Current Time: {datetime.now().isoformat()}
+                # 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')
 
-User Query: "{params.query}"
-
-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 = []
+                    # 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
 
-                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, ...]
-"""
-
-                    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(
             '',
@@ -280,15 +216,20 @@ Format: [index1, index2, index3, ...]
                 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
-                    if current_target_id != target_id:
+                    if browser_session._cached_browser_state_summary:
+                        current_url = browser_session._cached_browser_state_summary.url
+                    if current_target_id != target_id or url != current_url:
                         browser_session._dom_watchdog.clear_cache()
+                        browser_session._cached_browser_state_summary = None
                     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(
+                extracted_content = await _extract_structured_content(
                     browser_session, params.query, llm, target_id=target_id
                 )
 
@@ -339,15 +280,20 @@ Format: [index1, index2, index3, ...]
                 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
-                    if current_target_id != target_id:
+                    if browser_session._cached_browser_state_summary:
+                        current_url = browser_session._cached_browser_state_summary.url
+                    if current_target_id != target_id or url != current_url:
                         browser_session._dom_watchdog.clear_cache()
+                        browser_session._cached_browser_state_summary = None
                     await browser_session.get_or_create_cdp_session(target_id, focus=True)
 
                 # Extract and summarize content
-                summary = await self._extract_structured_content(
+                summary = await _extract_structured_content(
                     browser_session, "Provide a comprehensive summary of this webpage", llm, target_id=target_id
                 )
 
@@ -457,318 +403,21 @@ 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)
-
-                max_html_len = 60000
-                if len(web_page_html) > max_html_len:
-                    gap_len = (len(web_page_html) - max_html_len) // 2
-                    clip_len = max_html_len // 3
-                    web_page_html = (web_page_html[:clip_len] + "\n\n...\n\n" +
-                                     web_page_html[
-                                     clip_len + gap_len: clip_len + gap_len + clip_len + 10000] + "\n\n...\n\n" +
-                                     web_page_html[
-                                     clip_len + gap_len * 2 + clip_len: clip_len + gap_len * 2 + 2 * clip_len - 10000])
+                from vibe_surf.tools.utils import generate_java_script_code
 
-                # 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 Content:
-{web_page_html}
-
-Generate JavaScript code to fulfill the requirement:"""
-
-                message_history.append(UserMessage(content=initial_user_prompt))
-
-                # Get CDP session for JavaScript execution
-                cdp_session = await browser_session.get_or_create_cdp_session()
-
-                # Iterative code generation and execution
-                for iteration in range(1, MAX_ITERATIONS + 1):
-                    try:
-                        logger.info(f'🔄 Skill Code iteration {iteration}/{MAX_ITERATIONS}')
-
-                        # Generate JavaScript code using LLM with message history
-                        response = await asyncio.wait_for(
-                            page_extraction_llm.ainvoke(message_history),
-                            timeout=60.0,
-                        )
-
-                        generated_js_code = response.completion.strip()
-                        message_history.append(AssistantMessage(content=generated_js_code))
-
-                        # Clean up the generated code (remove markdown if present)
-                        if generated_js_code.startswith('```javascript'):
-                            generated_js_code = generated_js_code.replace('```javascript', '').replace('```',
-                                                                                                       '').strip()
-                        elif generated_js_code.startswith('```js'):
-                            generated_js_code = generated_js_code.replace('```js', '').replace('```', '').strip()
-                        elif generated_js_code.startswith('```'):
-                            generated_js_code = generated_js_code.replace('```', '').strip()
-
-                        # Execute the generated JavaScript code
-                        try:
-                            logger.info(generated_js_code)
-                            # Always use awaitPromise=True - it's ignored for non-promises
-                            result = await cdp_session.cdp_client.send.Runtime.evaluate(
-                                params={'expression': generated_js_code, 'returnByValue': True, 'awaitPromise': True},
-                                session_id=cdp_session.session_id,
-                            )
-
-                            logger.info(result)
-                            # Check for JavaScript execution errors
-                            if result.get('exceptionDetails'):
-                                exception = result['exceptionDetails']
-                                error_msg = f'JavaScript execution error: {exception.get("text", "Unknown error")}'
-                                if 'lineNumber' in exception:
-                                    error_msg += f' at line {exception["lineNumber"]}'
-
-                                # Add error feedback to message history for next iteration
-                                if iteration < MAX_ITERATIONS:
-                                    error_feedback = f"""The previous JavaScript code failed with error:
-{error_msg}
-
-Please fix the error and generate corrected JavaScript code:"""
-                                    message_history.append(UserMessage(content=error_feedback))
-                                    continue  # Try next iteration
-                                else:
-                                    # Final iteration, return error
-                                    msg = f'Requirement: {params.code_requirement}\n\nFinal Generated Code (Iteration {iteration}): {generated_js_code}\n\nError: {error_msg}'
-                                    logger.info(msg)
-                                    return ActionResult(error=msg)
-
-                            # Get the result data
-                            result_data = result.get('result', {})
-
-                            # Check for wasThrown flag (backup error detection)
-                            if result_data.get('wasThrown'):
-                                error_msg = 'JavaScript execution failed (wasThrown=true)'
-
-                                # Add error feedback to message history for next iteration
-                                if iteration < MAX_ITERATIONS:
-                                    error_feedback = f"""The previous JavaScript code failed with error:
-{error_msg}
-
-Please fix the error and generate corrected JavaScript code:"""
-                                    message_history.append(UserMessage(content=error_feedback))
-                                    continue  # Try next iteration
-                                else:
-                                    # Final iteration, return error
-                                    msg = f'Requirement: {params.code_requirement}\n\nFinal Generated Code (Iteration {iteration}): {generated_js_code}\n\nError: {error_msg}'
-                                    logger.info(msg)
-                                    return ActionResult(error=msg)
-
-                            # Get the actual value
-                            value = result_data.get('value')
-
-                            # Handle different value types
-                            if value is None:
-                                # Could be legitimate null/undefined result
-                                result_text = str(value) if 'value' in result_data else 'undefined'
-                            elif isinstance(value, (dict, list)):
-                                # Complex objects - should be serialized by returnByValue
-                                try:
-                                    result_text = json.dumps(value, ensure_ascii=False, 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(
-            'Return the guideline for deep research. Please follow the guideline to do real deep research actions.',
-            param_model=NoParamsAction,
-        )
-        async def skill_deep_research(
-                _: NoParamsAction,
-        ):
-            """
-            Skill: Deep research mode activation
-            """
-            research_prompt = f"""
-        🔬 **DEEP RESEARCH GUIDELINE**
-
-        To proceed with comprehensive research, please:
-
-        1. **Set up a detailed TODO list** for this research project that includes:
-           - Background research and context gathering
-           - Key questions to investigate
-           - Multiple source verification
-           - Data collection and analysis steps
-           - Report generation with proper citations
-
-        2. **Conduct systematic research** following these principles:
-           - Use multiple search strategies and sources
-           - Verify information across different platforms
-           - Document all sources with URLs for citation
-           - Take notes and screenshots of key findings
-           - Organize findings by themes or categories
-
-        3. **Generate a comprehensive report** that includes:
-           - Executive summary
-           - Detailed findings with analysis
-           - Proper citations and source references
-           - Supporting evidence (screenshots, quotes)
-           - Conclusions and recommendations
-           - Areas for further investigation
-
-        4. **Maintain research traceability** by:
-           - Recording all search queries used
-           - Saving important URLs and sources
-           - Including direct quotes with attribution
-           - Documenting methodology and approach
-
-        This deep research mode ensures thorough, traceable, and well-documented investigation of your topic with proper academic rigor and source citation.
-        """
-
-            return ActionResult(
-                extracted_content=research_prompt,
-                include_extracted_content_only_once=True,
-            )
-
         @self.registry.action(
             '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,
@@ -1274,326 +923,241 @@ Please generate alternative JavaScript code that avoids this system error:"""
                 logger.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);
-        }
+    def _register_extra_tools(self):
+        """
+        Register extra tools for dynamic toolkit and MCP tool access
+        """
         
-        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;
-                }
-            }
+        @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
             
-            // 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', '[]')
-
+            Returns:
+                ActionResult with list of all toolkit type names
+            """
             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 []
-
-    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
-
-Return results as a JSON array: [{{"title": "...", "url": "...", "summary": "..."}}, ...]
-"""
+                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)}')
 
-            results_text = await self._extract_structured_content(browser_session, extraction_query, llm)
+        @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
+                if params.filters:
+                    filters = [f.lower() for f in params.filters]
+                else:
+                    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)}')
 
-            # Try to parse JSON results
+        @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:
-                results = json.loads(results_text.strip())
-                if isinstance(results, list):
-                    return results[:search_ret_len]  # Ensure max 5 results
-            except (json.JSONDecodeError, ValueError):
+                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:
-                    results = repair_json(results_text.strip())
-                    if isinstance(results, list):
-                        return results[:search_ret_len]  # Ensure max 5 results
+                    param_dict = action.param_model.model_json_schema()
+                    result_text = json.dumps(param_dict, indent=2, ensure_ascii=False)
                 except Exception as e:
-                    logger.warning(f"Failed to parse JSON from LLM search results: {results_text}")
-
-            # Fallback: return raw text as single result
-            current_url = await browser_session.get_current_page_url()
-            return [{
-                "title": f"Search results for: {query}",
-                "url": current_url,
-                "summary": results_text[:200] + "..." if len(results_text) > 200 else results_text
-            }]
-
-        except Exception as e:
-            logger.error(f"Google search failed for query '{query}': {e}")
-            return []
-
-    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
-
-    async def _extract_structured_content(self, browser_session, query: str, llm: BaseChatModel,
-                                          target_id: str | None = None, extract_links: bool = False):
-        """Helper method to extract structured content from current page"""
-        MAX_CHAR_LIMIT = 30000
-
-        # Extract clean markdown using the existing method
-        try:
-            from browser_use.dom.markdown_extractor import extract_clean_markdown
-
-            content, content_stats = await extract_clean_markdown(
-                browser_session=browser_session, extract_links=extract_links
-            )
-        except Exception as e:
-            raise RuntimeError(f'Could not extract clean markdown: {e}')
-
-        # Smart truncation with context preservation
-        if len(content) > MAX_CHAR_LIMIT:
-            # Try to truncate at a natural break point
-            truncate_at = MAX_CHAR_LIMIT
-            paragraph_break = content.rfind('\n\n', MAX_CHAR_LIMIT - 500, MAX_CHAR_LIMIT)
-            if paragraph_break > 0:
-                truncate_at = paragraph_break
-            else:
-                sentence_break = content.rfind('.', MAX_CHAR_LIMIT - 200, MAX_CHAR_LIMIT)
-                if sentence_break > 0:
-                    truncate_at = sentence_break + 1
-            content = content[:truncate_at]
-
-        system_prompt = """
-You are an expert at extracting data from the markdown of a webpage.
-
-<input>
-You will be given a query and the markdown of a webpage that has been filtered to remove noise and advertising content.
-</input>
-
-<instructions>
-- You are tasked to extract information from the webpage that is relevant to the query.
-- You should ONLY use the information available in the webpage to answer the query. Do not make up information or provide guess from your own knowledge.
-- If the information relevant to the query is not available in the page, your response should mention that.
-- If the query asks for all items, products, etc., make sure to directly list all of them.
-</instructions>
-
-<output>
-- Your output should present ALL the information relevant to the query in a concise way.
-- Do not answer in conversational format - directly output the relevant information or that the information is unavailable.
-</output>
-""".strip()
-
-        prompt = f'<query>\n{query}\n</query>\n\n<webpage_content>\n{content}\n</webpage_content>'
+                    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)}')
 
-        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))
+        @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(
@@ -1876,71 +1440,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:
@@ -2303,7 +1809,7 @@ You will be given a query and the markdown of a webpage that has been filtered t
             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(
@@ -2328,7 +1834,7 @@ You will be given a query and the markdown of a webpage that has been filtered t
             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)}')
 
@@ -2347,7 +1853,7 @@ You will be given a query and the markdown of a webpage that has been filtered t
 
             # 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: