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
Add Rust agent logging helper parity
Magnus Müller6d14b73c26f2
diff --git a/RUST_AGENT_INTEGRATION_FEATURES.md b/RUST_AGENT_INTEGRATION_FEATURES.mdindex 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.pyindex 3ab0456a8..32e460c38 100644--- a/browser_use/rust/service.py+++ b/browser_use/rust/service.py@@ -14,6 +14,7 @@ from collections.abc import Awaitable, Callablefrom datetime import datetimefrom pathlib import Pathfrom typing import Any, Generic, Literal+from urllib.parse import urlparsefrom bubus import EventBusfrom pydantic import BaseModel, ValidationError@@ -38,10 +39,11 @@ from browser_use.browser.views import BrowserStateHistory, TabInfofrom browser_use.filesystem.file_system import FileSystemfrom browser_use.screenshots.service import ScreenshotServicefrom browser_use.telemetry.service import ProductTelemetry+from browser_use.telemetry.views import AgentTelemetryEventfrom browser_use.tokens.service import TokenCostfrom browser_use.tokens.views import ModelUsageStats, UsageSummaryfrom 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_versionAgentStructuredOutput = 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.pyindex 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 MessageManagerfrom browser_use.rust import Agent