@@ -7,7 +7,7 @@
 import random
 import threading
 import time
-from collections.abc import Callable
+from collections.abc import Callable, Mapping, Sequence
 from functools import cached_property
 from typing import Any, cast
 
@@ -318,7 +318,10 @@ def _should_sanitize_for_openai_tracing_api(self) -> bool:
         return self.endpoint.rstrip("/") == self._OPENAI_TRACING_INGEST_ENDPOINT.rstrip("/")
 
     def _sanitize_for_openai_tracing_api(self, payload_item: dict[str, Any]) -> dict[str, Any]:
-        """Drop or truncate span fields known to be rejected by traces ingest."""
+        """Omit reasoning from generation data and enforce traces ingest field limits.
+
+        Original spans remain available to custom processors and exporters.
+        """
         span_data = payload_item.get("span_data")
         if not isinstance(span_data, dict):
             return payload_item
@@ -329,7 +332,10 @@ def _sanitize_for_openai_tracing_api(self, payload_item: dict[str, Any]) -> dict
         for field_name in ("input", "output"):
             if field_name not in span_data:
                 continue
-            sanitized_field = self._truncate_span_field_value(span_data[field_name])
+            field_value = span_data[field_name]
+            if span_data.get("type") == "generation":
+                field_value = self._omit_generation_reasoning(field_value)
+            sanitized_field = self._truncate_span_field_value(field_value)
             if sanitized_field is span_data[field_name]:
                 continue
             if not did_mutate:
@@ -377,6 +383,46 @@ def _sanitize_for_openai_tracing_api(self, payload_item: dict[str, Any]) -> dict
         sanitized_payload_item["span_data"] = sanitized_span_data
         return sanitized_payload_item
 
+    def _omit_generation_reasoning(self, value: Any) -> Any:
+        """Filter SDK generation message shapes without traversing arbitrary user data."""
+        if not isinstance(value, Sequence) or isinstance(value, str | bytes | bytearray):
+            return value
+
+        def omit_message_reasoning(item: Any) -> Any:
+            if not isinstance(item, Mapping):
+                return item
+            item = dict(item)
+            if item.get("role") == "assistant":
+                for key in ("reasoning", "reasoning_content", "thinking_blocks", "thinking"):
+                    item.pop(key, None)
+                content = item.get("content")
+                if isinstance(content, list):
+                    # Legacy thinking replay uses inline Anthropic content blocks.
+                    item["content"] = [
+                        part
+                        for part in content
+                        if not isinstance(part, dict)
+                        or part.get("type") not in ("thinking", "redacted_thinking")
+                    ]
+            return item
+
+        def omit_items(items: Sequence[Any]) -> list[Any]:
+            # Third-party reasoning_content is also normalized into summary text.
+            return [
+                omit_message_reasoning(item)
+                for item in items
+                if not isinstance(item, Mapping) or item.get("type") != "reasoning"
+            ]
+
+        return [
+            {**item, "output": omit_items(item["output"])}
+            if isinstance(item, Mapping)
+            and item.get("object") == "response"
+            and isinstance(item.get("output"), list)
+            else item
+            for item in omit_items(value)
+        ]
+
     def _value_json_size_bytes(self, value: Any) -> int:
         try:
             serialized = json.dumps(value, ensure_ascii=False, separators=(",", ":"))
 
@@ -1,12 +1,15 @@
 from __future__ import annotations
 
 import asyncio
+import copy
 import importlib
+import json
 import sys
 import types as pytypes
 from collections.abc import AsyncIterator
 from typing import Any, Literal, cast
 
+import httpx2
 import pytest
 from openai.types.chat import (
     ChatCompletion,
@@ -47,6 +50,8 @@
     ModelBehaviorError,
     ModelSettings,
     ModelTracing,
+    RunConfig,
+    Runner,
     Tool,
     TResponseInputItem,
     __version__,
@@ -57,6 +62,8 @@
 from agents.exceptions import UserError
 from agents.models.chatcmpl_helpers import HEADERS_OVERRIDE
 from agents.models.fake_id import FAKE_RESPONSES_ID
+from agents.tracing.processors import BackendSpanExporter
+from tests.testing_processor import fetch_ordered_spans
 
 
 class FakeAnyLLMProvider:
@@ -1589,6 +1596,50 @@ def test_any_llm_stream_flattens_reasoning_object_when_reasoning_content_is_empt
     assert normalized.choices[0].delta.reasoning == "Plaintext reasoning"
 
 
+@pytest.mark.allow_call_model_methods
+async def test_any_llm_thinking_is_omitted_from_default_trace_export(monkeypatch) -> None:
+    secret = "PRIVATE_ANY_LLM_THINKING_SENTINEL"
+    completion = _chat_completion("Visible answer")
+    completion.choices[0].message = ChatCompletionMessage.model_validate(
+        {"role": "assistant", "content": "Visible answer", "thinking": secret}
+    )
+    provider = FakeAnyLLMProvider(supports_responses=False, chat_response=completion)
+    module, _ = _import_any_llm_module(monkeypatch, provider)
+    model = module.AnyLLMModel(model="openrouter/test-model", api="chat_completions")
+    result = await Runner.run(
+        Agent(name="Test", model=model),
+        "Question",
+        run_config=RunConfig(trace_include_sensitive_data=True),
+    )
+    generation = next(span for span in fetch_ordered_spans() if span.span_data.type == "generation")
+    original = copy.deepcopy(generation.export())
+    assert original is not None
+    assert original["span_data"]["output"][0]["thinking"] == secret
+    replay = result.to_input_list()
+    assert secret in json.dumps(replay)
+    assert result.final_output == "Visible answer"
+
+    payloads: list[dict[str, Any]] = []
+
+    def post(self, url, **kwargs):
+        payloads.append(copy.deepcopy(kwargs["json"]))
+        return httpx2.Response(200)
+
+    monkeypatch.setattr(httpx2.Client, "post", post)
+    exporter = BackendSpanExporter(api_key="test-key", max_retries=0)
+    try:
+        exporter.export([generation])
+        sent = payloads[-1]["data"][0]["span_data"]
+        assert secret not in json.dumps(sent)
+        assert sent["output"][0]["content"] == "Visible answer"
+        assert sent["usage"]["output_tokens"] == 5
+        assert generation.export() == original
+        assert result.to_input_list() == replay
+    finally:
+        exporter.close()
+        await model.close()
+
+
 def test_any_llm_nonstream_preserves_native_reasoning_content_field(monkeypatch) -> None:
     provider = FakeAnyLLMProvider(supports_responses=False)
     module, _create_calls = _import_any_llm_module(monkeypatch, provider)