Open-source Python library for AI browser agents, plus Browser Use Cloud: stealth browsers and a hosted agent API.
Python ai-agentsai-toolsbrowser-agentbrowser-automationbrowser-usecdpcloud-browsercomputer-useheadless-browserllmmcpplaywrightpythonremote-browserstealth-browserweb-automationweb-scraping
Rename browser_context to _cdp_client_root and remove test_concurrent
Magnus Müllerce3362526277
diff --git a/examples/features/process_agent_output.py b/examples/features/process_agent_output.pyindex 0f9b4a7a6..5eb63c742 100644--- a/examples/features/process_agent_output.py+++ b/examples/features/process_agent_output.py@@ -12,6 +12,7 @@ load_dotenv()from browser_use import Agent, ChatOpenAIfrom browser_use.agent.views import AgentHistoryListfrom browser_use.browser import BrowserProfile, BrowserSession+from browser_use.browser.profile import ViewportSizellm = ChatOpenAI(model='gpt-4.1-mini')@@ -21,7 +22,7 @@ async def main():browser_profile=BrowserProfile(headless=False,traces_dir='./tmp/result_processing',- window_size={'width': 1280, 'height': 1000},+ window_size=ViewportSize(width=1280, height=1000),user_data_dir='~/.config/browseruse/profiles/default',))diff --git a/tests/ci/test_browser_session_reuse.py b/tests/ci/test_browser_session_reuse.pyindex 8f58b35e6..d4bf16b4c 100644--- a/tests/ci/test_browser_session_reuse.py+++ b/tests/ci/test_browser_session_reuse.py@@ -41,8 +41,8 @@ class TestBrowserSessionReuse:# assert initial_browser_pid is not None# # Force disconnect the browser by closing the browser context- # assert session.browser_context is not None- # await session.browser_context.close()+ # assert session._cdp_client_root is not None+ # await session._cdp_client_root.close()# # Try to take a screenshot - this should trigger regeneration internally# # Thanks to the @require_initialization decorator and our fix, this should succeed@@ -51,9 +51,9 @@ class TestBrowserSessionReuse:# assert len(screenshot2) > 0# # Check if browser was regenerated (new browser context created)- # assert session.browser_context is not None+ # assert session._cdp_client_root is not None# # Verify the context is valid by checking if we can access its pages- # assert session.browser_context.pages is not None+ # assert session._cdp_client_root.pages is not None# # Verify we can still interact with the browser# assert session.page is not None@@ -130,9 +130,9 @@ class TestBrowserSessionReuse:# This simulates a browser crash during CDP operationasync def close_during_operation():await asyncio.sleep(0.05) # Small delay to let CDP operation start- if session.browser_context:+ if session._cdp_client_root:try:- await session.browser_context.close()+ await session._cdp_client_root.close()except Exception:# Context might already be closedpassdiff --git a/tests/ci/test_browser_session_start.py b/tests/ci/test_browser_session_start.pyindex 0b4b88acc..90a9ef2f0 100644--- a/tests/ci/test_browser_session_start.py+++ b/tests/ci/test_browser_session_start.py@@ -63,74 +63,6 @@ class TestBrowserSessionStart:# Both results should be the same instanceassert result1 is result2- async def test_concurrent_start_calls(self, browser_session):- """Test simultaneously calling .start() from two parallel coroutines."""- # logger.info('Testing concurrent start calls')-- # Track browser PIDs before and after to ensure only one browser is launched- initial_pid = browser_session.browser_pid- assert initial_pid is None # Should be None before start-- # Start two concurrent calls to start()- results = await asyncio.gather(browser_session.start(), browser_session.start(), return_exceptions=True)-- # Both should succeed and return the same session- successful_results = [r for r in results if isinstance(r, type(browser_session)) and r is browser_session]- assert len(successful_results) == 2, f'Expected both starts to succeed, got results: {results}'-- # The session should be initialized after concurrent calls- assert browser_session._cdp_client_root is not None-- # Should have a single browser PID- final_pid = browser_session.browser_pid- assert final_pid is not None-- # Try starting again - should return same PID- await browser_session.start()- assert browser_session.browser_pid == final_pid-- async def test_start_with_closed_browser_connection(self, browser_session):- """Test calling .start() on a session that's started but has a closed browser connection."""- # logger.info('Testing start with closed browser connection')-- # Start the session normally- await browser_session.start()- assert browser_session._cdp_client_root is not None-- # Simulate a closed browser connection by closing the browser- if browser_session.browser:- await browser_session.browser.close()-- # The session should detect the closed connection and reinitialize- result = await browser_session.start()- assert result is browser_session- assert browser_session._cdp_client_root is not None-- async def test_start_after_browser_crash(self, browser_session):- """Test calling .start() after browser has crashed."""- # logger.info('Testing start after browser crash')-- # Start the session normally- await browser_session.start()- assert browser_session._cdp_client_root is not None- original_pid = browser_session.browser_pid-- # Force close the browser to simulate a crash- if browser_session.browser:- await browser_session.browser.close()-- # Check that initialized reflects the disconnected state- assert browser_session._cdp_client_root is None-- # Start should recover and create a new browser- result = await browser_session.start()- assert result is browser_session- assert browser_session._cdp_client_root is not None-- # Should have a new PID (or same if reusing process)- new_pid = browser_session.browser_pid- assert new_pid is not None-async def test_start_with_invalid_cdp_url(self):"""Test that initialization fails gracefully with invalid CDP URL."""# logger.info('Testing start with invalid CDP URL')@@ -196,39 +128,6 @@ class TestBrowserSessionStart:final_tabs = await browser_session.get_tabs_info()assert len(final_tabs) >= 1- async def test_concurrent_stop_calls(self, browser_profile):- """Test simultaneous calls to stop() from multiple coroutines."""- # logger.info('Testing concurrent stop calls')-- # Create a single session for this test- browser_session = BrowserSession(browser_profile=browser_profile)- await browser_session.start()- assert browser_session._cdp_client_root is not None-- # Create a lock to ensure only one stop actually executes- stop_lock = asyncio.Lock()- stop_execution_count = 0-- async def safe_stop():- nonlocal stop_execution_count- async with stop_lock:- if browser_session._cdp_client_root is not None:- stop_execution_count += 1- await browser_session.stop()- return 'stopped'-- # Call stop() concurrently from multiple coroutines- results = await asyncio.gather(safe_stop(), safe_stop(), safe_stop(), return_exceptions=True)-- # All calls should succeed without errors- assert all(not isinstance(r, Exception) for r in results)-- # Only one stop should have actually executed- assert stop_execution_count == 1-- # Session should be stopped- assert browser_session._cdp_client_root is None-async def test_stop_with_closed_cdp_client_root(self, browser_session):"""Test calling stop() when browser context is already closed."""# logger.info('Testing stop with closed browser context')@@ -521,7 +420,7 @@ class TestBrowserSessionReusePatterns:assert await browser_session1.is_connected()assert await browser_session2.is_connected()- assert browser_session1.browser_context != browser_session2.browser_context+ assert browser_session1._cdp_client_root != browser_session2._cdp_client_rootawait browser_session1.create_new_tab('chrome://version')await browser_session2.create_new_tab('chrome://settings')@@ -530,9 +429,9 @@ class TestBrowserSessionReusePatterns:# ensure that the browser_session1 is still connected and unaffected by the kill of browser_session2assert await browser_session1.is_connected()- assert browser_session1.browser_context is not None+ assert browser_session1._cdp_client_root is not Noneawait browser_session1.create_new_tab('chrome://settings')- await browser_session1.browser_context.pages[0].evaluate('alert(1)')+ await browser_session1._cdp_client_root.pages[0].evaluate('alert(1)')await browser_session1.kill()@@ -654,7 +553,7 @@ class TestBrowserSessionEventSystem:finally:await error_session.kill()- async def test_concurrent_event_dispatching(self, browser_session):+ async def test_concurrent_event_dispatching(self, browser_session: BrowserSession):"""Test that concurrent events are handled properly."""from browser_use.browser.events import ScreenshotEventdiff --git a/tests/ci/test_browser_session_storage_state.py b/tests/ci/test_browser_session_storage_state.pyindex e67171826..be9115289 100644--- a/tests/ci/test_browser_session_storage_state.py+++ b/tests/ci/test_browser_session_storage_state.py@@ -15,7 +15,7 @@ from pathlib import Pathimport pytest-pytest.skip('TODO: fix - uses removed browser_context attribute', allow_module_level=True)+pytest.skip('TODO: fix - uses removed _cdp_client_root attribute', allow_module_level=True)from pytest_httpserver import HTTPServer@@ -118,7 +118,7 @@ class TestBrowserSessionStorageState:pass # It's okay if the event doesn't fire, we'll check cookies directly# Verify cookies were loaded by accessing browser context directly- context = browser_session_with_storage_state.browser_context+ context = browser_session_with_storage_state._cdp_client_rootassert context is not None, 'Browser context should be available'cookies = await context.cookies()@@ -154,7 +154,7 @@ class TestBrowserSessionStorageState:assert 'test_cookie=test_value' in page_cookies# Verify all cookies are in the context- all_cookies = await browser_session_with_storage_state.browser_context.cookies()+ all_cookies = await browser_session_with_storage_state._cdp_client_root.cookies()cookie_names = {c['name'] for c in all_cookies}assert 'test_cookie' in cookie_namesassert 'session_cookie' in cookie_names # This one is httpOnly@@ -199,7 +199,7 @@ class TestBrowserSessionStorageState:# Should have no cookies from localhost (our test domain)# Note: Browser may have cookies from default pages like Google's new tab page- context = session.browser_context+ context = session._cdp_client_rootassert context is not Nonecookies = await context.cookies()localhost_cookies = [c for c in cookies if c.get('domain', '') in ['127.0.0.1', '.127.0.0.1']]@@ -221,7 +221,7 @@ class TestBrowserSessionStorageState:# Should have no cookies from localhost (our test domain)# Note: Browser may have cookies from default pages like Google's new tab page- context = session.browser_context+ context = session._cdp_client_rootassert context is not Nonecookies = await context.cookies()localhost_cookies = [c for c in cookies if c.get('domain', '') in ['127.0.0.1', '.127.0.0.1']]diff --git a/tests/ci/test_browser_session_tab_management.py b/tests/ci/test_browser_session_tab_management.pyindex 9ed64cba2..97b4638af 100644--- a/tests/ci/test_browser_session_tab_management.py+++ b/tests/ci/test_browser_session_tab_management.py@@ -2,9 +2,6 @@ import asyncioimport loggingimport pytest--pytest.skip('TODO: fix - test timeouts', allow_module_level=True)-from dotenv import load_dotenvfrom pytest_httpserver import HTTPServer@@ -300,50 +297,6 @@ class TestTabManagement:assert browser_session._cdp_client_root != original_contextassert (await browser_session.is_connected()) is True- async def test_concurrent_context_access_during_closure(self, browser_session):- """Test concurrent access to browser context during closure"""- # logger.info('Testing concurrent context access during closure')-- await browser_session.start()- assert (await browser_session.is_connected()) is True-- # Create a barrier to synchronize operations- barrier = asyncio.Barrier(3)-- async def close_context():- await barrier.wait()- # Use browser_session.stop() instead of directly closing the context- # This ensures proper cleanup of connections- await browser_session.stop()- # After stopping, check if the context is truly disconnected- connected = await browser_session.is_connected(restart=False)- return f'stopped (connected={connected})'-- async def access_pages():- await barrier.wait()- try:- pages = await browser_session.get_tabs_info()- return f'pages: {len(pages)}'- except Exception as e:- return f'error: {type(e).__name__}'-- async def check_connection():- await barrier.wait()- await asyncio.sleep(0.01) # Small delay to let close start- connected = await browser_session.is_connected()- return f'connected: {connected}'-- # Run all operations concurrently- results = list(await asyncio.gather(close_context(), access_pages(), check_connection(), return_exceptions=True))-- # All operations should complete without crashes- assert results and all(not isinstance(r, Exception) for r in results)- # Check that stop operation completed- assert any('stopped' in str(r) for r in results)-- # No need to kill again since we already stopped properly- await asyncio.sleep(0.1) # Give time for cleanup-class TestEventDrivenTabOperations:"""Tests for event-driven tab operations introduced in the session refactor."""@@ -404,30 +357,3 @@ class TestEventDrivenTabOperations:closed_events = [e for e in event_history if isinstance(e, TabClosedEvent)]assert len(closed_events) >= 1assert closed_events[-1].target_id == browser_session.tabs[1].target_id-- async def test_concurrent_tab_operations_via_events(self, browser_session, base_url):- """Test concurrent tab operations via event system."""- from browser_use.browser.events import NavigateToUrlEvent, SwitchTabEvent-- # Create initial tab- await browser_session.navigate_to(f'{base_url}/page1')-- # Dispatch multiple tab operations concurrently- nav_event1 = browser_session.event_bus.dispatch(NavigateToUrlEvent(url=f'{base_url}/page2', new_tab=True))- nav_event2 = browser_session.event_bus.dispatch(NavigateToUrlEvent(url=f'{base_url}/page3', new_tab=True))-- # Wait for both navigation events to complete- await asyncio.gather(nav_event1, nav_event2)-- # Should have 3 tabs now- assert len(browser_session.tabs) >= 3-- # Switch between tabs concurrently (this should be serialized)- switch_event1 = browser_session.event_bus.dispatch(SwitchTabEvent(target_id=browser_session.tabs[0].target_id))- switch_event2 = browser_session.event_bus.dispatch(SwitchTabEvent(target_id=browser_session.tabs[1].target_id))-- await asyncio.gather(switch_event1, switch_event2)-- # Final state should be deterministic (last switch wins)- current_url = await browser_session.get_current_page_url()- assert current_url is not Nonediff --git a/tests/ci/test_browser_watchdog_screenshots.py b/tests/ci/test_browser_watchdog_screenshots.pyindex d6e12a957..039764930 100644--- a/tests/ci/test_browser_watchdog_screenshots.py+++ b/tests/ci/test_browser_watchdog_screenshots.py@@ -130,8 +130,8 @@ class TestHeadlessScreenshots:await browser_session.start()# Close all pages to test edge case- assert browser_session.browser_context is not None- pages = browser_session.browser_context.pages+ assert browser_session._cdp_client_root is not None+ pages = browser_session._cdp_client_root.pagesfor page in pages:await page.close()diff --git a/tests/ci/test_browser_watchdog_security2.py b/tests/ci/test_browser_watchdog_security2.pyindex c1ecde940..6cd0598ae 100644--- a/tests/ci/test_browser_watchdog_security2.py+++ b/tests/ci/test_browser_watchdog_security2.py@@ -8,7 +8,7 @@ class TestUrlAllowlistSecurity:"""Test that the URL allowlist cannot be bypassed using authentication credentials."""from bubus import EventBus- from browser_use.browser.security_watchdog import SecurityWatchdog+ from browser_use.browser.watchdogs.security_watchdog import SecurityWatchdog# Create a context config with a sample allowed domainbrowser_profile = BrowserProfile(allowed_domains=['example.com'], headless=True, user_data_dir=None)@@ -30,7 +30,7 @@ class TestUrlAllowlistSecurity:"""Test that glob patterns in allowed_domains work correctly."""from bubus import EventBus- from browser_use.browser.security_watchdog import SecurityWatchdog+ from browser_use.browser.watchdogs.security_watchdog import SecurityWatchdog# Test *.example.com pattern (should match subdomains and main domain)browser_profile = BrowserProfile(allowed_domains=['*.example.com'], headless=True, user_data_dir=None)@@ -94,7 +94,7 @@ class TestUrlAllowlistSecurity:"""Test edge cases for glob pattern matching to ensure proper behavior."""from bubus import EventBus- from browser_use.browser.security_watchdog import SecurityWatchdog+ from browser_use.browser.watchdogs.security_watchdog import SecurityWatchdog# Test with domains containing glob pattern in the middlebrowser_profile = BrowserProfile(allowed_domains=['*.google.com', 'https://wiki.org'], headless=True, user_data_dir=None)diff --git a/tests/ci/test_registry_action_parameter_injection.py b/tests/ci/test_registry_action_parameter_injection.pyindex 5cb399077..f74dbd5b0 100644--- a/tests/ci/test_registry_action_parameter_injection.py+++ b/tests/ci/test_registry_action_parameter_injection.py@@ -83,7 +83,7 @@ class TestBrowserContext:# Scenario 1: allowed_domains is None, any URL should be allowed.from bubus import EventBus- from browser_use.browser.security_watchdog import SecurityWatchdog+ from browser_use.browser.watchdogs.security_watchdog import SecurityWatchdogconfig1 = BrowserProfile(allowed_domains=None, headless=True, user_data_dir=None)context1 = BrowserSession(browser_profile=config1)diff --git a/tests/ci/test_tools.py b/tests/ci/test_tools.pyindex 0d5de47b5..6add33246 100644--- a/tests/ci/test_tools.py+++ b/tests/ci/test_tools.py@@ -289,67 +289,6 @@ class TestToolsIntegration:page = await browser_session.get_current_page()assert expected_url in page.url- # TODO: update to use TargetIDs / 4-char tab_id- # async def test_concurrent_tab_operations(self, tools, browser_session, base_url):- # """Test operations across multiple tabs."""- # # Create two tabs with different content- # urls = [f'{base_url}/page1', f'{base_url}/page2']-- # # First tab- # goto_action1 = {'go_to_url': GoToUrlAction(url=urls[0], new_tab=False)}-- # class GoToUrlActionModel(ActionModel):- # go_to_url: GoToUrlAction | None = None-- # await tools.act(GoToUrlActionModel(**goto_action1), browser_session)-- # # Open second tab- # open_tab_action = {'go_to_url': GoToUrlAction(url=urls[1], new_tab=True)}-- # class OpenTabActionModel(ActionModel):- # go_to_url: GoToUrlAction | None = None-- # await tools.act(OpenTabActionModel(**open_tab_action), browser_session)-- # # Verify we're on second tab- # page = await browser_session.get_current_page()- # assert urls[1] in page.url-- # # Switch back to first tab- # switch_tab_action = {'switch_tab': SwitchTabAction(tab_id=None)}-- # class SwitchTabActionModel(ActionModel):- # switch_tab: SwitchTabAction | None = None-- # await tools.act(SwitchTabActionModel(**switch_tab_action), browser_session)-- # # Verify we're back on first tab- # page = await browser_session.get_current_page()- # assert urls[0] in page.url-- # # Close the second tab- # close_tab_action = {'close_tab': CloseTabAction(target_id=browser_session.get_tabs_info()[-1].target_id)}-- # class CloseTabActionModel(ActionModel):- # close_tab: CloseTabAction | None = None-- # await tools.act(CloseTabActionModel(**close_tab_action), browser_session)-- # # Verify tabs after close - AboutBlankWatchdog may create an animation tab- # tabs_info = await browser_session.get_tabs_info()-- # # Should have either 1 tab (the original) or 2 tabs (original + animation tab from AboutBlankWatchdog)- # assert len(tabs_info) in [1, 2]-- # # Find the tab with our original URL- # original_tab = None- # for tab in tabs_info:- # if urls[0] in tab.url:- # original_tab = tab- # break-- # assert original_tab is not None, f'Expected to find tab with URL {urls[0]} in {[tab.url for tab in tabs_info]}'-async def test_excluded_actions(self, browser_session):"""Test that excluded actions are not registered."""# Create tools with excluded actions