camel-ai 0.2.73a4__py3-none-any.whl → 0.2.80a2__py3-none-any.whl

camel/toolkits/hybrid_browser_toolkit/hybrid_browser_toolkit_ts.py

@@ -13,22 +13,39 @@
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
 # =========
 
+import contextlib
 import time
-from typing import Any, Callable, ClassVar, Dict, List, Optional, cast
+from typing import (
+    Any,
+    Callable,
+    ClassVar,
+    Dict,
+    List,
+    Optional,
+    TypedDict,
+    cast,
+)
 
 from camel.logger import get_logger
 from camel.messages import BaseMessage
-from camel.models import BaseModelBackend
 from camel.toolkits.base import BaseToolkit, RegisteredAgentToolkit
 from camel.toolkits.function_tool import FunctionTool
 from camel.utils.commons import dependencies_required
 
 from .config_loader import ConfigLoader
-from .ws_wrapper import WebSocketBrowserWrapper
+from .ws_wrapper import WebSocketBrowserWrapper, high_level_action
 
 logger = get_logger(__name__)
 
 
+class SheetCell(TypedDict):
+    """Type definition for a sheet cell input."""
+
+    row: int
+    col: int
+    text: str
+
+
 class HybridBrowserToolkit(BaseToolkit, RegisteredAgentToolkit):
     r"""A hybrid browser toolkit that combines non-visual, DOM-based browser
     automation with visual, screenshot-based capabilities.
@@ -37,7 +54,6 @@ class HybridBrowserToolkit(BaseToolkit, RegisteredAgentToolkit):
     _snapshotForAI functionality for enhanced AI integration.
     """
 
-    # Default tool list - core browser functionality
     DEFAULT_TOOLS: ClassVar[List[str]] = [
         "browser_open",
         "browser_close",
@@ -49,7 +65,6 @@ class HybridBrowserToolkit(BaseToolkit, RegisteredAgentToolkit):
         "browser_switch_tab",
     ]
 
-    # All available tools
     ALL_TOOLS: ClassVar[List[str]] = [
         "browser_open",
         "browser_close",
@@ -58,17 +73,22 @@ class HybridBrowserToolkit(BaseToolkit, RegisteredAgentToolkit):
         "browser_forward",
         "browser_get_page_snapshot",
         "browser_get_som_screenshot",
-        "browser_get_page_links",
         "browser_click",
         "browser_type",
         "browser_select",
         "browser_scroll",
         "browser_enter",
+        "browser_mouse_control",
+        "browser_mouse_drag",
+        "browser_press_key",
         "browser_wait_user",
-        "browser_solve_task",
         "browser_switch_tab",
         "browser_close_tab",
         "browser_get_tab_info",
+        "browser_console_view",
+        "browser_console_exec",
+        "browser_sheet_input",
+        "browser_sheet_read",
     ]
 
     def __init__(
@@ -77,12 +97,12 @@ class HybridBrowserToolkit(BaseToolkit, RegisteredAgentToolkit):
         headless: bool = True,
         user_data_dir: Optional[str] = None,
         stealth: bool = False,
-        web_agent_model: Optional[BaseModelBackend] = None,
-        cache_dir: str = "tmp/",
+        cache_dir: Optional[str] = None,
         enabled_tools: Optional[List[str]] = None,
         browser_log_to_file: bool = False,
+        log_dir: Optional[str] = None,
         session_id: Optional[str] = None,
-        default_start_url: str = "https://google.com/",
+        default_start_url: Optional[str] = None,
         default_timeout: Optional[int] = None,
         short_timeout: Optional[int] = None,
         navigation_timeout: Optional[int] = None,
@@ -93,6 +113,8 @@ class HybridBrowserToolkit(BaseToolkit, RegisteredAgentToolkit):
         viewport_limit: bool = False,
         connect_over_cdp: bool = False,
         cdp_url: Optional[str] = None,
+        cdp_keep_current_page: bool = False,
+        full_visual_mode: bool = False,
     ) -> None:
         r"""Initialize the HybridBrowserToolkit.
 
@@ -103,13 +125,13 @@ class HybridBrowserToolkit(BaseToolkit, RegisteredAgentToolkit):
             persistence. Defaults to None.
             stealth (bool): Whether to enable stealth mode. Defaults to
             False.
-            web_agent_model (Optional[BaseModelBackend]): Model for web
-            agent operations. Defaults to None.
             cache_dir (str): Directory for caching. Defaults to "tmp/".
             enabled_tools (Optional[List[str]]): List of enabled tools.
             Defaults to None.
             browser_log_to_file (bool): Whether to log browser actions to
             file. Defaults to False.
+            log_dir (Optional[str]): Custom directory path for log files.
+            If None, defaults to "browser_log". Defaults to None.
             session_id (Optional[str]): Session identifier. Defaults to None.
             default_start_url (str): Default URL to start with. Defaults
             to "https://google.com/".
@@ -138,11 +160,15 @@ class HybridBrowserToolkit(BaseToolkit, RegisteredAgentToolkit):
             cdp_url (Optional[str]): WebSocket endpoint URL for CDP
             connection (e.g., 'ws://localhost:9222/devtools/browser/...').
             Required when connect_over_cdp is True. Defaults to None.
+            cdp_keep_current_page (bool): When True and using CDP mode,
+            won't create new pages but use the existing one. Defaults to False.
+            full_visual_mode (bool): When True, browser actions like click,
+            browser_open, visit_page, etc. will not return snapshots.
+            Defaults to False.
         """
         super().__init__()
         RegisteredAgentToolkit.__init__(self)
 
-        # Initialize configuration loader
         self.config_loader = ConfigLoader.from_kwargs(
             headless=headless,
             user_data_dir=user_data_dir,
@@ -158,27 +184,39 @@ class HybridBrowserToolkit(BaseToolkit, RegisteredAgentToolkit):
             viewport_limit=viewport_limit,
             cache_dir=cache_dir,
             browser_log_to_file=browser_log_to_file,
+            log_dir=log_dir,
             session_id=session_id,
             enabled_tools=enabled_tools,
             connect_over_cdp=connect_over_cdp,
             cdp_url=cdp_url,
+            cdp_keep_current_page=cdp_keep_current_page,
+            full_visual_mode=full_visual_mode,
         )
 
-        # Legacy attribute access for backward compatibility
         browser_config = self.config_loader.get_browser_config()
         toolkit_config = self.config_loader.get_toolkit_config()
 
+        if (
+            browser_config.cdp_keep_current_page
+            and default_start_url is not None
+        ):
+            raise ValueError(
+                "Cannot use default_start_url with "
+                "cdp_keep_current_page=True. When cdp_keep_current_page "
+                "is True, the browser will keep the current page and not "
+                "navigate to any URL."
+            )
+
         self._headless = browser_config.headless
         self._user_data_dir = browser_config.user_data_dir
         self._stealth = browser_config.stealth
-        self._web_agent_model = web_agent_model
         self._cache_dir = toolkit_config.cache_dir
         self._browser_log_to_file = toolkit_config.browser_log_to_file
         self._default_start_url = browser_config.default_start_url
         self._session_id = toolkit_config.session_id or "default"
         self._viewport_limit = browser_config.viewport_limit
+        self._full_visual_mode = browser_config.full_visual_mode
 
-        # Store timeout configuration for backward compatibility
         self._default_timeout = browser_config.default_timeout
         self._short_timeout = browser_config.short_timeout
         self._navigation_timeout = browser_config.navigation_timeout
@@ -189,11 +227,9 @@ class HybridBrowserToolkit(BaseToolkit, RegisteredAgentToolkit):
             browser_config.dom_content_loaded_timeout
         )
 
-        # Configure enabled tools
         if enabled_tools is None:
             self.enabled_tools = self.DEFAULT_TOOLS.copy()
         else:
-            # Validate enabled tools
             invalid_tools = [
                 tool for tool in enabled_tools if tool not in self.ALL_TOOLS
             ]
@@ -206,7 +242,6 @@ class HybridBrowserToolkit(BaseToolkit, RegisteredAgentToolkit):
 
         logger.info(f"Enabled tools: {self.enabled_tools}")
 
-        # Initialize WebSocket wrapper
         self._ws_wrapper: Optional[WebSocketBrowserWrapper] = None
         self._ws_config = self.config_loader.to_ws_config()
 
@@ -233,13 +268,29 @@ class HybridBrowserToolkit(BaseToolkit, RegisteredAgentToolkit):
 
             import asyncio
 
+            is_cdp = (
+                self._ws_config.get('connectOverCdp', False)
+                if hasattr(self, '_ws_config')
+                else False
+            )
+
             try:
                 loop = asyncio.get_event_loop()
                 if not loop.is_closed() and not loop.is_running():
                     try:
-                        loop.run_until_complete(
-                            asyncio.wait_for(self.browser_close(), timeout=2.0)
-                        )
+                        if is_cdp:
+                            # CDP: disconnect only
+                            loop.run_until_complete(
+                                asyncio.wait_for(
+                                    self.disconnect_websocket(), timeout=2.0
+                                )
+                            )
+                        else:
+                            loop.run_until_complete(
+                                asyncio.wait_for(
+                                    self.browser_close(), timeout=2.0
+                                )
+                            )
                     except asyncio.TimeoutError:
                         pass
             except (RuntimeError, ImportError):
@@ -247,23 +298,11 @@ class HybridBrowserToolkit(BaseToolkit, RegisteredAgentToolkit):
         except Exception:
             pass
 
-    @property
-    def web_agent_model(self) -> Optional[BaseModelBackend]:
-        """Get the web agent model."""
-        return self._web_agent_model
-
-    @web_agent_model.setter
-    def web_agent_model(self, value: Optional[BaseModelBackend]) -> None:
-        """Set the web agent model."""
-        self._web_agent_model = value
-
     @property
     def cache_dir(self) -> str:
         """Get the cache directory."""
         return self._cache_dir
 
-    # Public API Methods
-
     async def browser_open(self) -> Dict[str, Any]:
         r"""Starts a new browser session. This must be the first browser
         action.
@@ -284,7 +323,6 @@ class HybridBrowserToolkit(BaseToolkit, RegisteredAgentToolkit):
             ws_wrapper = await self._get_ws_wrapper()
             result = await ws_wrapper.open_browser(self._default_start_url)
 
-            # Add tab information
             tab_info = await ws_wrapper.get_tab_info()
             result.update(
                 {
@@ -329,6 +367,31 @@ class HybridBrowserToolkit(BaseToolkit, RegisteredAgentToolkit):
             logger.error(f"Failed to close browser: {e}")
             return f"Error closing browser: {e}"
 
+    async def disconnect_websocket(self) -> str:
+        r"""Disconnects the WebSocket connection without closing the browser.
+
+        This is useful when using CDP mode where the browser should
+        remain open.
+
+        Returns:
+            str: A confirmation message.
+        """
+        try:
+            if self._ws_wrapper:
+                is_cdp = self._ws_config.get('connectOverCdp', False)
+
+                if is_cdp:
+                    # CDP: disconnect only
+                    await self._ws_wrapper.disconnect_only()
+                else:
+                    await self._ws_wrapper.stop()
+
+                self._ws_wrapper = None
+            return "WebSocket disconnected."
+        except Exception as e:
+            logger.error(f"Failed to disconnect WebSocket: {e}")
+            return f"Error disconnecting WebSocket: {e}"
+
     async def browser_visit_page(self, url: str) -> Dict[str, Any]:
         r"""Opens a URL in a new browser tab and switches to it.
 
@@ -348,7 +411,6 @@ class HybridBrowserToolkit(BaseToolkit, RegisteredAgentToolkit):
             ws_wrapper = await self._get_ws_wrapper()
             result = await ws_wrapper.visit_page(url)
 
-            # Add tab information
             tab_info = await ws_wrapper.get_tab_info()
             result.update(
                 {
@@ -394,7 +456,6 @@ class HybridBrowserToolkit(BaseToolkit, RegisteredAgentToolkit):
             ws_wrapper = await self._get_ws_wrapper()
             result = await ws_wrapper.back()
 
-            # Add tab information
             tab_info = await ws_wrapper.get_tab_info()
             result.update(
                 {
@@ -440,7 +501,6 @@ class HybridBrowserToolkit(BaseToolkit, RegisteredAgentToolkit):
             ws_wrapper = await self._get_ws_wrapper()
             result = await ws_wrapper.forward()
 
-            # Add tab information
             tab_info = await ws_wrapper.get_tab_info()
             result.update(
                 {
@@ -532,19 +592,14 @@ class HybridBrowserToolkit(BaseToolkit, RegisteredAgentToolkit):
             ws_wrapper = await self._get_ws_wrapper()
             result = await ws_wrapper.get_som_screenshot()
 
-            # Initialize result text
             result_text = result.text
             file_path = None
 
-            # Save screenshot to cache directory if images are available
             if result.images:
-                # Ensure cache directory exists (use absolute path)
                 cache_dir = os.path.abspath(self._cache_dir)
                 os.makedirs(cache_dir, exist_ok=True)
 
-                # Get current page URL for filename
                 try:
-                    # Try to get the current page URL from the wrapper
                     page_info = await ws_wrapper.get_tab_info()
                     current_tab = next(
                         (tab for tab in page_info if tab.get('is_current')),
@@ -554,7 +609,6 @@ class HybridBrowserToolkit(BaseToolkit, RegisteredAgentToolkit):
                 except Exception:
                     url = 'unknown'
 
-                # Generate filename
                 parsed_url = urllib.parse.urlparse(url)
                 url_name = sanitize_filename(
                     str(parsed_url.path) or 'homepage', max_length=241
@@ -564,24 +618,19 @@ class HybridBrowserToolkit(BaseToolkit, RegisteredAgentToolkit):
                     cache_dir, f"{url_name}_{timestamp}_som.png"
                 )
 
-                # Extract base64 data and save to file
                 for _, image_data in enumerate(result.images):
                     if image_data.startswith('data:image/png;base64,'):
-                        # Remove data URL prefix
                         base64_data = image_data.split(',', 1)[1]
 
-                        # Decode and save
                         image_bytes = base64.b64decode(base64_data)
                         with open(file_path, 'wb') as f:
                             f.write(image_bytes)
 
                         logger.info(f"Screenshot saved to: {file_path}")
 
-                        # Update result text to include file path
                         result_text += f" (saved to: {file_path})"
                         break
 
-            # Analyze image if requested and agent is registered
             if read_image and file_path:
                 if self.agent is None:
                     logger.error(
@@ -596,7 +645,6 @@ class HybridBrowserToolkit(BaseToolkit, RegisteredAgentToolkit):
                     )
                 else:
                     try:
-                        # Load the image and create a message
                         from PIL import Image
 
                         img = Image.open(file_path)
@@ -607,7 +655,6 @@ class HybridBrowserToolkit(BaseToolkit, RegisteredAgentToolkit):
                             image_list=[img],
                         )
 
-                        # Get agent's analysis
                         response = await self.agent.astep(message)
                         agent_response = response.msgs[0].content
                         result_text += f". Agent analysis: {agent_response}"
@@ -641,24 +688,30 @@ class HybridBrowserToolkit(BaseToolkit, RegisteredAgentToolkit):
             ws_wrapper = await self._get_ws_wrapper()
             result = await ws_wrapper.click(ref)
 
-            # Add tab information
             tab_info = await ws_wrapper.get_tab_info()
-            result.update(
-                {
-                    "tabs": tab_info,
-                    "current_tab": next(
-                        (
-                            i
-                            for i, tab in enumerate(tab_info)
-                            if tab.get("is_current")
-                        ),
-                        0,
+
+            response = {
+                "result": result.get("result", ""),
+                "snapshot": result.get("snapshot", ""),
+                "tabs": tab_info,
+                "current_tab": next(
+                    (
+                        i
+                        for i, tab in enumerate(tab_info)
+                        if tab.get("is_current")
                     ),
-                    "total_tabs": len(tab_info),
-                }
-            )
+                    0,
+                ),
+                "total_tabs": len(tab_info),
+            }
 
-            return result
+            if "newTabId" in result:
+                response["newTabId"] = result["newTabId"]
+
+            if "timing" in result:
+                response["timing"] = result["timing"]
+
+            return response
         except Exception as e:
             logger.error(f"Failed to click element: {e}")
             return {
@@ -669,12 +722,29 @@ class HybridBrowserToolkit(BaseToolkit, RegisteredAgentToolkit):
                 "total_tabs": 0,
             }
 
-    async def browser_type(self, *, ref: str, text: str) -> Dict[str, Any]:
-        r"""Types text into an input element on the page.
+    async def browser_type(
+        self,
+        *,
+        ref: Optional[str] = None,
+        text: Optional[str] = None,
+        inputs: Optional[List[Dict[str, str]]] = None,
+    ) -> Dict[str, Any]:
+        r"""Types text into one or more input elements on the page.
+
+        This method supports two modes:
+        1. Single input mode (backward compatible): Provide 'ref' and 'text'
+        2. Multiple inputs mode: Provide 'inputs' as a list of dictionaries
+           with 'ref' and 'text' keys
 
         Args:
-            ref (str): The `ref` ID of the input element, from a snapshot.
-            text (str): The text to type into the element.
+            ref (Optional[str]): The `ref` ID of the input element, from a
+                snapshot. Required when using single input mode.
+            text (Optional[str]): The text to type into the element. Required
+                when using single input mode.
+            inputs (Optional[List[Dict[str, str]]]): List of dictionaries,
+                each containing 'ref' and 'text' keys for typing into multiple
+                elements. Example: [{'ref': '1', 'text': 'username'},
+                {'ref': '2', 'text': 'password'}]
 
         Returns:
             Dict[str, Any]: A dictionary with the result of the action:
@@ -684,12 +754,22 @@ class HybridBrowserToolkit(BaseToolkit, RegisteredAgentToolkit):
                 - "tabs" (List[Dict]): Information about all open tabs.
                 - "current_tab" (int): Index of the active tab.
                 - "total_tabs" (int): Total number of open tabs.
+                - "details" (Dict[str, Any]): When using multiple inputs,
+                  contains success/error status for each ref.
         """
         try:
             ws_wrapper = await self._get_ws_wrapper()
-            result = await ws_wrapper.type(ref, text)
 
-            # Add tab information
+            if ref is not None and text is not None:
+                result = await ws_wrapper.type(ref, text)
+            elif inputs is not None:
+                result = await ws_wrapper.type_multiple(inputs)
+            else:
+                raise ValueError(
+                    "Either provide 'ref' and 'text' for single input, "
+                    "or 'inputs' for multiple inputs"
+                )
+
             tab_info = await ws_wrapper.get_tab_info()
             result.update(
                 {
@@ -738,7 +818,6 @@ class HybridBrowserToolkit(BaseToolkit, RegisteredAgentToolkit):
             ws_wrapper = await self._get_ws_wrapper()
             result = await ws_wrapper.select(ref, value)
 
-            # Add tab information
             tab_info = await ws_wrapper.get_tab_info()
             result.update(
                 {
@@ -787,7 +866,6 @@ class HybridBrowserToolkit(BaseToolkit, RegisteredAgentToolkit):
             ws_wrapper = await self._get_ws_wrapper()
             result = await ws_wrapper.scroll(direction, amount)
 
-            # Add tab information
             tab_info = await ws_wrapper.get_tab_info()
             result.update(
                 {
@@ -835,7 +913,6 @@ class HybridBrowserToolkit(BaseToolkit, RegisteredAgentToolkit):
             ws_wrapper = await self._get_ws_wrapper()
             result = await ws_wrapper.enter()
 
-            # Add tab information
             tab_info = await ws_wrapper.get_tab_info()
             result.update(
                 {
@@ -863,6 +940,153 @@ class HybridBrowserToolkit(BaseToolkit, RegisteredAgentToolkit):
                 "total_tabs": 0,
             }
 
+    async def browser_mouse_control(
+        self, *, control: str, x: float, y: float
+    ) -> Dict[str, Any]:
+        r"""Control the mouse to interact with browser with x, y coordinates
+
+        Args:
+            control ([str]): The action to perform: 'click', 'right_click'
+            or 'dblclick'.
+            x (float): x-coordinate for the control action.
+            y (float): y-coordinate for the control action.
+
+        Returns:
+            Dict[str, Any]: A dictionary with the result of the action:
+                - "result" (str): Confirmation of the action.
+                - "snapshot" (str): A snapshot of the page after mouse
+                control action.
+                - "tabs" (List[Dict]): Information about all open tabs.
+                - "current_tab" (int): Index of the active tab.
+                - "total_tabs" (int): Total number of open tabs.
+        """
+        try:
+            ws_wrapper = await self._get_ws_wrapper()
+            result = await ws_wrapper.mouse_control(control, x, y)
+
+            tab_info = await ws_wrapper.get_tab_info()
+            result.update(
+                {
+                    "tabs": tab_info,
+                    "current_tab": next(
+                        (
+                            i
+                            for i, tab in enumerate(tab_info)
+                            if tab.get("is_current")
+                        ),
+                        0,
+                    ),
+                    "total_tabs": len(tab_info),
+                }
+            )
+
+            return result
+        except Exception as e:
+            logger.error(f"Failed to control mouse: {e}")
+            return {
+                "result": f"Error with mouse control: {e}",
+                "snapshot": "",
+                "tabs": [],
+                "current_tab": 0,
+                "total_tabs": 0,
+            }
+
+    async def browser_mouse_drag(
+        self, *, from_ref: str, to_ref: str
+    ) -> Dict[str, Any]:
+        r"""Control the mouse to drag and drop in the browser using ref IDs.
+
+        Args:
+            from_ref (str): The `ref` ID of the source element to drag from.
+            to_ref (str): The `ref` ID of the target element to drag to.
+
+        Returns:
+            Dict[str, Any]: A dictionary with the result of the action:
+                - "result" (str): Confirmation of the action.
+                - "snapshot" (str): A new page snapshot.
+                - "tabs" (List[Dict]): Information about all open tabs.
+                - "current_tab" (int): Index of the active tab.
+                - "total_tabs" (int): Total number of open tabs.
+        """
+        try:
+            ws_wrapper = await self._get_ws_wrapper()
+            result = await ws_wrapper.mouse_drag(from_ref, to_ref)
+
+            tab_info = await ws_wrapper.get_tab_info()
+            result.update(
+                {
+                    "tabs": tab_info,
+                    "current_tab": next(
+                        (
+                            i
+                            for i, tab in enumerate(tab_info)
+                            if tab.get("is_current")
+                        ),
+                        0,
+                    ),
+                    "total_tabs": len(tab_info),
+                }
+            )
+
+            return result
+        except Exception as e:
+            logger.error(f"Error with mouse drag and drop: {e}")
+            return {
+                "result": f"Error with mouse drag and drop: {e}",
+                "snapshot": "",
+                "tabs": [],
+                "current_tab": 0,
+                "total_tabs": 0,
+            }
+
+    async def browser_press_key(self, *, keys: List[str]) -> Dict[str, Any]:
+        r"""Press key and key combinations.
+        Supports single key press or combination of keys by concatenating
+        them with '+' separator.
+
+        Args:
+            keys (List[str]): key or list of keys.
+
+        Returns:
+            Dict[str, Any]: A dictionary with the result of the action:
+                - "result" (str): Confirmation of the action.
+                - "snapshot" (str): A snapshot of the page after
+                press key action.
+                - "tabs" (List[Dict]): Information about all open tabs.
+                - "current_tab" (int): Index of the active tab.
+                - "total_tabs" (int): Total number of open tabs.
+        """
+        try:
+            ws_wrapper = await self._get_ws_wrapper()
+            result = await ws_wrapper.press_key(keys)
+
+            tab_info = await ws_wrapper.get_tab_info()
+            result.update(
+                {
+                    "tabs": tab_info,
+                    "current_tab": next(
+                        (
+                            i
+                            for i, tab in enumerate(tab_info)
+                            if tab.get("is_current")
+                        ),
+                        0,
+                    ),
+                    "total_tabs": len(tab_info),
+                }
+            )
+
+            return result
+        except Exception as e:
+            logger.error(f"Failed to press key: {e}")
+            return {
+                "result": f"Error with press key: {e}",
+                "snapshot": "",
+                "tabs": [],
+                "current_tab": 0,
+                "total_tabs": 0,
+            }
+
     async def browser_switch_tab(self, *, tab_id: str) -> Dict[str, Any]:
         r"""Switches to a different browser tab using its ID.
 
@@ -884,7 +1108,6 @@ class HybridBrowserToolkit(BaseToolkit, RegisteredAgentToolkit):
             ws_wrapper = await self._get_ws_wrapper()
             result = await ws_wrapper.switch_tab(tab_id)
 
-            # Add tab information
             tab_info = await ws_wrapper.get_tab_info()
             result.update(
                 {
@@ -934,7 +1157,6 @@ class HybridBrowserToolkit(BaseToolkit, RegisteredAgentToolkit):
             ws_wrapper = await self._get_ws_wrapper()
             result = await ws_wrapper.close_tab(tab_id)
 
-            # Add tab information
             tab_info = await ws_wrapper.get_tab_info()
             result.update(
                 {
@@ -1002,6 +1224,582 @@ class HybridBrowserToolkit(BaseToolkit, RegisteredAgentToolkit):
                 "total_tabs": 0,
             }
 
+    async def browser_console_view(self) -> Dict[str, Any]:
+        r"""View current page console logs.
+
+        Returns:
+            Dict[str, Any]: A dictionary with tab information:
+                - "console_messages" (List[Dict]) : List of messages logged
+                in the current page
+
+        """
+        try:
+            ws_wrapper = await self._get_ws_wrapper()
+            console_logs = await ws_wrapper.console_view()
+
+            return {"console_messages": console_logs}
+        except Exception as e:
+            logger.error(f"Failed to get console view: {e}")
+            return {"console_messages": []}
+
+    async def browser_console_exec(self, code: str) -> Dict[str, Any]:
+        r"""Execute javascript code in the console of the current page and get
+        results.
+
+        Args:
+            code (str): JavaScript code to execute in the browser console.
+
+        Returns:
+            Dict[str, Any]: A dictionary with the result of the action:
+                - "result" (str): Confirmation of the action.
+                - "snapshot" (str): A snapshot of the active tab after
+                console execute action.
+                - "tabs" (List[Dict]): Information about remaining tabs.
+                - "current_tab" (int): Index of the new active tab.
+                - "total_tabs" (int): Total number of remaining tabs.
+        """
+        try:
+            ws_wrapper = await self._get_ws_wrapper()
+            result = await ws_wrapper.console_exec(code)
+
+            tab_info = await ws_wrapper.get_tab_info()
+            result.update(
+                {
+                    "tabs": tab_info,
+                    "current_tab": next(
+                        (
+                            i
+                            for i, tab in enumerate(tab_info)
+                            if tab.get("is_current")
+                        ),
+                        0,
+                    ),
+                    "total_tabs": len(tab_info),
+                }
+            )
+
+            return result
+        except Exception as e:
+            logger.error(f"Failed to execute javascript in console: {e}")
+            return {
+                "result": f"Error in code execution: {e}",
+                "snapshot": "",
+                "tabs": [],
+                "current_tab": 0,
+                "total_tabs": 0,
+            }
+
+    @high_level_action
+    async def browser_sheet_input(
+        self, *, cells: List[SheetCell]
+    ) -> Dict[str, Any]:
+        r"""Input text into multiple cells in a spreadsheet (e.g., Google
+        Sheets).
+
+        Args:
+            cells (List[Dict[str, Any]]): List of cells to input, each
+                containing:
+                - "row" (int): Row index (0-based). Row 0 = first row,
+                  Row 1 = second row, etc.
+                - "col" (int): Column index (0-based). Col 0 = Column A,
+                  Col 1 = Column B, etc.
+                - "text" (str): Text to input into the cell
+
+        Returns:
+            Dict[str, Any]: A dictionary with the result of the action:
+                - "result" (str): Confirmation of the action with details.
+                - "content" (str): The updated spreadsheet content (auto-read
+                  after input).
+                - "snapshot" (str): Always empty string (sheet tools don't
+                  return snapshots).
+                - "tabs" (List[Dict]): Information about all open tabs.
+                - "current_tab" (int): Index of the active tab.
+                - "total_tabs" (int): Total number of open tabs.
+
+        Example:
+            >>> cells = [
+            ...     {"row": 0, "col": 0, "text": "Name"},
+            ...     {"row": 0, "col": 1, "text": "Age"},
+            ...     {"row": 1, "col": 0, "text": "Alice"},
+            ...     {"row": 1, "col": 1, "text": "30"},
+            ... ]
+        """
+        try:
+            import platform
+
+            ws_wrapper = await self._get_ws_wrapper()
+            system = platform.system()
+
+            # Normalize cells: convert column labels to indices if needed
+            normalized_cells = []
+            for cell in cells:
+                normalized_cell = cell.copy()
+
+                # Convert column label (A, B, C, ...) to index if it's a string
+                col = cell.get("col", 0)
+                if isinstance(col, str):
+                    col = col.strip().upper()
+                    # Convert A->0, B->1, ..., Z->25, AA->26, AB->27, etc.
+                    col_index = 0
+                    for char in col:
+                        col_index = col_index * 26 + (ord(char) - ord('A') + 1)
+                    normalized_cell["col"] = col_index - 1
+                else:
+                    normalized_cell["col"] = int(col)
+
+                # Row is always used as-is (should be 0-based integer)
+                normalized_cell["row"] = int(cell.get("row", 0))
+                normalized_cell["text"] = str(cell.get("text", ""))
+                normalized_cells.append(normalized_cell)
+
+            # Perform batch input
+            input_result = await self._sheet_input_batch_js(
+                normalized_cells, ws_wrapper, system
+            )
+
+            # Read sheet content after input
+            try:
+                read_result = await self.browser_sheet_read()
+                return {
+                    "result": input_result["result"],
+                    "content": read_result.get("content", ""),
+                    "snapshot": "",
+                    "tabs": input_result.get("tabs", []),
+                    "current_tab": input_result.get("current_tab", 0),
+                    "total_tabs": input_result.get("total_tabs", 0),
+                }
+            except Exception as read_error:
+                logger.warning(f"Failed to auto-read sheet: {read_error}")
+                input_result["snapshot"] = ""
+                return input_result
+
+        except Exception as e:
+            logger.error(f"Failed to input to sheet: {e}")
+            return {
+                "result": f"Error inputting to sheet: {e}",
+                "content": "",
+                "snapshot": "",
+                "tabs": [],
+                "current_tab": 0,
+                "total_tabs": 0,
+            }
+
+    async def _sheet_input_batch_js(
+        self,
+        cells: List[SheetCell],
+        ws_wrapper: Any,
+        system: str,
+    ) -> Dict[str, Any]:
+        r"""Input to sheet using batch keyboard input with relative
+        positioning.
+
+        Builds all operations and sends them in ONE command to TypeScript,
+        which executes them and only waits for stability once at the end.
+        """
+        operations: List[Dict[str, Any]] = []
+
+        # Go to A1 to ensure we start from a known position
+        if system == "Darwin":
+            operations.append({"type": "press", "keys": ["Meta", "Home"]})
+        else:
+            operations.append({"type": "press", "keys": ["Control", "Home"]})
+        operations.append({"type": "wait", "delay": 310})
+
+        # Start at (0, 0)
+        current_row = 0
+        current_col = 0
+
+        for cell in cells:
+            target_row = cell.get("row", 0)
+            target_col = cell.get("col", 0)
+            text = cell.get("text", "")
+
+            # Calculate relative movement needed
+            row_diff = target_row - current_row
+            col_diff = target_col - current_col
+
+            # Navigate vertically
+            if row_diff > 0:
+                for _ in range(row_diff):
+                    operations.append({"type": "press", "keys": ["ArrowDown"]})
+                    operations.append({"type": "wait", "delay": 50})
+            elif row_diff < 0:
+                for _ in range(abs(row_diff)):
+                    operations.append({"type": "press", "keys": ["ArrowUp"]})
+                    operations.append({"type": "wait", "delay": 50})
+
+            # Navigate horizontally
+            if col_diff > 0:
+                for _ in range(col_diff):
+                    operations.append(
+                        {"type": "press", "keys": ["ArrowRight"]}
+                    )
+                    operations.append({"type": "wait", "delay": 50})
+            elif col_diff < 0:
+                for _ in range(abs(col_diff)):
+                    operations.append({"type": "press", "keys": ["ArrowLeft"]})
+                    operations.append({"type": "wait", "delay": 50})
+
+            # Wait after navigation if moved
+            if row_diff != 0 or col_diff != 0:
+                operations.append({"type": "wait", "delay": 100})
+
+            # Clear and input
+            operations.append({"type": "press", "keys": ["Delete"]})
+            operations.append({"type": "wait", "delay": 120})
+
+            if text:
+                operations.append({"type": "type", "text": text, "delay": 0})
+                operations.append({"type": "wait", "delay": 120})
+
+            # Press Enter to confirm
+            operations.append({"type": "press", "keys": ["Enter"]})
+            operations.append({"type": "wait", "delay": 130})
+
+            # Update current position (after Enter, cursor moves to next row)
+            current_row = target_row + 1
+            current_col = target_col
+
+        try:
+            await ws_wrapper._send_command(
+                'batch_keyboard_input',
+                {'operations': operations, 'skipStabilityWait': True},
+            )
+            tab_info = await ws_wrapper.get_tab_info()
+
+            return {
+                "result": f"Successfully input to {len(cells)} cells",
+                "snapshot": "",
+                "tabs": tab_info,
+                "current_tab": next(
+                    (
+                        i
+                        for i, tab in enumerate(tab_info)
+                        if tab.get("is_current")
+                    ),
+                    0,
+                ),
+                "total_tabs": len(tab_info),
+            }
+
+        except Exception as e:
+            logger.error(f"Batch keyboard execution failed: {e}")
+            return {
+                "result": f"Error in batch keyboard execution: {e}",
+                "snapshot": "",
+                "tabs": [],
+                "current_tab": 0,
+                "total_tabs": 0,
+            }
+
+    def _trim_sheet_content(self, content: str) -> str:
+        """Trim sheet content and add row/column labels.
+
+        Remove all empty rows and columns, then add:
+        - Column headers: A, B, C, D...
+        - Row numbers: 0, 1, 2, 3...
+
+        Args:
+            content (str): Raw sheet content with tabs and newlines.
+
+        Returns:
+            str: Trimmed content with row/column labels.
+        """
+        if not content or not content.strip():
+            return ""
+
+        # Split into rows and parse into 2D array
+        rows = content.split('\n')
+        grid: List[List[str]] = []
+        max_cols = 0
+        for row_str in rows:
+            cells = row_str.split('\t')
+            grid.append(cells)
+            max_cols = max(max_cols, len(cells))
+
+        # Pad rows to same length
+        for row_list in grid:
+            while len(row_list) < max_cols:
+                row_list.append('')
+
+        if not grid:
+            return ""
+
+        # Find non-empty rows and columns (keep original indices)
+        non_empty_rows = []
+        for i, row_cells in enumerate(grid):
+            if any(cell.strip() for cell in row_cells):
+                non_empty_rows.append(i)
+
+        non_empty_cols = []
+        for j in range(max_cols):
+            if any(grid[i][j].strip() for i in range(len(grid))):
+                non_empty_cols.append(j)
+
+        # If no content found
+        if not non_empty_rows or not non_empty_cols:
+            return ""
+
+        # Extract non-empty rows and columns
+        filtered_grid = []
+        for i in non_empty_rows:
+            filtered_row = [grid[i][j] for j in non_empty_cols]
+            filtered_grid.append(filtered_row)
+
+        # Generate column labels using original column indices
+        def col_label(index):
+            label = ""
+            while True:
+                label = chr(65 + (index % 26)) + label
+                index = index // 26
+                if index == 0:
+                    break
+                index -= 1
+            return label
+
+        col_headers = [col_label(j) for j in non_empty_cols]
+
+        # Add column headers as first row
+        result_rows = ['\t'.join(['', *col_headers])]
+
+        # Add data rows with original row numbers (0-based)
+        for row_idx, row_data in zip(non_empty_rows, filtered_grid):
+            result_rows.append('\t'.join([str(row_idx), *row_data]))
+
+        return '\n'.join(result_rows)
+
+    @high_level_action
+    async def browser_sheet_read(self) -> Dict[str, Any]:
+        r"""Read content from a spreadsheet.
+
+        This tool reads spreadsheet content and returns it in a structured
+        format with row/column labels. Empty rows and columns are
+        automatically removed.
+
+        Output format:
+        - First row: Column labels (A, B, C, ..., Z, AA, AB, ...)
+        - First column: Row numbers (0, 1, 2, 3, ...) - 0-based
+        - Labels show ORIGINAL positions in the spreadsheet (before removing
+          empty rows/columns)
+
+        Row/column indices match browser_sheet_input directly:
+        - Row label "0" in output = row index 0 in browser_sheet_input
+        - Column label "A" in output = col index 0 in browser_sheet_input
+        - Column label "C" in output = col index 2 in browser_sheet_input
+
+        Returns:
+            Dict[str, Any]: A dictionary with the result of the action:
+                - "result" (str): Confirmation message.
+                - "content" (str): Tab-separated spreadsheet content with
+                  row/column labels. Format:
+                  Line 1: "\tA\tB\tC" (column headers)
+                  Line 2+: "0\tdata1\tdata2\tdata3" (row number + data)
+                - "snapshot" (str): Always empty string (sheet tools don't
+                  return snapshots).
+                - "tabs" (List[Dict]): Information about all open tabs.
+                - "current_tab" (int): Index of the active tab.
+                - "total_tabs" (int): Total number of open tabs.
+
+        Example output:
+                A	B
+            0	Name	Age
+            1	Alice	30
+            2	Bob	25
+        """
+        import platform
+        import uuid
+
+        ws_wrapper = await self._get_ws_wrapper()
+
+        # Use unique ID to avoid conflicts in parallel execution
+        request_id = str(uuid.uuid4())
+        var_name = f"__sheetCopy_{request_id.replace('-', '_')}"
+
+        try:
+            # Step 1: Setup copy interception with multiple captures
+            js_inject = f"""
+            window.{var_name} = [];
+            let copyCount = 0;
+            const copyListener = function(e) {{
+                try {{
+                    // Intercept clipboard data before system clipboard write
+                    // Capture from Google Sheets' setData call
+                    const originalSetData = e.clipboardData.setData.bind(
+                        e.clipboardData
+                    );
+                    let capturedText = '';
+
+                    e.clipboardData.setData = function(type, data) {{
+                        if (type === 'text/plain') {{
+                            capturedText = data;
+                        }}
+                        // Prevent system clipboard write
+                    }};
+
+                    // Let Google Sheets process event (calls setData)
+                    // Event propagates and Sheets tries to set clipboard
+                    setTimeout(() => {{
+                        copyCount++;
+                        window.{var_name}.push(capturedText);
+                    }}, 0);
+
+                    // Prevent the default browser copy behavior
+                    e.preventDefault();
+                }} catch (err) {{
+                    console.error(
+                        '[SheetRead] Failed to intercept copy data:', err
+                    );
+                }}
+            }};
+
+            document.addEventListener('copy', copyListener, true);
+            window.{var_name}_removeListener = () => {{
+                document.removeEventListener('copy', copyListener, true);
+            }};
+
+            'Copy listener installed';
+            """
+            await ws_wrapper.console_exec(js_inject)
+
+            system = platform.system()
+            import asyncio
+
+            if system == "Darwin":
+                select_all_copy_ops: List[Dict[str, Any]] = [
+                    {"type": "press", "keys": ["Meta", "a"]},
+                    {"type": "wait", "delay": 100},
+                    {"type": "press", "keys": ["Meta", "c"]},
+                ]
+                await ws_wrapper._send_command(
+                    'batch_keyboard_input',
+                    {
+                        'operations': select_all_copy_ops,
+                        'skipStabilityWait': True,
+                    },
+                )
+                await asyncio.sleep(0.2)
+
+                # Repeat to capture correct one
+                await ws_wrapper._send_command(
+                    'batch_keyboard_input',
+                    {
+                        'operations': select_all_copy_ops,
+                        'skipStabilityWait': True,
+                    },
+                )
+                await asyncio.sleep(0.2)
+            else:
+                select_all_copy_ops = [
+                    {"type": "press", "keys": ["Control", "a"]},
+                    {"type": "wait", "delay": 100},
+                    {"type": "press", "keys": ["Control", "c"]},
+                ]
+                await ws_wrapper._send_command(
+                    'batch_keyboard_input',
+                    {
+                        'operations': select_all_copy_ops,
+                        'skipStabilityWait': True,
+                    },
+                )
+                await asyncio.sleep(0.2)
+
+                # Repeat to capture correct one
+                await ws_wrapper._send_command(
+                    'batch_keyboard_input',
+                    {
+                        'operations': select_all_copy_ops,
+                        'skipStabilityWait': True,
+                    },
+                )
+                await asyncio.sleep(0.2)
+
+            js_check = f"window.{var_name} || []"
+            content_result = await ws_wrapper.console_exec(js_check)
+            result_str = content_result.get("result", "[]")
+
+            import json
+
+            if isinstance(result_str, list):
+                captured_contents = result_str
+            elif isinstance(result_str, str):
+                if result_str.startswith("Console execution result: "):
+                    result_str = result_str[
+                        len("Console execution result: ") :
+                    ]
+                result_str = result_str.strip()
+
+                try:
+                    captured_contents = json.loads(result_str)
+                except json.JSONDecodeError:
+                    captured_contents = []
+            else:
+                captured_contents = []
+
+            if not captured_contents:
+                sheet_content = ""
+            elif len(captured_contents) == 1:
+                sheet_content = captured_contents[0]
+            else:
+
+                def count_non_empty_cells(content):
+                    if not content:
+                        return 0
+                    count = 0
+                    for line in content.split('\n'):
+                        for cell in line.split('\t'):
+                            if cell.strip():
+                                count += 1
+                    return count
+
+                counts = [
+                    count_non_empty_cells(content)
+                    for content in captured_contents[:2]
+                ]
+                best_idx = 0 if counts[0] > counts[1] else 1
+                sheet_content = captured_contents[best_idx]
+
+            sheet_content = self._trim_sheet_content(sheet_content)
+
+            tab_info = await ws_wrapper.get_tab_info()
+
+            return {
+                "result": "Successfully read spreadsheet content",
+                "content": sheet_content,
+                "snapshot": "",  # Sheet tools don't return snapshots
+                "tabs": tab_info,
+                "current_tab": next(
+                    (
+                        i
+                        for i, tab in enumerate(tab_info)
+                        if tab.get("is_current")
+                    ),
+                    0,
+                ),
+                "total_tabs": len(tab_info),
+            }
+
+        except Exception as e:
+            logger.error(f"Failed to read sheet: {e}")
+            return {
+                "result": f"Error reading sheet: {e}",
+                "content": "",
+                "snapshot": "",
+                "tabs": [],
+                "current_tab": 0,
+                "total_tabs": 0,
+            }
+        finally:
+            js_cleanup = f"""
+            if (window.{var_name}_removeListener) {{
+                window.{var_name}_removeListener();
+            }}
+            delete window.{var_name};
+            delete window.{var_name}_removeListener;
+            'cleaned'
+            """
+            with contextlib.suppress(Exception):
+                await ws_wrapper.console_exec(js_cleanup)
+
     # Additional methods for backward compatibility
     async def browser_wait_user(
         self, timeout_sec: Optional[float] = None
@@ -1113,7 +1911,6 @@ class HybridBrowserToolkit(BaseToolkit, RegisteredAgentToolkit):
             headless=self._headless,
             user_data_dir=self._user_data_dir,
             stealth=self._stealth,
-            web_agent_model=self._web_agent_model,
             cache_dir=f"{self._cache_dir.rstrip('/')}_clone_"
             f"{new_session_id}/",
             enabled_tools=self.enabled_tools.copy(),
@@ -1127,6 +1924,8 @@ class HybridBrowserToolkit(BaseToolkit, RegisteredAgentToolkit):
             screenshot_timeout=self._screenshot_timeout,
             page_stability_timeout=self._page_stability_timeout,
             dom_content_loaded_timeout=self._dom_content_loaded_timeout,
+            viewport_limit=self._viewport_limit,
+            full_visual_mode=self._full_visual_mode,
         )
 
     def get_tools(self) -> List[FunctionTool]:
@@ -1146,25 +1945,22 @@ class HybridBrowserToolkit(BaseToolkit, RegisteredAgentToolkit):
             "browser_select": self.browser_select,
             "browser_scroll": self.browser_scroll,
             "browser_enter": self.browser_enter,
+            "browser_mouse_control": self.browser_mouse_control,
+            "browser_mouse_drag": self.browser_mouse_drag,
+            "browser_press_key": self.browser_press_key,
             "browser_wait_user": self.browser_wait_user,
             "browser_switch_tab": self.browser_switch_tab,
             "browser_close_tab": self.browser_close_tab,
             "browser_get_tab_info": self.browser_get_tab_info,
+            "browser_console_view": self.browser_console_view,
+            "browser_console_exec": self.browser_console_exec,
+            "browser_sheet_input": self.browser_sheet_input,
+            "browser_sheet_read": self.browser_sheet_read,
         }
 
         enabled_tools = []
 
         for tool_name in self.enabled_tools:
-            if (
-                tool_name == "browser_solve_task"
-                and self._web_agent_model is None
-            ):
-                logger.warning(
-                    f"Tool '{tool_name}' is enabled but web_agent_model "
-                    f"is not provided. Skipping this tool."
-                )
-                continue
-
             if tool_name in tool_map:
                 tool = FunctionTool(
                     cast(Callable[..., Any], tool_map[tool_name])