@@ -11,6 +11,9 @@
 from ..logger import log_model_and_tool_action_warning
 from ..models._openai_shared import get_default_openai_client
 from ..run_internal.items import normalize_input_items_for_api
+from openai.types.responses.response_usage import InputTokensDetails, OutputTokensDetails
+
+from ..usage import Usage
 from .openai_conversations_session import OpenAIConversationsSession
 from .session import (
     OpenAIResponsesCompactionArgs,
@@ -122,6 +125,13 @@ def __init__(
 
         self.session_id = session_id
         self.underlying_session = underlying_session
+        self.compaction_usage = Usage()
+        """Tokens billed by responses.compact calls made by this session.
+
+        Compaction is a real model call, so it is billed, but it happens outside the
+        agent run loop and therefore never reaches ``RunResult.context_wrapper.usage``.
+        This accumulates it so the cost is visible rather than silently dropped.
+        """
         self._client = client
         self.model = model
         self.compaction_mode = compaction_mode
@@ -226,6 +236,8 @@ async def run_compaction(self, args: OpenAIResponsesCompactionArgs | None = None
 
         compacted = await self.client.responses.compact(**compact_kwargs)
 
+        self._record_compaction_usage(getattr(compacted, "usage", None))
+
         output_items = _strip_orphaned_assistant_ids(
             _normalize_compaction_output_items(compacted.output or [])
         )
@@ -247,6 +259,52 @@ async def run_compaction(self, args: OpenAIResponsesCompactionArgs | None = None
             len(self._compaction_candidate_items or []),
         )
 
+    def _record_compaction_usage(self, compacted_usage: Any) -> None:
+        """Accumulate the tokens a compaction pass billed.
+
+        Accounting must never break a run, so anything unexpected on the usage
+        object is logged and skipped rather than raised.
+        """
+        if compacted_usage is None:
+            return
+
+        def _count(name: str) -> int | None:
+            value = getattr(compacted_usage, name, None)
+            if value is None:
+                return 0
+            return value if isinstance(value, int) and not isinstance(value, bool) else None
+
+        input_tokens = _count("input_tokens")
+        output_tokens = _count("output_tokens")
+        total_tokens = _count("total_tokens")
+        if input_tokens is None or output_tokens is None or total_tokens is None:
+            logger.debug(
+                "compact: skipping usage for %s, unexpected token fields", self._response_id
+            )
+            return
+
+        usage = Usage(
+            requests=1,
+            input_tokens=input_tokens,
+            output_tokens=output_tokens,
+            total_tokens=total_tokens or input_tokens + output_tokens,
+        )
+        input_details = getattr(compacted_usage, "input_tokens_details", None)
+        if isinstance(input_details, InputTokensDetails):
+            usage.input_tokens_details = input_details
+        output_details = getattr(compacted_usage, "output_tokens_details", None)
+        if isinstance(output_details, OutputTokensDetails):
+            usage.output_tokens_details = output_details
+
+        self.compaction_usage.add(usage)
+        logger.debug(
+            "compact: usage for %s (input=%s, output=%s, total=%s)",
+            self._response_id,
+            input_tokens,
+            output_tokens,
+            usage.total_tokens,
+        )
+
     async def get_items(self, limit: int | None = None) -> list[TResponseInputItem]:
         return await self.underlying_session.get_items(limit)
 
 
@@ -0,0 +1,93 @@
+"""Compaction is a billed model call, so its tokens must not be discarded."""
+
+from __future__ import annotations
+
+from unittest.mock import AsyncMock, MagicMock
+
+import pytest
+from openai.types.responses.response_usage import InputTokensDetails, OutputTokensDetails
+
+from agents.memory.openai_responses_compaction_session import (
+    OpenAIResponsesCompactionSession,
+)
+from agents.memory.session import Session
+
+
+def _compact_response(input_tokens: int, output_tokens: int) -> MagicMock:
+    response = MagicMock()
+    response.output = []
+    response.usage = MagicMock()
+    response.usage.input_tokens = input_tokens
+    response.usage.output_tokens = output_tokens
+    response.usage.total_tokens = input_tokens + output_tokens
+    response.usage.input_tokens_details = InputTokensDetails(cached_tokens=0, cache_write_tokens=0)
+    response.usage.output_tokens_details = OutputTokensDetails(reasoning_tokens=0)
+    return response
+
+
+def _session(client: MagicMock) -> OpenAIResponsesCompactionSession:
+    return OpenAIResponsesCompactionSession(
+        session_id="s1",
+        underlying_session=MagicMock(spec=Session),
+        client=client,
+        model="gpt-4.1",
+        should_trigger_compaction=lambda _args: True,
+    )
+
+
+def test_compaction_usage_starts_empty() -> None:
+    session = _session(MagicMock())
+    assert session.compaction_usage.total_tokens == 0
+    assert session.compaction_usage.requests == 0
+
+
+@pytest.mark.asyncio
+async def test_compaction_usage_is_recorded() -> None:
+    client = MagicMock()
+    client.responses.compact = AsyncMock(return_value=_compact_response(150_000, 42_000))
+    session = _session(client)
+    session._response_id = "resp_1"
+    session._session_items = []
+    session._compaction_candidate_items = []
+
+    await session.run_compaction()
+
+    assert session.compaction_usage.requests == 1
+    assert session.compaction_usage.input_tokens == 150_000
+    assert session.compaction_usage.output_tokens == 42_000
+    assert session.compaction_usage.total_tokens == 192_000
+
+
+@pytest.mark.asyncio
+async def test_compaction_usage_accumulates_across_passes() -> None:
+    client = MagicMock()
+    client.responses.compact = AsyncMock(
+        side_effect=[_compact_response(100, 10), _compact_response(200, 20)]
+    )
+    session = _session(client)
+    session._response_id = "resp_1"
+    session._session_items = []
+    session._compaction_candidate_items = []
+
+    await session.run_compaction()
+    await session.run_compaction()
+
+    assert session.compaction_usage.requests == 2
+    assert session.compaction_usage.total_tokens == 330
+
+
+@pytest.mark.asyncio
+async def test_missing_usage_is_tolerated() -> None:
+    response = MagicMock()
+    response.output = []
+    response.usage = None
+    client = MagicMock()
+    client.responses.compact = AsyncMock(return_value=response)
+    session = _session(client)
+    session._response_id = "resp_1"
+    session._session_items = []
+    session._compaction_candidate_items = []
+
+    await session.run_compaction()
+
+    assert session.compaction_usage.total_tokens == 0