@@ -115,6 +115,7 @@ Looking to upgrade from Sentry SDK 2.x to 3.x? Here's a comprehensive list of wh
 - Dropped support for PySpark below 3.0.
 - Dropped support for redis-py below 4.2.
 - Dropped support for Pydantic AI below 1.76.
+- Dropped support for OpenAI Agents below 0.10.3.
 - Removed the RedisIntegration `max_data_size` option.
 - Removed the possibility to supply a specific client to the LaunchDarklyIntegration.
 - The `enable_tracing` option was removed. Use `traces_sample_rate=1.0` instead.
 
@@ -1,18 +1,17 @@
 from typing import TYPE_CHECKING
 
-from sentry_sdk.ai.utils import _set_span_data_attribute
 from sentry_sdk.consts import SPANDATA
-from sentry_sdk.traces import StreamedSpan
-from sentry_sdk.tracing import Span
 
 if TYPE_CHECKING:
     from typing import Any, Awaitable, Callable, Optional, TypeVar, Union
 
+    from sentry_sdk.traces import StreamedSpan
+
     F = TypeVar("F", bound=Union[Callable[..., Any], Callable[..., Awaitable[Any]]])
 
 
 def record_token_usage(
-    span: "Union[Span, StreamedSpan]",
+    span: "StreamedSpan",
     input_tokens: "Optional[int]" = None,
     input_tokens_cached: "Optional[int]" = None,
     input_tokens_cache_write: "Optional[int]" = None,
@@ -21,30 +20,25 @@ def record_token_usage(
     total_tokens: "Optional[int]" = None,
 ) -> None:
     if input_tokens is not None:
-        _set_span_data_attribute(span, SPANDATA.GEN_AI_USAGE_INPUT_TOKENS, input_tokens)
+        span.set_attribute(SPANDATA.GEN_AI_USAGE_INPUT_TOKENS, input_tokens)
 
     if input_tokens_cached is not None:
-        _set_span_data_attribute(
-            span,
+        span.set_attribute(
             SPANDATA.GEN_AI_USAGE_CACHE_READ_INPUT_TOKENS,
             input_tokens_cached,
         )
 
     if input_tokens_cache_write is not None:
-        _set_span_data_attribute(
-            span,
+        span.set_attribute(
             SPANDATA.GEN_AI_USAGE_CACHE_CREATION_INPUT_TOKENS,
             input_tokens_cache_write,
         )
 
     if output_tokens is not None:
-        _set_span_data_attribute(
-            span, SPANDATA.GEN_AI_USAGE_OUTPUT_TOKENS, output_tokens
-        )
+        span.set_attribute(SPANDATA.GEN_AI_USAGE_OUTPUT_TOKENS, output_tokens)
 
     if output_tokens_reasoning is not None:
-        _set_span_data_attribute(
-            span,
+        span.set_attribute(
             SPANDATA.GEN_AI_USAGE_REASONING_OUTPUT_TOKENS,
             output_tokens_reasoning,
         )
@@ -53,4 +47,4 @@ def record_token_usage(
         total_tokens = input_tokens + output_tokens
 
     if total_tokens is not None:
-        _set_span_data_attribute(span, SPANDATA.GEN_AI_USAGE_TOTAL_TOKENS, total_tokens)
+        span.set_attribute(SPANDATA.GEN_AI_USAGE_TOTAL_TOKENS, total_tokens)
@@ -3,12 +3,11 @@
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
-    from typing import Any, Dict, Optional, Tuple, Union
+    from typing import Any, Dict, Optional, Tuple
 
-    from sentry_sdk.tracing import Span
+    from sentry_sdk.traces import StreamedSpan
 
 import sentry_sdk
-from sentry_sdk.traces import StreamedSpan
 from sentry_sdk.utils import logger
 
 
@@ -449,25 +448,16 @@ def _normalize_data(data: "Any", unpack: bool = True) -> "Any":
 
 
 def set_data_normalized(
-    span: "Union[Span, StreamedSpan]",
+    span: "StreamedSpan",
     key: str,
     value: "Any",
     unpack: bool = True,
 ) -> None:
     normalized = _normalize_data(value, unpack=unpack)
     if isinstance(normalized, (int, float, bool, str)):
-        _set_span_data_attribute(span, key, normalized)
+        span.set_attribute(key, normalized)
     else:
-        _set_span_data_attribute(span, key, json.dumps(normalized))
-
-
-def _set_span_data_attribute(
-    span: "Union[Span, StreamedSpan]", key: str, value: "Any"
-) -> None:
-    if isinstance(span, StreamedSpan):
-        span.set_attribute(key, value)
-    else:
-        span.set_data(key, value)
+        span.set_attribute(key, json.dumps(normalized))
 
 
 def normalize_message_role(role: str) -> str:
 
@@ -593,6 +593,12 @@ class SPANDATA:
     Example: [{"role": "assistant", "parts": [{"type": "text", "content": "The weather in Paris is currently rainy with a temperature of 57°F."}], "finish_reason": "stop"}]
     """
 
+    GEN_AI_RESPONSE_TIME_TO_FIRST_CHUNK = "gen_ai.response.time_to_first_chunk"
+    """
+    Time in seconds when the first response content chunk arrived in streaming responses.
+    Example: 0.6853435
+    """
+
     GEN_AI_RESPONSE_TIME_TO_FIRST_TOKEN = "gen_ai.response.time_to_first_token"
     """
     The time it took to receive the first token from the model.
 
@@ -155,7 +155,7 @@ def iter_default_integrations(
     "loguru": (0, 7, 0),
     "mcp": (1, 15, 0),
     "openai": (1, 0, 0),
-    "openai_agents": (0, 0, 19),
+    "openai_agents": (0, 10, 3),
     "openfeature": (0, 7, 1),
     "pydantic_ai": (1, 76, 0),
     "pymongo": (3, 5, 0),
 
@@ -73,7 +73,6 @@
     from aiohttp.web_urldispatcher import UrlMappingMatchInfo
 
     from sentry_sdk._types import Attributes, Event, EventProcessor
-    from sentry_sdk.tracing import Span
     from sentry_sdk.utils import ExcInfo
 
 
@@ -343,7 +342,7 @@ async def on_request_start(
             parsed_url.url if parsed_url else SENSITIVE_DATA_SUBSTITUTE,
         )
 
-        span: "Union[Span, StreamedSpan, None]" = None
+        span: "Optional[StreamedSpan]" = None
         attributes: "Attributes" = {
             "sentry.op": OP.HTTP_CLIENT,
             "sentry.origin": AioHttpIntegration.origin,
 
@@ -241,32 +241,21 @@ def _get_connect_data(conn: Any, *, use_streaming_keys: bool = False) -> dict[st
 
 def _set_db_data(span: Any, conn: Any) -> None:
     """Set database-related span data from connection object."""
-    if isinstance(span, StreamedSpan):
-        set_value = span.set_attribute
-        db_system = SPANDATA.DB_SYSTEM_NAME
-        db_name = SPANDATA.DB_NAMESPACE
-    else:
-        # Remove this else block once we've completely migrated to streamed spans
-        # The use of deprecated attributes here is to ensure backwards compatibility
-        set_value = span.set_data
-        db_system = SPANDATA.DB_SYSTEM
-        db_name = SPANDATA.DB_NAME
-
-    set_value(db_system, "mysql")
-    set_value(SPANDATA.DB_DRIVER_NAME, "aiomysql")
+    span.set_attribute(SPANDATA.DB_SYSTEM_NAME, "mysql")
+    span.set_attribute(SPANDATA.DB_DRIVER_NAME, "aiomysql")
 
     host = getattr(conn, "host", None)
     if host is not None:
-        set_value(SPANDATA.SERVER_ADDRESS, host)
+        span.set_attribute(SPANDATA.SERVER_ADDRESS, host)
 
     port = getattr(conn, "port", None)
     if port is not None:
-        set_value(SPANDATA.SERVER_PORT, port)
+        span.set_attribute(SPANDATA.SERVER_PORT, port)
 
     database = getattr(conn, "db", None)
     if database is not None:
-        set_value(db_name, database)
+        span.set_attribute(SPANDATA.DB_NAMESPACE, database)
 
     user = getattr(conn, "user", None)
     if user is not None:
-        set_value(SPANDATA.DB_USER, user)
+        span.set_attribute(SPANDATA.DB_USER, user)
@@ -455,7 +455,7 @@ def _set_common_input_data(
     """
     Set input data for the span based on the provided keyword arguments for the anthropic message creation.
     """
-    span.set_attribute(SPANDATA.GEN_AI_SYSTEM, "anthropic")
+    span.set_attribute(SPANDATA.GEN_AI_PROVIDER_NAME, "anthropic")
     span.set_attribute(SPANDATA.GEN_AI_OPERATION_NAME, "chat")
 
     if max_tokens is not None and _is_given(max_tokens):