refactor(usage): narrow request attribution to agent name

Author: adityasingh2400

src/agents/run_internal/run_loop.py

@@ -260,31 +260,6 @@ def _should_attach_generic_agent_error(exc: Exception) -> bool:
     )
 
 
-def _get_model_name(model: Any) -> str | None:
-    """Extract the string model name from a Model instance, if available.
-
-    Most built-in model implementations (``OpenAIResponsesModel``,
-    ``OpenAIChatCompletionsModel``) expose a ``model`` attribute that contains
-    the underlying model name string. This helper retrieves it in a
-    forward-compatible, duck-typed way so that third-party model
-    implementations are handled gracefully.
-
-    The function tries ``model`` first, then ``model_name`` for
-    implementations that prefer that name. Any exception raised while
-    resolving the attribute (for example, a custom descriptor or property
-    that throws) is swallowed so that usage accounting can never crash the
-    run, and ``None`` is returned when no string-valued name is available.
-    """
-    for attr in ("model", "model_name"):
-        try:
-            value = getattr(model, attr, None)
-        except Exception:
-            continue
-        if isinstance(value, str) and value:
-            return value
-    return None
-
-
 async def _should_persist_stream_items(
     *,
     session: Session | None,
@@ -1641,7 +1616,6 @@ async def rewind_model_request() -> None:
         context_wrapper.usage.add(
             final_response.usage,
             agent_name=public_agent.name,
-            model_name=_get_model_name(model),
         )
         await asyncio.gather(
             (
@@ -1923,7 +1897,6 @@ async def rewind_model_request() -> None:
     context_wrapper.usage.add(
         new_response.usage,
         agent_name=public_agent.name,
-        model_name=_get_model_name(model),
     )
 
     await asyncio.gather(

src/agents/usage.py

@@ -44,7 +44,6 @@ def deserialize_usage(usage_data: Mapping[str, Any]) -> Usage:
                     OutputTokensDetails(reasoning_tokens=0),
                 ),
                 agent_name=entry.get("agent_name", None),
-                model_name=entry.get("model_name", None),
             )
         )
 
@@ -85,14 +84,6 @@ class RequestUsage:
     token usage and costs to specific agents in multi-agent workflows.
     """
 
-    model_name: str | None = None
-    """Name of the model used for this request, if available.
-
-    Populated automatically when an agent makes a model call so that callers can attribute
-    token usage and costs to specific models.
-    """
-
-
 def _normalize_input_tokens_details(
     v: InputTokensDetails | PromptTokensDetails | None,
 ) -> InputTokensDetails:
@@ -175,7 +166,6 @@ def add(
         other: Usage,
         *,
         agent_name: str | None = None,
-        model_name: str | None = None,
     ) -> None:
         """Add another Usage object to this one, aggregating all fields.
 
@@ -185,8 +175,6 @@ def add(
             other: The Usage object to add to this one.
             agent_name: Optional name of the agent making this request, used to annotate the
                 resulting ``RequestUsage`` entry for per-agent cost attribution.
-            model_name: Optional name of the model used for this request, used to annotate the
-                resulting ``RequestUsage`` entry for per-model cost attribution.
         """
         self.requests += other.requests if other.requests else 0
         self.input_tokens += other.input_tokens if other.input_tokens else 0
@@ -239,9 +227,6 @@ def add(
                         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)
             else:
@@ -256,12 +241,11 @@ def add(
                     input_tokens_details=input_details,
                     output_tokens_details=output_details,
                     agent_name=agent_name,
-                    model_name=model_name,
                 )
                 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 to entries that don't already have it 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:
@@ -274,9 +258,6 @@ def add(
                     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)
 
@@ -309,8 +290,6 @@ def _serialize_request_entry(entry: RequestUsage) -> dict[str, Any]:
         }
         if entry.agent_name is not None:
             result["agent_name"] = entry.agent_name
-        if entry.model_name is not None:
-            result["model_name"] = entry.model_name
         return result
 
     return {

tests/test_usage.py

@@ -380,12 +380,12 @@ def test_usage_normalizes_chat_completions_types():
 
 
 # ============================================================================
-# Tests for agent_name and model_name on RequestUsage (issue #2100)
+# Tests for agent_name on RequestUsage (issue #2100)
 # ============================================================================
 
 
-def test_request_usage_default_agent_model_names_are_none():
-    """Backward-compat: RequestUsage without agent_name/model_name defaults to None."""
+def test_request_usage_default_agent_name_is_none():
+    """Backward-compat: RequestUsage without agent_name defaults to None."""
     entry = RequestUsage(
         input_tokens=10,
         output_tokens=5,
@@ -394,14 +394,13 @@ def test_request_usage_default_agent_model_names_are_none():
         output_tokens_details=OutputTokensDetails(reasoning_tokens=0),
     )
     assert entry.agent_name is None
-    assert entry.model_name is None
 
 
-def test_serialize_deserialize_roundtrip_preserves_agent_and_model_names():
-    """JSON round-trip must preserve agent_name and model_name on each entry.
+def test_serialize_deserialize_roundtrip_preserves_agent_name():
+    """JSON round-trip must preserve agent_name on each entry.
 
     This guards against a regression where serialize_usage drops the new
-    attribution fields, or deserialize_usage forgets to read them back.
+    attribution field, or deserialize_usage forgets to read it back.
     Both branches of the conditional emit (entry-with-name and entry-without-name)
     are exercised so the all-None fast path can't silently strip the keys.
     """
@@ -414,7 +413,6 @@ def test_serialize_deserialize_roundtrip_preserves_agent_and_model_names():
         input_tokens_details=InputTokensDetails(cached_tokens=0),
         output_tokens_details=OutputTokensDetails(reasoning_tokens=0),
         agent_name="Math Tutor",
-        model_name="gpt-4o",
     )
     unnamed_entry = RequestUsage(
         input_tokens=2,
@@ -438,32 +436,28 @@ def test_serialize_deserialize_roundtrip_preserves_agent_and_model_names():
     restored_unnamed = restored.request_usage_entries[1]
 
     assert restored_named.agent_name == "Math Tutor"
-    assert restored_named.model_name == "gpt-4o"
     assert restored_named.input_tokens == 10
     assert restored_named.output_tokens == 5
 
     assert restored_unnamed.agent_name is None
-    assert restored_unnamed.model_name is None
     assert restored_unnamed.input_tokens == 2
 
 
-def test_request_usage_with_agent_and_model_names():
-    """RequestUsage can be created with explicit agent_name and model_name."""
+def test_request_usage_with_agent_name():
+    """RequestUsage can be created with an explicit agent_name."""
     entry = RequestUsage(
         input_tokens=10,
         output_tokens=5,
         total_tokens=15,
         input_tokens_details=InputTokensDetails(cached_tokens=0),
         output_tokens_details=OutputTokensDetails(reasoning_tokens=0),
         agent_name="Math Tutor",
-        model_name="gpt-4o",
     )
     assert entry.agent_name == "Math Tutor"
-    assert entry.model_name == "gpt-4o"
 
 
-def test_usage_add_propagates_agent_and_model_names():
-    """Usage.add() with agent_name/model_name annotates the RequestUsage entry."""
+def test_usage_add_propagates_agent_name():
+    """Usage.add() with agent_name annotates the RequestUsage entry."""
     parent = Usage()
     child = Usage(
         requests=1,
@@ -473,18 +467,17 @@ def test_usage_add_propagates_agent_and_model_names():
         input_tokens_details=InputTokensDetails(cached_tokens=0),
         output_tokens_details=OutputTokensDetails(reasoning_tokens=0),
     )
-    parent.add(child, agent_name="Code Reviewer", model_name="gpt-4o-mini")
+    parent.add(child, agent_name="Code Reviewer")
 
     assert len(parent.request_usage_entries) == 1
     entry = parent.request_usage_entries[0]
     assert entry.agent_name == "Code Reviewer"
-    assert entry.model_name == "gpt-4o-mini"
     assert entry.input_tokens == 65
     assert entry.output_tokens == 13
 
 
-def test_usage_add_without_agent_model_names_stays_none():
-    """Usage.add() without agent/model names leaves them as None (backward compat)."""
+def test_usage_add_without_agent_name_stays_none():
+    """Usage.add() without agent_name leaves it as None (backward compat)."""
     parent = Usage()
     child = Usage(
         requests=1,
@@ -499,19 +492,17 @@ def test_usage_add_without_agent_model_names_stays_none():
     assert len(parent.request_usage_entries) == 1
     entry = parent.request_usage_entries[0]
     assert entry.agent_name is None
-    assert entry.model_name is None
 
 
 def test_usage_add_single_request_preserves_prebuilt_entry_attribution():
-    """Single-request Usage with request_usage_entries keeps agent/model when add() has no kwargs."""
+    """Single-request Usage with request_usage_entries keeps agent name when add() has no kwargs."""
     inner = RequestUsage(
         input_tokens=20,
         output_tokens=10,
         total_tokens=30,
         input_tokens_details=InputTokensDetails(cached_tokens=0),
         output_tokens_details=OutputTokensDetails(reasoning_tokens=0),
         agent_name="Prior Run Agent",
-        model_name="prior-model",
     )
     child = Usage(
         requests=1,
@@ -528,11 +519,10 @@ def test_usage_add_single_request_preserves_prebuilt_entry_attribution():
     assert len(parent.request_usage_entries) == 1
     out = parent.request_usage_entries[0]
     assert out.agent_name == "Prior Run Agent"
-    assert out.model_name == "prior-model"
 
 
-def test_usage_add_merge_existing_entries_applies_agent_model_names():
-    """When merging existing request_usage_entries, agent/model names are applied to unset ones."""
+def test_usage_add_merge_existing_entries_applies_agent_name():
+    """When merging existing request_usage_entries, agent_name is applied to unset ones."""
     # An existing entry without names
     existing_entry = RequestUsage(
         input_tokens=100,
@@ -551,23 +541,21 @@ def test_usage_add_merge_existing_entries_applies_agent_model_names():
         output_tokens_details=OutputTokensDetails(reasoning_tokens=0),
         request_usage_entries=[existing_entry],
     )
-    parent.add(child, agent_name="Triage Agent", model_name="gpt-4o")
+    parent.add(child, agent_name="Triage Agent")
 
     assert len(parent.request_usage_entries) == 1
     assert parent.request_usage_entries[0].agent_name == "Triage Agent"
-    assert parent.request_usage_entries[0].model_name == "gpt-4o"
 
 
-def test_usage_add_merge_existing_entries_does_not_overwrite_names():
-    """Existing agent/model names on entries are not overwritten during merge."""
+def test_usage_add_merge_existing_entries_does_not_overwrite_agent_name():
+    """Existing agent_name on entries is not overwritten during merge."""
     existing_entry = RequestUsage(
         input_tokens=100,
         output_tokens=50,
         total_tokens=150,
         input_tokens_details=InputTokensDetails(cached_tokens=0),
         output_tokens_details=OutputTokensDetails(reasoning_tokens=0),
         agent_name="Already Named Agent",
-        model_name="already-named-model",
     )
     parent = Usage()
     child = Usage(
@@ -579,11 +567,10 @@ def test_usage_add_merge_existing_entries_does_not_overwrite_names():
         output_tokens_details=OutputTokensDetails(reasoning_tokens=0),
         request_usage_entries=[existing_entry],
     )
-    parent.add(child, agent_name="New Agent Name", model_name="new-model")
+    parent.add(child, agent_name="New Agent Name")
 
-    # The existing names should NOT be overwritten
+    # The existing name should NOT be overwritten
     assert parent.request_usage_entries[0].agent_name == "Already Named Agent"
-    assert parent.request_usage_entries[0].model_name == "already-named-model"
 
 
 @pytest.mark.asyncio
@@ -610,33 +597,6 @@ async def test_runner_run_populates_agent_name_in_request_usage():
     assert entries[0].agent_name == "My Assistant"
 
 
-@pytest.mark.asyncio
-async def test_runner_run_populates_model_name_in_request_usage():
-    """Integration: Running an agent populates model_name in RequestUsage entries."""
-    from agents.usage import Usage as AgentUsage
-
-    model_usage = AgentUsage(
-        requests=1,
-        input_tokens=30,
-        output_tokens=10,
-        total_tokens=40,
-        input_tokens_details=InputTokensDetails(cached_tokens=0),
-        output_tokens_details=OutputTokensDetails(reasoning_tokens=0),
-    )
-    # FakeModel doesn't expose a `.model` attribute by default → model_name should be None
-    # We give it one to test that model_name is picked up.
-    fake = FakeModel(initial_output=[get_text_message("ok")])
-    fake.model = "test-model-name"  # type: ignore[attr-defined]
-    fake.set_hardcoded_usage(model_usage)
-    agent = Agent(name="Model-Aware Agent", model=fake)
-
-    result = await Runner.run(agent, input="ping")
-
-    entries = result.context_wrapper.usage.request_usage_entries
-    assert len(entries) == 1
-    assert entries[0].model_name == "test-model-name"
-
-
 @pytest.mark.asyncio
 async def test_multi_agent_run_attributes_usage_to_correct_agents():
     """Multi-agent scenario: each RequestUsage entry has the right agent_name."""
@@ -663,12 +623,10 @@ async def test_multi_agent_run_attributes_usage_to_correct_agents():
     )
 
     specialist_model = FakeModel(initial_output=[get_text_message("specialist done")])
-    specialist_model.model = "gpt-4o-specialist"  # type: ignore[attr-defined]
     specialist_model.set_hardcoded_usage(specialist_usage)
     specialist_agent = Agent(name="Specialist Agent", model=specialist_model)
 
     triage_model = FakeModel()
-    triage_model.model = "gpt-4o-triage"  # type: ignore[attr-defined]
     triage_model.add_multiple_turn_outputs(
         [
             [get_handoff_tool_call(specialist_agent)],
@@ -688,16 +646,9 @@ async def test_multi_agent_run_attributes_usage_to_correct_agents():
 
     triage_entry = next(e for e in all_entries if e.agent_name == "Triage Agent")
     assert triage_entry.input_tokens == 100
-    assert triage_entry.model_name == "gpt-4o-triage", (
-        f"Triage entry model_name should be 'gpt-4o-triage', got {triage_entry.model_name!r}"
-    )
 
     specialist_entry = next(e for e in all_entries if e.agent_name == "Specialist Agent")
     assert specialist_entry.input_tokens == 200
-    assert specialist_entry.model_name == "gpt-4o-specialist", (
-        "Specialist entry model_name should be 'gpt-4o-specialist', "
-        f"got {specialist_entry.model_name!r}"
-    )
 
 
 def test_add_does_not_mutate_other_entries() -> None:
@@ -716,7 +667,6 @@ def test_add_does_not_mutate_other_entries() -> None:
         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)
@@ -729,13 +679,11 @@ def test_add_does_not_mutate_other_entries() -> None:
     )
 
     agg = Usage()
-    agg.add(other, agent_name="MyAgent", model_name="gpt-4o")
+    agg.add(other, agent_name="MyAgent")
 
     # 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!"