camel-ai 0.2.71a7__py3-none-any.whl → 0.2.71a9__py3-none-any.whl

camel/toolkits/hybrid_browser_toolkit/actions.py

@@ -14,6 +14,8 @@
 import asyncio
 from typing import TYPE_CHECKING, Any, Dict, Optional
 
+from .config_loader import ConfigLoader
+
 if TYPE_CHECKING:
     from playwright.async_api import Page
 
@@ -21,15 +23,24 @@ if TYPE_CHECKING:
 class ActionExecutor:
     r"""Executes high-level actions (click, type …) on a Playwright Page."""
 
-    # Configuration constants
-    DEFAULT_TIMEOUT = 5000  # 5 seconds
-    SHORT_TIMEOUT = 2000  # 2 seconds
-    MAX_SCROLL_AMOUNT = 5000  # Maximum scroll distance in pixels
-
-    def __init__(self, page: "Page", session: Optional[Any] = None):
+    def __init__(
+        self,
+        page: "Page",
+        session: Optional[Any] = None,
+        default_timeout: Optional[int] = None,
+        short_timeout: Optional[int] = None,
+        max_scroll_amount: Optional[int] = None,
+    ):
         self.page = page
         self.session = session  # HybridBrowserSession instance
 
+        # Configure timeouts using the config file with optional overrides
+        self.default_timeout = ConfigLoader.get_action_timeout(default_timeout)
+        self.short_timeout = ConfigLoader.get_short_timeout(short_timeout)
+        self.max_scroll_amount = ConfigLoader.get_max_scroll_amount(
+            max_scroll_amount
+        )
+
     # ------------------------------------------------------------------
     # Public helpers
     # ------------------------------------------------------------------
@@ -139,7 +150,7 @@ class ActionExecutor:
         try:
             if self.session:
                 async with self.page.context.expect_page(
-                    timeout=self.SHORT_TIMEOUT
+                    timeout=self.short_timeout
                 ) as new_page_info:
                     await element.click(modifiers=["ControlOrMeta"])
                 new_page = await new_page_info.value
@@ -188,7 +199,7 @@ class ActionExecutor:
 
         # Fallback to normal force click if ctrl+click fails
         try:
-            await element.click(force=True, timeout=self.DEFAULT_TIMEOUT)
+            await element.click(force=True, timeout=self.default_timeout)
             details["click_method"] = "playwright_force_click"
             return {
                 "message": f"Fallback clicked element: {found_selector}",
@@ -224,7 +235,7 @@ class ActionExecutor:
         }
 
         try:
-            await self.page.fill(target, text, timeout=self.SHORT_TIMEOUT)
+            await self.page.fill(target, text, timeout=self.short_timeout)
             return {
                 "message": f"Typed '{text}' into {target}",
                 "details": details,
@@ -254,7 +265,7 @@ class ActionExecutor:
 
         try:
             await self.page.select_option(
-                target, value, timeout=self.DEFAULT_TIMEOUT
+                target, value, timeout=self.default_timeout
             )
             return {
                 "message": f"Selected '{value}' in {target}",
@@ -283,7 +294,7 @@ class ActionExecutor:
             details["wait_type"] = "selector"
             details["selector"] = sel
             await self.page.wait_for_selector(
-                sel, timeout=self.DEFAULT_TIMEOUT
+                sel, timeout=self.default_timeout
             )
             return {"message": f"Waited for {sel}", "details": details}
         return {
@@ -303,7 +314,7 @@ class ActionExecutor:
         target = f"[aria-ref='{ref}']"
         details = {"ref": ref, "target": target}
 
-        await self.page.wait_for_selector(target, timeout=self.DEFAULT_TIMEOUT)
+        await self.page.wait_for_selector(target, timeout=self.default_timeout)
         txt = await self.page.text_content(target)
 
         details["extracted_text"] = txt
@@ -337,9 +348,9 @@ class ActionExecutor:
             # Safely convert amount to integer and clamp to reasonable range
             amount_int = int(amount)
             amount_int = max(
-                -self.MAX_SCROLL_AMOUNT,
-                min(self.MAX_SCROLL_AMOUNT, amount_int),
-            )  # Clamp to MAX_SCROLL_AMOUNT range
+                -self.max_scroll_amount,
+                min(self.max_scroll_amount, amount_int),
+            )  # Clamp to max_scroll_amount range
             details["actual_amount"] = amount_int
         except (ValueError, TypeError):
             return {
@@ -366,7 +377,6 @@ class ActionExecutor:
 
         # Press Enter on whatever element currently has focus
         await self.page.keyboard.press("Enter")
-        await asyncio.sleep(0.3)
         return {
             "message": "Pressed Enter on focused element",
             "details": details,
@@ -378,13 +388,13 @@ class ActionExecutor:
         try:
             # Wait for basic DOM content loading
             await self.page.wait_for_load_state(
-                'domcontentloaded', timeout=self.SHORT_TIMEOUT
+                'domcontentloaded', timeout=self.short_timeout
             )
 
             # Try to wait for network idle briefly
             try:
                 await self.page.wait_for_load_state(
-                    'networkidle', timeout=self.SHORT_TIMEOUT
+                    'networkidle', timeout=self.short_timeout
                 )
             except Exception:
                 pass  # Network idle is optional

camel/toolkits/hybrid_browser_toolkit/agent.py

@@ -81,9 +81,15 @@ what was accomplished
         headless: bool = False,
         stealth: bool = False,
         model_backend: Optional[BaseModelBackend] = None,
+        default_timeout: Optional[int] = None,
+        short_timeout: Optional[int] = None,
     ):
         self._session = HybridBrowserSession(
-            headless=headless, user_data_dir=user_data_dir, stealth=stealth
+            headless=headless,
+            user_data_dir=user_data_dir,
+            stealth=stealth,
+            default_timeout=default_timeout,
+            short_timeout=short_timeout,
         )
         from camel.agents import ChatAgent
 

camel/toolkits/hybrid_browser_toolkit/browser_session.py

@@ -19,8 +19,8 @@ from typing import TYPE_CHECKING, Any, ClassVar, Dict, List, Optional, Tuple
 from camel.logger import get_logger
 
 from .actions import ActionExecutor
+from .config_loader import ConfigLoader
 from .snapshot import PageSnapshot
-from .stealth_config import StealthConfig
 
 if TYPE_CHECKING:
     from playwright.async_api import (
@@ -44,10 +44,6 @@ class HybridBrowserSession:
     This class is a singleton per event-loop and session-id combination.
     """
 
-    # Configuration constants
-    DEFAULT_NAVIGATION_TIMEOUT = 10000  # 10 seconds
-    NETWORK_IDLE_TIMEOUT = 5000  # 5 seconds
-
     # Class-level registry for singleton instances
     # Format: {(loop_id, session_id): HybridBrowserSession}
     _instances: ClassVar[Dict[Tuple[Any, str], "HybridBrowserSession"]] = {}
@@ -63,6 +59,10 @@ class HybridBrowserSession:
         user_data_dir: Optional[str] = None,
         stealth: bool = False,
         session_id: Optional[str] = None,
+        default_timeout: Optional[int] = None,
+        short_timeout: Optional[int] = None,
+        navigation_timeout: Optional[int] = None,
+        network_idle_timeout: Optional[int] = None,
     ) -> "HybridBrowserSession":
         # Create a unique key for this event loop and session combination
         # We defer the event loop lookup to avoid issues with creation
@@ -75,6 +75,10 @@ class HybridBrowserSession:
             "user_data_dir": user_data_dir,
             "stealth": stealth,
             "session_id": session_id,
+            "default_timeout": default_timeout,
+            "short_timeout": short_timeout,
+            "navigation_timeout": navigation_timeout,
+            "network_idle_timeout": network_idle_timeout,
         }
         return instance
 
@@ -126,6 +130,10 @@ class HybridBrowserSession:
         user_data_dir: Optional[str] = None,
         stealth: bool = False,
         session_id: Optional[str] = None,
+        default_timeout: Optional[int] = None,
+        short_timeout: Optional[int] = None,
+        navigation_timeout: Optional[int] = None,
+        network_idle_timeout: Optional[int] = None,
     ):
         if self._initialized:
             return
@@ -136,12 +144,27 @@ class HybridBrowserSession:
         self._stealth = stealth
         self._session_id = session_id or "default"
 
+        # Store timeout configuration for ActionExecutor instances and
+        # browser operations
+        self._default_timeout = default_timeout
+        self._short_timeout = short_timeout
+        self._navigation_timeout = ConfigLoader.get_navigation_timeout(
+            navigation_timeout
+        )
+        self._network_idle_timeout = ConfigLoader.get_network_idle_timeout(
+            network_idle_timeout
+        )
+
         # Initialize _creation_params to fix linter error
         self._creation_params = {
             "headless": headless,
             "user_data_dir": user_data_dir,
             "stealth": stealth,
             "session_id": session_id,
+            "default_timeout": default_timeout,
+            "short_timeout": short_timeout,
+            "navigation_timeout": navigation_timeout,
+            "network_idle_timeout": network_idle_timeout,
         }
 
         self._playwright: Optional[Playwright] = None
@@ -164,7 +187,8 @@ class HybridBrowserSession:
         self._stealth_config: Optional[Dict[str, Any]] = None
         if self._stealth:
             self._stealth_script = self._load_stealth_script()
-            self._stealth_config = StealthConfig.get_all_config()
+            stealth_config_class = ConfigLoader.get_stealth_config()
+            self._stealth_config = stealth_config_class.get_stealth_config()
 
     def _load_stealth_script(self) -> str:
         r"""Load the stealth JavaScript script from file."""
@@ -231,9 +255,7 @@ class HybridBrowserSession:
         # Navigate if URL provided
         if url:
             try:
-                await new_page.goto(
-                    url, timeout=self.DEFAULT_NAVIGATION_TIMEOUT
-                )
+                await new_page.goto(url, timeout=self._navigation_timeout)
                 await new_page.wait_for_load_state('domcontentloaded')
             except Exception as e:
                 logger.warning(f"Failed to navigate new tab to {url}: {e}")
@@ -319,7 +341,12 @@ class HybridBrowserSession:
             await self._page.bring_to_front()
 
             # Update executor and snapshot for new tab
-            self.executor = ActionExecutor(self._page, self)
+            self.executor = ActionExecutor(
+                self._page,
+                self,
+                default_timeout=self._default_timeout,
+                short_timeout=self._short_timeout,
+            )
             self.snapshot = PageSnapshot(self._page)
 
             logger.info(f"Switched to tab {tab_index}")
@@ -506,14 +533,17 @@ class HybridBrowserSession:
                 logger.warning(f"Failed to apply stealth script: {e}")
 
         # Set up timeout for navigation
-        self._page.set_default_navigation_timeout(
-            self.DEFAULT_NAVIGATION_TIMEOUT
-        )
-        self._page.set_default_timeout(self.DEFAULT_NAVIGATION_TIMEOUT)
+        self._page.set_default_navigation_timeout(self._navigation_timeout)
+        self._page.set_default_timeout(self._navigation_timeout)
 
         # Initialize utilities
         self.snapshot = PageSnapshot(self._page)
-        self.executor = ActionExecutor(self._page, self)
+        self.executor = ActionExecutor(
+            self._page,
+            self,
+            default_timeout=self._default_timeout,
+            short_timeout=self._short_timeout,
+        )
         self._current_tab_index = 0
 
         logger.info("Browser session initialized successfully")
@@ -579,7 +609,7 @@ class HybridBrowserSession:
                         await page.close()
                         logger.debug(
                             f"Closed page: "
-                            f"{page.url if hasattr(page, 'url') else 'unknown'}"  # noqa: E501
+                            f"{page.url if hasattr(page, 'url') else 'unknown'}"  # noqa:E501
                         )
                 except Exception as e:
                     logger.warning(f"Error closing page: {e}")
@@ -668,13 +698,13 @@ class HybridBrowserSession:
         await self.ensure_browser()
         page = await self.get_page()
 
-        await page.goto(url, timeout=self.DEFAULT_NAVIGATION_TIMEOUT)
+        await page.goto(url, timeout=self._navigation_timeout)
         await page.wait_for_load_state('domcontentloaded')
 
         # Try to wait for network idle
         try:
             await page.wait_for_load_state(
-                'networkidle', timeout=self.NETWORK_IDLE_TIMEOUT
+                'networkidle', timeout=self._network_idle_timeout
             )
         except Exception:
             logger.debug("Network idle timeout - continuing anyway")