ddtrace 3.11.0rc1__cp312-cp312-win32.whl → 3.11.0rc3__cp312-cp312-win32.whl

ddtrace/llmobs/_integrations/openai_agents.py

@@ -8,7 +8,9 @@ import weakref
 
 from ddtrace.internal import core
 from ddtrace.internal.logger import get_logger
+from ddtrace.internal.utils import get_argument_value
 from ddtrace.internal.utils.formats import format_trace_id
+from ddtrace.llmobs._constants import AGENT_MANIFEST
 from ddtrace.llmobs._constants import DISPATCH_ON_LLM_TOOL_CHOICE
 from ddtrace.llmobs._constants import DISPATCH_ON_TOOL_CALL
 from ddtrace.llmobs._constants import DISPATCH_ON_TOOL_CALL_OUTPUT_USED
@@ -31,6 +33,7 @@ from ddtrace.llmobs._integrations.utils import OaiSpanAdapter
 from ddtrace.llmobs._integrations.utils import OaiTraceAdapter
 from ddtrace.llmobs._utils import _get_nearest_llmobs_ancestor
 from ddtrace.llmobs._utils import _get_span_name
+from ddtrace.llmobs._utils import load_data_value
 from ddtrace.trace import Pin
 from ddtrace.trace import Span
 
@@ -296,3 +299,145 @@ class OpenAIAgentsIntegration(BaseLLMIntegration):
     def clear_state(self) -> None:
         self.oai_to_llmobs_span.clear()
         self.llmobs_traces.clear()
+
+    def tag_agent_manifest(self, span: Span, args: List[Any], kwargs: Dict[str, Any], agent_index: int) -> None:
+        agent = get_argument_value(args, kwargs, agent_index, "agent", True)
+        if not agent or not self.llmobs_enabled:
+            return
+
+        manifest = {}
+        manifest["framework"] = "OpenAI"
+        if hasattr(agent, "name"):
+            manifest["name"] = agent.name
+        if hasattr(agent, "instructions"):
+            manifest["instructions"] = agent.instructions
+        if hasattr(agent, "handoff_description"):
+            manifest["handoff_description"] = agent.handoff_description
+        if hasattr(agent, "model"):
+            model = agent.model
+            manifest["model"] = model if isinstance(model, str) else getattr(model, "model", "")
+
+        model_settings = self._extract_model_settings_from_agent(agent)
+        if model_settings:
+            manifest["model_settings"] = model_settings
+
+        tools = self._extract_tools_from_agent(agent)
+        if tools:
+            manifest["tools"] = tools
+
+        handoffs = self._extract_handoffs_from_agent(agent)
+        if handoffs:
+            manifest["handoffs"] = handoffs
+
+        guardrails = self._extract_guardrails_from_agent(agent)
+        if guardrails:
+            manifest["guardrails"] = guardrails
+
+        span._set_ctx_item(AGENT_MANIFEST, manifest)
+
+    def _extract_model_settings_from_agent(self, agent):
+        if not hasattr(agent, "model_settings"):
+            return None
+
+        # convert model_settings to dict if it's not already
+        model_settings = agent.model_settings
+        if type(model_settings) != dict:
+            model_settings = getattr(model_settings, "__dict__", None)
+
+        return load_data_value(model_settings)
+
+    def _extract_tools_from_agent(self, agent):
+        if not hasattr(agent, "tools") or not agent.tools:
+            return None
+
+        tools = []
+        for tool in agent.tools:
+            tool_dict = {}
+            tool_name = getattr(tool, "name", None)
+            if tool_name:
+                tool_dict["name"] = tool_name
+            if tool_name == "web_search_preview":
+                if hasattr(tool, "user_location"):
+                    tool_dict["user_location"] = tool.user_location
+                if hasattr(tool, "search_context_size"):
+                    tool_dict["search_context_size"] = tool.search_context_size
+            elif tool_name == "file_search":
+                if hasattr(tool, "vector_store_ids"):
+                    tool_dict["vector_store_ids"] = tool.vector_store_ids
+                if hasattr(tool, "max_num_results"):
+                    tool_dict["max_num_results"] = tool.max_num_results
+                if hasattr(tool, "include_search_results"):
+                    tool_dict["include_search_results"] = tool.include_search_results
+                if hasattr(tool, "ranking_options"):
+                    tool_dict["ranking_options"] = tool.ranking_options
+                if hasattr(tool, "filters"):
+                    tool_dict["filters"] = tool.filters
+            elif tool_name == "computer_use_preview":
+                if hasattr(tool, "computer"):
+                    tool_dict["computer"] = tool.computer
+                if hasattr(tool, "on_safety_check"):
+                    tool_dict["on_safety_check"] = tool.on_safety_check
+            elif tool_name == "code_interpreter":
+                if hasattr(tool, "tool_config"):
+                    tool_dict["tool_config"] = tool.tool_config
+            elif tool_name == "hosted_mcp":
+                if hasattr(tool, "tool_config"):
+                    tool_dict["tool_config"] = tool.tool_config
+                if hasattr(tool, "on_approval_request"):
+                    tool_dict["on_approval_request"] = tool.on_approval_request
+            elif tool_name == "image_generation":
+                if hasattr(tool, "tool_config"):
+                    tool_dict["tool_config"] = tool.tool_config
+            elif tool_name == "local_shell":
+                if hasattr(tool, "executor"):
+                    tool_dict["executor"] = tool.executor
+            else:
+                if hasattr(tool, "description"):
+                    tool_dict["description"] = tool.description
+                if hasattr(tool, "strict_json_schema"):
+                    tool_dict["strict_json_schema"] = tool.strict_json_schema
+                if hasattr(tool, "params_json_schema"):
+                    parameter_schema = tool.params_json_schema
+                    required_params = {param: True for param in parameter_schema.get("required", [])}
+                    parameters = {}
+                    for param, schema in parameter_schema.get("properties", {}).items():
+                        param_dict = {}
+                        if "type" in schema:
+                            param_dict["type"] = schema["type"]
+                        if "title" in schema:
+                            param_dict["title"] = schema["title"]
+                        if param in required_params:
+                            param_dict["required"] = True
+                        parameters[param] = param_dict
+                    tool_dict["parameters"] = parameters
+            tools.append(tool_dict)
+
+        return tools
+
+    def _extract_handoffs_from_agent(self, agent):
+        if not hasattr(agent, "handoffs") or not agent.handoffs:
+            return None
+
+        handoffs = []
+        for handoff in agent.handoffs:
+            handoff_dict = {}
+            if hasattr(handoff, "handoff_description") or hasattr(handoff, "tool_description"):
+                handoff_dict["handoff_description"] = getattr(handoff, "handoff_description", None) or getattr(
+                    handoff, "tool_description", None
+                )
+            if hasattr(handoff, "name") or hasattr(handoff, "agent_name"):
+                handoff_dict["agent_name"] = getattr(handoff, "name", None) or getattr(handoff, "agent_name", None)
+            if hasattr(handoff, "tool_name"):
+                handoff_dict["tool_name"] = handoff.tool_name
+            if handoff_dict:
+                handoffs.append(handoff_dict)
+
+        return handoffs
+
+    def _extract_guardrails_from_agent(self, agent):
+        guardrails = []
+        if hasattr(agent, "input_guardrails"):
+            guardrails.extend([getattr(guardrail, "name", "") for guardrail in agent.input_guardrails])
+        if hasattr(agent, "output_guardrails"):
+            guardrails.extend([getattr(guardrail, "name", "") for guardrail in agent.output_guardrails])
+        return guardrails

ddtrace/llmobs/_integrations/pydantic_ai.py

@@ -2,9 +2,11 @@ from typing import Any
 from typing import Dict
 from typing import List
 from typing import Optional
+from typing import Tuple
 
 from ddtrace.internal.utils import get_argument_value
 from ddtrace.internal.utils.formats import format_trace_id
+from ddtrace.llmobs._constants import AGENT_MANIFEST
 from ddtrace.llmobs._constants import INPUT_TOKENS_METRIC_KEY
 from ddtrace.llmobs._constants import INPUT_VALUE
 from ddtrace.llmobs._constants import METADATA
@@ -45,13 +47,19 @@ class PydanticAIIntegration(BaseLLMIntegration):
             span._set_ctx_item(SPAN_KIND, kind)
         return span
 
-    def _set_base_span_tags(self, span: Span, model: Optional[str] = None, **kwargs) -> None:
+    def _set_base_span_tags(self, span: Span, model: Optional[Any] = None, **kwargs) -> None:
         if model:
-            span.set_tag("pydantic_ai.request.model", getattr(model, "model_name", ""))
-            system = getattr(model, "system", None)
-            if system:
-                system = PYDANTIC_AI_SYSTEM_TO_PROVIDER.get(system, system)
-                span.set_tag("pydantic_ai.request.provider", system)
+            model_name, provider = self._get_model_and_provider(model)
+            span.set_tag("pydantic_ai.request.model", model_name)
+            if provider:
+                span.set_tag("pydantic_ai.request.provider", provider)
+
+    def _get_model_and_provider(self, model: Optional[Any]) -> Tuple[str, str]:
+        model_name = getattr(model, "model_name", "")
+        system = getattr(model, "system", None)
+        if system:
+            system = PYDANTIC_AI_SYSTEM_TO_PROVIDER.get(system, system)
+        return model_name, system
 
     def _llmobs_set_tags(
         self,
@@ -84,26 +92,8 @@ class PydanticAIIntegration(BaseLLMIntegration):
         from pydantic_ai.agent import AgentRun
 
         agent_instance = kwargs.get("instance", None)
-        if agent_instance:
-            agent_name = getattr(agent_instance, "name", None)
-            agent_instructions = getattr(agent_instance, "_instructions", None)
-            agent_system_prompts = getattr(agent_instance, "_system_prompts", None)
-            agent_tools = list(getattr(agent_instance, "_function_tools", {}).keys())
-            agent_model_settings = getattr(agent_instance, "model_settings", None)
-            metadata = {
-                "instructions": agent_instructions,
-                "system_prompts": agent_system_prompts,
-                "tools": agent_tools,
-            }
-            if agent_model_settings:
-                metadata["max_tokens"] = agent_model_settings.get("max_tokens", None)
-                metadata["temperature"] = agent_model_settings.get("temperature", None)
-            span._set_ctx_items(
-                {
-                    NAME: agent_name or "PydanticAI Agent",
-                    METADATA: metadata,
-                }
-            )
+        agent_name = getattr(agent_instance, "name", None)
+        self._tag_agent_manifest(span, kwargs, agent_instance)
         user_prompt = get_argument_value(args, kwargs, 0, "user_prompt")
         result = response
         if isinstance(result, AgentRun) and hasattr(result, "result"):
@@ -119,6 +109,7 @@ class PydanticAIIntegration(BaseLLMIntegration):
         metrics = self.extract_usage_metrics(response, kwargs)
         span._set_ctx_items(
             {
+                NAME: agent_name or "PydanticAI Agent",
                 INPUT_VALUE: user_prompt,
                 OUTPUT_VALUE: result,
                 METRICS: metrics,
@@ -145,6 +136,56 @@ class PydanticAIIntegration(BaseLLMIntegration):
         if not span.error:
             span._set_ctx_item(OUTPUT_VALUE, getattr(response, "content", ""))
 
+    def _tag_agent_manifest(self, span: Span, kwargs: Dict[str, Any], agent: Any) -> None:
+        if not agent:
+            return
+
+        manifest: Dict[str, Any] = {}
+        manifest["framework"] = "PydanticAI"
+        manifest["name"] = agent.name if hasattr(agent, "name") and agent.name else "PydanticAI Agent"
+        model = getattr(agent, "model", None)
+        if model:
+            model_name, _ = self._get_model_and_provider(model)
+            if model_name:
+                manifest["model"] = model_name
+        if hasattr(agent, "model_settings"):
+            manifest["model_settings"] = agent.model_settings
+        if hasattr(agent, "_instructions"):
+            manifest["instructions"] = agent._instructions
+        if hasattr(agent, "_system_prompts"):
+            manifest["system_prompts"] = agent._system_prompts
+        if hasattr(agent, "_function_tools"):
+            manifest["tools"] = self._get_agent_tools(agent._function_tools)
+        if kwargs.get("deps", None):
+            agent_dependencies = kwargs.get("deps", None)
+            manifest["dependencies"] = getattr(agent_dependencies, "__dict__", agent_dependencies)
+
+        span._set_ctx_item(AGENT_MANIFEST, manifest)
+
+    def _get_agent_tools(self, tools: Any) -> List[Dict[str, Any]]:
+        if not tools:
+            return []
+        formatted_tools = []
+        for tool_name, tool_instance in tools.items():
+            tool_dict = {}
+            tool_dict["name"] = tool_name
+            if hasattr(tool_instance, "description"):
+                tool_dict["description"] = tool_instance.description
+            function_schema = getattr(tool_instance, "function_schema", {})
+            json_schema = getattr(function_schema, "json_schema", {})
+            required_params = {param: True for param in json_schema.get("required", [])}
+            parameters = {}
+            for param, schema in json_schema.get("properties", {}).items():
+                param_dict = {}
+                if "type" in schema:
+                    param_dict["type"] = schema["type"]
+                if param in required_params:
+                    param_dict["required"] = True
+                parameters[param] = param_dict
+            tool_dict["parameters"] = parameters
+            formatted_tools.append(tool_dict)
+        return formatted_tools
+
     def extract_usage_metrics(self, response: Any, kwargs: Dict[str, Any]) -> Dict[str, Any]:
         response = kwargs.get("streamed_run_result", None) or response
         usage = None

ddtrace/llmobs/_integrations/utils.py

@@ -1,6 +1,4 @@
-from dataclasses import asdict
 from dataclasses import dataclass
-from dataclasses import is_dataclass
 import json
 import re
 from typing import Any
@@ -19,7 +17,6 @@ from ddtrace.llmobs._constants import DISPATCH_ON_TOOL_CALL_OUTPUT_USED
 from ddtrace.llmobs._constants import INPUT_MESSAGES
 from ddtrace.llmobs._constants import INPUT_TOKENS_METRIC_KEY
 from ddtrace.llmobs._constants import INPUT_VALUE
-from ddtrace.llmobs._constants import LITELLM_ROUTER_INSTANCE_KEY
 from ddtrace.llmobs._constants import METADATA
 from ddtrace.llmobs._constants import OAI_HANDOFF_TOOL_ARG
 from ddtrace.llmobs._constants import OUTPUT_MESSAGES
@@ -27,6 +24,7 @@ from ddtrace.llmobs._constants import OUTPUT_TOKENS_METRIC_KEY
 from ddtrace.llmobs._constants import OUTPUT_VALUE
 from ddtrace.llmobs._constants import TOTAL_TOKENS_METRIC_KEY
 from ddtrace.llmobs._utils import _get_attr
+from ddtrace.llmobs._utils import load_data_value
 from ddtrace.llmobs._utils import safe_json
 
 
@@ -39,31 +37,71 @@ except ModuleNotFoundError:
 
 logger = get_logger(__name__)
 
-OPENAI_SKIPPED_COMPLETION_TAGS = (
-    "model",
-    "prompt",
-    "api_key",
-    "user_api_key",
-    "user_api_key_hash",
-    LITELLM_ROUTER_INSTANCE_KEY,
+COMMON_METADATA_KEYS = (
+    "stream",
+    "temperature",
+    "top_p",
+    "user",
 )
-OPENAI_SKIPPED_CHAT_TAGS = (
-    "model",
-    "messages",
+OPENAI_METADATA_RESPONSE_KEYS = (
+    "background",
+    "include",
+    "max_output_tokens",
+    "max_tool_calls",
+    "parallel_tool_calls",
+    "previous_response_id",
+    "prompt",
+    "reasoning",
+    "service_tier",
+    "store",
+    "text",
+    "tool_choice",
     "tools",
-    "functions",
-    "api_key",
-    "user_api_key",
-    "user_api_key_hash",
-    LITELLM_ROUTER_INSTANCE_KEY,
+    "top_logprobs",
+    "truncation",
+)
+OPENAI_METADATA_CHAT_KEYS = (
+    "audio",
+    "frequency_penalty",
+    "function_call",
+    "logit_bias",
+    "logprobs",
+    "max_completion_tokens",
+    "max_tokens",
+    "modalities",
+    "n",
+    "parallel_tool_calls",
+    "prediction",
+    "presence_penalty",
+    "reasoning_effort",
+    "response_format",
+    "seed",
+    "service_tier",
+    "stop",
+    "store",
+    "stream_options",
+    "tool_choice",
+    "top_logprobs",
+    "web_search_options",
+)
+OPENAI_METADATA_COMPLETION_KEYS = (
+    "best_of",
+    "echo",
+    "frequency_penalty",
+    "logit_bias",
+    "logprobs",
+    "max_tokens",
+    "n",
+    "presence_penalty",
+    "seed",
+    "stop",
+    "stream_options",
+    "suffix",
 )
 
 LITELLM_METADATA_CHAT_KEYS = (
     "timeout",
-    "temperature",
-    "top_p",
     "n",
-    "stream",
     "stream_options",
     "stop",
     "max_completion_tokens",
@@ -73,7 +111,6 @@ LITELLM_METADATA_CHAT_KEYS = (
     "presence_penalty",
     "frequency_penalty",
     "logit_bias",
-    "user",
     "response_format",
     "seed",
     "tool_choice",
@@ -97,12 +134,8 @@ LITELLM_METADATA_COMPLETION_KEYS = (
     "n",
     "presence_penalty",
     "stop",
-    "stream",
     "stream_options",
     "suffix",
-    "temperature",
-    "top_p",
-    "user",
     "api_base",
     "api_version",
     "model_list",
@@ -110,67 +143,6 @@ LITELLM_METADATA_COMPLETION_KEYS = (
 )
 
 
-def extract_model_name_google(instance, model_name_attr):
-    """Extract the model name from the instance.
-    Model names are stored in the format `"models/{model_name}"`
-    so we do our best to return the model name instead of the full string.
-    """
-    model_name = _get_attr(instance, model_name_attr, "")
-    if not model_name or not isinstance(model_name, str):
-        return ""
-    if "/" in model_name:
-        return model_name.split("/")[-1]
-    return model_name
-
-
-def get_generation_config_google(instance, kwargs):
-    """
-    The generation config can be defined on the model instance or
-    as a kwarg of the request. Therefore, try to extract this information
-    from the kwargs and otherwise default to checking the model instance attribute.
-    """
-    generation_config = kwargs.get("generation_config", {})
-    return generation_config or _get_attr(instance, "_generation_config", {})
-
-
-def llmobs_get_metadata_google(kwargs, instance):
-    metadata = {}
-    model_config = getattr(instance, "_generation_config", {}) or {}
-    model_config = model_config.to_dict() if hasattr(model_config, "to_dict") else model_config
-    request_config = kwargs.get("generation_config", {}) or {}
-    request_config = request_config.to_dict() if hasattr(request_config, "to_dict") else request_config
-
-    parameters = ("temperature", "max_output_tokens", "candidate_count", "top_p", "top_k")
-    for param in parameters:
-        model_config_value = _get_attr(model_config, param, None)
-        request_config_value = _get_attr(request_config, param, None)
-        if model_config_value or request_config_value:
-            metadata[param] = request_config_value or model_config_value
-    return metadata
-
-
-def extract_message_from_part_google(part, role=None):
-    text = _get_attr(part, "text", "")
-    function_call = _get_attr(part, "function_call", None)
-    function_response = _get_attr(part, "function_response", None)
-    message = {"content": text}
-    if role:
-        message["role"] = role
-    if function_call:
-        function_call_dict = function_call
-        if not isinstance(function_call, dict):
-            function_call_dict = type(function_call).to_dict(function_call)
-        message["tool_calls"] = [
-            {"name": function_call_dict.get("name", ""), "arguments": function_call_dict.get("args", {})}
-        ]
-    if function_response:
-        function_response_dict = function_response
-        if not isinstance(function_response, dict):
-            function_response_dict = type(function_response).to_dict(function_response)
-        message["content"] = "[tool result: {}]".format(function_response_dict.get("response", ""))
-    return message
-
-
 def get_llmobs_metrics_tags(integration_name, span):
     usage = {}
 
@@ -209,41 +181,6 @@ def parse_llmobs_metric_args(metrics):
     return usage
 
 
-def get_system_instructions_from_google_model(model_instance):
-    """
-    Extract system instructions from model and convert to []str for tagging.
-    """
-    try:
-        from google.ai.generativelanguage_v1beta.types.content import Content
-    except ImportError:
-        Content = None
-    try:
-        from vertexai.generative_models._generative_models import Part
-    except ImportError:
-        Part = None
-
-    raw_system_instructions = getattr(model_instance, "_system_instruction", [])
-    if Content is not None and isinstance(raw_system_instructions, Content):
-        system_instructions = []
-        for part in raw_system_instructions.parts:
-            system_instructions.append(_get_attr(part, "text", ""))
-        return system_instructions
-    elif isinstance(raw_system_instructions, str):
-        return [raw_system_instructions]
-    elif Part is not None and isinstance(raw_system_instructions, Part):
-        return [_get_attr(raw_system_instructions, "text", "")]
-    elif not isinstance(raw_system_instructions, list):
-        return []
-
-    system_instructions = []
-    for elem in raw_system_instructions:
-        if isinstance(elem, str):
-            system_instructions.append(elem)
-        elif Part is not None and isinstance(elem, Part):
-            system_instructions.append(_get_attr(elem, "text", ""))
-    return system_instructions
-
-
 LANGCHAIN_ROLE_MAPPING = {
     "human": "user",
     "ai": "assistant",
@@ -471,12 +408,12 @@ def get_metadata_from_kwargs(
     kwargs: Dict[str, Any], integration_name: str = "openai", operation: str = "chat"
 ) -> Dict[str, Any]:
     metadata = {}
+    keys_to_include: Tuple[str, ...] = COMMON_METADATA_KEYS
     if integration_name == "openai":
-        keys_to_skip = OPENAI_SKIPPED_CHAT_TAGS if operation == "chat" else OPENAI_SKIPPED_COMPLETION_TAGS
-        metadata = {k: v for k, v in kwargs.items() if k not in keys_to_skip}
+        keys_to_include += OPENAI_METADATA_CHAT_KEYS if operation == "chat" else OPENAI_METADATA_COMPLETION_KEYS
     elif integration_name == "litellm":
-        keys_to_include = LITELLM_METADATA_CHAT_KEYS if operation == "chat" else LITELLM_METADATA_COMPLETION_KEYS
-        metadata = {k: v for k, v in kwargs.items() if k in keys_to_include}
+        keys_to_include += LITELLM_METADATA_CHAT_KEYS if operation == "chat" else LITELLM_METADATA_COMPLETION_KEYS
+    metadata = {k: v for k, v in kwargs.items() if k in keys_to_include}
     return metadata
 
 
@@ -621,7 +558,7 @@ def openai_get_metadata_from_response(
     metadata = {}
 
     if kwargs:
-        metadata.update({k: v for k, v in kwargs.items() if k not in ("model", "input", "instructions")})
+        metadata.update({k: v for k, v in kwargs.items() if k in OPENAI_METADATA_RESPONSE_KEYS + COMMON_METADATA_KEYS})
 
     if not response:
         return metadata
@@ -630,7 +567,7 @@ def openai_get_metadata_from_response(
     for field in ["temperature", "max_output_tokens", "top_p", "tools", "tool_choice", "truncation", "text", "user"]:
         value = getattr(response, field, None)
         if value is not None:
-            metadata[field] = load_oai_span_data_value(value)
+            metadata[field] = load_data_value(value)
 
     usage = getattr(response, "usage", None)
     output_tokens_details = getattr(usage, "output_tokens_details", None)
@@ -863,7 +800,7 @@ class OaiSpanAdapter:
         data = self.data
         if not data:
             return {}
-        return load_oai_span_data_value(data)
+        return load_data_value(data)
 
     @property
     def response_output_text(self) -> str:
@@ -922,25 +859,14 @@ class OaiSpanAdapter:
                 if hasattr(self.response, field):
                     value = getattr(self.response, field)
                     if value is not None:
-                        metadata[field] = load_oai_span_data_value(value)
+                        metadata[field] = load_data_value(value)
 
             if hasattr(self.response, "text") and self.response.text:
-                metadata["text"] = load_oai_span_data_value(self.response.text)
+                metadata["text"] = load_data_value(self.response.text)
 
             if hasattr(self.response, "usage") and hasattr(self.response.usage, "output_tokens_details"):
                 metadata["reasoning_tokens"] = self.response.usage.output_tokens_details.reasoning_tokens
 
-        if self.span_type == "agent":
-            agent_metadata: Dict[str, List[str]] = {
-                "handoffs": [],
-                "tools": [],
-            }
-            if self.handoffs:
-                agent_metadata["handoffs"] = load_oai_span_data_value(self.handoffs)
-            if self.tools:
-                agent_metadata["tools"] = load_oai_span_data_value(self.tools)
-            metadata.update(agent_metadata)
-
         if self.span_type == "custom" and hasattr(self._raw_oai_span.span_data, "data"):
             custom_data = getattr(self._raw_oai_span.span_data, "data", None)
             if custom_data:
@@ -1153,22 +1079,6 @@ class OaiTraceAdapter:
         return self._trace
 
 
-def load_oai_span_data_value(value):
-    """Helper function to load values stored in openai span data in a consistent way"""
-    if isinstance(value, list):
-        return [load_oai_span_data_value(item) for item in value]
-    elif hasattr(value, "model_dump"):
-        return value.model_dump()
-    elif is_dataclass(value):
-        return asdict(value)
-    else:
-        value_str = safe_json(value)
-        try:
-            return json.loads(value_str)
-        except json.JSONDecodeError:
-            return value_str
-
-
 @dataclass
 class LLMObsTraceInfo:
     """Metadata for llmobs trace used for setting root span attributes and span links"""

ddtrace/llmobs/_integrations/vertexai.py

@@ -17,9 +17,9 @@ from ddtrace.llmobs._constants import OUTPUT_TOKENS_METRIC_KEY
 from ddtrace.llmobs._constants import SPAN_KIND
 from ddtrace.llmobs._constants import TOTAL_TOKENS_METRIC_KEY
 from ddtrace.llmobs._integrations.base import BaseLLMIntegration
-from ddtrace.llmobs._integrations.utils import extract_message_from_part_google
-from ddtrace.llmobs._integrations.utils import get_system_instructions_from_google_model
-from ddtrace.llmobs._integrations.utils import llmobs_get_metadata_google
+from ddtrace.llmobs._integrations.google_utils import extract_message_from_part_gemini_vertexai
+from ddtrace.llmobs._integrations.google_utils import get_system_instructions_gemini_vertexai
+from ddtrace.llmobs._integrations.google_utils import llmobs_get_metadata_gemini_vertexai
 from ddtrace.llmobs._utils import _get_attr
 from ddtrace.trace import Span
 
@@ -46,9 +46,9 @@ class VertexAIIntegration(BaseLLMIntegration):
         instance = kwargs.get("instance", None)
         history = kwargs.get("history", [])
         metrics = kwargs.get("metrics", {})
-        metadata = llmobs_get_metadata_google(kwargs, instance)
+        metadata = llmobs_get_metadata_gemini_vertexai(kwargs, instance)
 
-        system_instruction = get_system_instructions_from_google_model(instance)
+        system_instruction = get_system_instructions_gemini_vertexai(instance)
         input_contents = None
         try:
             input_contents = get_argument_value(args, kwargs, 0, "content")
@@ -117,7 +117,7 @@ class VertexAIIntegration(BaseLLMIntegration):
             messages.append({"content": contents})
             return messages
         if isinstance(contents, Part):
-            message = extract_message_from_part_google(contents)
+            message = extract_message_from_part_gemini_vertexai(contents)
             messages.append(message)
             return messages
         if not isinstance(contents, list):
@@ -128,7 +128,7 @@ class VertexAIIntegration(BaseLLMIntegration):
                 messages.append({"content": content})
                 continue
             if isinstance(content, Part):
-                message = extract_message_from_part_google(content)
+                message = extract_message_from_part_gemini_vertexai(content)
                 messages.append(message)
                 continue
             messages.extend(self._extract_messages_from_content(content))
@@ -170,6 +170,6 @@ class VertexAIIntegration(BaseLLMIntegration):
             messages.append(message)
             return messages
         for part in parts:
-            message = extract_message_from_part_google(part, role)
+            message = extract_message_from_part_gemini_vertexai(part, role)
             messages.append(message)
         return messages