fix(usage): copy RequestUsage entries instead of mutating other in place

The elif branch in Usage.add() was mutating agent_name/model_name directly
on the RequestUsage objects inside other.request_usage_entries, bypassing
the non-overwrite guard and causing silent mis-attribution when the same
Usage instance was added to multiple aggregators.

Fix: create a new RequestUsage copy for each entry with the annotation
applied, leaving the originals unchanged.

Adds a regression test that verifies the original entries are not mutated.

Author: Aditya Singh

src/agents/usage.py

@@ -238,13 +238,20 @@ def add(
             self.request_usage_entries.append(request_usage)
         elif other.request_usage_entries:
             # If the other Usage already has individual request breakdowns, merge them.
-            # Apply agent_name/model_name to entries that don't already have them set.
+            # Apply agent_name/model_name to entries that don't already have them set,
+            # but copy each entry rather than mutating the original objects in place
+            # to avoid silent mis-attribution when the same Usage is added multiple times.
             for entry in other.request_usage_entries:
-                if agent_name is not None and entry.agent_name is None:
-                    entry.agent_name = agent_name
-                if model_name is not None and entry.model_name is None:
-                    entry.model_name = model_name
-            self.request_usage_entries.extend(other.request_usage_entries)
+                annotated_entry = RequestUsage(
+                    input_tokens=entry.input_tokens,
+                    output_tokens=entry.output_tokens,
+                    total_tokens=entry.total_tokens,
+                    input_tokens_details=entry.input_tokens_details,
+                    output_tokens_details=entry.output_tokens_details,
+                    agent_name=agent_name if (agent_name is not None and entry.agent_name is None) else entry.agent_name,
+                    model_name=model_name if (model_name is not None and entry.model_name is None) else entry.model_name,
+                )
+                self.request_usage_entries.append(annotated_entry)
 
 
 def _serialize_usage_details(details: Any, default: dict[str, int]) -> dict[str, Any]:

tests/test_usage.py

@@ -610,3 +610,44 @@ async def test_multi_agent_run_attributes_usage_to_correct_agents():
 
     specialist_entry = next(e for e in all_entries if e.agent_name == "Specialist Agent")
     assert specialist_entry.input_tokens == 200
+
+
+def test_add_does_not_mutate_other_entries() -> None:
+    """Adding a Usage with existing request_usage_entries must not mutate the original entries.
+
+    Previously, the elif branch in Usage.add() called entry.agent_name = ... directly on
+    the objects inside other.request_usage_entries, causing silent mis-attribution when the
+    same Usage object was re-used or added to multiple aggregators.
+    """
+    from openai.types.responses.response_usage import InputTokensDetails, OutputTokensDetails
+
+    source_entry = RequestUsage(
+        input_tokens=50,
+        output_tokens=25,
+        total_tokens=75,
+        input_tokens_details=InputTokensDetails(cached_tokens=0),
+        output_tokens_details=OutputTokensDetails(reasoning_tokens=0),
+        agent_name=None,
+        model_name=None,
+    )
+
+    # Build a Usage that already has request_usage_entries (requests != 1 path)
+    other = Usage(
+        requests=2,
+        input_tokens=50,
+        output_tokens=25,
+        total_tokens=75,
+        request_usage_entries=[source_entry],
+    )
+
+    agg = Usage()
+    agg.add(other, agent_name="MyAgent", model_name="gpt-4o")
+
+    # The aggregator should have a copy with the annotation applied
+    assert len(agg.request_usage_entries) == 1
+    assert agg.request_usage_entries[0].agent_name == "MyAgent"
+    assert agg.request_usage_entries[0].model_name == "gpt-4o"
+
+    # The original entry must NOT be mutated
+    assert source_entry.agent_name is None, "Original entry was mutated!"
+    assert source_entry.model_name is None, "Original entry was mutated!"