fix(desktop): count the paused leg's tokens and web searches

A streaming turn that Anthropic pauses (`stop_reason: pause_turn`) is finished
by a non-streaming continuation whose result is spliced into the open SSE body.
That splice reported usage as `merge_stream_usage(message_start, continuation)`,
which takes output tokens from the continuation alone — so the streamed leg was
dropped from both the client's usage chunk and the Firestore `record_llm_usage`
row.

The dropped leg is not a rounding error: it is the leg that ran the web search.
A turn pauses *because* a server tool ran, so its `usage.server_tool_use`
carries the `web_search_requests` Anthropic bills per request (see
`compute_cost`, `WEB_SEARCH_COST_PER_REQUEST`), plus every output token spent
before the pause (thinking and the search query). Every paused turn was
therefore billed as if its first half never happened.

The non-streaming lane already sums every leg (`accumulate_anthropic_usage` in
transport.rs). Extract `paused_turn_total_usage()` so the streaming splice
totals the same way: merge `message_start` with the pausing `message_delta` to
make the streamed leg whole, then accumulate the continuation on top. A pause
that reported no usage falls back to `message_start`, never to less than
before.

Verified: cargo test 382 passed; both new tests fail on the pre-fix expression
(input 130 vs 230, 110 vs 200) and pass on the fix; cargo fmt --check and cargo
clippy --all-targets -D warnings clean. The live Anthropic pause_turn round
trip is not driveable on demand and the upstream URL is a constant with no test
seam, so the fix is proven through the production usage-totalling function
rather than against the provider.

Failure-Class: none

Author: kodjima33

desktop/macos/Backend-Rust/src/routes/chat/streaming.rs

@@ -16,7 +16,8 @@ use super::request_translation::{compute_cost, response_text_content};
 use super::response_or_500;
 use super::sse::{drain_sse_events, make_chunk, sse_line, stream_termination_chunks};
 use super::transport::{
-    append_pause_turn_continuation, complete_anthropic_server_tool_turn, send_anthropic_with_retry,
+    accumulate_anthropic_usage, append_pause_turn_continuation,
+    complete_anthropic_server_tool_turn, send_anthropic_with_retry,
 };
 
 /// How long a streaming turn may go without a single byte from Anthropic before we end it.
@@ -167,6 +168,28 @@ pub(super) fn continuation_delta_chunks(
     chunks
 }
 
+/// Total the usage of a turn that paused: the streamed leg plus the continuation.
+///
+/// The paused leg is the leg that ran the server tool — it holds the output tokens
+/// generated before the pause *and* the `web_search_requests` Anthropic bills per
+/// request. Reporting only the continuation's usage drops both, so a paused turn is
+/// billed as if its first half never happened. The non-streaming lane already sums
+/// every leg (`accumulate_anthropic_usage`); the streaming splice totals the same way.
+pub(super) fn paused_turn_total_usage(
+    initial: Option<&AnthropicUsage>,
+    streamed_final: Option<&AnthropicUsage>,
+    continuation: &AnthropicUsage,
+) -> AnthropicUsage {
+    // `message_start` carries the input side, `message_delta` the output side, so the
+    // streamed leg is only whole once the two are merged.
+    let mut total = match streamed_final {
+        Some(final_usage) => merge_stream_usage(initial, final_usage),
+        None => initial.cloned().unwrap_or_default(),
+    };
+    accumulate_anthropic_usage(&mut total, continuation);
+    total
+}
+
 fn append_string_field(block: &mut Value, key: &str, suffix: &str) {
     if let Some(current) = block.get_mut(key).and_then(|value| value.as_str()) {
         let mut combined = current.to_string();
@@ -547,7 +570,11 @@ where
                     );
                     yield Ok(sse_line(&chunk_val));
 
-                    let merged = merge_stream_usage(initial_usage.as_ref(), &anthropic_resp.usage);
+                    let merged = paused_turn_total_usage(
+                        initial_usage.as_ref(),
+                        final_usage.as_ref(),
+                        &anthropic_resp.usage,
+                    );
                     let openai_usage = anthropic_usage_to_openai(&merged);
                     let usage_chunk = ChatCompletionChunk {
                         id: stream_id.clone(),

desktop/macos/Backend-Rust/src/routes/chat/tests/all.rs

@@ -1329,6 +1329,63 @@ fn pause_turn_continuation_tool_ordinals_continue_from_the_streamed_prefix() {
     );
 }
 
+/// Regression: a paused turn used to report only its continuation's usage, so the
+/// leg that actually ran the web search — its output tokens and its billed
+/// `web_search_requests` — was never recorded. Every paused turn under-billed.
+#[test]
+fn paused_turn_usage_totals_the_streamed_leg_and_the_continuation() {
+    let initial: AnthropicUsage = serde_json::from_value(json!({
+        "input_tokens": 100,
+        "cache_read_input_tokens": 20
+    }))
+    .expect("message_start usage must decode");
+    let streamed_final: AnthropicUsage = serde_json::from_value(json!({
+        "output_tokens": 40,
+        "server_tool_use": {"web_search_requests": 1}
+    }))
+    .expect("message_delta usage must decode");
+    let continuation: AnthropicUsage = serde_json::from_value(json!({
+        "input_tokens": 130,
+        "output_tokens": 25,
+        "server_tool_use": {"web_search_requests": 1}
+    }))
+    .expect("continuation usage must decode");
+
+    let total = paused_turn_total_usage(Some(&initial), Some(&streamed_final), &continuation);
+
+    assert_eq!(total.input_tokens, 230);
+    assert_eq!(total.cache_read_input_tokens, 20);
+    assert_eq!(
+        total.output_tokens, 65,
+        "the paused leg's output is billable"
+    );
+    assert_eq!(
+        total
+            .server_tool_use
+            .as_ref()
+            .map(|tool_use| tool_use.web_search_requests),
+        Some(2),
+        "both legs' web searches are billed per request"
+    );
+}
+
+/// A `message_delta` may carry no usage at all. The turn then totals what
+/// `message_start` reported plus the continuation, never less than before.
+#[test]
+fn paused_turn_usage_falls_back_to_message_start_when_the_pause_reported_none() {
+    let initial: AnthropicUsage =
+        serde_json::from_value(json!({"input_tokens": 90})).expect("usage must decode");
+    let continuation: AnthropicUsage =
+        serde_json::from_value(json!({"input_tokens": 110, "output_tokens": 7}))
+            .expect("usage must decode");
+
+    let total = paused_turn_total_usage(Some(&initial), None, &continuation);
+
+    assert_eq!(total.input_tokens, 200);
+    assert_eq!(total.output_tokens, 7);
+    assert!(total.server_tool_use.is_none());
+}
+
 #[test]
 fn test_translate_request_degrades_when_web_search_disabled() {
     let mut req = test_request(vec![user_message("Search the web for HumanPost")]);

desktop/macos/Backend-Rust/src/routes/chat/transport.rs

@@ -153,7 +153,7 @@ async fn receive_anthropic_response(
     })
 }
 
-fn accumulate_anthropic_usage(total: &mut AnthropicUsage, usage: &AnthropicUsage) {
+pub(super) fn accumulate_anthropic_usage(total: &mut AnthropicUsage, usage: &AnthropicUsage) {
     total.input_tokens += usage.input_tokens;
     total.output_tokens += usage.output_tokens;
     total.cache_creation_input_tokens += usage.cache_creation_input_tokens;