camel-ai 0.2.69a1__tar.gz → 0.2.69a3__tar.gz

{camel_ai-0.2.69a1 → camel_ai-0.2.69a3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: camel-ai
-Version: 0.2.69a1
+Version: 0.2.69a3
 Summary: Communicative Agents for AI Society Study
 Project-URL: Homepage, https://www.camel-ai.org/
 Project-URL: Repository, https://github.com/camel-ai/camel
@@ -99,6 +99,7 @@ Requires-Dist: pymupdf<2,>=1.22.5; extra == 'all'
 Requires-Dist: pyobvector>=0.1.18; extra == 'all'
 Requires-Dist: pyowm<4,>=3.3.0; extra == 'all'
 Requires-Dist: pytelegrambotapi<5,>=4.18.0; extra == 'all'
+Requires-Dist: pytesseract>=0.3.13; extra == 'all'
 Requires-Dist: pytest-asyncio<0.24,>=0.23.0; extra == 'all'
 Requires-Dist: pytest-cov<5,>=4; extra == 'all'
 Requires-Dist: pytest<8,>=7; extra == 'all'
@@ -226,6 +227,7 @@ Provides-Extra: media-tools
 Requires-Dist: ffmpeg-python<0.3,>=0.2.0; extra == 'media-tools'
 Requires-Dist: imageio[pyav]<3,>=2.34.2; extra == 'media-tools'
 Requires-Dist: pydub<0.26,>=0.25.1; extra == 'media-tools'
+Requires-Dist: pytesseract>=0.3.13; extra == 'media-tools'
 Requires-Dist: scenedetect>=0.6.5.2; extra == 'media-tools'
 Requires-Dist: yt-dlp<2025,>=2024.11.4; extra == 'media-tools'
 Provides-Extra: model-platforms
@@ -252,6 +254,7 @@ Requires-Dist: ffmpeg-python<0.3,>=0.2.0; extra == 'owl'
 Requires-Dist: fpdf>=1.7.2; extra == 'owl'
 Requires-Dist: html2text>=2024.2.26; extra == 'owl'
 Requires-Dist: imageio[pyav]<3,>=2.34.2; extra == 'owl'
+Requires-Dist: markitdown==0.1.1; extra == 'owl'
 Requires-Dist: mcp-server-fetch==2025.1.17; extra == 'owl'
 Requires-Dist: mcp-simple-arxiv==0.2.2; extra == 'owl'
 Requires-Dist: newspaper3k<0.3,>=0.2.8; extra == 'owl'
@@ -266,6 +269,7 @@ Requires-Dist: pyautogui<0.10,>=0.9.54; extra == 'owl'
 Requires-Dist: pydub<0.26,>=0.25.1; extra == 'owl'
 Requires-Dist: pylatex>=1.4.2; extra == 'owl'
 Requires-Dist: pymupdf<2,>=1.22.5; extra == 'owl'
+Requires-Dist: pytesseract>=0.3.13; extra == 'owl'
 Requires-Dist: python-dotenv<2,>=1.0.0; extra == 'owl'
 Requires-Dist: python-pptx>=1.0.2; extra == 'owl'
 Requires-Dist: requests-oauthlib<2,>=1.3.1; extra == 'owl'

{camel_ai-0.2.69a1 → camel_ai-0.2.69a3}/camel/__init__.py

@@ -14,7 +14,7 @@
 
 from camel.logger import disable_logging, enable_logging, set_log_level
 
-__version__ = '0.2.69a1'
+__version__ = '0.2.69a3'
 
 __all__ = [
     '__version__',

{camel_ai-0.2.69a1 → camel_ai-0.2.69a3}/camel/agents/chat_agent.py

@@ -1904,12 +1904,36 @@ class ChatAgent(BaseAgent):
             ChatAgent: A new instance of :obj:`ChatAgent` with the same
                 configuration.
         """
+        import copy
+
         # Create a new instance with the same configuration
         # If with_memory is True, set system_message to None
         # If with_memory is False, use the original system message
         # To avoid duplicated system memory.
         system_message = None if with_memory else self._original_system_message
 
+        # Create deep copies of tools to avoid shared state
+        cloned_tools: List[Union[FunctionTool, Callable]] = []
+        for tool in self._internal_tools.values():
+            # Create a new FunctionTool instance to avoid sharing state
+            cloned_tool = copy.deepcopy(tool)
+            cloned_tools.append(cloned_tool)
+
+        # Create deep copies of external tool schemas
+        cloned_external_tools: List[
+            Union[FunctionTool, Callable, Dict[str, Any]]
+        ] = []
+        for schema in self._external_tool_schemas.values():
+            cloned_schema = copy.deepcopy(schema)
+            cloned_external_tools.append(cloned_schema)
+
+        # Create deep copies of response terminators to avoid shared state
+        cloned_terminators: List[ResponseTerminator] = []
+        if self.response_terminators:
+            for terminator in self.response_terminators:
+                cloned_terminator = copy.deepcopy(terminator)
+                cloned_terminators.append(cloned_terminator)
+
         new_agent = ChatAgent(
             system_message=system_message,
             model=self.model_backend.models,  # Pass the existing model_backend
@@ -1919,11 +1943,9 @@ class ChatAgent(BaseAgent):
                 self.memory.get_context_creator(), "token_limit", None
             ),
             output_language=self._output_language,
-            tools=list(self._internal_tools.values()),
-            external_tools=[
-                schema for schema in self._external_tool_schemas.values()
-            ],
-            response_terminators=self.response_terminators,
+            tools=cloned_tools,
+            external_tools=cloned_external_tools,
+            response_terminators=cloned_terminators,
             scheduling_strategy=self.model_backend.scheduling_strategy.__name__,
             max_iteration=self.max_iteration,
             stop_event=self.stop_event,

{camel_ai-0.2.69a1 → camel_ai-0.2.69a3}/camel/societies/workforce/single_agent_worker.py

@@ -286,8 +286,8 @@ class SingleAgentWorker(Worker):
             )
         except Exception as e:
             print(
-                f"{Fore.RED}Error occurred while processing task {task.id}:"
-                f"\n{e}{Fore.RESET}"
+                f"{Fore.RED}Error processing task {task.id}: "
+                f"{type(e).__name__}: {e}{Fore.RESET}"
             )
             return TaskState.FAILED
         finally:
@@ -336,8 +336,15 @@ class SingleAgentWorker(Worker):
 
         print(f"======\n{Fore.GREEN}Reply from {self}:{Fore.RESET}")
 
-        result_dict = json.loads(response.msg.content)
-        task_result = TaskResult(**result_dict)
+        try:
+            result_dict = json.loads(response.msg.content)
+            task_result = TaskResult(**result_dict)
+        except json.JSONDecodeError as e:
+            print(
+                f"{Fore.RED}JSON parsing error for task {task.id}: "
+                f"Invalid response format - {e}{Fore.RESET}"
+            )
+            return TaskState.FAILED
 
         color = Fore.RED if task_result.failed else Fore.GREEN
         print(

{camel_ai-0.2.69a1 → camel_ai-0.2.69a3}/camel/societies/workforce/workforce.py

@@ -882,11 +882,16 @@ class Workforce(BaseNode):
         self._task = task
         self._state = WorkforceState.RUNNING
         task.state = TaskState.FAILED  # TODO: Add logic for OPEN
-        self._pending_tasks.append(task)
 
         # Decompose the task into subtasks first
         subtasks = self._decompose_task(task)
-        self._pending_tasks.extendleft(reversed(subtasks))
+        if subtasks:
+            # If decomposition happened, the original task becomes a container.
+            # We only execute its subtasks.
+            self._pending_tasks.extendleft(reversed(subtasks))
+        else:
+            # If no decomposition, execute the original task.
+            self._pending_tasks.append(task)
         self.set_channel(TaskChannel())
 
         # Save initial snapshot

{camel_ai-0.2.69a1 → camel_ai-0.2.69a3}/camel/toolkits/function_tool.py

@@ -531,9 +531,10 @@ class FunctionTool:
             param_dict = properties[param_name]
             if "description" not in param_dict:
                 warnings.warn(
-                    f"Parameter description is missing "
-                    f"for {param_dict}. This may affect the "
-                    f"quality of tool calling."
+                    f"Parameter description is missing for the "
+                    f"function '{openai_tool_schema['function']['name']}'. "
+                    f"The parameter definition is {param_dict}. "
+                    f"This may affect the quality of tool calling."
                 )
 
     def get_openai_tool_schema(self) -> Dict[str, Any]:

{camel_ai-0.2.69a1 → camel_ai-0.2.69a3}/camel/toolkits/non_visual_browser_toolkit/browser_non_visual_toolkit.py

@@ -15,15 +15,16 @@ from __future__ import annotations
 
 from typing import Any, Dict, List, Optional
 
+from camel.logger import get_logger
 from camel.models import BaseModelBackend
 from camel.toolkits.base import BaseToolkit
 from camel.toolkits.function_tool import FunctionTool
 
 from .agent import PlaywrightLLMAgent
-
-# session wrapper
 from .nv_browser_session import NVBrowserSession
 
+logger = get_logger(__name__)
+
 
 class BrowserNonVisualToolkit(BaseToolkit):
     r"""A lightweight, *non-visual* browser toolkit exposing primitive
@@ -52,24 +53,50 @@ class BrowserNonVisualToolkit(BaseToolkit):
         self._agent: Optional[PlaywrightLLMAgent] = None
 
     def __del__(self):
-        r"""Ensure cleanup when toolkit is garbage collected."""
-        # Note: __del__ cannot be async, so we schedule cleanup if needed
-        import asyncio
-
+        r"""Best-effort cleanup when toolkit is garbage collected.
+
+        1. We *avoid* running during the Python interpreter shutdown phase
+           (`sys.is_finalizing()`), because the import machinery and/or event
+           loop may already be torn down which leads to noisy exceptions such
+           as `ImportError: sys.meta_path is None` or
+           `RuntimeError: Event loop is closed`.
+        2. We protect all imports and event-loop operations with defensive
+           `try/except` blocks.  This ensures that, even if cleanup cannot be
+           carried out, we silently ignore the failure instead of polluting
+           stderr on program exit.
+        """
         try:
-            loop = asyncio.get_event_loop()
+            import sys
+
+            if getattr(sys, "is_finalizing", lambda: False)():
+                return  # Skip cleanup during interpreter shutdown
+
+            import asyncio
+
+            try:
+                loop = asyncio.get_event_loop()
+            except RuntimeError:
+                # No event loop in current thread → nothing to clean
+                return
+
+            if loop.is_closed():
+                # Event loop already closed → cannot run async cleanup
+                return
+
             if loop.is_running():
-                task = loop.create_task(self.close_browser())
-                # Don't wait for completion to avoid blocking
-                del task
+                try:
+                    task = loop.create_task(self.close_browser())
+                    del task  # Fire-and-forget
+                except RuntimeError:
+                    # Loop is running but not in this thread → ignore
+                    pass
             else:
+                # Own the loop → safe to run
                 asyncio.run(self.close_browser())
         except Exception:
-            pass  # Don't fail during garbage collection
+            # Suppress *all* errors during garbage collection
+            pass
 
-    # ------------------------------------------------------------------
-    # Internal helpers
-    # ------------------------------------------------------------------
     async def _ensure_browser(self):
         await self._session.ensure_browser()
 
@@ -78,28 +105,26 @@ class BrowserNonVisualToolkit(BaseToolkit):
         return await self._session.get_page()
 
     def _validate_ref(self, ref: str, method_name: str) -> None:
-        """Validate that ref parameter is a non-empty string."""
+        r"""Validate that ref parameter is a non-empty string."""
         if not ref or not isinstance(ref, str):
-            raise ValueError(
+            logger.error(
                 f"{method_name}(): 'ref' must be a non-empty string, "
                 f"got: {ref}"
             )
 
-    # ------------------------------------------------------------------
-    # Tool implementations
-    # ------------------------------------------------------------------
     async def open_browser(
         self, start_url: Optional[str] = None
     ) -> Dict[str, str]:
         r"""Launch a Playwright browser session.
 
         Args:
-            start_url (Optional[str]): If provided, the page will navigate to
-                this URL immediately after the browser launches.
+            start_url (Optional[str]): Optional URL to navigate to immediately
+                after the browser launches. If not provided, the browser will
+                not navigate to any URL. (default: :obj:`None`)
 
         Returns:
             Dict[str, str]: Keys: ``result`` for action outcome,
-            ``snapshot`` for full DOM snapshot.
+                ``snapshot`` for full DOM snapshot.
         """
         await self._session.ensure_browser()
         if start_url:
@@ -128,16 +153,15 @@ class BrowserNonVisualToolkit(BaseToolkit):
         await self._session.close()
         return "Browser session closed."
 
-    # Navigation / page state ------------------------------------------------
     async def visit_page(self, url: str) -> Dict[str, str]:
-        """Navigate the current page to the specified URL.
+        r"""Navigate the current page to the specified URL.
 
         Args:
             url (str): The destination URL.
 
         Returns:
             Dict[str, str]: Keys: ``result`` for action outcome,
-            ``snapshot`` for full DOM snapshot.
+                ``snapshot`` for full DOM snapshot.
         """
         if not url or not isinstance(url, str):
             raise ValueError("visit_page(): 'url' must be a non-empty string")
@@ -155,10 +179,10 @@ class BrowserNonVisualToolkit(BaseToolkit):
 
         Args:
             force_refresh (bool): When ``True`` always re-generate the
-            snapshot even
-                if the URL has not changed.
-            diff_only (bool): If ``True`` return only the diff relative to the
-                previous snapshot.
+                snapshot even if the URL has not changed. (default:
+                :obj:`False`)
+            diff_only (bool): When ``True`` return only the diff relative to
+                the previous snapshot. (default: :obj:`False`)
 
         Returns:
             str: Formatted snapshot string.
@@ -167,13 +191,12 @@ class BrowserNonVisualToolkit(BaseToolkit):
             force_refresh=force_refresh, diff_only=diff_only
         )
 
-    # Element-level wrappers -------------------------------------------------
     async def click(self, *, ref: str) -> Dict[str, str]:
         r"""Click an element identified by ``ref``
 
         Args:
-            ref (str): Element reference ID extracted from snapshot (e.g.
-            ``"e3"``).
+            ref (str): Element reference ID extracted from snapshot
+                (e.g.``"e3"``).
 
         Returns:
             Dict[str, str]: Result message from ``ActionExecutor``.
@@ -187,8 +210,8 @@ class BrowserNonVisualToolkit(BaseToolkit):
         r"""Type text into an input or textarea element.
 
         Args:
-            ref (str): Element reference ID extracted from snapshot (e.g.
-            ``"e3"``).
+            ref (str): Element reference ID extracted from snapshot.
+                (e.g.``"e3"``).
             text (str): The text to enter.
 
         Returns:
@@ -218,67 +241,70 @@ class BrowserNonVisualToolkit(BaseToolkit):
         r"""Scroll the page.
 
         Args:
-            direction (str): ``"down"`` or ``"up"``.
+            direction (str): Scroll direction, should be ``"down"`` or
+                ``"up"``.
             amount (int): Pixel distance to scroll.
 
         Returns:
             Dict[str, str]: Execution result message.
         """
         if direction not in ("up", "down"):
-            raise ValueError("scroll(): 'direction' must be 'up' or 'down'")
+            logger.error("scroll(): 'direction' must be 'up' or 'down'")
+            return {
+                "result": "scroll() Error: 'direction' must be 'up' or 'down'"
+            }
 
         action = {"type": "scroll", "direction": direction, "amount": amount}
         return await self._exec_with_snapshot(action)
 
-    async def wait(
-        self, *, timeout_ms: int | None = None, selector: str | None = None
-    ) -> Dict[str, str]:
-        r"""Explicit wait utility.
+    async def enter(self, *, ref: str) -> Dict[str, str]:
+        r"""Press the Enter key.
 
         Args:
-            timeout_ms (Optional[int]): Milliseconds to sleep.
-            selector (Optional[str]): Wait until this CSS selector appears
-                in DOM.
+            ref (str): Element reference ID to focus before pressing.
 
         Returns:
             Dict[str, str]: Execution result message.
         """
-        # Default to 1 000 ms sleep when no arguments provided
-        if timeout_ms is None and selector is None:
-            timeout_ms = 1000
-
-        action: Dict[str, Any] = {"type": "wait"}
-        if timeout_ms is not None:
-            action["timeout"] = timeout_ms
-        if selector is not None:
-            action["selector"] = selector
+        self._validate_ref(ref, "enter")
+
+        action: Dict[str, Any] = {"type": "enter", "ref": ref}
         return await self._exec_with_snapshot(action)
 
-    async def extract(self, *, ref: str) -> Dict[str, str]:
-        r"""Extract text content from an element.
+    async def wait_user(self, *, seconds: float = 1.0) -> Dict[str, str]:
+        r"""Pause execution for a given amount of *real* time and then
+        return a *full* page snapshot.
+
+        This is a convenience wrapper around the existing wait action for
+        scenarios where you encounter a CAPTCHA or need to pause for manual
+        user input, and want to retrieve the complete DOM snapshot afterward.
 
         Args:
-            ref (str): Element reference ID obtained from snapshot.
+            seconds (float): How long to sleep, expressed in seconds. Must
+                be a positive number. (default: :obj:`1.0`)
 
         Returns:
-            Dict[str, str]: Extracted text or error message.
+            Dict[str, str]: Keys ``result`` and ``snapshot``.
         """
-        self._validate_ref(ref, "extract")
-        return await self._exec_with_snapshot({"type": "extract", "ref": ref})
+        if seconds is None or seconds <= 0:
+            logger.error("wait_time(): 'seconds' must be a positive number")
+            return {
+                "result": "wait_time(): 'seconds' must be a positive number"
+            }
 
-    async def enter(self, *, ref: str) -> Dict[str, str]:
-        r"""Press the Enter key.
+        # Reuse underlying ActionExecutor's ``wait`` implementation (expects
+        # ms)
+        timeout_ms = int(seconds * 1000)
+        action: Dict[str, Any] = {"type": "wait", "timeout": timeout_ms}
 
-        Args:
-            ref (str): Element reference ID to focus before pressing.
+        # Execute the sleep via ActionExecutor (no snapshot diff expected)
+        result = await self._exec(action)
 
-        Returns:
-            Dict[str, str]: Execution result message.
-        """
-        self._validate_ref(ref, "enter")
-
-        action: Dict[str, Any] = {"type": "enter", "ref": ref}
-        return await self._exec_with_snapshot(action)
+        # Always return a *full* snapshot after the pause
+        snapshot = await self._session.get_snapshot(
+            force_refresh=True, diff_only=False
+        )
+        return {"result": result, "snapshot": snapshot}
 
     # Helper to run through ActionExecutor
     async def _exec(self, action: Dict[str, Any]) -> str:
@@ -308,9 +334,6 @@ class BrowserNonVisualToolkit(BaseToolkit):
 
         return {"result": result, "snapshot": diff}
 
-    # ------------------------------------------------------------------
-    # Optional PlaywrightLLMAgent helpers
-    # ------------------------------------------------------------------
     def _ensure_agent(self) -> PlaywrightLLMAgent:
         r"""Create PlaywrightLLMAgent on first use if `web_agent_model`
         provided."""
@@ -332,29 +355,34 @@ class BrowserNonVisualToolkit(BaseToolkit):
         self, task_prompt: str, start_url: str, max_steps: int = 15
     ) -> str:
         r"""Use LLM agent to autonomously complete the task (requires
-        `web_agent_model`)."""
+        `web_agent_model`).
+
+        Args:
+            task_prompt (str): The task prompt to complete.
+            start_url (str): The URL to navigate to.
+            max_steps (int): The maximum number of steps to take.
+                (default: :obj:`15`)
+
+        Returns:
+            str: The result of the task.
+        """
 
         agent = self._ensure_agent()
         await agent.navigate(start_url)
         await agent.process_command(task_prompt, max_steps=max_steps)
         return "Task processing finished - see stdout for detailed trace."
 
-    # ------------------------------------------------------------------
-    # Toolkit registration
-    # ------------------------------------------------------------------
     def get_tools(self) -> List[FunctionTool]:
         base_tools = [
             FunctionTool(self.open_browser),
             FunctionTool(self.close_browser),
             FunctionTool(self.visit_page),
-            FunctionTool(self.get_page_snapshot),
             FunctionTool(self.click),
             FunctionTool(self.type),
             FunctionTool(self.select),
             FunctionTool(self.scroll),
-            FunctionTool(self.wait),
-            FunctionTool(self.extract),
             FunctionTool(self.enter),
+            FunctionTool(self.wait_user),
         ]
 
         if self.web_agent_model is not None:

{camel_ai-0.2.69a1 → camel_ai-0.2.69a3}/camel/toolkits/non_visual_browser_toolkit/nv_browser_session.py

@@ -55,10 +55,23 @@ class NVBrowserSession:
         self.snapshot: Optional[PageSnapshot] = None
         self.executor: Optional[ActionExecutor] = None
 
+        # Protect browser initialisation against concurrent calls
+        import asyncio
+
+        self._ensure_lock: "asyncio.Lock" = asyncio.Lock()
+
     # ------------------------------------------------------------------
     # Browser lifecycle helpers
     # ------------------------------------------------------------------
     async def ensure_browser(self) -> None:
+        # Serialise initialisation to avoid race conditions where multiple
+        # concurrent coroutine calls create multiple browser instances for
+        # the same NVBrowserSession.
+        async with self._ensure_lock:
+            await self._ensure_browser_inner()
+
+    # Moved original logic to helper
+    async def _ensure_browser_inner(self) -> None:
         from playwright.async_api import async_playwright
 
         if self._page is not None:
@@ -80,12 +93,27 @@ class NVBrowserSession:
             self._browser = await pl.chromium.launch(headless=self._headless)
             self._context = await self._browser.new_context()
 
+        from camel.logger import get_logger
+
+        _dbg_logger = get_logger(__name__)
+
         # Reuse an already open page (persistent context may restore last
         # session)
         if self._context.pages:
             self._page = self._context.pages[0]
         else:
             self._page = await self._context.new_page()
+
+        # Debug information to help trace concurrency issues
+        _dbg_logger.debug(
+            "Session %s created browser=%s context=%s page=%s (url=%s)",
+            hex(id(self)),
+            hex(id(self._browser)) if self._browser else None,
+            hex(id(self._context)) if self._context else None,
+            hex(id(self._page)),
+            self._page.url if self._page else "<none>",
+        )
+
         # helpers
         self.snapshot = PageSnapshot(self._page)
         self.executor = ActionExecutor(self._page)

{camel_ai-0.2.69a1 → camel_ai-0.2.69a3}/camel/toolkits/non_visual_browser_toolkit/snapshot.py

@@ -99,16 +99,65 @@ class PageSnapshot:
     _snapshot_js_cache: Optional[str] = None  # class-level cache
 
     async def _get_snapshot_direct(self) -> Optional[str]:
-        try:
-            if PageSnapshot._snapshot_js_cache is None:
-                js_path = Path(__file__).parent / "snapshot.js"
-                PageSnapshot._snapshot_js_cache = js_path.read_text(
-                    encoding="utf-8"
+        r"""Evaluate the snapshot-extraction JS with simple retry logic.
+
+        Playwright throws *Execution context was destroyed* when a new page
+        navigation happens between scheduling and evaluating the JS. In that
+        case we retry a few times after waiting for the next DOMContentLoaded
+        event; for all other exceptions we abort immediately.
+        """
+
+        # Load JS once and cache it at class level
+        if PageSnapshot._snapshot_js_cache is None:
+            js_path = Path(__file__).parent / "snapshot.js"
+            PageSnapshot._snapshot_js_cache = js_path.read_text(
+                encoding="utf-8"
+            )
+
+        js_code = PageSnapshot._snapshot_js_cache
+
+        retries: int = 3
+        while retries > 0:
+            try:
+                return await self.page.evaluate(js_code)
+            except Exception as e:
+                msg = str(e)
+
+                # Typical error when navigation happens between calls
+                nav_err = "Execution context was destroyed"
+
+                if (
+                    nav_err in msg
+                    or "Most likely because of a navigation" in msg
+                ):
+                    retries -= 1
+                    logger.debug(
+                        "Snapshot evaluate failed due to navigation; "
+                        "retrying (%d left)…",
+                        retries,
+                    )
+
+                    # Wait for next DOM stability before retrying
+                    try:
+                        await self.page.wait_for_load_state(
+                            "domcontentloaded", timeout=self.MAX_TIMEOUT_MS
+                        )
+                    except Exception:
+                        # Even if waiting fails, attempt retry to give it
+                        # one more chance
+                        pass
+
+                    continue  # retry the evaluate()
+
+                # Any other exception → abort
+                logger.warning(
+                    "Failed to execute snapshot JavaScript: %s",
+                    e,
                 )
-            return await self.page.evaluate(PageSnapshot._snapshot_js_cache)
-        except Exception as e:
-            logger.warning("Failed to execute snapshot JavaScript: %s", e)
-            return None
+                return None
+
+        logger.warning("Failed to execute snapshot JavaScript after retries")
+        return None
 
     @staticmethod
     def _format_snapshot(text: str) -> str: