Skip to content

Open-source Python library for AI browser agents, plus Browser Use Cloud: stealth browsers and a hosted agent API.

Checkpoint before follow-up message

Cursor Agent444825f307c5
diff --git a/browser_use/agent/service.py b/browser_use/agent/service.py
index d0652371d..725f80c6b 100644
--- a/browser_use/agent/service.py
+++ b/browser_use/agent/service.py
@@ -295,6 +295,10 @@ class Agent(Generic[Context, AgentStructuredOutput]):
exclude_actions = ['screenshot'] if use_vision != 'auto' else []
self.tools = Tools(exclude_actions=exclude_actions, display_files_in_done_text=display_files_in_done_text)
+ # Enforce screenshot exclusion when use_vision != 'auto', even if user passed custom tools
+ if use_vision != 'auto':
+ self.tools.exclude_action('screenshot')
+
# Structured output
self.output_model_schema = output_model_schema
if self.output_model_schema is not None:
diff --git a/browser_use/tools/registry/service.py b/browser_use/tools/registry/service.py
index f1608ff8c..d57edf46c 100644
--- a/browser_use/tools/registry/service.py
+++ b/browser_use/tools/registry/service.py
@@ -35,7 +35,23 @@ class Registry(Generic[Context]):
def __init__(self, exclude_actions: list[str] | None = None):
self.registry = ActionRegistry()
self.telemetry = ProductTelemetry()
- self.exclude_actions = exclude_actions if exclude_actions is not None else []
+ # Create a new list to avoid mutable default argument issues
+ self.exclude_actions = list(exclude_actions) if exclude_actions is not None else []
+
+ def exclude_action(self, action_name: str) -> None:
+ """Exclude an action from the registry after initialization.
+
+ If the action is already registered, it will be removed from the registry.
+ The action is also added to the exclude_actions list to prevent re-registration.
+ """
+ # Add to exclude list to prevent future registration
+ if action_name not in self.exclude_actions:
+ self.exclude_actions.append(action_name)
+
+ # Remove from registry if already registered
+ if action_name in self.registry.actions:
+ del self.registry.actions[action_name]
+ logger.debug(f'Excluded action "{action_name}" from registry')
def _get_special_param_types(self) -> dict[str, type | UnionType | None]:
"""Get the expected types for special parameters from SpecialActionParameters"""
diff --git a/browser_use/tools/service.py b/browser_use/tools/service.py
index 5547c4956..b649a983e 100644
--- a/browser_use/tools/service.py
+++ b/browser_use/tools/service.py
@@ -104,11 +104,11 @@ def handle_browser_error(e: BrowserError) -> ActionResult:
class Tools(Generic[Context]):
def __init__(
self,
- exclude_actions: list[str] = [],
+ exclude_actions: list[str] | None = None,
output_model: type[T] | None = None,
display_files_in_done_text: bool = True,
):
- self.registry = Registry[Context](exclude_actions)
+ self.registry = Registry[Context](exclude_actions if exclude_actions is not None else [])
self.display_files_in_done_text = display_files_in_done_text
"""Register all default browser actions"""
@@ -1329,6 +1329,17 @@ Validated Code (after quote fixing):
"""
return self.registry.action(description, **kwargs)
+ def exclude_action(self, action_name: str) -> None:
+ """Exclude an action from the tools registry.
+
+ This method can be used to remove actions after initialization,
+ useful for enforcing constraints like disabling screenshot when use_vision != 'auto'.
+
+ Args:
+ action_name: Name of the action to exclude (e.g., 'screenshot')
+ """
+ self.registry.exclude_action(action_name)
+
# Act --------------------------------------------------------------------
@observe_debug(ignore_input=True, ignore_output=True, name='act')
@time_execution_sync('--act')
diff --git a/tests/ci/test_screenshot_exclusion.py b/tests/ci/test_screenshot_exclusion.py
new file mode 100644
index 000000000..683dc53fd
--- /dev/null
+++ b/tests/ci/test_screenshot_exclusion.py
@@ -0,0 +1,173 @@
+"""Test that screenshot action is excluded when use_vision != 'auto'."""
+
+import pytest
+
+from browser_use.agent.service import Agent
+from browser_use.browser.profile import BrowserProfile
+from browser_use.browser.session import BrowserSession
+from browser_use.tools.service import Tools
+from tests.ci.conftest import create_mock_llm
+
+
[email protected](scope='function')
+async def browser_session():
+ session = BrowserSession(browser_profile=BrowserProfile(headless=True))
+ await session.start()
+ yield session
+ await session.kill()
+
+
+def test_screenshot_excluded_with_use_vision_false():
+ """Test that screenshot action is excluded when use_vision=False."""
+ mock_llm = create_mock_llm(actions=['{"action": [{"done": {"text": "test", "success": true}}]}'])
+
+ agent = Agent(
+ task='test',
+ llm=mock_llm,
+ use_vision=False,
+ )
+
+ # Verify screenshot is not in the registry
+ assert 'screenshot' not in agent.tools.registry.registry.actions, 'Screenshot should be excluded when use_vision=False'
+
+
+def test_screenshot_excluded_with_use_vision_true():
+ """Test that screenshot action is excluded when use_vision=True."""
+ mock_llm = create_mock_llm(actions=['{"action": [{"done": {"text": "test", "success": true}}]}'])
+
+ agent = Agent(
+ task='test',
+ llm=mock_llm,
+ use_vision=True,
+ )
+
+ # Verify screenshot is not in the registry
+ assert 'screenshot' not in agent.tools.registry.registry.actions, 'Screenshot should be excluded when use_vision=True'
+
+
+def test_screenshot_included_with_use_vision_auto():
+ """Test that screenshot action is included when use_vision='auto'."""
+ mock_llm = create_mock_llm(actions=['{"action": [{"done": {"text": "test", "success": true}}]}'])
+
+ agent = Agent(
+ task='test',
+ llm=mock_llm,
+ use_vision='auto',
+ )
+
+ # Verify screenshot IS in the registry
+ assert 'screenshot' in agent.tools.registry.registry.actions, 'Screenshot should be included when use_vision="auto"'
+
+
+def test_screenshot_excluded_with_custom_tools_and_use_vision_false():
+ """Test that screenshot action is excluded even when user passes custom tools and use_vision=False.
+
+ This is the critical test case that verifies the fix:
+ When users pass their own Tools instance with screenshot included,
+ the Agent should still enforce the exclusion if use_vision != 'auto'.
+ """
+ mock_llm = create_mock_llm(actions=['{"action": [{"done": {"text": "test", "success": true}}]}'])
+
+ # Create custom tools that includes screenshot action
+ custom_tools = Tools()
+ assert 'screenshot' in custom_tools.registry.registry.actions, 'Custom tools should have screenshot by default'
+
+ # Pass custom tools to agent with use_vision=False
+ agent = Agent(
+ task='test',
+ llm=mock_llm,
+ tools=custom_tools,
+ use_vision=False,
+ )
+
+ # Verify screenshot is excluded even though user passed custom tools
+ assert (
+ 'screenshot' not in agent.tools.registry.registry.actions
+ ), 'Screenshot should be excluded when use_vision=False, even with custom tools'
+
+
+def test_screenshot_excluded_with_custom_tools_and_use_vision_true():
+ """Test that screenshot action is excluded even when user passes custom tools and use_vision=True.
+
+ This is another critical test case:
+ When users pass their own Tools instance with screenshot included,
+ the Agent should still enforce the exclusion if use_vision != 'auto'.
+ """
+ mock_llm = create_mock_llm(actions=['{"action": [{"done": {"text": "test", "success": true}}]}'])
+
+ # Create custom tools - by default Tools() includes screenshot
+ # (unless exclude_actions is passed)
+ custom_tools = Tools()
+ # Note: We check if screenshot exists in the default set, but it might not
+ # exist if use_vision defaults have changed. The key is that after passing
+ # to Agent with use_vision=True, it should be excluded.
+ has_screenshot_before = 'screenshot' in custom_tools.registry.registry.actions
+
+ # Pass custom tools to agent with use_vision=True
+ agent = Agent(
+ task='test',
+ llm=mock_llm,
+ tools=custom_tools,
+ use_vision=True,
+ )
+
+ # Verify screenshot is excluded even though user passed custom tools
+ # The key test: screenshot should be excluded after Agent init
+ assert (
+ 'screenshot' not in agent.tools.registry.registry.actions
+ ), f'Screenshot should be excluded when use_vision=True, even with custom tools (had screenshot before: {has_screenshot_before})'
+
+
+def test_screenshot_included_with_custom_tools_and_use_vision_auto():
+ """Test that screenshot action is kept when user passes custom tools and use_vision='auto'."""
+ mock_llm = create_mock_llm(actions=['{"action": [{"done": {"text": "test", "success": true}}]}'])
+
+ # Create custom tools that includes screenshot action
+ custom_tools = Tools()
+ assert 'screenshot' in custom_tools.registry.registry.actions, 'Custom tools should have screenshot by default'
+
+ # Pass custom tools to agent with use_vision='auto'
+ agent = Agent(
+ task='test',
+ llm=mock_llm,
+ tools=custom_tools,
+ use_vision='auto',
+ )
+
+ # Verify screenshot is kept when use_vision='auto'
+ assert (
+ 'screenshot' in agent.tools.registry.registry.actions
+ ), 'Screenshot should be included when use_vision="auto", even with custom tools'
+
+
+def test_tools_exclude_action_method():
+ """Test the Tools.exclude_action() method directly."""
+ tools = Tools()
+
+ # Verify screenshot is included initially
+ assert 'screenshot' in tools.registry.registry.actions, 'Screenshot should be included by default'
+
+ # Exclude screenshot
+ tools.exclude_action('screenshot')
+
+ # Verify screenshot is excluded
+ assert 'screenshot' not in tools.registry.registry.actions, 'Screenshot should be excluded after calling exclude_action()'
+ assert 'screenshot' in tools.registry.exclude_actions, 'Screenshot should be in exclude_actions list'
+
+
+def test_exclude_action_prevents_re_registration():
+ """Test that excluded actions cannot be re-registered."""
+ tools = Tools()
+
+ # Exclude screenshot
+ tools.exclude_action('screenshot')
+ assert 'screenshot' not in tools.registry.registry.actions
+
+ # Try to re-register screenshot (simulating what happens in __init__)
+ # The decorator should skip registration since it's in exclude_actions
+ @tools.registry.action('Test screenshot action')
+ async def screenshot():
+ return 'test'
+
+ # Verify it was not re-registered
+ assert 'screenshot' not in tools.registry.registry.actions, 'Excluded action should not be re-registered'