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

camel/toolkits/hybrid_browser_toolkit_py/actions.py

@@ -73,6 +73,9 @@ class ActionExecutor:
                 "extract": self._extract,
                 "scroll": self._scroll,
                 "enter": self._enter,
+                "mouse_control": self._mouse_control,
+                "mouse_drag": self._mouse_drag,
+                "press_key": self._press_key,
             }.get(action_type)
 
             if handler is None:
@@ -382,6 +385,150 @@ class ActionExecutor:
             "details": details,
         }
 
+    async def _mouse_control(self, action: Dict[str, Any]) -> Dict[str, Any]:
+        r"""Handle mouse_control action based on the coordinates"""
+        control = action.get("control", "click")
+        x_coord = action.get("x", 0)
+        y_coord = action.get("y", 0)
+
+        details = {
+            "action_type": "mouse_control",
+            "target": f"coordinates : ({x_coord}, {y_coord})",
+        }
+        try:
+            if not self._valid_coordinates(x_coord, y_coord):
+                raise ValueError(
+                    "Invalid coordinates, outside viewport bounds :"
+                    f"({x_coord}, {y_coord})"
+                )
+            match control:
+                case "click":
+                    await self.page.mouse.click(x_coord, y_coord)
+                    message = "Action 'click' performed on the target"
+
+                case "right_click":
+                    await self.page.mouse.click(
+                        x_coord, y_coord, button="right"
+                    )
+                    message = "Action 'right_click' performed on the target"
+
+                case "dblclick":
+                    await self.page.mouse.dblclick(x_coord, y_coord)
+                    message = "Action 'dblclick' performed on the target"
+
+                case _:
+                    return {
+                        "message": f"Invalid control action {control}",
+                        "details": details,
+                    }
+
+            return {"message": message, "details": details}
+        except Exception as e:
+            return {"message": f"Action failed: {e}", "details": details}
+
+    async def _mouse_drag(self, action: Dict[str, Any]) -> Dict[str, Any]:
+        r"""Handle mouse_drag action using ref IDs"""
+        from_ref = action.get("from_ref")
+        to_ref = action.get("to_ref")
+
+        if not from_ref or not to_ref:
+            return {
+                "message": "Error: mouse_drag requires from_ref and to_ref",
+                "details": {"error": "missing_refs"},
+            }
+
+        from_selector = f"[aria-ref='{from_ref}']"
+        to_selector = f"[aria-ref='{to_ref}']"
+
+        details = {
+            "action_type": "mouse_drag",
+            "from_ref": from_ref,
+            "to_ref": to_ref,
+            "from_selector": from_selector,
+            "to_selector": to_selector,
+        }
+
+        try:
+            # Get the source element
+            from_element = self.page.locator(from_selector)
+            from_count = await from_element.count()
+            if from_count == 0:
+                raise ValueError(
+                    f"Source element with ref '{from_ref}' not found"
+                )
+
+            # Get the target element
+            to_element = self.page.locator(to_selector)
+            to_count = await to_element.count()
+            if to_count == 0:
+                raise ValueError(
+                    f"Target element with ref '{to_ref}' not found"
+                )
+
+            # Get bounding boxes
+            from_box = await from_element.first.bounding_box()
+            to_box = await to_element.first.bounding_box()
+
+            if not from_box:
+                raise ValueError(
+                    f"Could not get bounding box for source element "
+                    f"with ref '{from_ref}'"
+                )
+            if not to_box:
+                raise ValueError(
+                    f"Could not get bounding box for target element "
+                    f"with ref '{to_ref}'"
+                )
+
+            # Calculate center coordinates
+            from_x = from_box['x'] + from_box['width'] / 2
+            from_y = from_box['y'] + from_box['height'] / 2
+            to_x = to_box['x'] + to_box['width'] / 2
+            to_y = to_box['y'] + to_box['height'] / 2
+
+            details.update(
+                {
+                    "from_coordinates": {"x": from_x, "y": from_y},
+                    "to_coordinates": {"x": to_x, "y": to_y},
+                }
+            )
+
+            # Perform the drag operation
+            await self.page.mouse.move(from_x, from_y)
+            await self.page.mouse.down()
+            # Destination coordinates
+            await self.page.mouse.move(to_x, to_y)
+            await self.page.mouse.up()
+
+            return {
+                "message": (
+                    f"Dragged from element [ref={from_ref}] to element "
+                    f"[ref={to_ref}]"
+                ),
+                "details": details,
+            }
+        except Exception as e:
+            return {"message": f"Action failed: {e}", "details": details}
+
+    async def _press_key(self, action: Dict[str, Any]) -> Dict[str, Any]:
+        r"""Handle press_key action by combining the keys in a list."""
+        keys = action.get("keys", [])
+        if not keys:
+            return {
+                "message": "Error: No keys specified",
+                "details": {"action_type": "press_key", "keys": ""},
+            }
+        combined_keys = "+".join(keys)
+        details = {"action_type": "press_key", "keys": combined_keys}
+        try:
+            await self.page.keyboard.press(combined_keys)
+            return {
+                "message": "Pressed keys in the browser",
+                "details": details,
+            }
+        except Exception as e:
+            return {"message": f"Action failed: {e}", "details": details}
+
     # utilities
     async def _wait_dom_stable(self) -> None:
         r"""Wait for DOM to become stable before executing actions."""
@@ -402,6 +549,17 @@ class ActionExecutor:
         except Exception:
             pass  # Don't fail if wait times out
 
+    def _valid_coordinates(self, x_coord: float, y_coord: float) -> bool:
+        r"""Validate given coordinates against viewport bounds."""
+        viewport = self.page.viewport_size
+        if not viewport:
+            raise ValueError("Viewport size not available from current page.")
+
+        return (
+            0 <= x_coord <= viewport['width']
+            and 0 <= y_coord <= viewport['height']
+        )
+
     # static helpers
     @staticmethod
     def should_update_snapshot(action: Dict[str, Any]) -> bool:

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)