browser_tools.py
browser_tools.py
"""Browser automation tools using browser-use library."""
import asyncio
import json
from typing import Optional, Dict, Any, List
from pathlib import Path
import logging
logger = logging.getLogger(__name__)
# Browser session singleton
_browser_session = None
async def init_browser(headless: bool = False, user_data_dir: Optional[str] = None):
"""Initialize browser session."""
global _browser_session
if _browser_session is not None:
return _browser_session
try:
from browser_use import Browser
from browser_use.browser.profile import BrowserProfile
# Create browser profile
profile_data = {
'headless': headless,
'keep_alive': True,
}
if user_data_dir:
profile_data['user_data_dir'] = str(Path(user_data_dir).expanduser())
profile = BrowserProfile(**profile_data)
# Create browser session
browser = Browser(browser_profile=profile)
await browser.start()
_browser_session = browser
# Note: ChatOpenAI is initialized on-demand in browser_execute_task()
# to avoid Pydantic v2 initialization issues during browser startup
logger.info("Browser session initialized successfully")
return _browser_session
except Exception as e:
logger.error(f"Failed to initialize browser: {e}")
raise
async def close_browser():
"""Close browser session."""
global _browser_session
if _browser_session:
try:
await _browser_session.close()
_browser_session = None
logger.info("Browser session closed")
except Exception as e:
logger.error(f"Error closing browser: {e}")
async def browser_navigate(url: str, new_tab: bool = False) -> Dict[str, Any]:
"""Navigate to a URL in the browser.
Args:
url: The URL to navigate to
new_tab: Whether to open in a new tab
Returns:
Dictionary with success status and page information
"""
try:
browser = await init_browser()
if new_tab:
page = await browser.new_page(url)
else:
page = await browser.get_current_page()
await page.goto(url)
return {
"success": True,
"url": url,
"title": await page.title() if hasattr(page, 'title') else "N/A",
"message": f"Successfully navigated to {url}"
}
except Exception as e:
logger.error(f"Browser navigation failed: {e}")
return {
"success": False,
"error": str(e),
"message": f"Failed to navigate to {url}"
}
async def browser_get_content(selector: Optional[str] = None) -> Dict[str, Any]:
"""Get content from the current page.
Args:
selector: Optional CSS selector to extract specific content
Returns:
Dictionary with page content
"""
try:
browser = await init_browser()
page = await browser.get_current_page()
if selector:
# Get specific elements
elements = await page.get_elements_by_css_selector(selector)
content = []
for elem in elements[:10]: # Limit to 10 elements
try:
text = await elem.get_text()
content.append(text)
except Exception:
pass
return {
"success": True,
"content": content,
"selector": selector,
"count": len(content)
}
else:
# Get page text content
content = await page.get_text()
return {
"success": True,
"content": content[:5000], # Limit to 5000 characters
"message": "Retrieved page content"
}
except Exception as e:
logger.error(f"Failed to get content: {e}")
return {
"success": False,
"error": str(e),
"message": "Failed to retrieve page content"
}
async def browser_execute_task(task: str, max_steps: int = 20) -> Dict[str, Any]:
"""Execute a high-level browser task using the browser-use agent.
Args:
task: Natural language description of the task to perform
max_steps: Maximum number of steps the agent can take
Returns:
Dictionary with task execution results
"""
try:
from browser_use import Agent
from langchain_openai import ChatOpenAI
import os
from llm_fallback import resolve_llm
browser = await init_browser()
# Create LLM (direct OpenAI, or OpenRouter fallback when only that key is set)
try:
api_key, base_url, model = resolve_llm()
except RuntimeError as e:
return {
"success": False,
"error": str(e),
"message": "Cannot execute autonomous tasks without LLM configuration"
}
llm_kwargs = {"model": model, "api_key": api_key, "temperature": 0.7}
if base_url:
llm_kwargs["base_url"] = base_url
llm = ChatOpenAI(**llm_kwargs)
# Create and run agent
agent = Agent(
task=task,
llm=llm,
browser_session=browser,
max_steps=max_steps,
)
result = await agent.run()
return {
"success": True,
"task": task,
"result": str(result),
"message": "Task completed successfully"
}
except Exception as e:
logger.error(f"Browser task execution failed: {e}")
return {
"success": False,
"error": str(e),
"task": task,
"message": "Failed to execute browser task"
}
async def browser_screenshot(full_page: bool = False) -> Dict[str, Any]:
"""Take a screenshot of the current page.
Args:
full_page: Whether to capture the full page or just viewport
Returns:
Dictionary with screenshot path and metadata
"""
try:
browser = await init_browser()
page = await browser.get_current_page()
# Create screenshots directory
screenshot_dir = Path.home() / ".config" / "collaboration-tools" / "screenshots"
screenshot_dir.mkdir(parents=True, exist_ok=True)
# Generate filename with timestamp
import time
filename = f"screenshot_{int(time.time())}.png"
filepath = screenshot_dir / filename
# Take screenshot
await page.screenshot(path=str(filepath), full_page=full_page)
return {
"success": True,
"path": str(filepath),
"full_page": full_page,
"message": f"Screenshot saved to {filepath}"
}
except Exception as e:
logger.error(f"Screenshot failed: {e}")
return {
"success": False,
"error": str(e),
"message": "Failed to take screenshot"
}
async def browser_list_tabs() -> Dict[str, Any]:
"""List all open browser tabs.
Returns:
Dictionary with list of tabs
"""
try:
browser = await init_browser()
pages = await browser.get_pages()
tabs = []
for idx, page in enumerate(pages):
tabs.append({
"index": idx,
"url": page.url if hasattr(page, 'url') else "N/A",
"title": await page.title() if hasattr(page, 'title') else "N/A"
})
return {
"success": True,
"tabs": tabs,
"count": len(tabs),
"message": f"Found {len(tabs)} open tabs"
}
except Exception as e:
logger.error(f"Failed to list tabs: {e}")
return {
"success": False,
"error": str(e),
"message": "Failed to list browser tabs"
}