feat: implemented tokens_details throughout src

Author: WJPBProjects

src/agents/extensions/models/litellm_model.py

@@ -6,6 +6,7 @@
 from typing import Any, Literal, cast, overload
 
 import litellm.types
+from openai.types.responses.response_usage import InputTokensDetails, OutputTokensDetails
 
 from agents.exceptions import ModelBehaviorError
 
@@ -107,6 +108,16 @@ async def get_response(
                         input_tokens=response_usage.prompt_tokens,
                         output_tokens=response_usage.completion_tokens,
                         total_tokens=response_usage.total_tokens,
+                        input_tokens_details=InputTokensDetails(
+                            cached_tokens=getattr(
+                                response_usage.prompt_tokens_details, "cached_tokens", 0
+                            )
+                        ),
+                        output_tokens_details=OutputTokensDetails(
+                            reasoning_tokens=getattr(
+                                response_usage.completion_tokens_details, "reasoning_tokens", 0
+                            )
+                        ),
                     )
                     if response.usage
                     else Usage()

src/agents/models/openai_chatcompletions.py

@@ -9,6 +9,7 @@
 from openai.types import ChatModel
 from openai.types.chat import ChatCompletion, ChatCompletionChunk
 from openai.types.responses import Response
+from openai.types.responses.response_usage import InputTokensDetails, OutputTokensDetails
 
 from .. import _debug
 from ..agent_output import AgentOutputSchemaBase
@@ -83,6 +84,18 @@ async def get_response(
                     input_tokens=response.usage.prompt_tokens,
                     output_tokens=response.usage.completion_tokens,
                     total_tokens=response.usage.total_tokens,
+                    input_tokens_details=InputTokensDetails(
+                        cached_tokens=getattr(
+                            response.usage.prompt_tokens_details, "cached_tokens", 0
+                        )
+                        or 0,
+                    ),
+                    output_tokens_details=OutputTokensDetails(
+                        reasoning_tokens=getattr(
+                            response.usage.completion_tokens_details, "reasoning_tokens", 0
+                        )
+                        or 0,
+                    ),
                 )
                 if response.usage
                 else Usage()
@@ -252,7 +265,7 @@ async def _fetch_response(
             stream_options=self._non_null_or_not_given(stream_options),
             store=self._non_null_or_not_given(store),
             reasoning_effort=self._non_null_or_not_given(reasoning_effort),
-            extra_headers={ **HEADERS, **(model_settings.extra_headers or {}) },
+            extra_headers={**HEADERS, **(model_settings.extra_headers or {})},
             extra_query=model_settings.extra_query,
             extra_body=model_settings.extra_body,
             metadata=self._non_null_or_not_given(model_settings.metadata),

src/agents/models/openai_responses.py

@@ -98,6 +98,8 @@ async def get_response(
                         input_tokens=response.usage.input_tokens,
                         output_tokens=response.usage.output_tokens,
                         total_tokens=response.usage.total_tokens,
+                        input_tokens_details=response.usage.input_tokens_details,
+                        output_tokens_details=response.usage.output_tokens_details,
                     )
                     if response.usage
                     else Usage()

src/agents/run.py

@@ -689,6 +689,8 @@ async def _run_single_turn_streamed(
                         input_tokens=event.response.usage.input_tokens,
                         output_tokens=event.response.usage.output_tokens,
                         total_tokens=event.response.usage.total_tokens,
+                        input_tokens_details=event.response.usage.input_tokens_details,
+                        output_tokens_details=event.response.usage.output_tokens_details,
                     )
                     if event.response.usage
                     else Usage()

src/agents/usage.py

@@ -1,17 +1,34 @@
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from typing import TypeVar
 
 from openai.types.responses.response_usage import InputTokensDetails, OutputTokensDetails
+from pydantic import BaseModel
 
-T = TypeVar("T", bound="InputTokensDetails | OutputTokensDetails")
+T = TypeVar("T", bound=BaseModel)
 
 
-def add_numeric_fields(current: T, other: T) -> None:
-    for field in current.__dataclass_fields__:
-        v1 = getattr(current, field, 0)
-        v2 = getattr(other, field, 0)
+def add_numeric_fields(current: T, other: T) -> T:
+    """
+    Add numeric fields from other to current.
+    """
+    clone = current.model_copy()
+    for key, v1 in current.model_dump().items():
+        v2 = getattr(other, key, 0)
         if isinstance(v1, (int, float)) and isinstance(v2, (int, float)):
-            setattr(current, field, (v1 or 0) + (v2 or 0))
+            setattr(clone, key, (v1 or 0) + (v2 or 0))
+    return clone
+
+
+def add_input_tokens_details(
+    current: InputTokensDetails, other: InputTokensDetails
+) -> InputTokensDetails:
+    return add_numeric_fields(current, other)
+
+
+def add_output_tokens_details(
+    current: OutputTokensDetails, other: OutputTokensDetails
+) -> OutputTokensDetails:
+    return add_numeric_fields(current, other)
 
 
 @dataclass
@@ -22,12 +39,17 @@ class Usage:
     input_tokens: int = 0
     """Total input tokens sent, across all requests."""
 
-    input_tokens_details: InputTokensDetails = InputTokensDetails(cached_tokens=0)
-
+    input_tokens_details: InputTokensDetails = field(
+        default_factory=lambda: InputTokensDetails(cached_tokens=0)
+    )
+    """Details about the input tokens, matching responses API usage details."""
     output_tokens: int = 0
     """Total output tokens received, across all requests."""
 
-    output_tokens_details: OutputTokensDetails = OutputTokensDetails(reasoning_tokens=0)
+    output_tokens_details: OutputTokensDetails = field(
+        default_factory=lambda: OutputTokensDetails(reasoning_tokens=0)
+    )
+    """Details about the output tokens, matching responses API usage details."""
 
     total_tokens: int = 0
     """Total tokens sent and received, across all requests."""
@@ -37,5 +59,9 @@ def add(self, other: "Usage") -> None:
         self.input_tokens += other.input_tokens if other.input_tokens else 0
         self.output_tokens += other.output_tokens if other.output_tokens else 0
         self.total_tokens += other.total_tokens if other.total_tokens else 0
-        add_numeric_fields(self.input_tokens_details, other.input_tokens_details)
-        add_numeric_fields(self.output_tokens_details, other.output_tokens_details)
+        self.input_tokens_details = add_input_tokens_details(
+            self.input_tokens_details, other.input_tokens_details
+        )
+        self.output_tokens_details = add_output_tokens_details(
+            self.output_tokens_details, other.output_tokens_details
+        )