Change to async browser

browser.py

@@ -1,9 +1,11 @@
 import subprocess
+import anyio
 from contextlib import contextmanager
 from typing import List, Optional
 from threading import Lock
 from smolagents.tools import Tool
 from langchain_community.tools.playwright.utils import (
+    create_async_playwright_browser,
     create_sync_playwright_browser
 )
 from langchain_community.agent_toolkits import PlayWrightBrowserToolkit
@@ -26,6 +28,21 @@ 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()
+        
+        # Create toolkit and tools
+        browser_toolkit = PlayWrightBrowserToolkit.from_browser(
+            async_browser=async_browser,
+            sync_browser=None  # Don't use sync browser
+        )
+        return [
+            Tool.from_langchain(tool) 
+            for tool in browser_toolkit.get_tools()
+        ]
+    
     @contextmanager
     def get_browser_tools(self):
         """Get browser tools in a context that ensures proper cleanup"""
@@ -33,18 +50,16 @@ class BrowserManager:
             if self._browser_tools is None:
                 with self._lock:
                     if self._browser_tools is None:
-                        # Create only sync browser
-                        sync_browser = create_sync_playwright_browser()
+                        # Create new event loop for this thread if needed
+                        try:
+                            loop = anyio.get_current_loop()
+                        except RuntimeError:
+                            # Create new event loop in this thread
+                            loop = anyio.new_event_loop()
+                            anyio.set_event_loop(loop)
                         
-                        # Create toolkit with only sync browser
-                        browser_toolkit = PlayWrightBrowserToolkit.from_browser(
-                            sync_browser=sync_browser,
-                            async_browser=None
-                        )
-                        self._browser_tools = [
-                            Tool.from_langchain(tool) 
-                            for tool in browser_toolkit.get_tools()
-                        ]
+                        # Create tools in the event loop
+                        self._browser_tools = loop.run_until_complete(self._create_async_tools())
             
             yield self._browser_tools
             
@@ -59,7 +74,9 @@ class BrowserManager:
                 for tool in self._browser_tools:
                     if hasattr(tool, 'browser'):
                         try:
-                            tool.browser.close()
+                            # Run cleanup in event loop
+                            loop = anyio.get_current_loop()
+                            loop.run_until_complete(tool.browser.close())
                         except:
                             pass
                 self._browser_tools = None

mini_agents.py

@@ -9,6 +9,9 @@ from browser import browser_manager
 import os
 import logging
 import yaml
+import anyio
+from typing import List, Optional
+from smolagents.tools import Tool
 
 logging.basicConfig(level=logging.DEBUG)
 
@@ -166,22 +169,34 @@ class MasterAgentWrapper:
             description="This agent is responsible for managing audio, vlm, arithmetic and pandas agents."
         )
     
+    async def _run_with_browser_tools(self, question: str, browser_tools: List[Tool]) -> str:
+        """Async method to 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 async run
+            result = await self.master_agent.arun(question)
+            return result
+        finally:
+            # Restore original tools
+            self.master_agent.tools = original_tools
+    
     def run(self, question: str) -> str:
         """Run the agent with thread-safe browser tools"""
         try:
             # Get browser tools in the correct context
             with browser_manager.get_browser_tools() as browser_tools:
-                # Temporarily add browser tools for this run
-                original_tools = self.master_agent.tools
-                self.master_agent.tools = original_tools + browser_tools
-                
+                # Get or create event loop
                 try:
-                    # Run the agent (using sync run since we're using sync browser)
-                    result = self.master_agent.run(question)
-                    return result
-                finally:
-                    # Restore original tools
-                    self.master_agent.tools = original_tools
+                    loop = anyio.get_current_loop()
+                except RuntimeError:
+                    loop = anyio.new_event_loop()
+                    anyio.set_event_loop(loop)
+                
+                # Run with browser tools in async context
+                return loop.run_until_complete(self._run_with_browser_tools(question, browser_tools))
                     
         except Exception as e:
             logging.error(f"Error in master agent run: {e}")