Skip to content

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

Trace Rust Agent tools and cache usage

Magnus Mülleree8a86a091bb
diff --git a/RUST_AGENT_INTEGRATION_FEATURES.md b/RUST_AGENT_INTEGRATION_FEATURES.md
index e81e48421..edf596c91 100644
--- a/RUST_AGENT_INTEGRATION_FEATURES.md
+++ b/RUST_AGENT_INTEGRATION_FEATURES.md
@@ -1450,6 +1450,18 @@ Terminal core branch: `magnus/browser-use-rust-main-integration` at terminal mai
- Direct Python-interface diagnostic through `from browser_use.rust import Agent` with Browser Use cloud completed a 3-step `https://example.com` task successfully and proved the cost breakdown: `$0.11142345` total, including `$0.09388125` for 25,035 cache-write tokens and `$0.0110772` for 36,924 cache-read tokens.
- Proof: terminal `cargo test -p browser-use-agent turn_request_event_carries_full_llm_input_messages -- --nocapture`, terminal `cargo test -p browser-use-agent turn_request_event_carries_all_observability_messages_without_text_budget -- --nocapture`, terminal `cargo fmt --check`, browser-use `.venv/bin/python -m pytest -q tests/ci/test_rust_agent.py -k 'rust_terminal_usage_prices_token_count_events or rust_terminal_usage_prices_anthropic_raw_cache_reads or rust_terminal_usage_sums_token_count_cache_creation or rust_token_summary_does_not_double_count_cache_reads or rust_agent_laminar_run_summary_populates_current_span'`, browser-use `.venv/bin/python -m py_compile browser_use/rust/service.py browser_use/tokens/service.py browser_use/tokens/views.py`, and the saved diagnostic conversation at `/tmp/rust_usage_diag_conv`.
+277. Rust Agent exact Laminar tool replay
+ - Python `browser_use.rust.Agent` Laminar replay now creates child `TOOL` spans for terminal tool calls, including tool arguments, status/error attributes, structured text results, and inline image parts when the terminal event carries them.
+ - Rust LLM spans now include cache-read/cache-write usage and per-bucket cost attributes derived from the same official usage fields used by Browser Use token accounting, so Laminar and the eval dashboard can be compared without hidden pricing heuristics.
+ - Timeout/error reconstruction now preserves the latest streamed assistant text as the visible final result when the terminal process fails after an LLM turn has already produced content, while keeping the original error on the history.
+ - Proof: browser-use `uv run pytest -q tests/ci/test_rust_agent.py -k 'laminar_run_summary or loads_started_session_events_after_terminal_timeout' --disable-warnings`, browser-use `uv run python -m py_compile browser_use/rust/service.py tests/ci/test_rust_agent.py`, and browser-use `git diff --check -- browser_use/rust/service.py tests/ci/test_rust_agent.py`.
+
+278. Rust terminal structured replay and cache-window parity
+ - Terminal session reconstruction now falls back to structured `summary`, `data`, and `outputs` fields when browser_script and other tools return successful structured payloads with empty `text`/`content`, preventing future LLM turns and Laminar replay from seeing a blank tool result while the agent actually received evidence.
+ - The Rust request builder keeps the latest model-visible message cacheable and adds one earlier non-system cache breakpoint for long histories, staying within Anthropic's four-breakpoint limit together with the system prompt and tool schema breakpoint.
+ - This is a general cache-window fix for long browser/research trajectories; it does not add task-specific instructions or domain-specific behavior.
+ - Proof: terminal `cargo test -q -p browser-use-agent tool_output_event_uses_structured_browser_script_fallback_text -- --nocapture`, terminal `cargo test -q -p browser-use-agent open_stream_marks_an_earlier_cache_breakpoint_for_long_histories -- --nocapture`, terminal `cargo test -q -p browser-use-agent turn_request_event_carries_full_llm_input_messages -- --nocapture`, terminal `cargo test -q -p browser-use-agent turn_request_event_carries_all_observability_messages_without_text_budget -- --nocapture`, terminal `cargo fmt --check`, terminal `git diff --check -- crates/browser-use-agent/src/session/reconstruct.rs crates/browser-use-agent/src/session/reconstruct_tests.rs crates/browser-use-agent/src/turn/sampling.rs crates/browser-use-agent/src/turn/sampling_tests.rs`, and terminal `cargo build -q -p browser-use-cli --bin browser-use-terminal`.
+
## Current Verification
- terminal `cargo test -p browser-use-agent driver_passes_populated_per_call_request_to_open_stream -- --nocapture`
diff --git a/browser_use/rust/service.py b/browser_use/rust/service.py
index 3fd987bfb..a7d3d8d76 100644
--- a/browser_use/rust/service.py
+++ b/browser_use/rust/service.py
@@ -58,6 +58,7 @@ from browser_use.observability import observe
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.custom_pricing import CUSTOM_MODEL_PRICING
from browser_use.tokens.service import TokenCost
from browser_use.tokens.views import ModelUsageStats, UsageSummary
from browser_use.tools.registry.views import ActionModel
@@ -1092,6 +1093,17 @@ def _result_from_events(events: list[dict[str, Any]]) -> str | None:
return None
+def _last_streamed_assistant_text_from_events(events: list[dict[str, Any]]) -> str | None:
+ last_request_index = next(
+ (index for index in range(len(events) - 1, -1, -1) if _event_type(events[index]) == 'model.turn.request'),
+ -1,
+ )
+ candidates = events[last_request_index + 1 :] if last_request_index >= 0 else events
+ text = _streaming_text_from_events(candidates, ('model.delta', 'model.stream_delta', 'model.response.output_item'))
+ text = text.strip()
+ return text or None
+
+
def _attachments_from_events(events: list[dict[str, Any]]) -> list[str] | None:
attachments: list[str] = []
for event in events:
@@ -2531,6 +2543,33 @@ def _terminal_laminar_usage_summary(raw_usage: dict[str, Any] | None) -> dict[st
return summary
+def _terminal_laminar_usage_cost(model: str, usage: dict[str, int | float] | None) -> dict[str, float] | None:
+ if not usage:
+ return None
+ pricing = CUSTOM_MODEL_PRICING.get(model) or CUSTOM_MODEL_PRICING.get(model.replace('.', '-'))
+ if not pricing:
+ return None
+ input_tokens = int(usage.get('input_tokens') or 0)
+ cached_tokens = int(usage.get('cached_input_tokens') or 0)
+ cache_creation_tokens = int(usage.get('cache_creation_input_tokens') or 0)
+ output_tokens = int(usage.get('output_tokens') or 0)
+ uncached_tokens = max(0, input_tokens - cached_tokens)
+ input_cost = uncached_tokens * float(pricing.get('input_cost_per_token') or 0.0)
+ cache_read_cost = cached_tokens * float(pricing.get('cache_read_input_token_cost') or 0.0)
+ cache_creation_cost = cache_creation_tokens * float(pricing.get('cache_creation_input_token_cost') or 0.0)
+ output_cost = output_tokens * float(pricing.get('output_cost_per_token') or 0.0)
+ total_cost = input_cost + cache_read_cost + cache_creation_cost + output_cost
+ if total_cost <= 0:
+ return None
+ return {
+ 'input_cost_usd': input_cost,
+ 'input_cached_cost_usd': cache_read_cost,
+ 'input_cache_creation_cost_usd': cache_creation_cost,
+ 'output_cost_usd': output_cost,
+ 'cost_usd': total_cost,
+ }
+
+
def _terminal_laminar_turn_input(
request_payload: dict[str, Any],
*,
@@ -2582,8 +2621,8 @@ def _terminal_laminar_turn_output(events: list[dict[str, Any]], raw_usage: dict[
assistant_preview = _laminar_preview(assistant_text, limit=2000)
thinking_preview = _laminar_preview(thinking_text, limit=1200)
output_messages = []
- if assistant_preview:
- output_messages.append({'role': 'assistant', 'content': [{'type': 'text', 'text': assistant_preview}]})
+ if assistant_text:
+ output_messages.append({'role': 'assistant', 'content': [{'type': 'text', 'text': assistant_text}]})
if tool_calls:
output_messages.append(
{
@@ -2627,6 +2666,16 @@ def _terminal_laminar_content_part_for_span(part: Any) -> Any:
if not isinstance(part, dict):
return part
part_type = part.get('type')
+ if part_type == 'tool_result':
+ content = part.get('content')
+ if isinstance(content, list):
+ return [_terminal_laminar_content_part_for_span(item) for item in content]
+ if isinstance(content, str):
+ return {'type': 'text', 'text': content}
+ if part_type in {'input_text', 'output_text'}:
+ text = part.get('text')
+ if isinstance(text, str):
+ return {'type': 'text', 'text': text}
if part_type == 'media':
mime_type = part.get('mime_type')
mime_type = mime_type if isinstance(mime_type, str) and mime_type else 'application/octet-stream'
@@ -2645,14 +2694,33 @@ def _terminal_laminar_content_part_for_span(part: Any) -> Any:
return {'type': 'image_url', 'image_url': image_url}
if resolved_url:
return {'type': 'file', 'file_data': resolved_url}
+ if part_type in {'input_image', 'image'}:
+ image_url = part.get('image_url')
+ if isinstance(image_url, str) and image_url:
+ resolved_image: dict[str, Any] = {'url': image_url}
+ detail = part.get('detail')
+ if isinstance(detail, str) and detail:
+ resolved_image['detail'] = detail
+ return {'type': 'image_url', 'image_url': resolved_image}
content = part.get('content')
if isinstance(content, list):
normalized = dict(part)
- normalized['content'] = [_terminal_laminar_content_part_for_span(item) for item in content]
+ normalized['content'] = _terminal_laminar_content_parts_for_span(content)
return normalized
return part
+def _terminal_laminar_content_parts_for_span(parts: list[Any]) -> list[Any]:
+ normalized_parts: list[Any] = []
+ for part in parts:
+ normalized = _terminal_laminar_content_part_for_span(part)
+ if isinstance(normalized, list):
+ normalized_parts.extend(normalized)
+ else:
+ normalized_parts.append(normalized)
+ return normalized_parts
+
+
def _terminal_laminar_message_for_span(message: Any) -> Any:
if not isinstance(message, dict):
return message
@@ -2660,7 +2728,7 @@ def _terminal_laminar_message_for_span(message: Any) -> Any:
if not isinstance(content, list):
return message
normalized = dict(message)
- normalized['content'] = [_terminal_laminar_content_part_for_span(part) for part in content]
+ normalized['content'] = _terminal_laminar_content_parts_for_span(content)
return normalized
@@ -2735,8 +2803,17 @@ def _terminal_laminar_gen_ai_attributes(
attributes.update(
{
'gen_ai.usage.input_tokens': usage.get('input_tokens'),
+ 'gen_ai.usage.input_cached_tokens': usage.get('cached_input_tokens'),
+ 'gen_ai.usage.cached_input_tokens': usage.get('cached_input_tokens'),
+ 'gen_ai.usage.cache_read_input_tokens': usage.get('cached_input_tokens'),
+ 'gen_ai.usage.cache_creation_input_tokens': usage.get('cache_creation_input_tokens') or 0,
+ 'gen_ai.usage.input_cache_creation_tokens': usage.get('cache_creation_input_tokens') or 0,
'gen_ai.usage.output_tokens': usage.get('output_tokens'),
'gen_ai.usage.total_tokens': usage.get('total_tokens'),
+ 'llm.usage.input_tokens': usage.get('input_tokens'),
+ 'llm.usage.output_tokens': usage.get('output_tokens'),
+ 'llm.usage.input_cached_tokens': usage.get('cached_input_tokens'),
+ 'llm.usage.cache_creation_input_tokens': usage.get('cache_creation_input_tokens') or 0,
'llm.usage.total_tokens': usage.get('total_tokens'),
}
)
@@ -2745,6 +2822,78 @@ def _terminal_laminar_gen_ai_attributes(
return attributes
+def _terminal_laminar_tool_result_payload(events: list[dict[str, Any]], tool_call_id: str) -> tuple[str, dict[str, Any]] | None:
+ for event in events:
+ event_type = _event_type(event)
+ if event_type not in ('tool.output', 'tool.failed', 'tool.aborted', 'tool.finished', 'exec_command.end'):
+ continue
+ payload = _event_payload(event)
+ call_id = payload.get('tool_call_id') or payload.get('call_id')
+ if call_id is not None and str(call_id) == tool_call_id:
+ return event_type, payload
+ return None
+
+
+def _terminal_laminar_tool_input_message(tool_call: dict[str, Any]) -> list[dict[str, Any]]:
+ return [
+ {
+ 'role': 'assistant',
+ 'tool_calls': [
+ {
+ 'id': tool_call.get('tool_call_id'),
+ 'name': tool_call.get('name'),
+ 'arguments': tool_call.get('arguments'),
+ }
+ ],
+ }
+ ]
+
+
+def _terminal_laminar_tool_output_message(event_type: str | None, payload: dict[str, Any]) -> list[dict[str, Any]]:
+ content = payload.get('content')
+ if isinstance(content, list) and content:
+ parts = _terminal_laminar_content_parts_for_span(content)
+ else:
+ text = _tool_result_text(payload)
+ if not text and event_type == 'tool.finished':
+ text = _synthetic_tool_result_text(str(payload.get('name') or 'tool'))
+ parts = [{'type': 'text', 'text': text or ''}]
+ role = 'tool'
+ return [{'role': role, 'content': parts}]
+
+
+def _record_laminar_terminal_tool_spans(events: list[dict[str, Any]], *, max_spans: int) -> None:
+ if not _laminar_ready() or max_spans <= 0:
+ return
+ tool_calls = _tool_started_calls(events)
+ for span_index, tool_call in enumerate(tool_calls[:max_spans], start=1):
+ tool_call_id = str(tool_call.get('tool_call_id') or '')
+ result = _terminal_laminar_tool_result_payload(events, tool_call_id)
+ event_type, payload = result if result is not None else (None, {})
+ input_messages = _terminal_laminar_tool_input_message(tool_call)
+ output_messages = _terminal_laminar_tool_output_message(event_type, payload)
+ with _laminar_start_span(f"rust_core.tool.{tool_call.get('name') or 'tool'}", input=input_messages, span_type='TOOL'):
+ _laminar_set_span_attributes(
+ {
+ 'runtime': 'browser_use.rust',
+ 'tool_name': tool_call.get('name'),
+ 'tool_call_id': tool_call_id,
+ 'tool_index': span_index,
+ 'event_type': event_type,
+ 'ok': payload.get('ok') if payload else None,
+ 'status': payload.get('status') if payload else None,
+ 'error': payload.get('error') if payload else None,
+ 'has_content': bool(payload.get('content')) if payload else False,
+ 'has_images': bool(payload.get('images')) if payload else False,
+ 'has_outputs': bool(payload.get('outputs')) if payload else False,
+ 'has_summary': bool(payload.get('summary')) if payload else False,
+ }
+ )
+ _laminar_set_span_output(output_messages)
+ if len(tool_calls) > max_spans:
+ _laminar_event('rust_core.tool_spans_truncated', {'recorded': max_spans, 'available': len(tool_calls)})
+
+
def _record_laminar_terminal_llm_spans(
events: list[dict[str, Any]],
*,
@@ -2769,6 +2918,9 @@ def _record_laminar_terminal_llm_spans(
)
raw_usage = _terminal_turn_usage_payload(turn_events)
usage = _terminal_laminar_usage_summary(raw_usage)
+ cost = _terminal_laminar_usage_cost(str(span_input.get('model') or default_model), usage)
+ if cost and usage is not None:
+ usage.update(cost)
start_time = _event_time_seconds(turn_events[0], 0.0)
end_time = _event_time_seconds(turn_events[-1], start_time)
span_input_messages = _terminal_laminar_span_input_messages(span_input)
@@ -2798,6 +2950,10 @@ def _record_laminar_terminal_llm_spans(
'cache_creation_input_tokens': usage.get('cache_creation_input_tokens') if usage else None,
'output_tokens': usage.get('output_tokens') if usage else None,
'total_tokens': usage.get('total_tokens') if usage else None,
+ 'input_cost_usd': usage.get('input_cost_usd') if usage else None,
+ 'input_cached_cost_usd': usage.get('input_cached_cost_usd') if usage else None,
+ 'input_cache_creation_cost_usd': usage.get('input_cache_creation_cost_usd') if usage else None,
+ 'output_cost_usd': usage.get('output_cost_usd') if usage else None,
'cost_usd': usage.get('cost_usd') if usage else None,
'duration_seconds': max(0.0, end_time - start_time),
}
@@ -2823,6 +2979,8 @@ def _history_from_events(
events = _events_after_terminal_rollbacks(_events_after_terminal_compaction(events))
final_result = _structured_result_text(_result_from_events(events), output_model_schema)
failure = process_error or _failure_from_events(events)
+ if final_result is None and failure is not None:
+ final_result = _structured_result_text(_last_streamed_assistant_text_from_events(events), output_model_schema)
if final_result is None and failure is None:
failure = _recoverable_failure_from_events(events)
if final_result is None and failure is None:
@@ -3598,7 +3756,14 @@ class Agent(Generic[Context, AgentStructuredOutput]):
{
'usage_total_tokens': usage.total_tokens,
'usage_prompt_tokens': usage.total_prompt_tokens,
+ 'usage_prompt_cost': usage.total_prompt_cost,
+ 'usage_prompt_cached_tokens': usage.total_prompt_cached_tokens,
+ 'usage_prompt_cached_cost': usage.total_prompt_cached_cost,
+ 'usage_prompt_cache_creation_tokens': usage.total_prompt_cache_creation_tokens,
+ 'usage_prompt_cache_creation_cost': usage.total_prompt_cache_creation_cost,
'usage_completion_tokens': usage.total_completion_tokens,
+ 'usage_completion_cost': usage.total_completion_cost,
+ 'usage_total_cost': usage.total_cost,
}
)
_record_laminar_terminal_llm_spans(
@@ -3606,6 +3771,10 @@ class Agent(Generic[Context, AgentStructuredOutput]):
default_model=str(model),
default_provider=str(provider),
)
+ _record_laminar_terminal_tool_spans(
+ self.last_events or [],
+ max_spans=_int_value(os.getenv('BROWSER_USE_RUST_LAMINAR_MAX_TOOL_SPANS') or 160),
+ )
_laminar_set_span_attributes(
{
'runtime': summary['runtime'],
@@ -3619,6 +3788,9 @@ class Agent(Generic[Context, AgentStructuredOutput]):
'terminal_events_count': summary['terminal_events_count'],
'duration_seconds': duration_seconds,
'process_error': process_error,
+ 'usage_total_cost': usage.total_cost if usage is not None else None,
+ 'usage_prompt_cached_tokens': usage.total_prompt_cached_tokens if usage is not None else None,
+ 'usage_prompt_cache_creation_tokens': usage.total_prompt_cache_creation_tokens if usage is not None else None,
}
)
_laminar_set_span_output(summary)
diff --git a/tests/ci/test_rust_agent.py b/tests/ci/test_rust_agent.py
index 07d25dac6..c771941e7 100644
--- a/tests/ci/test_rust_agent.py
+++ b/tests/ci/test_rust_agent.py
@@ -5878,6 +5878,8 @@ async def test_rust_agent_loads_started_session_events_after_terminal_timeout(mo
agent = Agent(task='timeout after start', llm=type('LLM', (), {'model': 'gpt-test'})(), step_timeout=5)
process_commands = []
stored_events = [
+ {'event_type': 'model.turn.request', 'payload': {'model': 'gpt-test'}},
+ {'event_type': 'model.stream_delta', 'payload': {'text': 'partial answer before timeout'}},
{'event_type': 'browser.state', 'payload': {'url': 'https://example.com', 'title': 'Example'}},
{'event_type': 'model.usage', 'payload': {'input_tokens': 11, 'output_tokens': 7}},
]
@@ -5901,6 +5903,7 @@ async def test_rust_agent_loads_started_session_events_after_terminal_timeout(mo
assert agent.terminal_session_id == '12345678-1234-1234-1234-123456789abc'
assert agent.last_events == stored_events
assert history.urls() == ['https://example.com']
+ assert history.final_result() == 'partial answer before timeout'
assert history.usage is not None
assert history.usage.total_prompt_tokens == 11
assert history.errors() == ['browser-use-terminal timed out after 5 seconds']
@@ -7452,14 +7455,14 @@ def test_rust_agent_laminar_run_summary_populates_current_span(monkeypatch):
monkeypatch.setattr(rust_service, 'Laminar', FakeLaminar)
- agent = Agent(task='Trace terminal observability.', llm=type('LLM', (), {'model': 'gpt-test'})())
+ agent = Agent(task='Trace terminal observability.', llm=type('LLM', (), {'model': 'claude-sonnet-4-6'})())
agent.terminal_session_id = 'terminal-session-1'
agent.last_events = [
{
'event_type': 'model.turn.request',
'ts_ms': 1000,
'payload': {
- 'model': 'gpt-test',
+ 'model': 'claude-sonnet-4-6',
'provider': 'test-provider',
'turn_idx': 0,
'composition': {
@@ -7487,6 +7490,31 @@ def test_rust_agent_laminar_run_summary_populates_current_span(monkeypatch):
},
},
},
+ {
+ 'event_type': 'tool.started',
+ 'ts_ms': 1200,
+ 'payload': {
+ 'name': 'browser_script',
+ 'tool_call_id': 'call-browser',
+ 'arguments': {'code': 'emit_output(page_info(), label="page_info")'},
+ },
+ },
+ {
+ 'event_type': 'tool.output',
+ 'ts_ms': 1400,
+ 'payload': {
+ 'name': 'browser_script',
+ 'tool_call_id': 'call-browser',
+ 'ok': True,
+ 'text': '',
+ 'summary': [{'kind': 'page', 'title': 'Example Domain', 'url': 'https://example.com'}],
+ 'outputs': [{'label': 'page_info', 'value': {'title': 'Example Domain'}}],
+ 'content': [
+ {'type': 'input_text', 'text': 'Example Domain page info'},
+ {'type': 'input_image', 'image_url': 'data:image/png;base64,iVBORw0KGgo=', 'detail': 'low'},
+ ],
+ },
+ },
{'event_type': 'model.stream_delta', 'ts_ms': 1500, 'payload': {'text': 'laminar answer'}},
{
'event_type': 'token_count',
@@ -7495,15 +7523,17 @@ def test_rust_agent_laminar_run_summary_populates_current_span(monkeypatch):
'info': {
'last_token_usage': {
'cached_input_tokens': 5,
+ 'input_cache_creation_tokens': 13,
'input_tokens': 100,
'output_tokens': 20,
- 'total_tokens': 120,
+ 'total_tokens': 133,
},
'total_token_usage': {
'cached_input_tokens': 5,
+ 'input_cache_creation_tokens': 13,
'input_tokens': 100,
'output_tokens': 20,
- 'total_tokens': 120,
+ 'total_tokens': 133,
},
},
},
@@ -7512,7 +7542,7 @@ def test_rust_agent_laminar_run_summary_populates_current_span(monkeypatch):
]
agent.history = _history_from_events(
agent.last_events,
- model='gpt-test',
+ model='claude-sonnet-4-6',
started=1.0,
finished=4.0,
output_model_schema=None,
@@ -7525,7 +7555,7 @@ def test_rust_agent_laminar_run_summary_populates_current_span(monkeypatch):
assert FakeLaminar.attributes[-1]['terminal_session_id'] == 'terminal-session-1'
assert FakeLaminar.outputs[-1]['final_result_preview'] == 'laminar answer'
assert FakeLaminar.outputs[-1]['steps'] == agent.history.number_of_steps()
- assert FakeLaminar.outputs[-1]['terminal_events_count'] == 4
+ assert FakeLaminar.outputs[-1]['terminal_events_count'] == 6
assert FakeLaminar.events[-1][0] == 'agent.run.terminal_summary'
assert FakeLaminar.spans[0]['name'] == 'rust_core.llm'
assert FakeLaminar.spans[0]['span_type'] == 'LLM'
@@ -7545,10 +7575,14 @@ def test_rust_agent_laminar_run_summary_populates_current_span(monkeypatch):
assert span_attrs['tools_count'] == 2
assert 'browser' in span_attrs['tool_names']
assert span_attrs['input_tokens'] == 100
+ assert span_attrs['cached_input_tokens'] == 5
+ assert span_attrs['cache_creation_input_tokens'] == 13
assert span_attrs['output_tokens'] == 20
- assert span_attrs['total_tokens'] == 120
+ assert span_attrs['total_tokens'] == 133
+ assert span_attrs['input_cached_cost_usd'] == 5 * (0.30 / 1_000_000)
+ assert span_attrs['input_cache_creation_cost_usd'] == 13 * (3.75 / 1_000_000)
assert span_attrs['gen_ai.operation.name'] == 'chat'
- assert span_attrs['gen_ai.request.model'] == 'gpt-test'
+ assert span_attrs['gen_ai.request.model'] == 'claude-sonnet-4-6'
assert span_attrs['gen_ai.prompt.0.role'] == 'system'
assert span_attrs['gen_ai.prompt.0.content'] == 'System prompt'
assert span_attrs['gen_ai.prompt.1.role'] == 'user'
@@ -7556,10 +7590,24 @@ def test_rust_agent_laminar_run_summary_populates_current_span(monkeypatch):
assert span_attrs['gen_ai.completion.0.role'] == 'assistant'
assert span_attrs['gen_ai.completion.0.content'] == 'laminar answer'
assert span_attrs['gen_ai.usage.input_tokens'] == 100
+ assert span_attrs['gen_ai.usage.input_cached_tokens'] == 5
+ assert span_attrs['gen_ai.usage.cache_creation_input_tokens'] == 13
assert span_attrs['gen_ai.usage.output_tokens'] == 20
- assert span_attrs['gen_ai.usage.total_tokens'] == 120
+ assert span_attrs['gen_ai.usage.total_tokens'] == 133
assert span_attrs['assistant_output_preview'] == 'laminar answer'
assert FakeLaminar.spans[0]['outputs'][-1][0]['content'][0]['text'] == 'laminar answer'
+ assert FakeLaminar.spans[1]['name'] == 'rust_core.tool.browser_script'
+ assert FakeLaminar.spans[1]['span_type'] == 'TOOL'
+ tool_attrs = {}
+ for attributes in FakeLaminar.spans[1]['attributes']:
+ tool_attrs.update(attributes)
+ assert tool_attrs['tool_index'] == 1
+ assert FakeLaminar.spans[1]['input'][0]['tool_calls'][0]['arguments']['code'] == 'emit_output(page_info(), label="page_info")'
+ assert FakeLaminar.spans[1]['outputs'][-1][0]['content'][0] == {'type': 'text', 'text': 'Example Domain page info'}
+ assert FakeLaminar.spans[1]['outputs'][-1][0]['content'][1] == {
+ 'type': 'image_url',
+ 'image_url': {'url': 'data:image/png;base64,iVBORw0KGgo=', 'detail': 'low'},
+ }
async def test_rust_agent_authenticate_cloud_sync_logs_browser_use_warning(monkeypatch):