Relevant issues

Anthropic /v1/messages responses report built-in web search usage under usage.server_tool_use.web_search_requests, but the spend record intermittently missed the web-search fee. On the sync cost path the response is the raw Anthropic dict while the reconstructed OpenAI-shape Usage drops server_tool_use, and separately AnthropicResponse.model_validate(...).model_dump(...) stripped the field before cost tracking ever saw it

Linear ticket

N/A

Pre-Submission checklist

Please complete all items before asking a LiteLLM maintainer to review your PR

• I have added meaningful tests
• My PR passes all unit tests on make test-unit
• My PR's scope is as isolated as possible; it only solves 1 specific problem
• I have requested a Greptile review by commenting @greptileai and received a Confidence Score of at least 4/5 before requesting a maintainer review

Delays in PR merge?

If you're seeing a delay in your PR being merged, ping the LiteLLM Team on Slack (#pr-review).

CI (LiteLLM team)

• Branch creation CI run
  Link:

• CI run for the last commit
  Link:

• Merge / cherry-pick CI run
  Links:

Screenshots / Proof of Fix

Fully end to end against a live proxy hitting the real Anthropic /v1/messages web search API, no mocks. The model actually runs server-side web searches (both responses carry real web_search_result citations to Wikipedia, CBS, and others) and Anthropic reports usage.server_tool_use.web_search_requests. The per-request spend is read straight off the x-litellm-response-cost-original response header, so the number shown is exactly what the proxy attributes to the call

Setup is identical for before and after. claude-sonnet-4-5 is used because its cost map entry carries the web search per-query price (search_context_size_medium = $0.01):

# config.yaml
model_list:
  - model_name: claude-sonnet-4-5-websearch
    litellm_params:
      model: anthropic/claude-sonnet-4-5
      api_key: os.environ/ANTHROPIC_API_KEY

general_settings:
  master_key: sk-1234

export ANTHROPIC_API_KEY=sk-ant-...        # real key, billed for real searches
litellm --config config.yaml --port 4000

One non-streaming /v1/messages request whose prompt forces a web_search call, so Anthropic returns usage.server_tool_use.web_search_requests:

curl -sS -D - -o /tmp/body.json \
  -X POST http://localhost:4000/v1/messages \
  -H 'content-type: application/json' \
  -H 'x-api-key: sk-1234' \
  -H 'anthropic-version: 2023-06-01' \
  -d '{
        "model": "claude-sonnet-4-5-websearch",
        "max_tokens": 1024,
        "tools": [{"type": "web_search_20250305", "name": "web_search", "max_uses": 3}],
        "messages": [{"role": "user", "content": "Use web_search to find who won the 2022 FIFA World Cup, then answer in one sentence. You must call web_search."}]
      }' | grep -i '^x-litellm-response-cost-original'

jq -r '.usage.server_tool_use, (.content[] | select(.type=="text").text)' /tmp/body.json
# {"web_search_requests": 1, "web_fetch_requests": 0}
# Argentina won the 2022 FIFA World Cup in Qatar, defeating France in the final

Output tokens differ slightly between the two calls since each is a fresh live generation, so each total is decomposed against that response's own usage. Input tokens are identical at 11850 and the only thing that changes is whether the one reported web_search_request is billed

Before (on litellm_internal_staging, without this PR)

The search runs and usage.server_tool_use.web_search_requests is 1, but the reconstructed Usage on the sync cost path drops server_tool_use, so the web search fee is computed as $0 and the spend equals token cost only

x-litellm-response-cost-original: 0.03735

usage: input_tokens=11850  output_tokens=120  server_tool_use.web_search_requests=1
token-only cost = 11850 * $3/M + 120 * $15/M = 0.03735
web search fee billed = 0.03735 - 0.03735 = $0.00   <- dropped

After (with this PR)

Same request, same real search. The fallback recovers web_search_requests from the raw Anthropic response, so the $0.01 per-search fee is added on top of token cost

x-litellm-response-cost-original: 0.047005

usage: input_tokens=11850  output_tokens=97  server_tool_use.web_search_requests=1
token-only cost = 11850 * $3/M + 97 * $15/M = 0.037005
web search fee billed = 0.047005 - 0.037005 = $0.01   <- now included

Type

🐛 Bug Fix

Changes

AnthropicResponseUsageBlock now sets model_config = ConfigDict(extra="allow") so that AnthropicResponse.model_validate(...).model_dump(...) keeps server_tool_use instead of silently dropping it on the logging fallback

StandardBuiltInToolCostTracking reads the web search count straight off the raw Anthropic response dict when the reconstructed Usage lacks server_tool_use. The raw dict is parsed by get_anthropic_web_search_requests_from_response in litellm/llms/anthropic/cost_calculation.py, a small typed Pydantic probe rather than ad-hoc dict access, so the Anthropic-specific parsing lives under llms/ and no new Any/Unknown leaks into the type budget. Detection happens in response_object_includes_web_search_call, and _usage_with_anthropic_web_search synthesizes a ServerToolUse so the Anthropic web-search calculator sees the correct count without mutating the caller's Usage; it copies an existing Usage via model_copy, or builds a fresh one when the cost path is handed only the raw dict

The fallback only activates for a raw Anthropic /v1/messages dict that carries an integer usage.server_tool_use.web_search_requests. Every other response shape keeps its existing behavior, Usage objects that already expose server_tool_use are returned untouched, and a reported count of zero prices the call at $0 rather than the default medium tier

Regression coverage lives in tests/test_litellm/litellm_core_utils/llm_cost_calc/test_tool_call_cost_tracking.py. The tests fail before this change (fee computed as 0.0, and server_tool_use stripped by model_dump) and pass after, asserting the exact per-query fee times the request count, that the passed-in Usage is not mutated, that a dict-only path with no parallel Usage is still priced per request, and that a zero count charges nothing