timeouts

Author: miguelg719

stagehand/context.py

@@ -1,3 +1,4 @@
+import asyncio
 import os
 import weakref
 
@@ -85,20 +86,21 @@ async def init(cls, context: BrowserContext, stagehand):
 
         # Add event listener for new pages (popups, new tabs from window.open, etc.)
         def handle_page_event(pw_page):
-            instance._handle_new_page(pw_page)
+            # Playwright expects sync handler, so we schedule the async work
+            asyncio.create_task(instance._handle_new_page(pw_page))
 
         context.on("page", handle_page_event)
 
         return instance
 
-    def _handle_new_page(self, pw_page: Page):
+    async def _handle_new_page(self, pw_page: Page):
         """
         Handle new pages created by the browser (popups, window.open, etc.).
-        This runs synchronously in the event handler context.
+        Uses the page switch lock to prevent race conditions with ongoing operations.
         """
-
-        async def _async_handle():
-            try:
+        try:
+            # Use timeout to prevent indefinite blocking
+            async with asyncio.timeout(30):
                 async with self.stagehand._page_switch_lock:
                     self.stagehand.logger.debug(
                         f"Creating StagehandPage for new page with URL: {pw_page.url}",
@@ -109,26 +111,14 @@ async def _async_handle():
                     self.stagehand.logger.debug(
                         "New page detected and initialized", category="context"
                     )
-            except Exception as e:
-                self.stagehand.logger.error(
-                    f"Failed to initialize new page: {str(e)}", category="context"
-                )
-                import traceback
-
-                self.stagehand.logger.error(
-                    f"Traceback: {traceback.format_exc()}", category="context"
-                )
-
-        # Schedule the async work
-        import asyncio
-
-        try:
-            loop = asyncio.get_running_loop()
-            loop.create_task(_async_handle())
-        except RuntimeError:
-            # No event loop running, which shouldn't happen in normal operation
+        except asyncio.TimeoutError:
+            self.stagehand.logger.error(
+                f"Timeout waiting for page switch lock when handling new page: {pw_page.url}",
+                category="context",
+            )
+        except Exception as e:
             self.stagehand.logger.error(
-                "No event loop available to handle new page", category="context"
+                f"Failed to initialize new page: {str(e)}", category="context"
             )
 
     def __getattr__(self, name):

stagehand/main.py

@@ -46,8 +46,20 @@ def __init__(self, stagehand_instance):
     async def _ensure_page_stability(self):
         """Wait for any pending page switches to complete"""
         if hasattr(self._stagehand, "_page_switch_lock"):
-            async with self._stagehand._page_switch_lock:
-                pass  # Just wait for any ongoing switches
+            try:
+                # Use timeout to prevent indefinite blocking
+                async with asyncio.timeout(30):
+                    async with self._stagehand._page_switch_lock:
+                        pass  # Just wait for any ongoing switches
+            except asyncio.TimeoutError:
+                # Log the timeout and raise to let caller handle it
+                if hasattr(self._stagehand, "logger"):
+                    self._stagehand.logger.error(
+                        "Timeout waiting for page stability lock", category="live_proxy"
+                    )
+                raise RuntimeError from asyncio.TimeoutError(
+                    "Page stability lock timeout - possible deadlock detected"
+                )
 
     def __getattr__(self, name):
         """Delegate all attribute access to the current active page."""