camel-ai 0.2.71a2__py3-none-any.whl → 0.2.71a4__py3-none-any.whl

camel/toolkits/{non_visual_browser_toolkit → hybrid_browser_toolkit}/agent.py

@@ -12,24 +12,24 @@
 # limitations under the License.
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
 import json
-import logging
 import re
 from typing import TYPE_CHECKING, Any, Dict, List, Optional
 
+from camel.logger import get_logger
 from camel.models import BaseModelBackend, ModelFactory
 from camel.types import ModelPlatformType, ModelType
 
 from .actions import ActionExecutor
-from .nv_browser_session import NVBrowserSession
+from .browser_session import NVBrowserSession
 
 if TYPE_CHECKING:
     from camel.agents import ChatAgent
 
-logger = logging.getLogger(__name__)
+logger = get_logger(__name__)
 
 
 class PlaywrightLLMAgent:
-    """High-level orchestration: snapshot ↔ LLM ↔ action executor."""
+    r"""High-level orchestration: snapshot ↔ LLM ↔ action executor."""
 
     # System prompt as class constant to avoid recreation
     SYSTEM_PROMPT = """
@@ -90,8 +90,8 @@ what was accomplished
         self.action_history: List[Dict[str, Any]] = []
         if model_backend is None:
             model_backend = ModelFactory.create(
-                model_platform=ModelPlatformType.OPENAI,
-                model_type=ModelType.GPT_4O_MINI,
+                model_platform=ModelPlatformType.DEFAULT,
+                model_type=ModelType.DEFAULT,
                 model_config_dict={"temperature": 0, "top_p": 1},
             )
         self.model_backend = model_backend
@@ -99,16 +99,19 @@ what was accomplished
         self._chat_agent: Optional[ChatAgent] = None
 
     async def navigate(self, url: str) -> str:
+        r"""Navigate to a URL and return the snapshot."""
         try:
             # NVBrowserSession handles waits internally
             logger.debug("Navigated to URL: %s", url)
             await self._session.visit(url)
             return await self._session.get_snapshot(force_refresh=True)
         except Exception as exc:
-            return f"Error: could not navigate - {exc}"
+            error_msg = f"Error: could not navigate to {url} - {exc}"
+            logger.error(error_msg)
+            return error_msg
 
     def _get_chat_agent(self) -> "ChatAgent":
-        """Get or create the ChatAgent instance."""
+        r"""Get or create the ChatAgent instance."""
         from camel.agents import ChatAgent
 
         if self._chat_agent is None:
@@ -165,12 +168,16 @@ what was accomplished
         logger.warning(
             "Could not parse JSON from LLM response: %s", content[:200]
         )
+        return self._get_fallback_response("Parsing error")
+
+    def _get_fallback_response(self, error_msg: str) -> Dict[str, Any]:
+        r"""Generate a fallback response structure."""
         return {
-            "plan": ["Could not parse response"],
+            "plan": [f"Could not parse response: {error_msg}"],
             "action": {
                 "type": "finish",
                 "ref": None,
-                "summary": "Parsing error",
+                "summary": f"Parsing error: {error_msg}",
             },
         }
 
@@ -181,7 +188,7 @@ what was accomplished
         is_initial: bool,
         history: Optional[List[Dict[str, Any]]] = None,
     ) -> Dict[str, Any]:
-        """Call the LLM (via CAMEL ChatAgent) to get plan & next action."""
+        r"""Call the LLM (via CAMEL ChatAgent) to get plan & next action."""
         # Build user message
         if is_initial:
             user_content = f"Snapshot:\n{snapshot}\n\nTask: {prompt}"
@@ -208,6 +215,7 @@ what was accomplished
         return self._safe_parse_json(content)
 
     async def process_command(self, prompt: str, max_steps: int = 15):
+        r"""Process a command using LLM-guided browser automation."""
         # initial full snapshot
         full_snapshot = await self._session.get_snapshot()
         assert self._session.snapshot is not None
@@ -270,9 +278,11 @@ what was accomplished
         logger.info("Process completed with %d steps", steps)
 
     async def _run_action(self, action: Dict[str, Any]) -> str:
+        r"""Execute a single action and return the result."""
         if action.get("type") == "navigate":
             return await self.navigate(action.get("url", ""))
         return await self._session.exec_action(action)
 
     async def close(self):
+        r"""Clean up browser session and resources."""
         await self._session.close()

camel/toolkits/{non_visual_browser_toolkit/nv_browser_session.py → hybrid_browser_toolkit/browser_session.py}

@@ -57,13 +57,12 @@ class NVBrowserSession:
 
     def __new__(
         cls, *, headless: bool = True, user_data_dir: Optional[str] = None
-    ):
-        loop = asyncio.get_running_loop()
-        if loop not in cls._sessions:
-            instance = super().__new__(cls)
-            instance._initialized = False
-            cls._sessions[loop] = instance
-        return cls._sessions[loop]
+    ) -> "NVBrowserSession":
+        # Defer event loop lookup until we actually need it
+        # This allows creation outside of async context
+        instance = super().__new__(cls)
+        instance._initialized = False
+        return instance
 
     def __init__(
         self, *, headless: bool = True, user_data_dir: Optional[str] = None
@@ -90,6 +89,47 @@ class NVBrowserSession:
     # Browser lifecycle helpers
     # ------------------------------------------------------------------
     async def ensure_browser(self) -> None:
+        r"""Ensure browser is ready, implementing singleton pattern per event
+        loop.
+        """
+        # Check if we need to reuse or create a session for this event loop
+        try:
+            loop = asyncio.get_running_loop()
+        except RuntimeError as e:
+            raise RuntimeError(
+                "ensure_browser() must be called from within an async context"
+            ) from e
+
+        # Check if there's already a session for this loop
+        if loop in self._sessions and self._sessions[loop] is not self:
+            # Copy the existing session's browser resources
+            existing = self._sessions[loop]
+            # Wait for existing session to be fully initialized
+            async with existing._ensure_lock:
+                if (
+                    existing._initialized
+                    and existing._page is not None
+                    and existing._playwright is not None
+                ):
+                    try:
+                        # Verify the page is still responsive
+                        await existing._page.title()
+                        self._playwright = existing._playwright
+                        self._browser = existing._browser
+                        self._context = existing._context
+                        self._page = existing._page
+                        self.snapshot = existing.snapshot
+                        self.executor = existing.executor
+                        self._initialized = True
+                        return
+                    except Exception:
+                        # Existing session is broken, continue with new
+                        # initialization
+                        pass
+
+        # Register this instance for the current loop
+        self._sessions[loop] = self
+
         # Serialise initialisation to avoid race conditions where multiple
         # concurrent coroutine calls create multiple browser instances for
         # the same NVBrowserSession.
@@ -98,6 +138,7 @@ class NVBrowserSession:
 
     # Moved original logic to helper
     async def _ensure_browser_inner(self) -> None:
+        r"""Internal browser initialization logic."""
         from playwright.async_api import async_playwright
 
         if self._page is not None:
@@ -144,11 +185,23 @@ class NVBrowserSession:
         r"""Close all browser resources, ensuring cleanup even if some
         operations fail.
         """
-        # The close method will now only close the *current* event-loop's
-        # browser instance.  Use `close_all_sessions` for a full cleanup.
+        # Remove this session from the sessions dict and close resources
+        try:
+            loop = asyncio.get_running_loop()
+            if loop in self._sessions and self._sessions[loop] is self:
+                del self._sessions[loop]
+        except RuntimeError:
+            pass  # No running loop, that's okay
+
+        # Clean up any stale loop references
+        stale_loops = [loop for loop in self._sessions if loop.is_closed()]
+        for loop in stale_loops:
+            del self._sessions[loop]
+
         await self._close_session()
 
     async def _close_session(self) -> None:
+        r"""Internal session cleanup with comprehensive error handling."""
         errors: list[str] = []
 
         # Close context first (which closes pages)
@@ -204,6 +257,7 @@ class NVBrowserSession:
     # Convenience wrappers around common actions
     # ------------------------------------------------------------------
     async def visit(self, url: str) -> str:
+        r"""Navigate to a URL with proper error handling."""
         await self.ensure_browser()
         assert self._page is not None
 
@@ -233,7 +287,7 @@ class NVBrowserSession:
             force_refresh=force_refresh, diff_only=diff_only
         )
 
-    async def exec_action(self, action: dict[str, Any]) -> str:
+    async def exec_action(self, action: Dict[str, Any]) -> str:
         await self.ensure_browser()
         assert self.executor is not None
         return await self.executor.execute(action)