Skip to content

Commit 1c5c275

Browse files
fix: normalize nullable token counts in remaining provider paths (#5260)
* fix: normalize nullable token counts in remaining provider paths * fix: preserve request usage when total tokens are null
1 parent f76153c commit 1c5c275

6 files changed

Lines changed: 190 additions & 18 deletions

File tree

‎src/agents/extensions/models/any_llm_model.py‎

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -423,9 +423,9 @@ async def _get_response_via_responses(
423423
usage = (
424424
Usage(
425425
requests=1,
426-
input_tokens=response.usage.input_tokens,
427-
output_tokens=response.usage.output_tokens,
428-
total_tokens=response.usage.total_tokens,
426+
input_tokens=response.usage.input_tokens or 0,
427+
output_tokens=response.usage.output_tokens or 0,
428+
total_tokens=response.usage.total_tokens or 0,
429429
input_tokens_details=response.usage.input_tokens_details,
430430
output_tokens_details=response.usage.output_tokens_details,
431431
)

‎src/agents/extensions/models/litellm_model.py‎

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -274,9 +274,9 @@ async def get_response(
274274
usage = (
275275
Usage(
276276
requests=1,
277-
input_tokens=response_usage.prompt_tokens,
278-
output_tokens=response_usage.completion_tokens,
279-
total_tokens=response_usage.total_tokens,
277+
input_tokens=response_usage.prompt_tokens or 0,
278+
output_tokens=response_usage.completion_tokens or 0,
279+
total_tokens=response_usage.total_tokens or 0,
280280
input_tokens_details=_make_input_tokens_details(
281281
cached_tokens=getattr(
282282
response_usage.prompt_tokens_details, "cached_tokens", 0

‎src/agents/usage.py‎

Lines changed: 6 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -298,7 +298,9 @@ def add(self, other: Usage) -> None:
298298
# when synthesizing an entry from only the top-level fields).
299299
if other.request_usage_entries:
300300
self.request_usage_entries.extend(copy.deepcopy(other.request_usage_entries))
301-
elif other.requests == 1 and other.total_tokens > 0:
301+
elif other.requests == 1 and (
302+
other.input_tokens > 0 or other.output_tokens > 0 or other.total_tokens > 0
303+
):
302304
# Otherwise, if the other Usage represents a single request with tokens, record it.
303305
input_details = other.input_tokens_details or _make_input_tokens_details()
304306
output_details = other.output_tokens_details or OutputTokensDetails(reasoning_tokens=0)
@@ -370,9 +372,9 @@ def _response_usage_to_usage(response_usage: Any) -> Usage:
370372

371373
return Usage(
372374
requests=request_count,
373-
input_tokens=response_usage.input_tokens,
374-
output_tokens=response_usage.output_tokens,
375-
total_tokens=response_usage.total_tokens,
375+
input_tokens=response_usage.input_tokens or 0,
376+
output_tokens=response_usage.output_tokens or 0,
377+
total_tokens=response_usage.total_tokens or 0,
376378
input_tokens_details=response_usage.input_tokens_details,
377379
output_tokens_details=response_usage.output_tokens_details,
378380
)

‎tests/models/test_any_llm_model.py‎

Lines changed: 39 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -307,6 +307,7 @@ async def _empty_chat_stream() -> AsyncIterator[ChatCompletionChunk]:
307307

308308
@pytest.mark.allow_call_model_methods
309309
@pytest.mark.asyncio
310+
@pytest.mark.parametrize("api", ["chat_completions", "responses"])
310311
@pytest.mark.parametrize(
311312
("counts", "expected"),
312313
[
@@ -319,8 +320,9 @@ async def _empty_chat_stream() -> AsyncIterator[ChatCompletionChunk]:
319320
],
320321
ids=["null-input", "null-output", "null-total", "all-null", "valid", "no-usage"],
321322
)
322-
async def test_any_llm_runner_normalizes_nullable_chat_usage(
323+
async def test_any_llm_runner_normalizes_nullable_usage(
323324
monkeypatch: pytest.MonkeyPatch,
325+
api: str,
324326
counts: tuple[int | None, int | None, int | None] | None,
325327
expected: tuple[int, int, int],
326328
) -> None:
@@ -335,17 +337,38 @@ async def test_any_llm_runner_normalizes_nullable_chat_usage(
335337
if counts is not None
336338
else None
337339
)
338-
chat = _chat_completion("Hello")
339340
# Provider SDK parsing can construct typed responses without validating null counts.
340-
chat.usage = CompletionUsage.model_construct(**usage) if usage is not None else None
341-
if chat.usage is not None:
342-
chat.usage.prompt_tokens_details = PromptTokensDetails(cached_tokens=3)
343-
chat.usage.completion_tokens_details = CompletionTokensDetails(reasoning_tokens=2)
344-
provider = FakeAnyLLMProvider(supports_responses=False, chat_response=chat)
341+
if api == "responses":
342+
usage = (
343+
{
344+
"input_tokens": counts[0],
345+
"output_tokens": counts[1],
346+
"total_tokens": counts[2],
347+
"input_tokens_details": {"cached_tokens": 3, "cache_write_tokens": 0},
348+
"output_tokens_details": {"reasoning_tokens": 2},
349+
}
350+
if counts is not None
351+
else None
352+
)
353+
response = _response("Hello")
354+
response.usage = ResponseUsage.model_construct(**usage) if usage is not None else None
355+
if response.usage is not None:
356+
response.usage.input_tokens_details = InputTokensDetails.model_validate(
357+
{"cached_tokens": 3, "cache_write_tokens": 0}
358+
)
359+
response.usage.output_tokens_details = OutputTokensDetails(reasoning_tokens=2)
360+
provider = FakeAnyLLMProvider(supports_responses=True, responses_response=response)
361+
else:
362+
chat = _chat_completion("Hello")
363+
chat.usage = CompletionUsage.model_construct(**usage) if usage is not None else None
364+
if chat.usage is not None:
365+
chat.usage.prompt_tokens_details = PromptTokensDetails(cached_tokens=3)
366+
chat.usage.completion_tokens_details = CompletionTokensDetails(reasoning_tokens=2)
367+
provider = FakeAnyLLMProvider(supports_responses=False, chat_response=chat)
345368
module, _ = _import_any_llm_module(monkeypatch, provider)
346369
agent = Agent(
347370
name="test",
348-
model=module.AnyLLMModel(model="openai/fake", api="chat_completions"),
371+
model=module.AnyLLMModel(model="openai/fake", api=api),
349372
model_settings=ModelSettings(preserve_raw_usage=True),
350373
)
351374
result = await Runner.run(agent, "hi")
@@ -357,6 +380,14 @@ async def test_any_llm_runner_normalizes_nullable_chat_usage(
357380
assert normalized.input_tokens_details.cached_tokens == (3 if counts is not None else 0)
358381
assert normalized.output_tokens_details.reasoning_tokens == (2 if counts is not None else 0)
359382
assert result.raw_responses[0].raw_usage == usage
383+
if expected == (0, 0, 0):
384+
assert normalized.request_usage_entries == []
385+
else:
386+
assert len(normalized.request_usage_entries) == 1
387+
entry = normalized.request_usage_entries[0]
388+
assert (entry.input_tokens, entry.output_tokens, entry.total_tokens) == expected
389+
assert entry.input_tokens_details.cached_tokens == 3
390+
assert entry.output_tokens_details.reasoning_tokens == 2
360391

361392

362393
@pytest.mark.allow_call_model_methods

‎tests/models/test_litellm_usage_requests.py‎

Lines changed: 63 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1,7 +1,13 @@
11
import litellm
22
import pytest
33
from litellm.types.utils import Choices, Message, ModelResponse
4+
from openai.types.completion_usage import (
5+
CompletionTokensDetails,
6+
CompletionUsage,
7+
PromptTokensDetails,
8+
)
49

10+
from agents import Agent, Runner
511
from agents.extensions.models.litellm_model import LitellmModel
612
from agents.model_settings import ModelSettings
713
from agents.models.interface import ModelTracing
@@ -43,3 +49,60 @@ async def test_request_is_counted_when_litellm_reports_no_usage(monkeypatch) ->
4349
assert resp.usage.input_tokens == 0
4450
assert resp.usage.output_tokens == 0
4551
assert resp.usage.total_tokens == 0
52+
53+
54+
@pytest.mark.allow_call_model_methods
55+
@pytest.mark.asyncio
56+
@pytest.mark.parametrize(
57+
("counts", "expected"),
58+
[
59+
((None, 5, 12), (0, 5, 12)),
60+
((7, None, 12), (7, 0, 12)),
61+
((7, 5, None), (7, 5, 0)),
62+
((None, None, None), (0, 0, 0)),
63+
((0, 0, 0), (0, 0, 0)),
64+
((7, 5, 12), (7, 5, 12)),
65+
],
66+
ids=["null-input", "null-output", "null-total", "all-null", "zero", "valid"],
67+
)
68+
async def test_runner_normalizes_nullable_litellm_usage(
69+
monkeypatch: pytest.MonkeyPatch,
70+
counts: tuple[int | None, int | None, int | None],
71+
expected: tuple[int, int, int],
72+
) -> None:
73+
response = _response_without_usage()
74+
# Preserve provider nulls through the adapter boundary instead of normalizing in the fixture.
75+
usage = CompletionUsage.model_construct(
76+
prompt_tokens=counts[0],
77+
completion_tokens=counts[1],
78+
total_tokens=counts[2],
79+
prompt_tokens_details=PromptTokensDetails(cached_tokens=3),
80+
completion_tokens_details=CompletionTokensDetails(reasoning_tokens=2),
81+
)
82+
response.usage = usage # type: ignore[attr-defined]
83+
84+
async def fake_acompletion(**kwargs):
85+
return response
86+
87+
monkeypatch.setattr(litellm, "acompletion", fake_acompletion)
88+
agent = Agent(
89+
name="test",
90+
model=LitellmModel(model="test-model"),
91+
)
92+
result = await Runner.run(agent, "hi")
93+
94+
assert result.final_output == "ok"
95+
normalized = result.context_wrapper.usage
96+
assert normalized.requests == 1
97+
assert (normalized.input_tokens, normalized.output_tokens, normalized.total_tokens) == expected
98+
assert normalized.input_tokens_details.cached_tokens == 3
99+
assert normalized.output_tokens_details.reasoning_tokens == 2
100+
assert (usage.prompt_tokens, usage.completion_tokens, usage.total_tokens) == counts
101+
if expected == (0, 0, 0):
102+
assert normalized.request_usage_entries == []
103+
else:
104+
assert len(normalized.request_usage_entries) == 1
105+
entry = normalized.request_usage_entries[0]
106+
assert (entry.input_tokens, entry.output_tokens, entry.total_tokens) == expected
107+
assert entry.input_tokens_details.cached_tokens == 3
108+
assert entry.output_tokens_details.reasoning_tokens == 2

‎tests/models/test_openai_responses.py‎

Lines changed: 76 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -56,9 +56,85 @@
5656
from agents.retry import ModelRetryAdviceRequest
5757
from agents.usage import Usage
5858
from tests.model_test_helpers import get_response_obj
59+
from tests.test_responses import get_text_message
5960
from tests.testing_processor import fetch_ordered_spans
6061

6162

63+
@pytest.mark.allow_call_model_methods
64+
@pytest.mark.asyncio
65+
@pytest.mark.parametrize("stream", [False, True], ids=["non-streaming", "streaming"])
66+
@pytest.mark.parametrize(
67+
("counts", "expected"),
68+
[
69+
((None, 5, 12), (0, 5, 12)),
70+
((7, None, 12), (7, 0, 12)),
71+
((7, 5, None), (7, 5, 0)),
72+
((None, None, None), (0, 0, 0)),
73+
((0, 0, 0), (0, 0, 0)),
74+
((7, 5, 12), (7, 5, 12)),
75+
],
76+
ids=["null-input", "null-output", "null-total", "all-null", "zero", "valid"],
77+
)
78+
async def test_runner_normalizes_nullable_responses_usage(
79+
stream: bool,
80+
counts: tuple[int | None, int | None, int | None],
81+
expected: tuple[int, int, int],
82+
) -> None:
83+
usage = {
84+
"input_tokens": counts[0],
85+
"output_tokens": counts[1],
86+
"total_tokens": counts[2],
87+
"input_tokens_details": {"cached_tokens": 3},
88+
"output_tokens_details": {"reasoning_tokens": 2},
89+
}
90+
91+
# Exercise provider parsing and usage conversion instead of a normalized scripted model.
92+
async def handler(request: httpx2.Request) -> httpx2.Response:
93+
payload = get_response_obj([get_text_message("Hello")]).model_dump()
94+
payload["usage"] = usage
95+
if stream:
96+
event = {"type": "response.completed", "response": payload, "sequence_number": 0}
97+
return httpx2.Response(
98+
200,
99+
content=f"event: response.completed\ndata: {json.dumps(event)}\n\n",
100+
headers={"content-type": "text/event-stream"},
101+
)
102+
return httpx2.Response(200, json=payload)
103+
104+
async with AsyncOpenAI(
105+
api_key="test-key",
106+
base_url="https://provider.example/v1",
107+
http_client=httpx2.AsyncClient(transport=httpx2.MockTransport(handler)),
108+
) as client:
109+
agent = Agent(
110+
name="test",
111+
model=OpenAIResponsesModel(model="fake", openai_client=client),
112+
model_settings=ModelSettings(preserve_raw_usage=True),
113+
)
114+
if stream:
115+
result = Runner.run_streamed(agent, "hi")
116+
async for _ in result.stream_events():
117+
pass
118+
else:
119+
result = await Runner.run(agent, "hi")
120+
121+
assert result.final_output == "Hello"
122+
normalized = result.context_wrapper.usage
123+
assert normalized.requests == 1
124+
assert (normalized.input_tokens, normalized.output_tokens, normalized.total_tokens) == expected
125+
assert normalized.input_tokens_details.cached_tokens == 3
126+
assert normalized.output_tokens_details.reasoning_tokens == 2
127+
assert result.raw_responses[0].raw_usage == usage
128+
if expected == (0, 0, 0):
129+
assert normalized.request_usage_entries == []
130+
else:
131+
assert len(normalized.request_usage_entries) == 1
132+
entry = normalized.request_usage_entries[0]
133+
assert (entry.input_tokens, entry.output_tokens, entry.total_tokens) == expected
134+
assert entry.input_tokens_details.cached_tokens == 3
135+
assert entry.output_tokens_details.reasoning_tokens == 2
136+
137+
62138
async def _run_responses_model_with_custom_base_url(
63139
model_settings: ModelSettings | dict[str, Any] | None = None,
64140
) -> dict[str, Any]:

0 commit comments

Comments
 (0)