fix(integrations): openai/openai-agents: convert input message format

sentry_sdk/ai/utils.py

@@ -498,6 +498,46 @@ def set_data_normalized(
         span.set_data(key, json.dumps(normalized))
 
 
+def extract_response_output(
+    output_items: "Any",
+) -> "Tuple[List[Any], List[Dict[str, Any]]]":
+    """
+    Extract response text and tool calls from OpenAI Responses API output.
+
+    This handles the output format from OpenAI's Responses API where each output
+    item has a `type` field that can be "message" or "function_call".
+
+    Args:
+        output_items: Iterable of output items from the response
+
+    Returns:
+        Tuple of (response_texts, tool_calls) where:
+        - response_texts: List of text strings or dicts for unknown message types
+        - tool_calls: List of tool call dicts
+    """
+    response_texts = []  # type: List[Any]
+    tool_calls = []  # type: List[Dict[str, Any]]
+
+    for output in output_items:
+        if output.type == "function_call":
+            if hasattr(output, "model_dump"):
+                tool_calls.append(output.model_dump())
+            elif hasattr(output, "dict"):
+                tool_calls.append(output.dict())
+        elif output.type == "message":
+            for output_message in output.content:
+                try:
+                    response_texts.append(output_message.text)
+                except AttributeError:
+                    # Unknown output message type, just return the json
+                    if hasattr(output_message, "model_dump"):
+                        response_texts.append(output_message.model_dump())
+                    elif hasattr(output_message, "dict"):
+                        response_texts.append(output_message.dict())
+
+    return response_texts, tool_calls
+
+
 def normalize_message_role(role: str) -> str:
     """
     Normalize a message role to one of the 4 allowed gen_ai role values.

sentry_sdk/integrations/openai.py

@@ -5,8 +5,10 @@
 from sentry_sdk import consts
 from sentry_sdk.ai.monitoring import record_token_usage
 from sentry_sdk.ai.utils import (
+    extract_response_output,
     set_data_normalized,
     normalize_message_roles,
+    transform_openai_content_part,
     truncate_and_annotate_messages,
 )
 from sentry_sdk.consts import SPANDATA
@@ -203,6 +205,21 @@ def _set_input_data(
         and integration.include_prompts
     ):
         normalized_messages = normalize_message_roles(messages)
+        # Transform content parts to standardized format using OpenAI-specific transformer
+        for message in normalized_messages:
+            if isinstance(message, dict) and "content" in message:
+                content = message["content"]
+                if isinstance(content, (list, tuple)):
+                    transformed = []
+                    for item in content:
+                        if isinstance(item, dict):
+                            result = transform_openai_content_part(item)
+                            # If transformation succeeded, use the result; otherwise keep original
+                            transformed.append(result if result is not None else item)
+                        else:
+                            transformed.append(item)
+                    message["content"] = transformed
+
         scope = sentry_sdk.get_current_scope()
         messages_data = truncate_and_annotate_messages(normalized_messages, span, scope)
         if messages_data is not None:
@@ -265,49 +282,64 @@ def _set_output_data(
 
     if hasattr(response, "choices"):
         if should_send_default_pii() and integration.include_prompts:
-            response_text = [
-                choice.message.model_dump()
-                for choice in response.choices
-                if choice.message is not None
-            ]
+            response_text = []  # type: list[str]
+            tool_calls = []  # type: list[Any]
+
+            for choice in response.choices:
+                if choice.message is None:
+                    continue
+
+                # Extract text content
+                content = getattr(choice.message, "content", None)
+                if content is not None:
+                    response_text.append(content)
+
+                # Extract audio transcript if available
+                audio = getattr(choice.message, "audio", None)
+                if audio is not None:
+                    transcript = getattr(audio, "transcript", None)
+                    if transcript is not None:
+                        response_text.append(transcript)
+
+                # Extract tool calls
+                message_tool_calls = getattr(choice.message, "tool_calls", None)
+                if message_tool_calls is not None:
+                    for tool_call in message_tool_calls:
+                        if hasattr(tool_call, "model_dump"):
+                            tool_calls.append(tool_call.model_dump())
+                        elif hasattr(tool_call, "dict"):
+                            tool_calls.append(tool_call.dict())
+
             if len(response_text) > 0:
                 set_data_normalized(span, SPANDATA.GEN_AI_RESPONSE_TEXT, response_text)
 
+            if len(tool_calls) > 0:
+                set_data_normalized(
+                    span,
+                    SPANDATA.GEN_AI_RESPONSE_TOOL_CALLS,
+                    tool_calls,
+                    unpack=False,
+                )
+
         _calculate_token_usage(messages, response, span, None, integration.count_tokens)
 
         if finish_span:
             span.__exit__(None, None, None)
 
     elif hasattr(response, "output"):
         if should_send_default_pii() and integration.include_prompts:
-            output_messages: "dict[str, list[Any]]" = {
-                "response": [],
-                "tool": [],
-            }
-
-            for output in response.output:
-                if output.type == "function_call":
-                    output_messages["tool"].append(output.dict())
-                elif output.type == "message":
-                    for output_message in output.content:
-                        try:
-                            output_messages["response"].append(output_message.text)
-                        except AttributeError:
-                            # Unknown output message type, just return the json
-                            output_messages["response"].append(output_message.dict())
-
-            if len(output_messages["tool"]) > 0:
+            response_texts, tool_calls = extract_response_output(response.output)
+
+            if len(tool_calls) > 0:
                 set_data_normalized(
                     span,
                     SPANDATA.GEN_AI_RESPONSE_TOOL_CALLS,
-                    output_messages["tool"],
+                    tool_calls,
                     unpack=False,
                 )
 
-            if len(output_messages["response"]) > 0:
-                set_data_normalized(
-                    span, SPANDATA.GEN_AI_RESPONSE_TEXT, output_messages["response"]
-                )
+            if len(response_texts) > 0:
+                set_data_normalized(span, SPANDATA.GEN_AI_RESPONSE_TEXT, response_texts)
 
         _calculate_token_usage(messages, response, span, None, integration.count_tokens)
 

sentry_sdk/integrations/openai_agents/spans/invoke_agent.py

@@ -3,14 +3,19 @@
     get_start_span_function,
     set_data_normalized,
     normalize_message_roles,
+    normalize_message_role,
     truncate_and_annotate_messages,
 )
 from sentry_sdk.consts import OP, SPANDATA
 from sentry_sdk.scope import should_send_default_pii
 from sentry_sdk.utils import safe_serialize
 
 from ..consts import SPAN_ORIGIN
-from ..utils import _set_agent_data, _set_usage_data
+from ..utils import (
+    _set_agent_data,
+    _set_usage_data,
+    _transform_openai_agents_message_content,
+)
 
 from typing import TYPE_CHECKING
 
@@ -49,17 +54,40 @@ def invoke_agent_span(
 
         original_input = kwargs.get("original_input")
         if original_input is not None:
-            message = (
-                original_input
-                if isinstance(original_input, str)
-                else safe_serialize(original_input)
-            )
-            messages.append(
-                {
-                    "content": [{"text": message, "type": "text"}],
-                    "role": "user",
-                }
-            )
+            if isinstance(original_input, str):
+                # String input: wrap in text block
+                messages.append(
+                    {
+                        "content": [{"text": original_input, "type": "text"}],
+                        "role": "user",
+                    }
+                )
+            elif isinstance(original_input, list) and len(original_input) > 0:
+                # Check if list contains message objects (with type="message")
+                # or content parts (input_text, input_image, etc.)
+                first_item = original_input[0]
+                if isinstance(first_item, dict) and first_item.get("type") == "message":
+                    # List of message objects - process each individually
+                    for msg in original_input:
+                        if isinstance(msg, dict) and msg.get("type") == "message":
+                            role = normalize_message_role(msg.get("role", "user"))
+                            content = msg.get("content")
+                            transformed = _transform_openai_agents_message_content(
+                                content
+                            )
+                            if isinstance(transformed, str):
+                                transformed = [{"text": transformed, "type": "text"}]
+                            elif not isinstance(transformed, list):
+                                transformed = [
+                                    {"text": str(transformed), "type": "text"}
+                                ]
+                            messages.append({"content": transformed, "role": role})
+                else:
+                    # List of content parts - transform and wrap as user message
+                    content = _transform_openai_agents_message_content(original_input)
+                    if not isinstance(content, list):
+                        content = [{"text": str(content), "type": "text"}]
+                    messages.append({"content": content, "role": "user"})
 
         if len(messages) > 0:
             normalized_messages = normalize_message_roles(messages)