Skip to content

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

Add Rust agent logging helper parity

Magnus Müller6d14b73c26f2
diff --git a/RUST_AGENT_INTEGRATION_FEATURES.md b/RUST_AGENT_INTEGRATION_FEATURES.md
index 3b29965b8..a2983e1e0 100644
--- a/RUST_AGENT_INTEGRATION_FEATURES.md
+++ b/RUST_AGENT_INTEGRATION_FEATURES.md
@@ -486,10 +486,15 @@ Terminal core branch: `magnus/browser-use-rust-integration` at terminal main `ee
- Construction routes through the helper methods, and direct calls support state restoration, explicit file-system initialization, screenshot storage setup, source overrides, and Rust-terminal LLM verification compatibility.
- Proof: `test_rust_agent_exposes_setup_helper_methods`.
+96. Rust Agent logging helper parity
+ - The Rust-backed `Agent` now exposes Browser Use's run, startup, step context, action summary, step completion, final outcome, telemetry event, and action logging helpers.
+ - Telemetry is emitted from reconstructed Rust history, preserving URLs, errors, usage tokens, final result, timing, and Browser Use model/session metadata where available.
+ - Proof: `test_rust_agent_exposes_logging_helper_methods`.
+
## Current Verification
- `python3 -m py_compile 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` (69 tests)
+- `uv run pytest -q tests/ci/test_rust_agent.py` (70 tests)
- `cargo build -q -p browser-use-cli`
- `CARGO_INCREMENTAL=0 cargo test -q -p browser-use-agent selected_remote_cdp_mode_allows_remote_cdp_connect -- --nocapture`
- `CARGO_INCREMENTAL=0 cargo test -q -p browser-use-agent bare_browser_connect_resolves_to_selected_managed_mode_with_launch_args -- --nocapture`
diff --git a/browser_use/rust/service.py b/browser_use/rust/service.py
index 3ab0456a8..32e460c38 100644
--- a/browser_use/rust/service.py
+++ b/browser_use/rust/service.py
@@ -14,6 +14,7 @@ from collections.abc import Awaitable, Callable
from datetime import datetime
from pathlib import Path
from typing import Any, Generic, Literal
+from urllib.parse import urlparse
from bubus import EventBus
from pydantic import BaseModel, ValidationError
@@ -38,10 +39,11 @@ from browser_use.browser.views import BrowserStateHistory, TabInfo
from browser_use.filesystem.file_system import FileSystem
from browser_use.screenshots.service import ScreenshotService
from browser_use.telemetry.service import ProductTelemetry
+from browser_use.telemetry.views import AgentTelemetryEvent
from browser_use.tokens.service import TokenCost
from browser_use.tokens.views import ModelUsageStats, UsageSummary
from browser_use.tools.service import Tools
-from browser_use.utils import URL_PATTERN, get_browser_use_version
+from browser_use.utils import URL_PATTERN, check_latest_browser_use_version, get_browser_use_version
AgentStructuredOutput = TypeVar('AgentStructuredOutput', bound=BaseModel)
@@ -1259,6 +1261,178 @@ class Agent(Generic[AgentStructuredOutput]):
setattr(self.llm, '_verified_api_keys', True)
return True
+ async def _log_agent_run(self) -> None:
+ """Log Browser Use run metadata for the Rust-backed wrapper."""
+ self.logger.info(f'\033[34mTask: {self.task}\033[0m')
+ self.logger.debug(f'Browser-Use Library Version {self.version} ({self.source})')
+ latest_version = await check_latest_browser_use_version()
+ if latest_version and latest_version != self.version:
+ self.logger.info(
+ f'Newer version available: {latest_version} (current: {self.version}). Upgrade with: uv add browser-use@{latest_version}'
+ )
+
+ def _log_first_step_startup(self) -> None:
+ """Log the first-step startup line used by Browser Use callers."""
+ if len(self.history.history) != 0:
+ return
+ provider = getattr(self.llm, 'provider', None) or 'rust-terminal'
+ model = getattr(self.llm, 'model', None) or self.model
+ self.logger.info(
+ f'Starting a browser-use agent with version {self.version}, with provider={provider} and model={model}'
+ )
+
+ def _log_step_context(self, browser_state_summary: Any) -> None:
+ """Log current step and page context."""
+ url = getattr(browser_state_summary, 'url', '') if browser_state_summary else ''
+ url_short = url[:50] + '...' if len(url) > 50 else url
+ dom_state = getattr(browser_state_summary, 'dom_state', None)
+ selector_map = getattr(dom_state, 'selector_map', {}) if dom_state else {}
+ interactive_count = len(selector_map) if selector_map else 0
+ self.logger.info('')
+ self.logger.info(f'Step {self.state.n_steps}:')
+ self.logger.debug(f'Evaluating page with {interactive_count} interactive elements on: {url_short}')
+
+ def _log_next_action_summary(self, parsed: AgentOutput) -> None:
+ """Log a concise summary of the next action list."""
+ actions = getattr(parsed, 'action', None)
+ if not (self.logger.isEnabledFor(logging.DEBUG) and actions):
+ return
+ action_details = []
+ for action in actions:
+ action_data = action.model_dump(exclude_unset=True)
+ action_name = next(iter(action_data.keys())) if action_data else 'unknown'
+ action_params = action_data.get(action_name, {}) if action_data else {}
+ param_summary = []
+ if isinstance(action_params, dict):
+ for key, value in action_params.items():
+ if key == 'index':
+ param_summary.append(f'#{value}')
+ elif key == 'text' and isinstance(value, str):
+ text_preview = value[:30] + '...' if len(value) > 30 else value
+ param_summary.append(f'text="{text_preview}"')
+ elif key == 'url':
+ param_summary.append(f'url="{value}"')
+ elif key == 'success':
+ param_summary.append(f'success={value}')
+ elif isinstance(value, (str, int, bool)):
+ value_str = str(value)
+ value_preview = value_str[:30] + '...' if len(value_str) > 30 else value_str
+ param_summary.append(f'{key}={value_preview}')
+ param_text = f'({", ".join(param_summary)})' if param_summary else ''
+ action_details.append(f'{action_name}{param_text}')
+ self.logger.debug(f'Next actions: {", ".join(action_details)}')
+
+ def _log_step_completion_summary(self, step_start_time: float, result: list[ActionResult]) -> None:
+ """Log action count, timing, and success/failure counts for a completed step."""
+ if not result:
+ return
+ step_duration = time.time() - step_start_time
+ action_count = len(result)
+ success_count = sum(1 for item in result if not item.error)
+ failure_count = action_count - success_count
+ status_parts = []
+ if success_count > 0:
+ status_parts.append(f'success={success_count}')
+ if failure_count > 0:
+ status_parts.append(f'failed={failure_count}')
+ status_text = ' | '.join(status_parts) if status_parts else 'success=0'
+ self.logger.debug(
+ f'Step {self.state.n_steps}: Ran {action_count} action{"" if action_count == 1 else "s"} in {step_duration:.2f}s: {status_text}'
+ )
+
+ def _log_final_outcome_messages(self) -> None:
+ """Log Browser Use-style guidance for failed runs."""
+ is_successful = self.history.is_successful()
+ if is_successful is not False and is_successful is not None:
+ return
+ final_result = self.history.final_result()
+ final_result_str = str(final_result).lower() if final_result else ''
+ captcha_keywords = ['captcha', 'cloudflare', 'recaptcha', 'challenge', 'bot detection', 'access denied']
+ if any(keyword in final_result_str for keyword in captcha_keywords):
+ task_preview = self.task[:10] if len(self.task) > 10 else self.task
+ self.logger.info('')
+ self.logger.info('Failed because of CAPTCHA? For better browser stealth, try:')
+ self.logger.info(f' agent = Agent(task="{task_preview}...", browser=Browser(use_cloud=True))')
+ self.logger.info('')
+ self.logger.info('Did the Agent not work as expected? Let us fix this!')
+ self.logger.info(' Please open a short issue here: https://github.com/browser-use/browser-use/issues')
+
+ def _log_agent_event(self, max_steps: int, agent_run_error: str | None = None) -> None:
+ """Emit Browser Use telemetry for a Rust-backed run."""
+ usage = self.history.usage
+ if usage is None:
+ total_input_tokens = 0
+ total_output_tokens = 0
+ prompt_cached_tokens = 0
+ total_tokens = 0
+ else:
+ total_input_tokens = usage.total_prompt_tokens
+ total_output_tokens = usage.total_completion_tokens
+ prompt_cached_tokens = usage.total_prompt_cached_tokens
+ total_tokens = usage.total_tokens
+
+ action_history_data = []
+ for item in self.history.history:
+ if item.model_output and item.model_output.action:
+ action_history_data.append(
+ [action.model_dump(exclude_unset=True) for action in item.model_output.action if action]
+ )
+ else:
+ action_history_data.append(None)
+
+ final_result = self.history.final_result()
+ final_result_str = json.dumps(final_result) if final_result is not None else None
+ cdp_url = getattr(self.browser_session, 'cdp_url', None) if self.browser_session else None
+ model = getattr(self.llm, 'model', None) or self.model
+ provider = getattr(self.llm, 'provider', None) or 'rust-terminal'
+
+ self.telemetry.capture(
+ AgentTelemetryEvent(
+ task=self.task,
+ model=model,
+ model_provider=provider,
+ max_steps=max_steps,
+ max_actions_per_step=self.settings.max_actions_per_step,
+ use_vision=self.settings.use_vision,
+ version=self.version or '',
+ source=self.source,
+ cdp_url=urlparse(cdp_url).hostname if cdp_url else None,
+ agent_type=None,
+ action_errors=self.history.errors(),
+ action_history=action_history_data,
+ urls_visited=self.history.urls(),
+ steps=self.state.n_steps,
+ total_input_tokens=total_input_tokens,
+ total_output_tokens=total_output_tokens,
+ prompt_cached_tokens=prompt_cached_tokens,
+ total_tokens=total_tokens,
+ total_duration_seconds=self.history.total_duration_seconds(),
+ success=self.history.is_successful(),
+ final_result_response=final_result_str,
+ error_message=agent_run_error,
+ )
+ )
+
+ def _log_action(self, action: Any, action_name: str, action_num: int, total_actions: int) -> None:
+ """Log an action before execution with Browser Use-style structure."""
+ action_header = f'[{action_num}/{total_actions}] {action_name}:' if total_actions > 1 else f'{action_name}:'
+ action_data = action.model_dump(exclude_unset=True)
+ params = action_data.get(action_name, {}) if isinstance(action_data, dict) else {}
+ param_parts = []
+ if isinstance(params, dict):
+ for param_name, value in params.items():
+ if isinstance(value, str) and len(value) > 150:
+ display_value = value[:150] + '...'
+ elif isinstance(value, list) and len(str(value)) > 200:
+ display_value = str(value)[:200] + '...'
+ else:
+ display_value = value
+ param_parts.append(f'{param_name}: {display_value}')
+ if param_parts:
+ self.logger.info(f' {action_header} {", ".join(param_parts)}')
+ else:
+ self.logger.info(f' {action_header}')
+
async def run(
self,
max_steps: int = 100,
diff --git a/tests/ci/test_rust_agent.py b/tests/ci/test_rust_agent.py
index 7dcbe43cb..b675af28c 100644
--- a/tests/ci/test_rust_agent.py
+++ b/tests/ci/test_rust_agent.py
@@ -925,6 +925,89 @@ def test_rust_agent_initializes_runtime_metadata_and_observability():
assert agent.DoneAgentOutput is not None
+async def test_rust_agent_exposes_logging_helper_methods(monkeypatch):
+ import time
+
+ import browser_use.rust.service as rust_service
+ from browser_use.agent.views import ActionResult
+ from browser_use.rust import Agent
+
+ class LLM:
+ model = 'gpt-test'
+ provider = 'test-provider'
+
+ class BrowserProfile:
+ downloads_path = None
+
+ class BrowserSession:
+ cdp_url = 'wss://browser.example/devtools/browser/1'
+ browser_profile = BrowserProfile()
+
+ class FakeAction:
+ def model_dump(self, **kwargs):
+ return {'navigate': {'url': 'https://example.com', 'new_tab': False}}
+
+ class Parsed:
+ action = [FakeAction()]
+
+ class DomState:
+ selector_map = {1: object(), 2: object()}
+
+ class BrowserStateSummary:
+ url = 'https://example.com/a/very/long/path/that/will/be/shortened/in/logging'
+ dom_state = DomState()
+
+ async def no_latest_version():
+ return None
+
+ captured_events = []
+
+ class Telemetry:
+ def capture(self, event):
+ captured_events.append(event)
+
+ monkeypatch.setattr(rust_service, 'check_latest_browser_use_version', no_latest_version)
+ agent = Agent(task='Log helper parity.', llm=LLM(), browser_session=BrowserSession())
+ agent.telemetry = Telemetry()
+
+ await agent._log_agent_run()
+ agent._log_first_step_startup()
+ agent._log_step_context(BrowserStateSummary())
+ agent._log_next_action_summary(Parsed())
+ agent._log_step_completion_summary(time.time() - 1, [ActionResult(extracted_content='ok')])
+ agent._log_action(FakeAction(), 'navigate', 1, 2)
+ agent.history = rust_service._history_from_events(
+ [
+ {'event_type': 'browser.state', 'payload': {'url': 'https://example.com', 'title': 'Example'}},
+ {
+ 'event_type': 'model.usage',
+ 'payload': {'input_tokens': 11, 'cached_input_tokens': 3, 'output_tokens': 7, 'cost_usd': 0.12},
+ },
+ {'event_type': 'session.done', 'payload': {'result': 'done'}},
+ ],
+ model='gpt-test',
+ started=1.0,
+ finished=2.5,
+ output_model_schema=None,
+ process_error=None,
+ )
+ agent._sync_state_from_history()
+ agent._log_final_outcome_messages()
+ agent._log_agent_event(max_steps=9, agent_run_error='manual-error')
+
+ assert captured_events
+ assert captured_events[0].model == 'gpt-test'
+ assert captured_events[0].model_provider == 'test-provider'
+ assert captured_events[0].cdp_url == 'browser.example'
+ assert captured_events[0].action_history == [None]
+ assert captured_events[0].urls_visited == ['https://example.com']
+ assert captured_events[0].total_input_tokens == 11
+ assert captured_events[0].total_output_tokens == 7
+ assert captured_events[0].prompt_cached_tokens == 3
+ assert captured_events[0].final_result_response == '"done"'
+ assert captured_events[0].error_message == 'manual-error'
+
+
def test_rust_agent_initializes_message_manager_and_followup_state():
from browser_use.agent.message_manager.service import MessageManager
from browser_use.rust import Agent