Retry

browser.py

@@ -13,6 +13,7 @@ class BrowserManager:
     _instance = None
     _lock = Lock()
     _browser_tools: Optional[List[Tool]] = None
+    _loop: Optional[asyncio.AbstractEventLoop] = None
     
     def __new__(cls):
         if cls._instance is None:
@@ -37,10 +38,31 @@ class BrowserManager:
             async_browser=async_browser,
             sync_browser=None  # Don't use sync browser
         )
-        return [
+        tools = [
             Tool.from_langchain(tool) 
             for tool in browser_toolkit.get_tools()
         ]
+        
+        # Store browser reference for cleanup
+        for tool in tools:
+            tool._browser = async_browser
+            
+        return tools
+    
+    def _ensure_event_loop(self):
+        """Ensure we have a valid event loop in this thread"""
+        try:
+            loop = asyncio.get_event_loop()
+            if loop.is_running():
+                # If loop is running, we're in an async context
+                # Create a new loop for our browser tools
+                loop = asyncio.new_event_loop()
+                asyncio.set_event_loop(loop)
+        except RuntimeError:
+            # No event loop exists, create one
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+        return loop
     
     @contextmanager
     def get_browser_tools(self):
@@ -49,13 +71,9 @@ class BrowserManager:
             if self._browser_tools is None:
                 with self._lock:
                     if self._browser_tools is None:
-                        # Create new event loop for this thread if needed
-                        try:
-                            loop = asyncio.get_event_loop()
-                        except RuntimeError:
-                            # Create new event loop in this thread
-                            loop = asyncio.new_event_loop()
-                            asyncio.set_event_loop(loop)
+                        # Get or create event loop
+                        loop = self._ensure_event_loop()
+                        self._loop = loop
                         
                         # Create tools in the event loop
                         self._browser_tools = loop.run_until_complete(self._create_async_tools())
@@ -66,19 +84,21 @@ class BrowserManager:
             print(f"Error in browser context: {e}")
             # Reset tools on error
             self._browser_tools = None
+            self._loop = None
             raise
         finally:
             # Cleanup if needed
             if self._browser_tools:
                 for tool in self._browser_tools:
-                    if hasattr(tool, 'browser'):
+                    if hasattr(tool, '_browser'):
                         try:
-                            # Run cleanup in event loop
-                            loop = asyncio.get_event_loop()
-                            loop.run_until_complete(tool.browser.close())
-                        except:
-                            pass
+                            # Use the stored loop for cleanup
+                            if self._loop and not self._loop.is_closed():
+                                self._loop.run_until_complete(tool._browser.close())
+                        except Exception as e:
+                            print(f"Error during browser cleanup: {e}")
                 self._browser_tools = None
+                self._loop = None
 
 # Create a singleton instance
 browser_manager = BrowserManager()

mini_agents.py

@@ -176,8 +176,9 @@ class MasterAgentWrapper:
         self.master_agent.tools = original_tools + browser_tools
         
         try:
-            # Run the agent using sync run
-            result = self.master_agent.run(question)
+            # Run the agent using sync run, but in a way that doesn't block the event loop
+            loop = asyncio.get_running_loop()
+            result = loop.run_in_executor(None, self.master_agent.run, question)
             return result
         finally:
             # Restore original tools
@@ -188,13 +189,6 @@ class MasterAgentWrapper:
         try:
             # Get browser tools in the correct context
             with browser_manager.get_browser_tools() as browser_tools:
-                # Get or create event loop for browser tools
-                try:
-                    loop = asyncio.get_event_loop()
-                except RuntimeError:
-                    loop = asyncio.new_event_loop()
-                    asyncio.set_event_loop(loop)
-                
                 # Run with browser tools
                 # The browser tools will handle their own async operations
                 return self._run_with_browser_tools(question, browser_tools)