optexity-browser-use 0.9.5__py3-none-any.whl

browser_use/sync/service.py

@@ -0,0 +1,161 @@
+"""
+Cloud sync service for sending events to the Browser Use cloud.
+"""
+
+import logging
+
+import httpx
+from bubus import BaseEvent
+
+from browser_use.config import CONFIG
+from browser_use.sync.auth import TEMP_USER_ID, DeviceAuthClient
+
+logger = logging.getLogger(__name__)
+
+
+class CloudSync:
+	"""Service for syncing events to the Browser Use cloud"""
+
+	def __init__(self, base_url: str | None = None, allow_session_events_for_auth: bool = False):
+		# Backend API URL for all API requests - can be passed directly or defaults to env var
+		self.base_url = base_url or CONFIG.BROWSER_USE_CLOUD_API_URL
+		self.auth_client = DeviceAuthClient(base_url=self.base_url)
+		self.session_id: str | None = None
+		self.allow_session_events_for_auth = allow_session_events_for_auth
+		self.auth_flow_active = False  # Flag to indicate auth flow is running
+		# Check if cloud sync is actually enabled - if not, we should remain silent
+		self.enabled = CONFIG.BROWSER_USE_CLOUD_SYNC
+
+	async def handle_event(self, event: BaseEvent) -> None:
+		"""Handle an event by sending it to the cloud"""
+		try:
+			# If cloud sync is disabled, don't handle any events
+			if not self.enabled:
+				return
+
+			# Extract session ID from CreateAgentSessionEvent
+			if event.event_type == 'CreateAgentSessionEvent' and hasattr(event, 'id'):
+				self.session_id = str(event.id)  # type: ignore
+
+			# Send events based on authentication status and context
+			if self.auth_client.is_authenticated:
+				# User is authenticated - send all events
+				await self._send_event(event)
+			elif self.allow_session_events_for_auth:
+				# Special case: allow ALL events during auth flow
+				await self._send_event(event)
+				# Mark auth flow as active when we see a session event
+				if event.event_type == 'CreateAgentSessionEvent':
+					self.auth_flow_active = True
+			else:
+				# User is not authenticated and no auth in progress - don't send anything
+				logger.debug(f'Skipping event {event.event_type} - user not authenticated')
+
+		except Exception as e:
+			logger.error(f'Failed to handle {event.event_type} event: {type(e).__name__}: {e}', exc_info=True)
+
+	async def _send_event(self, event: BaseEvent) -> None:
+		"""Send event to cloud API"""
+		try:
+			headers = {}
+
+			# Override user_id only if it's not already set to a specific value
+			# This allows CLI and other code to explicitly set temp user_id when needed
+			if self.auth_client and self.auth_client.is_authenticated:
+				# Only override if we're fully authenticated and event doesn't have temp user_id
+				current_user_id = getattr(event, 'user_id', None)
+				if current_user_id != TEMP_USER_ID:
+					setattr(event, 'user_id', str(self.auth_client.user_id))
+			else:
+				# Set temp user_id if not already set
+				if not hasattr(event, 'user_id') or not getattr(event, 'user_id', None):
+					setattr(event, 'user_id', TEMP_USER_ID)
+
+			# Add auth headers if available
+			if self.auth_client:
+				headers.update(self.auth_client.get_headers())
+
+			# Send event (batch format with direct BaseEvent serialization)
+			async with httpx.AsyncClient() as client:
+				# Serialize event and add device_id to all events
+				event_data = event.model_dump(mode='json')
+				if self.auth_client and self.auth_client.device_id:
+					event_data['device_id'] = self.auth_client.device_id
+
+				response = await client.post(
+					f'{self.base_url.rstrip("/")}/api/v1/events',
+					json={'events': [event_data]},
+					headers=headers,
+					timeout=10.0,
+				)
+
+				if response.status_code >= 400:
+					# Log error but don't raise - we want to fail silently
+					logger.debug(
+						f'Failed to send sync event: POST {response.request.url} {response.status_code} - {response.text}'
+					)
+		except httpx.TimeoutException:
+			logger.debug(f'Event send timed out after 10 seconds: {event}')
+		except httpx.ConnectError as e:
+			# logger.warning(f'⚠️ Failed to connect to cloud service at {self.base_url}: {e}')
+			pass
+		except httpx.HTTPError as e:
+			logger.debug(f'HTTP error sending event {event}: {type(e).__name__}: {e}')
+		except Exception as e:
+			logger.debug(f'Unexpected error sending event {event}: {type(e).__name__}: {e}')
+
+	# async def _update_wal_user_ids(self, session_id: str) -> None:
+	# 	"""Update user IDs in WAL file after authentication"""
+	# 	try:
+	# 		assert self.auth_client, 'Cloud sync must be authenticated to update WAL user ID'
+
+	# 		wal_path = CONFIG.BROWSER_USE_CONFIG_DIR / 'events' / f'{session_id}.jsonl'
+	# 		if not await anyio.Path(wal_path).exists():
+	# 			raise FileNotFoundError(
+	# 				f'CloudSync failed to update saved event user_ids after auth: Agent EventBus WAL file not found: {wal_path}'
+	# 			)
+
+	# 		# Read all events
+	# 		events = []
+	# 		content = await anyio.Path(wal_path).read_text()
+	# 		for line in content.splitlines():
+	# 			if line.strip():
+	# 				events.append(json.loads(line))
+
+	# 		# Update user_id and device_id
+	# 		user_id = self.auth_client.user_id
+	# 		device_id = self.auth_client.device_id
+	# 		for event in events:
+	# 			if 'user_id' in event:
+	# 				event['user_id'] = user_id
+	# 			# Add device_id to all events
+	# 			event['device_id'] = device_id
+
+	# 		# Write back
+	# 		updated_content = '\n'.join(json.dumps(event) for event in events) + '\n'
+	# 		await anyio.Path(wal_path).write_text(updated_content)
+
+	# 	except Exception as e:
+	# 		logger.warning(f'Failed to update WAL user IDs: {e}')
+
+	def set_auth_flow_active(self) -> None:
+		"""Mark auth flow as active to allow all events"""
+		self.auth_flow_active = True
+
+	async def authenticate(self, show_instructions: bool = True) -> bool:
+		"""Authenticate with the cloud service"""
+		# If cloud sync is disabled, don't authenticate
+		if not self.enabled:
+			return False
+
+		# Check if already authenticated first
+		if self.auth_client.is_authenticated:
+			import logging
+
+			logger = logging.getLogger(__name__)
+			if show_instructions:
+				logger.info('✅ Already authenticated! Skipping OAuth flow.')
+			return True
+
+		# Not authenticated - run OAuth flow
+		return await self.auth_client.authenticate(agent_session_id=self.session_id, show_instructions=show_instructions)

browser_use/telemetry/__init__.py

@@ -0,0 +1,51 @@
+"""
+Telemetry for Browser Use.
+"""
+
+from typing import TYPE_CHECKING
+
+# Type stubs for lazy imports
+if TYPE_CHECKING:
+	from browser_use.telemetry.service import ProductTelemetry
+	from browser_use.telemetry.views import (
+		BaseTelemetryEvent,
+		CLITelemetryEvent,
+		MCPClientTelemetryEvent,
+		MCPServerTelemetryEvent,
+	)
+
+# Lazy imports mapping
+_LAZY_IMPORTS = {
+	'ProductTelemetry': ('browser_use.telemetry.service', 'ProductTelemetry'),
+	'BaseTelemetryEvent': ('browser_use.telemetry.views', 'BaseTelemetryEvent'),
+	'CLITelemetryEvent': ('browser_use.telemetry.views', 'CLITelemetryEvent'),
+	'MCPClientTelemetryEvent': ('browser_use.telemetry.views', 'MCPClientTelemetryEvent'),
+	'MCPServerTelemetryEvent': ('browser_use.telemetry.views', 'MCPServerTelemetryEvent'),
+}
+
+
+def __getattr__(name: str):
+	"""Lazy import mechanism for telemetry components."""
+	if name in _LAZY_IMPORTS:
+		module_path, attr_name = _LAZY_IMPORTS[name]
+		try:
+			from importlib import import_module
+
+			module = import_module(module_path)
+			attr = getattr(module, attr_name)
+			# Cache the imported attribute in the module's globals
+			globals()[name] = attr
+			return attr
+		except ImportError as e:
+			raise ImportError(f'Failed to import {name} from {module_path}: {e}') from e
+
+	raise AttributeError(f"module '{__name__}' has no attribute '{name}'")
+
+
+__all__ = [
+	'BaseTelemetryEvent',
+	'ProductTelemetry',
+	'CLITelemetryEvent',
+	'MCPClientTelemetryEvent',
+	'MCPServerTelemetryEvent',
+]

browser_use/telemetry/service.py

@@ -0,0 +1,112 @@
+import logging
+import os
+
+from dotenv import load_dotenv
+from posthog import Posthog
+from uuid_extensions import uuid7str
+
+from browser_use.telemetry.views import BaseTelemetryEvent
+from browser_use.utils import singleton
+
+load_dotenv()
+
+from browser_use.config import CONFIG
+
+logger = logging.getLogger(__name__)
+
+
+POSTHOG_EVENT_SETTINGS = {
+	'process_person_profile': True,
+}
+
+
+@singleton
+class ProductTelemetry:
+	"""
+	Service for capturing anonymized telemetry data.
+
+	If the environment variable `ANONYMIZED_TELEMETRY=False`, anonymized telemetry will be disabled.
+	"""
+
+	USER_ID_PATH = str(CONFIG.BROWSER_USE_CONFIG_DIR / 'device_id')
+	PROJECT_API_KEY = 'phc_F8JMNjW1i2KbGUTaW1unnDdLSPCoyc52SGRU0JecaUh'
+	HOST = 'https://eu.i.posthog.com'
+	UNKNOWN_USER_ID = 'UNKNOWN'
+
+	_curr_user_id = None
+
+	def __init__(self) -> None:
+		telemetry_disabled = not CONFIG.ANONYMIZED_TELEMETRY
+		self.debug_logging = CONFIG.BROWSER_USE_LOGGING_LEVEL == 'debug'
+
+		if telemetry_disabled:
+			self._posthog_client = None
+		else:
+			logger.info('Using anonymized telemetry, see https://docs.browser-use.com/development/telemetry.')
+			self._posthog_client = Posthog(
+				project_api_key=self.PROJECT_API_KEY,
+				host=self.HOST,
+				disable_geoip=False,
+				enable_exception_autocapture=True,
+			)
+
+			# Silence posthog's logging
+			if not self.debug_logging:
+				posthog_logger = logging.getLogger('posthog')
+				posthog_logger.disabled = True
+
+		if self._posthog_client is None:
+			logger.debug('Telemetry disabled')
+
+	def capture(self, event: BaseTelemetryEvent) -> None:
+		if self._posthog_client is None:
+			return
+
+		self._direct_capture(event)
+
+	def _direct_capture(self, event: BaseTelemetryEvent) -> None:
+		"""
+		Should not be thread blocking because posthog magically handles it
+		"""
+		if self._posthog_client is None:
+			return
+
+		try:
+			self._posthog_client.capture(
+				distinct_id=self.user_id,
+				event=event.name,
+				properties={**event.properties, **POSTHOG_EVENT_SETTINGS},
+			)
+		except Exception as e:
+			logger.error(f'Failed to send telemetry event {event.name}: {e}')
+
+	def flush(self) -> None:
+		if self._posthog_client:
+			try:
+				self._posthog_client.flush()
+				logger.debug('PostHog client telemetry queue flushed.')
+			except Exception as e:
+				logger.error(f'Failed to flush PostHog client: {e}')
+		else:
+			logger.debug('PostHog client not available, skipping flush.')
+
+	@property
+	def user_id(self) -> str:
+		if self._curr_user_id:
+			return self._curr_user_id
+
+		# File access may fail due to permissions or other reasons. We don't want to
+		# crash so we catch all exceptions.
+		try:
+			if not os.path.exists(self.USER_ID_PATH):
+				os.makedirs(os.path.dirname(self.USER_ID_PATH), exist_ok=True)
+				with open(self.USER_ID_PATH, 'w') as f:
+					new_user_id = uuid7str()
+					f.write(new_user_id)
+				self._curr_user_id = new_user_id
+			else:
+				with open(self.USER_ID_PATH) as f:
+					self._curr_user_id = f.read()
+		except Exception:
+			self._curr_user_id = 'UNKNOWN_USER_ID'
+		return self._curr_user_id

browser_use/telemetry/views.py

@@ -0,0 +1,101 @@
+from abc import ABC, abstractmethod
+from collections.abc import Sequence
+from dataclasses import asdict, dataclass
+from typing import Any, Literal
+
+from browser_use.config import is_running_in_docker
+
+
+@dataclass
+class BaseTelemetryEvent(ABC):
+	@property
+	@abstractmethod
+	def name(self) -> str:
+		pass
+
+	@property
+	def properties(self) -> dict[str, Any]:
+		props = {k: v for k, v in asdict(self).items() if k != 'name'}
+		# Add Docker context if running in Docker
+		props['is_docker'] = is_running_in_docker()
+		return props
+
+
+@dataclass
+class AgentTelemetryEvent(BaseTelemetryEvent):
+	# start details
+	task: str
+	model: str
+	model_provider: str
+	max_steps: int
+	max_actions_per_step: int
+	use_vision: bool | Literal['auto']
+	version: str
+	source: str
+	cdp_url: str | None
+	agent_type: str | None  # 'code' for CodeAgent, None for regular Agent
+	# step details
+	action_errors: Sequence[str | None]
+	action_history: Sequence[list[dict] | None]
+	urls_visited: Sequence[str | None]
+	# end details
+	steps: int
+	total_input_tokens: int
+	total_output_tokens: int
+	prompt_cached_tokens: int
+	total_tokens: int
+	total_duration_seconds: float
+	success: bool | None
+	final_result_response: str | None
+	error_message: str | None
+	# judge details
+	judge_verdict: bool | None = None
+	judge_reasoning: str | None = None
+	judge_failure_reason: str | None = None
+
+	name: str = 'agent_event'
+
+
+@dataclass
+class MCPClientTelemetryEvent(BaseTelemetryEvent):
+	"""Telemetry event for MCP client usage"""
+
+	server_name: str
+	command: str
+	tools_discovered: int
+	version: str
+	action: str  # 'connect', 'disconnect', 'tool_call'
+	tool_name: str | None = None
+	duration_seconds: float | None = None
+	error_message: str | None = None
+
+	name: str = 'mcp_client_event'
+
+
+@dataclass
+class MCPServerTelemetryEvent(BaseTelemetryEvent):
+	"""Telemetry event for MCP server usage"""
+
+	version: str
+	action: str  # 'start', 'stop', 'tool_call'
+	tool_name: str | None = None
+	duration_seconds: float | None = None
+	error_message: str | None = None
+	parent_process_cmdline: str | None = None
+
+	name: str = 'mcp_server_event'
+
+
+@dataclass
+class CLITelemetryEvent(BaseTelemetryEvent):
+	"""Telemetry event for CLI usage"""
+
+	version: str
+	action: str  # 'start', 'message_sent', 'task_completed', 'error'
+	mode: str  # 'interactive', 'oneshot', 'mcp_server'
+	model: str | None = None
+	model_provider: str | None = None
+	duration_seconds: float | None = None
+	error_message: str | None = None
+
+	name: str = 'cli_event'

browser_use/tokens/custom_pricing.py

@@ -0,0 +1,24 @@
+"""
+Custom model pricing for models not available in LiteLLM's pricing data.
+
+Prices are per token (not per 1M tokens).
+"""
+
+from typing import Any
+
+# Custom model pricing data
+# Format matches LiteLLM's model_prices_and_context_window.json structure
+CUSTOM_MODEL_PRICING: dict[str, dict[str, Any]] = {
+	'bu-1-0': {
+		'input_cost_per_token': 0.2 / 1_000_000,  # $0.50 per 1M tokens
+		'output_cost_per_token': 2.00 / 1_000_000,  # $3.00 per 1M tokens
+		'cache_read_input_token_cost': 0.02 / 1_000_000,  # $0.10 per 1M tokens
+		'cache_creation_input_token_cost': None,  # Not specified
+		'max_tokens': None,  # Not specified
+		'max_input_tokens': None,  # Not specified
+		'max_output_tokens': None,  # Not specified
+	}
+}
+CUSTOM_MODEL_PRICING['bu-latest'] = CUSTOM_MODEL_PRICING['bu-1-0']
+
+CUSTOM_MODEL_PRICING['smart'] = CUSTOM_MODEL_PRICING['bu-1-0']

browser_use/tokens/mappings.py

@@ -0,0 +1,4 @@
+# Mapping from model_name to LiteLLM model name
+MODEL_TO_LITELLM: dict[str, str] = {
+	'gemini-flash-latest': 'gemini/gemini-flash-latest',
+}