Skip to content

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

Register Rust agent run signal handler

Magnus Müllerd9f9d24d2342
diff --git a/RUST_AGENT_INTEGRATION_FEATURES.md b/RUST_AGENT_INTEGRATION_FEATURES.md
index c0faf5781..a4646602a 100644
--- a/RUST_AGENT_INTEGRATION_FEATURES.md
+++ b/RUST_AGENT_INTEGRATION_FEATURES.md
@@ -856,10 +856,15 @@ Terminal core branch: `magnus/browser-use-rust-main-integration` at terminal mai
- The wrapper logs the task and Browser Use library version through the same public helper path that callers can also invoke directly.
- Proof: `test_rust_agent_run_logs_browser_use_run_metadata`.
+169. Rust Agent run signal-handler parity
+ - Terminal-backed `Agent.run()` and direct `Agent.follow_up()` now register Browser Use's run-level signal handler around Rust terminal execution.
+ - SIGINT handling is wired to the wrapper's `pause()`, `resume()`, force-exit telemetry, telemetry flush, and cleanup-time unregister path.
+ - Proof: `test_rust_agent_run_registers_browser_use_signal_handler`.
+
## Current Verification
- `python3 -m py_compile browser_use/agent/service.py browser_use/rust/service.py browser_use/rust/__init__.py browser_use/__init__.py tests/ci/test_rust_agent.py examples/rust_agent/basic.py examples/rust_agent/real_v8_smoke.py`
-- `uv run pytest -q tests/ci/test_rust_agent.py` (140 tests)
+- `uv run pytest -q tests/ci/test_rust_agent.py` (141 tests)
- `cargo build -q -p browser-use-cli` on terminal branch `magnus/browser-use-rust-main-integration`
- `cargo test -q -p browser-use-cli run_codex_session_command_accepts_task_id_and_model -- --nocapture`
- `CARGO_INCREMENTAL=0 cargo test -q -p browser-use-agent selected_remote_cdp_mode_allows_remote_cdp_connect -- --nocapture`
diff --git a/browser_use/rust/service.py b/browser_use/rust/service.py
index fcad2bdb4..3032d358b 100644
--- a/browser_use/rust/service.py
+++ b/browser_use/rust/service.py
@@ -57,7 +57,7 @@ from browser_use.tokens.service import TokenCost
from browser_use.tokens.views import ModelUsageStats, UsageSummary
from browser_use.tools.registry.views import ActionModel
from browser_use.tools.service import Tools
-from browser_use.utils import URL_PATTERN, check_latest_browser_use_version, get_browser_use_version
+from browser_use.utils import SignalHandler, URL_PATTERN, check_latest_browser_use_version, get_browser_use_version
Context = TypeVar('Context')
@@ -2785,6 +2785,9 @@ class Agent(Generic[Context, AgentStructuredOutput]):
def _record_run_telemetry(self, max_steps: int, agent_run_error: str | None = None) -> None:
"""Record Browser Use run telemetry without allowing telemetry failures to break the run."""
+ if getattr(self, '_force_exit_telemetry_logged', False):
+ self.logger.debug('Telemetry for force exit (SIGINT) was logged by custom exit callback.')
+ return
try:
self._log_agent_event(max_steps=max_steps, agent_run_error=agent_run_error)
except Exception as exc:
@@ -2805,6 +2808,37 @@ class Agent(Generic[Context, AgentStructuredOutput]):
self.eventbus = EventBus(name=_unique_eventbus_name(self.id))
self._eventbus_stopped = False
+ def _register_run_signal_handler(self, max_steps: int) -> SignalHandler:
+ """Register Browser Use SIGINT/SIGTERM handling for a Rust-backed run."""
+ self._unregister_run_signal_handler()
+ self._force_exit_telemetry_logged = False
+
+ def on_force_exit_log_telemetry() -> None:
+ self._record_run_telemetry(max_steps=max_steps, agent_run_error='SIGINT: Cancelled by user')
+ if hasattr(self, 'telemetry') and self.telemetry:
+ self.telemetry.flush()
+ self._force_exit_telemetry_logged = True
+
+ signal_handler = SignalHandler(
+ loop=asyncio.get_event_loop(),
+ pause_callback=self.pause,
+ resume_callback=self.resume,
+ custom_exit_callback=on_force_exit_log_telemetry,
+ exit_on_second_int=True,
+ )
+ signal_handler.register()
+ self._run_signal_handler = signal_handler
+ return signal_handler
+
+ def _unregister_run_signal_handler(self) -> None:
+ signal_handler = getattr(self, '_run_signal_handler', None)
+ if signal_handler is None:
+ return
+ try:
+ signal_handler.unregister()
+ finally:
+ self._run_signal_handler = None
+
def _dispatch_run_start_events(self) -> None:
"""Emit Browser Use cloud lifecycle create events for a Rust-backed run."""
self._ensure_eventbus()
@@ -2835,6 +2869,7 @@ class Agent(Generic[Context, AgentStructuredOutput]):
async def _finalize_run_cleanup(self) -> None:
"""Mirror Browser Use run cleanup ordering."""
+ self._unregister_run_signal_handler()
await self._stop_eventbus_after_run()
await self.close()
@@ -2870,6 +2905,7 @@ class Agent(Generic[Context, AgentStructuredOutput]):
on_step_start: AgentHookFunc | None = None,
on_step_end: AgentHookFunc | None = None,
) -> AgentHistoryList[AgentStructuredOutput]:
+ self._register_run_signal_handler(max_steps)
await self._log_agent_run()
await self._call_callback(on_step_start, self)
self._initialize_run_lifecycle_state()
@@ -2952,6 +2988,8 @@ class Agent(Generic[Context, AgentStructuredOutput]):
async def follow_up(self, task: str, max_steps: int | None = None) -> AgentHistoryList[AgentStructuredOutput]:
if not self.terminal_session_id:
raise RustAgentError('No active Rust session. Call run() before follow_up().')
+ resolved_max_steps = max_steps if max_steps is not None else self.kwargs.get('max_steps', 100)
+ self._register_run_signal_handler(resolved_max_steps)
self._initialize_run_lifecycle_state()
started = time.time()
binary = find_browser_use_terminal_binary()
@@ -2980,7 +3018,6 @@ class Agent(Generic[Context, AgentStructuredOutput]):
)
self.history = self.result
self._sync_state_from_history()
- resolved_max_steps = max_steps if max_steps is not None else self.kwargs.get('max_steps', 100)
await self._log_run_usage_summary()
self._record_run_telemetry(max_steps=resolved_max_steps, agent_run_error=process_error)
self._dispatch_run_update_event()
diff --git a/tests/ci/test_rust_agent.py b/tests/ci/test_rust_agent.py
index b26664ce2..7170a4035 100644
--- a/tests/ci/test_rust_agent.py
+++ b/tests/ci/test_rust_agent.py
@@ -3076,6 +3076,78 @@ async def test_rust_agent_run_logs_browser_use_run_metadata(monkeypatch):
assert logger.errors == []
+async def test_rust_agent_run_registers_browser_use_signal_handler(monkeypatch):
+ import asyncio
+
+ import browser_use.rust.service as rust_service
+ from browser_use.rust import Agent
+
+ monkeypatch.setenv('BROWSER_USE_TERMINAL_BINARY', '/tmp/browser-use-terminal')
+ events = []
+ handlers = []
+ captured_events = []
+
+ class FakeSignalHandler:
+ def __init__(
+ self,
+ loop=None,
+ pause_callback=None,
+ resume_callback=None,
+ custom_exit_callback=None,
+ exit_on_second_int=False,
+ interruptible_task_patterns=None,
+ ):
+ assert loop is asyncio.get_event_loop()
+ self.pause_callback = pause_callback
+ self.resume_callback = resume_callback
+ self.custom_exit_callback = custom_exit_callback
+ self.exit_on_second_int = exit_on_second_int
+ handlers.append(self)
+ events.append('init')
+
+ def register(self):
+ events.append('register')
+
+ def unregister(self):
+ events.append('unregister')
+
+ class Telemetry:
+ def capture(self, event):
+ captured_events.append(event)
+
+ def flush(self):
+ events.append('flush')
+
+ monkeypatch.setattr(rust_service, 'SignalHandler', FakeSignalHandler)
+ agent = Agent(task='Handle run signals.', llm=type('LLM', (), {'model': 'gpt-test'})())
+ agent.telemetry = Telemetry()
+
+ async def fake_run_process(argv, timeout_seconds=None):
+ assert events == ['init', 'register']
+ assert len(handlers) == 1
+ assert handlers[0].exit_on_second_int is True
+ handlers[0].pause_callback()
+ assert agent.state.paused is True
+ handlers[0].resume_callback()
+ assert agent.state.paused is False
+ handlers[0].custom_exit_callback()
+ return 0, 'Session: 12345678-1234-1234-1234-123456789abc\n', ''
+
+ async def fake_load_events():
+ return [{'event_type': 'session.done', 'payload': {'result': 'handled signals'}}]
+
+ agent._run_process = fake_run_process
+ agent._load_events = fake_load_events
+
+ history = await agent.run(max_steps=4)
+
+ assert history.final_result() == 'handled signals'
+ assert events == ['init', 'register', 'flush', 'unregister']
+ assert len(captured_events) == 1
+ assert captured_events[0].max_steps == 4
+ assert captured_events[0].error_message == 'SIGINT: Cancelled by user'
+
+
async def test_rust_agent_run_logs_token_usage_summary(monkeypatch):
from browser_use.rust import Agent