Test

browser.py

@@ -8,6 +8,11 @@ from langchain_community.tools.playwright.utils import (
     create_async_playwright_browser,
 )
 from langchain_community.agent_toolkits import PlayWrightBrowserToolkit
+import logging
+from playwright.async_api import async_playwright
+
+logging.basicConfig(level=logging.DEBUG)
+logger = logging.getLogger(__name__)
 
 class BrowserManager:
     _instance = None
@@ -35,27 +40,42 @@ class BrowserManager:
         asyncio.set_event_loop(loop)
         
         try:
+            logger.debug("Creating async browser...")
             # Create browsers in the new loop
-            async_browser = loop.run_until_complete(create_async_playwright_browser())
+            async def create_browser():
+                playwright = await async_playwright().start()
+                return await playwright.chromium.launch(headless=True)
+            
+            async_browser = loop.run_until_complete(create_browser())
+            logger.debug("Async browser created successfully")
             
             # Create toolkit and tools
+            logger.debug("Creating browser toolkit...")
             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()
-            ]
+            logger.debug("Browser toolkit created successfully")
             
-            # Store browser reference for cleanup
-            for tool in tools:
-                tool._browser = async_browser
-                tool._loop = loop
+            logger.debug("Converting tools...")
+            tools = []
+            for tool in browser_toolkit.get_tools():
+                logger.debug(f"Converting tool: {tool.name}")
+                try:
+                    converted_tool = Tool.from_langchain(tool)
+                    converted_tool._browser = async_browser
+                    converted_tool._loop = loop
+                    tools.append(converted_tool)
+                    logger.debug(f"Successfully converted tool: {tool.name}")
+                except Exception as e:
+                    logger.error(f"Error converting tool {tool.name}: {e}")
+                    raise
                 
+            logger.debug(f"Successfully created {len(tools)} browser tools")
             return tools
+            
         except Exception as e:
-            print(f"Error creating browser tools: {e}")
+            logger.error(f"Error creating browser tools: {e}")
             if loop.is_running():
                 loop.stop()
             loop.close()
@@ -68,12 +88,14 @@ class BrowserManager:
             if self._browser_tools is None:
                 with self._lock:
                     if self._browser_tools is None:
+                        logger.debug("Creating new browser tools...")
                         self._browser_tools = self._create_browser_tools()
+                        logger.debug("Browser tools created successfully")
             
             yield self._browser_tools
             
         except Exception as e:
-            print(f"Error in browser context: {e}")
+            logger.error(f"Error in browser context: {e}")
             # Reset tools on error
             self._browser_tools = None
             raise
@@ -85,10 +107,12 @@ class BrowserManager:
                         try:
                             loop = tool._loop
                             if loop and not loop.is_closed():
+                                logger.debug("Cleaning up browser...")
                                 loop.run_until_complete(tool._browser.close())
                                 loop.close()
+                                logger.debug("Browser cleanup completed")
                         except Exception as e:
-                            print(f"Error during browser cleanup: {e}")
+                            logger.error(f"Error during browser cleanup: {e}")
                 self._browser_tools = None
 
 # Create a singleton instance