Test

browser.py

@@ -28,41 +28,38 @@ class BrowserManager:
             subprocess.run(["bash", "scripts.sh"])
             self.initialized = True
     
-    async def _create_async_tools(self):
-        """Create async browser tools in the correct event loop"""
-        # Create browsers in the current context
-        async_browser = await create_async_playwright_browser()
+    def _create_browser_tools(self):
+        """Create browser tools in a new event loop"""
+        # Create a new event loop for browser tools
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
         
-        # Create toolkit and tools
-        browser_toolkit = PlayWrightBrowserToolkit.from_browser(
-            async_browser=async_browser,
-            sync_browser=None  # Don't use sync browser
-        )
-        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()
+            # Create browsers in the new loop
+            async_browser = loop.run_until_complete(create_async_playwright_browser())
+            
+            # Create toolkit and tools
+            browser_toolkit = PlayWrightBrowserToolkit.from_browser(
+                async_browser=async_browser,
+                sync_browser=None  # Don't use sync browser
+            )
+            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
+                tool._loop = loop
+                
+            return tools
+        except Exception as e:
+            print(f"Error creating browser tools: {e}")
             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
+                loop.stop()
+            loop.close()
+            raise
     
     @contextmanager
     def get_browser_tools(self):
@@ -71,12 +68,7 @@ class BrowserManager:
             if self._browser_tools is None:
                 with self._lock:
                     if self._browser_tools is None:
-                        # 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())
+                        self._browser_tools = self._create_browser_tools()
             
             yield self._browser_tools
             
@@ -84,21 +76,20 @@ 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') and hasattr(tool, '_loop'):
                         try:
-                            # Use the stored loop for cleanup
-                            if self._loop and not self._loop.is_closed():
-                                self._loop.run_until_complete(tool._browser.close())
+                            loop = tool._loop
+                            if loop and not loop.is_closed():
+                                loop.run_until_complete(tool._browser.close())
+                                loop.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

@@ -170,15 +170,14 @@ class MasterAgentWrapper:
         )
     
     def _run_with_browser_tools(self, question: str, browser_tools: List[Tool]) -> str:
-        """Run agent with browser tools in the current event loop"""
+        """Run agent with browser tools"""
         # Temporarily add browser tools
         original_tools = self.master_agent.tools
         self.master_agent.tools = original_tools + browser_tools
         
         try:
-            # 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)
+            # Run the agent directly since we're in a sync context
+            result = self.master_agent.run(question)
             return result
         finally:
             # Restore original tools
@@ -190,7 +189,6 @@ class MasterAgentWrapper:
             # Get browser tools in the correct context
             with browser_manager.get_browser_tools() as browser_tools:
                 # Run with browser tools
-                # The browser tools will handle their own async operations
                 return self._run_with_browser_tools(question, browser_tools)
                     
         except Exception as e: