Skip to content

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

Merge branch 'main' into kalil0321/demo-mode

kalil03210988199776fd
diff --cc browser_use/actor/page.py
index 9ebb27c14,ab8eecbb1..c912e2291
--- a/browser_use/actor/page.py
+++ b/browser_use/actor/page.py
@@@ -405,11 -405,11 +405,12 @@@ class Page
dom_service = self.dom_service
- enhanced_dom_tree = await dom_service.get_dom_tree(target_id=self._target_id)
+ # Lazy fetch all_frames inside get_dom_tree if needed (for cross-origin iframes)
+ enhanced_dom_tree, _ = await dom_service.get_dom_tree(target_id=self._target_id, all_frames=None)
+ session_id = self._browser_session.id
serialized_dom_state, _ = DOMTreeSerializer(
- enhanced_dom_tree, None, paint_order_filtering=True
+ enhanced_dom_tree, None, paint_order_filtering=True, session_id=session_id
).serialize_accessible_elements()
llm_representation = serialized_dom_state.llm_representation()
diff --cc browser_use/agent/service.py
index 8a4f5e666,1144f5635..652997c45
--- a/browser_use/agent/service.py
+++ b/browser_use/agent/service.py
@@@ -840,17 -855,21 +870,22 @@@ class Agent(Generic[Context, AgentStruc
# Handle all other exceptions
include_trace = self.logger.isEnabledFor(logging.DEBUG)
error_msg = AgentError.format_error(error, include_trace=include_trace)
- prefix = f'❌ Result failed {self.state.consecutive_failures + 1}/{self.settings.max_failures + int(self.settings.final_response_after_failure)} times:\n '
+ max_total_failures = self.settings.max_failures + int(self.settings.final_response_after_failure)
+ prefix = f'❌ Result failed {self.state.consecutive_failures + 1}/{max_total_failures} times: '
self.state.consecutive_failures += 1
+ # Use WARNING for partial failures, ERROR only when max failures reached
+ is_final_failure = self.state.consecutive_failures >= max_total_failures
+ log_level = logging.ERROR if is_final_failure else logging.WARNING
+
if 'Could not parse response' in error_msg or 'tool_use_failed' in error_msg:
# give model a hint how output should look like
- logger.error(f'Model: {self.llm.model} failed')
- logger.error(f'{prefix}{error_msg}')
+ self.logger.log(log_level, f'Model: {self.llm.model} failed')
+ self.logger.log(log_level, f'{prefix}{error_msg}')
else:
- self.logger.error(f'{prefix}{error_msg}')
+ self.logger.log(log_level, f'{prefix}{error_msg}')
+ await self._demo_mode_log(f'Step error: {error_msg}', 'error', {'step': self.state.n_steps})
self.state.last_result = [ActionResult(error=error_msg)]
return None
diff --cc browser_use/dom/service.py
index d19c7340a,1c060d018..b95dbeac2
--- a/browser_use/dom/service.py
+++ b/browser_use/dom/service.py
@@@ -730,25 -763,50 +763,53 @@@ class DomService
Returns:
Tuple of (serialized_dom_state, enhanced_dom_tree_root, timing_info)
"""
+ timing_info: dict[str, float] = {}
+ start_total = time.time()
# Use current target (None means use current)
- assert self.browser_session.current_target_id is not None
- enhanced_dom_tree = await self.get_dom_tree(target_id=self.browser_session.current_target_id)
+ assert self.browser_session.agent_focus_target_id is not None
+
++ session_id = self.browser_session.id
++
+ # Build DOM tree (includes CDP calls for snapshot, DOM, AX tree)
+ # Note: all_frames is fetched lazily inside get_dom_tree only if cross-origin iframes need it
+ enhanced_dom_tree, dom_tree_timing = await self.get_dom_tree(
+ target_id=self.browser_session.agent_focus_target_id,
+ all_frames=None, # Lazy - will fetch if needed
+ )
+
+ # Add sub-timings from DOM tree construction
+ timing_info.update(dom_tree_timing)
+
+ # Serialize DOM tree for LLM
+ start_serialize = time.time()
+
- session_id = self.browser_session.id
- self.logger.debug(f'Serializing DOM tree with session ID: {session_id}')
- start = time.time()
serialized_dom_state, serializer_timing = DOMTreeSerializer(
- enhanced_dom_tree, previous_cached_state, paint_order_filtering=self.paint_order_filtering
+ enhanced_dom_tree, previous_cached_state, paint_order_filtering=self.paint_order_filtering, session_id=session_id
).serialize_accessible_elements()
+ total_serialization_ms = (time.time() - start_serialize) * 1000
+
+ # Add serializer sub-timings (convert to ms)
+ for key, value in serializer_timing.items():
+ timing_info[f'{key}_ms'] = value * 1000
+
+ # Calculate untracked time in serialization
+ tracked_serialization_ms = sum(value * 1000 for value in serializer_timing.values())
+ serialization_overhead_ms = total_serialization_ms - tracked_serialization_ms
+ if serialization_overhead_ms > 0.1: # Only log if significant
+ timing_info['serialization_overhead_ms'] = serialization_overhead_ms
- end = time.time()
- serialize_total_timing = {'serialize_dom_tree_total': end - start}
+ # Calculate total time for get_serialized_dom_tree
+ total_get_serialized_dom_tree_ms = (time.time() - start_total) * 1000
+ timing_info['get_serialized_dom_tree_total_ms'] = total_get_serialized_dom_tree_ms
- # Combine all timing info
- all_timing = {**serializer_timing, **serialize_total_timing}
+ # Calculate overhead in get_serialized_dom_tree (time not accounted for)
+ tracked_major_operations_ms = timing_info.get('get_dom_tree_total_ms', 0) + total_serialization_ms
+ get_serialized_overhead_ms = total_get_serialized_dom_tree_ms - tracked_major_operations_ms
+ if get_serialized_overhead_ms > 0.1:
+ timing_info['get_serialized_dom_tree_overhead_ms'] = get_serialized_overhead_ms
- return serialized_dom_state, enhanced_dom_tree, all_timing
+ return serialized_dom_state, enhanced_dom_tree, timing_info
@staticmethod
def detect_pagination_buttons(selector_map: dict[int, EnhancedDOMTreeNode]) -> list[dict[str, str | int | bool]]: