camel-ai 0.2.73a12__py3-none-any.whl → 0.2.74__py3-none-any.whl

camel/toolkits/hybrid_browser_toolkit_py/browser_session.py

@@ -14,6 +14,7 @@
 from __future__ import annotations
 
 import asyncio
+from collections import deque
 from typing import TYPE_CHECKING, Any, ClassVar, Dict, List, Optional, Tuple
 
 from camel.logger import get_logger
@@ -26,6 +27,7 @@ if TYPE_CHECKING:
     from playwright.async_api import (
         Browser,
         BrowserContext,
+        ConsoleMessage,
         Page,
         Playwright,
     )
@@ -188,7 +190,9 @@ class HybridBrowserSession:
 
         # Dictionary-based tab management with monotonic IDs
         self._pages: Dict[str, Page] = {}  # tab_id -> Page object
+        self._console_logs: Dict[str, Any] = {}  # tab_id -> page logs
         self._current_tab_id: Optional[str] = None  # Current active tab ID
+        self.log_limit: int = ConfigLoader.get_max_log_limit() or 1000
 
         self.snapshot: Optional[PageSnapshot] = None
         self.executor: Optional[ActionExecutor] = None
@@ -266,7 +270,7 @@ class HybridBrowserSession:
                 )
 
         # Store in pages dictionary
-        self._pages[tab_id] = new_page
+        await self._register_new_page(tab_id, new_page)
 
         # Navigate if URL provided
         if url:
@@ -281,6 +285,32 @@ class HybridBrowserSession:
         )
         return tab_id
 
+    async def _register_new_page(self, tab_id: str, new_page: "Page") -> None:
+        r"""Register a page and add console event listerers.
+
+        Args:
+            new_page (Page): The new page object to register.
+        """
+        # Add new page
+        self._pages[tab_id] = new_page
+        # Create log for the page
+        self._console_logs[tab_id] = deque(maxlen=self.log_limit)
+
+        # Add event function
+        def handle_console_log(msg: ConsoleMessage):
+            logs = self._console_logs.get(tab_id)
+            if logs is not None:
+                logs.append({"type": msg.type, "text": msg.text})
+
+        # Add event listener for console logs
+        new_page.on(event="console", f=handle_console_log)
+
+        def handle_page_close(page: "Page"):
+            self._console_logs.pop(tab_id, None)
+
+        # Add event listener for cleanup
+        new_page.on(event="close", f=handle_page_close)
+
     async def register_page(self, new_page: "Page") -> str:
         r"""Register a page that was created externally (e.g., by a click).
 
@@ -297,7 +327,7 @@ class HybridBrowserSession:
 
         # Create new ID for the page
         tab_id = await TabIdGenerator.generate_tab_id()
-        self._pages[tab_id] = new_page
+        await self._register_new_page(tab_id, new_page)
 
         logger.info(
             f"Registered new tab {tab_id} (opened by user action). "
@@ -458,6 +488,7 @@ class HybridBrowserSession:
             self._context = singleton_instance._context
             self._page = singleton_instance._page
             self._pages = singleton_instance._pages
+            self._console_logs = singleton_instance._console_logs
             self._current_tab_id = singleton_instance._current_tab_id
             self.snapshot = singleton_instance.snapshot
             self.executor = singleton_instance.executor
@@ -502,16 +533,16 @@ class HybridBrowserSession:
                 self._page = pages[0]
                 # Create ID for initial page
                 initial_tab_id = await TabIdGenerator.generate_tab_id()
-                self._pages[initial_tab_id] = pages[0]
+                await self._register_new_page(initial_tab_id, pages[0])
                 self._current_tab_id = initial_tab_id
                 # Handle additional pages if any
                 for page in pages[1:]:
                     tab_id = await TabIdGenerator.generate_tab_id()
-                    self._pages[tab_id] = page
+                    await self._register_new_page(tab_id, page)
             else:
                 self._page = await context.new_page()
                 initial_tab_id = await TabIdGenerator.generate_tab_id()
-                self._pages[initial_tab_id] = self._page
+                await self._register_new_page(initial_tab_id, self._page)
                 self._current_tab_id = initial_tab_id
         else:
             self._browser = await self._playwright.chromium.launch(
@@ -522,7 +553,7 @@ class HybridBrowserSession:
 
             # Create ID for initial page
             initial_tab_id = await TabIdGenerator.generate_tab_id()
-            self._pages[initial_tab_id] = self._page
+            await self._register_new_page(initial_tab_id, self._page)
             self._current_tab_id = initial_tab_id
 
         # Apply stealth modifications if enabled
@@ -713,13 +744,19 @@ class HybridBrowserSession:
         return f"Navigated to {url}"
 
     async def get_snapshot(
-        self, *, force_refresh: bool = False, diff_only: bool = False
+        self,
+        *,
+        force_refresh: bool = False,
+        diff_only: bool = False,
+        viewport_limit: bool = False,
     ) -> str:
         r"""Get snapshot for current tab."""
         if not self.snapshot:
             return "<empty>"
         return await self.snapshot.capture(
-            force_refresh=force_refresh, diff_only=diff_only
+            force_refresh=force_refresh,
+            diff_only=diff_only,
+            viewport_limit=viewport_limit,
         )
 
     async def exec_action(self, action: Dict[str, Any]) -> Dict[str, Any]:
@@ -738,3 +775,13 @@ class HybridBrowserSession:
         if self._page is None:
             raise RuntimeError("No active page available")
         return self._page
+
+    async def get_console_logs(self) -> Dict[str, Any]:
+        r"""Get current active logs."""
+        await self.ensure_browser()
+        if self._current_tab_id is None:
+            raise RuntimeError("No active tab available")
+        logs = self._console_logs.get(self._current_tab_id, None)
+        if logs is None:
+            raise RuntimeError("No active logs available for the page")
+        return logs

camel/toolkits/hybrid_browser_toolkit_py/config_loader.py

@@ -40,6 +40,9 @@ class BrowserConfig:
     # Default action limits
     DEFAULT_MAX_SCROLL_AMOUNT = 5000  # Maximum scroll distance in pixels
 
+    # Default config limits
+    DEFAULT_MAX_LOG_LIMIT = 1000
+
     @staticmethod
     def get_timeout_config() -> Dict[str, int]:
         r"""Get timeout configuration with environment variable support.
@@ -108,6 +111,22 @@ class BrowserConfig:
             ),
         }
 
+    @staticmethod
+    def get_log_limits() -> Dict[str, int]:
+        r"""Get log limits configuration with environment variable support.
+
+        Returns:
+            Dict[str, int]: Console Log limits configuration.
+        """
+        return {
+            'max_log_limit': int(
+                os.getenv(
+                    'HYBRID_BROWSER_MAX_LOG_LIMIT',
+                    BrowserConfig.DEFAULT_MAX_LOG_LIMIT,
+                )
+            ),
+        }
+
     @staticmethod
     def get_action_timeout(override: Optional[int] = None) -> int:
         r"""Get action timeout with optional override.
@@ -178,6 +197,20 @@ class BrowserConfig:
             return override
         return BrowserConfig.get_action_limits()['max_scroll_amount']
 
+    @staticmethod
+    def get_max_log_limit(override: Optional[int] = None) -> int:
+        r"""Get maximum log limit with optional override.
+
+        Args:
+            override: Optional log limit override value.
+
+        Returns:
+            int: Maximum log limit.
+        """
+        if override is not None:
+            return override
+        return BrowserConfig.get_log_limits()['max_log_limit']
+
     @staticmethod
     def get_screenshot_timeout(override: Optional[int] = None) -> int:
         r"""Get screenshot timeout with optional override.
@@ -370,6 +403,11 @@ class ConfigLoader:
         r"""Get maximum scroll amount with optional override."""
         return BrowserConfig.get_max_scroll_amount(override)
 
+    @classmethod
+    def get_max_log_limit(cls, override: Optional[int] = None) -> int:
+        r"""Get maximum log limit with optional override."""
+        return BrowserConfig.get_max_log_limit(override)
+
     @classmethod
     def get_screenshot_timeout(cls, override: Optional[int] = None) -> int:
         r"""Get screenshot timeout with optional override."""
@@ -432,6 +470,11 @@ def get_max_scroll_amount(override: Optional[int] = None) -> int:
     return BrowserConfig.get_max_scroll_amount(override)
 
 
+def get_max_log_limit(override: Optional[int] = None) -> int:
+    r"""Get maximum log limit with optional override."""
+    return BrowserConfig.get_max_log_limit(override)
+
+
 def get_screenshot_timeout(override: Optional[int] = None) -> int:
     r"""Get screenshot timeout with optional override."""
     return BrowserConfig.get_screenshot_timeout(override)

camel/toolkits/hybrid_browser_toolkit_py/hybrid_browser_toolkit.py

@@ -73,11 +73,16 @@ class HybridBrowserToolkit(BaseToolkit, RegisteredAgentToolkit):
         "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",
     ]
 
     def __init__(
@@ -99,6 +104,7 @@ class HybridBrowserToolkit(BaseToolkit, RegisteredAgentToolkit):
         screenshot_timeout: Optional[int] = None,
         page_stability_timeout: Optional[int] = None,
         dom_content_loaded_timeout: Optional[int] = None,
+        viewport_limit: bool = False,
     ) -> None:
         r"""Initialize the HybridBrowserToolkit.
 
@@ -182,6 +188,10 @@ class HybridBrowserToolkit(BaseToolkit, RegisteredAgentToolkit):
                 HYBRID_BROWSER_DOM_CONTENT_LOADED_TIMEOUT or defaults to
                 5000ms.
                 Defaults to `None`.
+            viewport_limit (bool): When True, only return snapshot results
+                visible in the current viewport. When False, return all
+                elements on the page regardless of visibility.
+                Defaults to `False`.
         """
         super().__init__()
         RegisteredAgentToolkit.__init__(self)
@@ -193,6 +203,7 @@ class HybridBrowserToolkit(BaseToolkit, RegisteredAgentToolkit):
         self._browser_log_to_file = browser_log_to_file
         self._default_start_url = default_start_url
         self._session_id = session_id or "default"
+        self._viewport_limit = viewport_limit
 
         # Store timeout configuration
         self._default_timeout = default_timeout
@@ -309,7 +320,7 @@ class HybridBrowserToolkit(BaseToolkit, RegisteredAgentToolkit):
                     # Try to close browser with a timeout to prevent hanging
                     try:
                         loop.run_until_complete(
-                            asyncio.wait_for(self.close_browser(), timeout=2.0)
+                            asyncio.wait_for(self.browser_close(), timeout=2.0)
                         )
                     except asyncio.TimeoutError:
                         pass  # Skip cleanup if it takes too long
@@ -550,7 +561,7 @@ class HybridBrowserToolkit(BaseToolkit, RegisteredAgentToolkit):
             )
 
     async def _get_unified_analysis(
-        self, max_retries: int = 3
+        self, max_retries: int = 3, viewport_limit: Optional[bool] = None
     ) -> Dict[str, Any]:
         r"""Get unified analysis data from the page with retry mechanism for
         navigation issues."""
@@ -573,7 +584,15 @@ class HybridBrowserToolkit(BaseToolkit, RegisteredAgentToolkit):
                     # Don't fail if DOM wait times out
                     pass
 
-                result = await page.evaluate(self._unified_script)
+                # Use instance viewport_limit if parameter not provided
+                use_viewport_limit = (
+                    viewport_limit
+                    if viewport_limit is not None
+                    else self._viewport_limit
+                )
+                result = await page.evaluate(
+                    self._unified_script, use_viewport_limit
+                )
 
                 if not isinstance(result, dict):
                     logger.warning(f"Invalid result type: {type(result)}")
@@ -1703,6 +1722,149 @@ class HybridBrowserToolkit(BaseToolkit, RegisteredAgentToolkit):
 
         return result
 
+    @action_logger
+    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 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.
+        """
+        if control not in ("click", "right_click", "dblclick"):
+            tab_info = await self._get_tab_info_for_output()
+            return {
+                "result": "Error: supported control actions are "
+                "'click' or 'dblclick'",
+                "snapshot": "",
+                **tab_info,
+            }
+
+        action = {"type": "mouse_control", "control": control, "x": x, "y": y}
+
+        result = await self._exec_with_snapshot(action)
+
+        # Add tab information to the result
+        tab_info = await self._get_tab_info_for_output()
+        result.update(tab_info)
+
+        return result
+
+    @action_logger
+    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.
+        """
+        # Validate refs
+        self._validate_ref(from_ref, "drag source")
+        self._validate_ref(to_ref, "drag target")
+
+        # Get element analysis to find coordinates
+        analysis = await self._get_unified_analysis()
+        elements = analysis.get("elements", {})
+
+        if from_ref not in elements:
+            logger.error(
+                f"Error: Source element reference '{from_ref}' not found."
+            )
+            snapshot = self._format_snapshot_from_analysis(analysis)
+            tab_info = await self._get_tab_info_for_output()
+            return {
+                "result": (
+                    f"Error: Source element reference '{from_ref}' not found."
+                ),
+                "snapshot": snapshot,
+                **tab_info,
+            }
+
+        if to_ref not in elements:
+            logger.error(
+                f"Error: Target element reference '{to_ref}' not found."
+            )
+            snapshot = self._format_snapshot_from_analysis(analysis)
+            tab_info = await self._get_tab_info_for_output()
+            return {
+                "result": (
+                    f"Error: Target element reference '{to_ref}' not found."
+                ),
+                "snapshot": snapshot,
+                **tab_info,
+            }
+
+        action = {
+            "type": "mouse_drag",
+            "from_ref": from_ref,
+            "to_ref": to_ref,
+        }
+
+        result = await self._exec_with_snapshot(action)
+
+        # Add tab information to the result
+        tab_info = await self._get_tab_info_for_output()
+        result.update(tab_info)
+
+        return result
+
+    @action_logger
+    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 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.
+        """
+        if not isinstance(keys, list) or not all(
+            isinstance(item, str) for item in keys
+        ):
+            tab_info = await self._get_tab_info_for_output()
+            return {
+                "result": "Error: Expected keys as a list of strings.",
+                "snapshot": "",
+                **tab_info,
+            }
+        action = {"type": "press_key", "keys": keys}
+
+        result = await self._exec_with_snapshot(action)
+
+        # Add tab information to the result
+        tab_info = await self._get_tab_info_for_output()
+        result.update(tab_info)
+
+        return result
+
     @action_logger
     async def browser_wait_user(
         self, timeout_sec: Optional[float] = None
@@ -1830,6 +1992,148 @@ class HybridBrowserToolkit(BaseToolkit, RegisteredAgentToolkit):
         await agent.process_command(task_prompt, max_steps=max_steps)
         return "Task processing finished - see stdout for detailed trace."
 
+    @action_logger
+    async def browser_console_view(self) -> Dict[str, Any]:
+        r"""View current page console logs.
+
+        Returns:
+            Dict[str, Any]: A dictionary with the result of the action:
+                - console_messages (List[Dict]) : collection of logs from the
+                browser console
+        """
+        try:
+            logs = await self._session.get_console_logs()
+            # make output JSON serializable
+            return {"console_messages": list(logs)}
+        except Exception as e:
+            logger.warning(f"Failed to retrieve logs: {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 for execution.
+
+        Returns:
+            Dict[str, Any]: A dictionary with the result of the action:
+                - "result" (str): Result of the action.
+                - "console_output" (List[str]): Console log outputs during
+                  execution.
+                - "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.
+        """
+        page = await self._require_page()
+
+        try:
+            logger.info("Executing JavaScript code in browser console.")
+            exec_start = time.time()
+
+            # Wrap the code to capture console.log output and handle
+            # expressions
+            wrapped_code = (
+                """
+                (function() {
+                    const _logs = [];
+                    const originalLog = console.log;
+                    console.log = function(...args) {
+                        _logs.push(args.map(arg => {
+                            try {
+                                return typeof arg === 'object' ?
+                                    JSON.stringify(arg) : String(arg);
+                            } catch (e) {
+                                return String(arg);
+                            }
+                        }).join(' '));
+                        originalLog.apply(console, args);
+                    };
+                    
+                    let result;
+                    try {
+                        // First try to evaluate as an expression
+                        // (like browser console)
+                        result = eval("""
+                + repr(code)
+                + """);
+                    } catch (e) {
+                        // If that fails, execute as statements
+                        try {
+                            result = (function() { """
+                + code
+                + """ })();
+                        } catch (error) {
+                            console.log = originalLog;
+                            throw error;
+                        }
+                    }
+                    
+                    console.log = originalLog;
+                    return { result, logs: _logs };
+                })()
+            """
+            )
+
+            eval_result = await page.evaluate(wrapped_code)
+            result = eval_result.get('result')
+            console_logs = eval_result.get('logs', [])
+
+            exec_time = time.time() - exec_start
+            logger.info(f"Code execution completed in {exec_time:.2f}s.")
+
+            import asyncio
+            import json
+
+            await asyncio.sleep(0.2)
+
+            # Get snapshot
+            logger.info("Capturing page snapshot after code execution.")
+            snapshot_start = time.time()
+            snapshot = await self._session.get_snapshot(
+                force_refresh=True, diff_only=False
+            )
+            snapshot_time = time.time() - snapshot_start
+            logger.info(
+                f"Code execution snapshot captured in " f"{snapshot_time:.2f}s"
+            )
+
+            # Get tab information
+            tab_info = await self._get_tab_info_for_output()
+
+            # Properly serialize the result
+            try:
+                result_str = json.dumps(result, indent=2)
+            except (TypeError, ValueError):
+                result_str = str(result)
+
+            return {
+                "result": f"Code execution result: {result_str}",
+                "console_output": console_logs,
+                "snapshot": snapshot,
+                **tab_info,
+            }
+
+        except Exception as e:
+            logger.warning(f"Code execution failed: {e}")
+            # Get tab information for error case
+            try:
+                tab_info = await self._get_tab_info_for_output()
+            except Exception:
+                tab_info = {
+                    "tabs": [],
+                    "current_tab": 0,
+                    "total_tabs": 0,
+                }
+
+            return {
+                "result": f"Code execution failed: {e}",
+                "console_output": [],
+                "snapshot": "",
+                **tab_info,
+            }
+
     def get_log_summary(self) -> Dict[str, Any]:
         r"""Get a summary of logged actions."""
         if not self.log_buffer:
@@ -2045,11 +2349,16 @@ 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_solve_task": self.browser_solve_task,
             "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,
         }
 
         enabled_tools = []

camel/toolkits/hybrid_browser_toolkit_py/snapshot.py

@@ -43,7 +43,11 @@ class PageSnapshot:
     # Public API
     # ---------------------------------------------------------------------
     async def capture(
-        self, *, force_refresh: bool = False, diff_only: bool = False
+        self,
+        *,
+        force_refresh: bool = False,
+        diff_only: bool = False,
+        viewport_limit: bool = False,
     ) -> str:
         """Return current snapshot or just the diff to previous one."""
         try:
@@ -65,7 +69,9 @@ class PageSnapshot:
             )
 
             logger.debug("Capturing page snapshot …")
-            snapshot_result = await self._get_snapshot_direct()
+            snapshot_result = await self._get_snapshot_direct(
+                viewport_limit=viewport_limit
+            )
 
             # Extract snapshot text from the unified analyzer result
             if (
@@ -111,7 +117,7 @@ class PageSnapshot:
     _snapshot_js_cache: Optional[str] = None  # class-level cache
 
     async def _get_snapshot_direct(
-        self,
+        self, viewport_limit: bool = False
     ) -> Optional[Union[str, Dict[str, Any]]]:
         r"""Evaluate the snapshot-extraction JS with simple retry logic.
 
@@ -133,7 +139,7 @@ class PageSnapshot:
         retries: int = 3
         while retries > 0:
             try:
-                return await self.page.evaluate(js_code)
+                return await self.page.evaluate(js_code, viewport_limit)
             except Exception as e:
                 msg = str(e)