Merge branch 'master' into webb/openai-agents-prompt-message

Author: alexander-alderman-webb

sentry_sdk/integrations/anthropic.py

@@ -39,13 +39,14 @@
     from anthropic.resources import AsyncMessages, Messages
 
     if TYPE_CHECKING:
-        from anthropic.types import MessageStreamEvent
+        from anthropic.types import MessageStreamEvent, TextBlockParam
 except ImportError:
     raise DidNotEnable("Anthropic not installed")
 
 if TYPE_CHECKING:
     from typing import Any, AsyncIterator, Iterator, List, Optional, Union
     from sentry_sdk.tracing import Span
+    from sentry_sdk._types import TextPart
 
 
 class AnthropicIntegration(Integration):
@@ -177,44 +178,53 @@ def _transform_anthropic_content_block(
     return result if result is not None else content_block
 
 
+def _transform_system_instructions(
+    system_instructions: "Union[str, Iterable[TextBlockParam]]",
+) -> "list[TextPart]":
+    if isinstance(system_instructions, str):
+        return [
+            {
+                "type": "text",
+                "content": system_instructions,
+            }
+        ]
+
+    return [
+        {
+            "type": "text",
+            "content": instruction["text"],
+        }
+        for instruction in system_instructions
+        if isinstance(instruction, dict) and "text" in instruction
+    ]
+
+
 def _set_input_data(
     span: "Span", kwargs: "dict[str, Any]", integration: "AnthropicIntegration"
 ) -> None:
     """
     Set input data for the span based on the provided keyword arguments for the anthropic message creation.
     """
     set_data_normalized(span, SPANDATA.GEN_AI_OPERATION_NAME, "chat")
-    system_prompt = kwargs.get("system")
+    system_instructions: "Union[str, Iterable[TextBlockParam]]" = kwargs.get("system")  # type: ignore
     messages = kwargs.get("messages")
     if (
         messages is not None
         and len(messages) > 0
         and should_send_default_pii()
         and integration.include_prompts
     ):
-        normalized_messages = []
-        if system_prompt:
-            system_prompt_content: "Optional[Union[str, List[dict[str, Any]]]]" = None
-            if isinstance(system_prompt, str):
-                system_prompt_content = system_prompt
-            elif isinstance(system_prompt, Iterable):
-                system_prompt_content = []
-                for item in system_prompt:
-                    if (
-                        isinstance(item, dict)
-                        and item.get("type") == "text"
-                        and item.get("text")
-                    ):
-                        system_prompt_content.append(item.copy())
-
-            if system_prompt_content:
-                normalized_messages.append(
-                    {
-                        "role": GEN_AI_ALLOWED_MESSAGE_ROLES.SYSTEM,
-                        "content": system_prompt_content,
-                    }
-                )
+        if isinstance(system_instructions, str) or isinstance(
+            system_instructions, Iterable
+        ):
+            set_data_normalized(
+                span,
+                SPANDATA.GEN_AI_SYSTEM_INSTRUCTIONS,
+                _transform_system_instructions(system_instructions),
+                unpack=False,
+            )
 
+        normalized_messages = []
         for message in messages:
             if (
                 message.get("role") == GEN_AI_ALLOWED_MESSAGE_ROLES.USER

sentry_sdk/integrations/langchain.py

@@ -36,6 +36,7 @@
     from uuid import UUID
 
     from sentry_sdk.tracing import Span
+    from sentry_sdk._types import TextPart
 
 
 try:
@@ -189,6 +190,40 @@ def _get_current_agent() -> "Optional[str]":
     return None
 
 
+def _get_system_instructions(messages: "List[List[BaseMessage]]") -> "List[str]":
+    system_instructions = []
+
+    for list_ in messages:
+        for message in list_:
+            # type of content: str | list[str | dict] | None
+            if message.type == "system" and isinstance(message.content, str):
+                system_instructions.append(message.content)
+
+            elif message.type == "system" and isinstance(message.content, list):
+                for item in message.content:
+                    if isinstance(item, str):
+                        system_instructions.append(item)
+
+                    elif isinstance(item, dict) and item.get("type") == "text":
+                        instruction = item.get("text")
+                        if isinstance(instruction, str):
+                            system_instructions.append(instruction)
+
+    return system_instructions
+
+
+def _transform_system_instructions(
+    system_instructions: "List[str]",
+) -> "List[TextPart]":
+    return [
+        {
+            "type": "text",
+            "content": instruction,
+        }
+        for instruction in system_instructions
+    ]
+
+
 class LangchainIntegration(Integration):
     identifier = "langchain"
     origin = f"auto.ai.{identifier}"
@@ -430,9 +465,21 @@ def on_chat_model_start(
             _set_tools_on_span(span, all_params.get("tools"))
 
             if should_send_default_pii() and self.include_prompts:
+                system_instructions = _get_system_instructions(messages)
+                if len(system_instructions) > 0:
+                    set_data_normalized(
+                        span,
+                        SPANDATA.GEN_AI_SYSTEM_INSTRUCTIONS,
+                        _transform_system_instructions(system_instructions),
+                        unpack=False,
+                    )
+
                 normalized_messages = []
                 for list_ in messages:
                     for message in list_:
+                        if message.type == "system":
+                            continue
+
                         normalized_messages.append(
                             self._normalize_langchain_message(message)
                         )

sentry_sdk/integrations/pydantic_ai/spans/ai_client.py

@@ -26,9 +26,11 @@
 if TYPE_CHECKING:
     from typing import Any, List, Dict
     from pydantic_ai.usage import RequestUsage  # type: ignore
+    from pydantic_ai.messages import ModelMessage, SystemPromptPart  # type: ignore
+    from sentry_sdk._types import TextPart as SentryTextPart
 
 try:
-    from pydantic_ai.messages import (  # type: ignore
+    from pydantic_ai.messages import (
         BaseToolCallPart,
         BaseToolReturnPart,
         SystemPromptPart,
@@ -48,6 +50,47 @@
     BinaryContent = None
 
 
+def _transform_system_instructions(
+    permanent_instructions: "list[SystemPromptPart]",
+    current_instructions: "list[str]",
+) -> "list[SentryTextPart]":
+    text_parts: "list[SentryTextPart]" = [
+        {
+            "type": "text",
+            "content": instruction.content,
+        }
+        for instruction in permanent_instructions
+    ]
+
+    text_parts.extend(
+        {
+            "type": "text",
+            "content": instruction,
+        }
+        for instruction in current_instructions
+    )
+
+    return text_parts
+
+
+def _get_system_instructions(
+    messages: "list[ModelMessage]",
+) -> "tuple[list[SystemPromptPart], list[str]]":
+    permanent_instructions = []
+    current_instructions = []
+
+    for msg in messages:
+        if hasattr(msg, "parts"):
+            for part in msg.parts:
+                if SystemPromptPart and isinstance(part, SystemPromptPart):
+                    permanent_instructions.append(part)
+
+        if hasattr(msg, "instructions") and msg.instructions is not None:
+            current_instructions.append(msg.instructions)
+
+    return permanent_instructions, current_instructions
+
+
 def _set_input_messages(span: "sentry_sdk.tracing.Span", messages: "Any") -> None:
     """Set input messages data on a span."""
     if not _should_send_prompts():
@@ -56,29 +99,27 @@ def _set_input_messages(span: "sentry_sdk.tracing.Span", messages: "Any") -> Non
     if not messages:
         return
 
+    permanent_instructions, current_instructions = _get_system_instructions(messages)
+    if len(permanent_instructions) > 0 or len(current_instructions) > 0:
+        set_data_normalized(
+            span,
+            SPANDATA.GEN_AI_SYSTEM_INSTRUCTIONS,
+            _transform_system_instructions(
+                permanent_instructions, current_instructions
+            ),
+            unpack=False,
+        )
+
     try:
         formatted_messages = []
-        system_prompt = None
-
-        # Extract system prompt from any ModelRequest with instructions
-        for msg in messages:
-            if hasattr(msg, "instructions") and msg.instructions:
-                system_prompt = msg.instructions
-                break
-
-        # Add system prompt as first message if present
-        if system_prompt:
-            formatted_messages.append(
-                {"role": "system", "content": [{"type": "text", "text": system_prompt}]}
-            )
 
         for msg in messages:
             if hasattr(msg, "parts"):
                 for part in msg.parts:
                     role = "user"
                     # Use isinstance checks with proper base classes
                     if SystemPromptPart and isinstance(part, SystemPromptPart):
-                        role = "system"
+                        continue
                     elif (
                         (TextPart and isinstance(part, TextPart))
                         or (ThinkingPart and isinstance(part, ThinkingPart))