ddtrace 3.11.0rc2__cp38-cp38-win32.whl → 3.11.0rc3__cp38-cp38-win32.whl

ddtrace/internal/schema/processor.py

@@ -1,5 +1,6 @@
 from ddtrace._trace.processor import TraceProcessor
 from ddtrace.constants import _BASE_SERVICE_KEY
+from ddtrace.internal.serverless import in_aws_lambda
 from ddtrace.settings._config import config
 
 from . import schematize_service_name
@@ -8,10 +9,13 @@ from . import schematize_service_name
 class BaseServiceProcessor(TraceProcessor):
     def __init__(self):
         self._global_service = schematize_service_name((config.service or "").lower())
+        self._in_aws_lambda = in_aws_lambda()
 
     def process_trace(self, trace):
-        if not trace:
-            return
+        # AWS Lambda spans receive unhelpful base_service value of runtime
+        # Remove base_service to prevent service overrides in Lambda spans
+        if not trace or self._in_aws_lambda:
+            return trace
 
         traces_to_process = filter(
             lambda x: x.service and x.service.lower() != self._global_service,

ddtrace/internal/telemetry/writer.py

@@ -418,6 +418,23 @@ class TelemetryWriter(PeriodicService):
             payload = {"dependencies": packages}
             self.add_event(payload, "app-dependencies-loaded")
 
+    def _add_endpoints_event(self):
+        """Adds a Telemetry event which sends the list of HTTP endpoints found at startup to the agent"""
+        import ddtrace.settings.asm as asm_config_module
+
+        if not asm_config_module.config._api_security_endpoint_collection or not self._enabled:
+            return
+
+        if not asm_config_module.endpoint_collection.endpoints:
+            return
+
+        with self._service_lock:
+            payload = asm_config_module.endpoint_collection.flush(
+                asm_config_module.config._api_security_endpoint_collection_limit
+            )
+
+        self.add_event(payload, "app-endpoints")
+
     def _app_product_change(self):
         # type: () -> None
         """Adds a Telemetry event which reports the enablement of an APM product"""
@@ -660,6 +677,7 @@ class TelemetryWriter(PeriodicService):
             self._app_client_configuration_changed_event(configurations)
 
         self._app_dependencies_loaded_event()
+        self._add_endpoints_event()
 
         if shutting_down:
             self._app_closing_event()

ddtrace/llmobs/_constants.py

@@ -9,6 +9,7 @@ PARENT_ID_KEY = "_ml_obs.llmobs_parent_id"
 PROPAGATED_LLMOBS_TRACE_ID_KEY = "_dd.p.llmobs_trace_id"
 LLMOBS_TRACE_ID = "_ml_obs.llmobs_trace_id"
 TAGS = "_ml_obs.tags"
+AGENT_MANIFEST = "_ml_obs.meta.agent_manifest"
 
 MODEL_NAME = "_ml_obs.meta.model_name"
 MODEL_PROVIDER = "_ml_obs.meta.model_provider"

ddtrace/llmobs/_experiment.py

@@ -297,6 +297,12 @@ class Experiment:
         )
         return experiment_results
 
+    @property
+    def url(self) -> str:
+        # FIXME: need to use the user's site
+        # also will not work for subdomain orgs
+        return f"https://app.datadoghq.com/llm/experiments/{self._id}"
+
     def _process_record(self, idx_record: Tuple[int, DatasetRecord]) -> Optional[TaskResult]:
         if not self._llmobs_instance or not self._llmobs_instance.enabled:
             return None

ddtrace/llmobs/_integrations/crewai.py

@@ -8,6 +8,7 @@ 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 INPUT_VALUE
 from ddtrace.llmobs._constants import METADATA
 from ddtrace.llmobs._constants import NAME
@@ -151,9 +152,8 @@ class CrewAIIntegration(BaseLLMIntegration):
         Agent spans are 1:1 with its parent (task/tool) span, so we link them directly here, even on the parent itself.
         """
         agent_instance = kwargs.get("instance")
+        self._tag_agent_manifest(span, agent_instance)
         agent_role = getattr(agent_instance, "role", "")
-        agent_goal = getattr(agent_instance, "goal", "")
-        agent_backstory = getattr(agent_instance, "backstory", "")
         task_description = getattr(kwargs.get("task"), "description", "")
         context = get_argument_value(args, kwargs, 1, "context", optional=True) or ""
 
@@ -174,7 +174,6 @@ class CrewAIIntegration(BaseLLMIntegration):
         span._set_ctx_items(
             {
                 NAME: agent_role if agent_role else "CrewAI Agent",
-                METADATA: {"description": agent_goal, "backstory": agent_backstory},
                 INPUT_VALUE: {"context": context, "input": task_description},
                 SPAN_LINKS: curr_span_links + [span_link],
             }
@@ -198,6 +197,56 @@ class CrewAIIntegration(BaseLLMIntegration):
             return
         span._set_ctx_item(OUTPUT_VALUE, response)
 
+    def _tag_agent_manifest(self, span, agent):
+        if not agent:
+            return
+
+        manifest = {}
+        manifest["framework"] = "CrewAI"
+        manifest["name"] = agent.role if hasattr(agent, "role") and agent.role else "CrewAI Agent"
+        if hasattr(agent, "goal"):
+            manifest["goal"] = agent.goal
+        if hasattr(agent, "backstory"):
+            manifest["backstory"] = agent.backstory
+        if hasattr(agent, "llm"):
+            if hasattr(agent.llm, "model"):
+                manifest["model"] = agent.llm.model
+            model_settings = {}
+            if hasattr(agent.llm, "max_tokens"):
+                model_settings["max_tokens"] = agent.llm.max_tokens
+            if hasattr(agent.llm, "temperature"):
+                model_settings["temperature"] = agent.llm.temperature
+            if model_settings:
+                manifest["model_settings"] = model_settings
+        if hasattr(agent, "allow_delegation"):
+            manifest["handoffs"] = {"allow_delegation": agent.allow_delegation}
+        code_execution_permissions = {}
+        if hasattr(agent, "allow_code_execution"):
+            manifest["code_execution_permissions"] = {"allow_code_execution": agent.allow_code_execution}
+        if hasattr(agent, "code_execution_mode"):
+            manifest["code_execution_permissions"] = {"code_execution_mode": agent.code_execution_mode}
+        if code_execution_permissions:
+            manifest["code_execution_permissions"] = code_execution_permissions
+        if hasattr(agent, "max_iter"):
+            manifest["max_iterations"] = agent.max_iter
+        if hasattr(agent, "tools"):
+            manifest["tools"] = self._get_agent_tools(agent.tools)
+
+        span._set_ctx_item(AGENT_MANIFEST, manifest)
+
+    def _get_agent_tools(self, tools):
+        if not tools or not isinstance(tools, list):
+            return []
+        formatted_tools = []
+        for tool in tools:
+            tool_dict = {}
+            if hasattr(tool, "name"):
+                tool_dict["name"] = tool.name
+            if hasattr(tool, "description"):
+                tool_dict["description"] = tool.description
+            formatted_tools.append(tool_dict)
+        return formatted_tools
+
     def _llmobs_set_span_link_on_task(self, span, args, kwargs):
         """Set span links for the next queued task in a CrewAI workflow.
         This happens between task executions, (the current span is the crew span and the task span hasn't started yet)

ddtrace/llmobs/_integrations/gemini.py

@@ -16,9 +16,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
 
@@ -43,9 +43,9 @@ class GeminiIntegration(BaseLLMIntegration):
         operation: str = "",
     ) -> None:
         instance = kwargs.get("instance", None)
-        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 = get_argument_value(args, kwargs, 0, "contents")
         input_messages = self._extract_input_message(input_contents, system_instruction)
 
@@ -95,7 +95,7 @@ class GeminiIntegration(BaseLLMIntegration):
                 messages.append(message)
                 continue
             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
 
@@ -107,7 +107,7 @@ class GeminiIntegration(BaseLLMIntegration):
             role = content.get("role", "model")
             parts = content.get("parts", [])
             for part in parts:
-                message = extract_message_from_part_google(part, role)
+                message = extract_message_from_part_gemini_vertexai(part, role)
                 output_messages.append(message)
         return output_messages
 

ddtrace/llmobs/_integrations/google_genai.py

@@ -14,12 +14,12 @@ from ddtrace.llmobs._constants import OUTPUT_MESSAGES
 from ddtrace.llmobs._constants import OUTPUT_VALUE
 from ddtrace.llmobs._constants import SPAN_KIND
 from ddtrace.llmobs._integrations.base import BaseLLMIntegration
-from ddtrace.llmobs._integrations.google_genai_utils import DEFAULT_MODEL_ROLE
-from ddtrace.llmobs._integrations.google_genai_utils import extract_embedding_metrics_google_genai
-from ddtrace.llmobs._integrations.google_genai_utils import extract_generation_metrics_google_genai
-from ddtrace.llmobs._integrations.google_genai_utils import extract_message_from_part_google_genai
-from ddtrace.llmobs._integrations.google_genai_utils import extract_provider_and_model_name
-from ddtrace.llmobs._integrations.google_genai_utils import normalize_contents
+from ddtrace.llmobs._integrations.google_utils import GOOGLE_GENAI_DEFAULT_MODEL_ROLE
+from ddtrace.llmobs._integrations.google_utils import extract_embedding_metrics_google_genai
+from ddtrace.llmobs._integrations.google_utils import extract_generation_metrics_google_genai
+from ddtrace.llmobs._integrations.google_utils import extract_message_from_part_google_genai
+from ddtrace.llmobs._integrations.google_utils import extract_provider_and_model_name
+from ddtrace.llmobs._integrations.google_utils import normalize_contents_google_genai
 from ddtrace.llmobs._utils import _get_attr
 from ddtrace.llmobs.utils import Document
 
@@ -71,7 +71,7 @@ class GoogleGenAIIntegration(BaseLLMIntegration):
         response: Optional[Any] = None,
         operation: str = "",
     ) -> None:
-        provider_name, model_name = extract_provider_and_model_name(kwargs)
+        provider_name, model_name = extract_provider_and_model_name(kwargs=kwargs)
         span._set_ctx_items(
             {
                 SPAN_KIND: operation,
@@ -120,7 +120,7 @@ class GoogleGenAIIntegration(BaseLLMIntegration):
 
     def _extract_messages_from_contents(self, contents, default_role: str) -> List[Dict[str, Any]]:
         messages = []
-        for content in normalize_contents(contents):
+        for content in normalize_contents_google_genai(contents):
             role = content.get("role") or default_role
             for part in content.get("parts", []):
                 messages.append(extract_message_from_part_google_genai(part, role))
@@ -128,7 +128,7 @@ class GoogleGenAIIntegration(BaseLLMIntegration):
 
     def _extract_output_messages(self, response) -> List[Dict[str, Any]]:
         if not response:
-            return [{"content": "", "role": DEFAULT_MODEL_ROLE}]
+            return [{"content": "", "role": GOOGLE_GENAI_DEFAULT_MODEL_ROLE}]
         messages = []
         candidates = _get_attr(response, "candidates", [])
         for candidate in candidates:
@@ -136,7 +136,7 @@ class GoogleGenAIIntegration(BaseLLMIntegration):
             if not content:
                 continue
             parts = _get_attr(content, "parts", [])
-            role = _get_attr(content, "role", DEFAULT_MODEL_ROLE)
+            role = _get_attr(content, "role", GOOGLE_GENAI_DEFAULT_MODEL_ROLE)
             for part in parts:
                 message = extract_message_from_part_google_genai(part, role)
                 messages.append(message)

ddtrace/llmobs/_integrations/{google_genai_utils.py → google_utils.py}

@@ -1,6 +1,7 @@
 from typing import Any
 from typing import Dict
 from typing import List
+from typing import Optional
 from typing import Tuple
 
 from ddtrace.llmobs._constants import BILLABLE_CHARACTER_COUNT_METRIC_KEY
@@ -11,9 +12,9 @@ from ddtrace.llmobs._constants import TOTAL_TOKENS_METRIC_KEY
 from ddtrace.llmobs._utils import _get_attr
 
 
-# google genai has roles "model" and "user", but in order to stay consistent with other integrations,
+# Google GenAI has roles "model" and "user", but in order to stay consistent with other integrations,
 # we use "assistant" as the default role for model messages
-DEFAULT_MODEL_ROLE = "assistant"
+GOOGLE_GENAI_DEFAULT_MODEL_ROLE = "assistant"
 
 # https://cloud.google.com/vertex-ai/generative-ai/docs/partner-models/use-partner-models
 # GeminiAPI: only exports google provided models
@@ -40,9 +41,31 @@ KNOWN_MODEL_PREFIX_TO_PROVIDER = {
 }
 
 
-def extract_provider_and_model_name(kwargs: Dict[str, Any]) -> Tuple[str, str]:
-    model_path = kwargs.get("model", "")
-    model_name = model_path.split("/")[-1]
+def extract_provider_and_model_name(
+    kwargs: Optional[Dict[str, Any]] = None, instance: Any = None, model_name_attr: Optional[str] = None
+) -> Tuple[str, str]:
+    """
+    Function to extract provider and model name from either kwargs or instance attributes.
+    Args:
+        kwargs: Dictionary containing model information (used for google_genai)
+        instance: Model instance with attributes (used for vertexai and google_generativeai)
+        model_name_attr: Attribute name to extract from instance (e.g., "_model_name", "model_name", used for vertexai
+                         and google_generativeai)
+
+    Returns:
+        Tuple of (provider_name, model_name)
+    """
+    model_path = ""
+    if kwargs is not None:
+        model_path = kwargs.get("model", "")
+    elif instance is not None and model_name_attr is not None:
+        model_path = _get_attr(instance, model_name_attr, "")
+
+    if not model_path or not isinstance(model_path, str):
+        return "custom", "custom"
+
+    model_name = model_path.split("/")[-1] if "/" in model_path else model_path
+
     for prefix in KNOWN_MODEL_PREFIX_TO_PROVIDER.keys():
         if model_name.lower().startswith(prefix):
             provider_name = KNOWN_MODEL_PREFIX_TO_PROVIDER[prefix]
@@ -50,7 +73,7 @@ def extract_provider_and_model_name(kwargs: Dict[str, Any]) -> Tuple[str, str]:
     return "custom", model_name if model_name else "custom"
 
 
-def normalize_contents(contents) -> List[Dict[str, Any]]:
+def normalize_contents_google_genai(contents) -> List[Dict[str, Any]]:
     """
     contents has a complex union type structure:
     - contents: Union[ContentListUnion, ContentListUnionDict]
@@ -142,7 +165,7 @@ def extract_message_from_part_google_genai(part, role: str) -> Dict[str, Any]:
     returns a dict representing a message with format {"role": role, "content": content}
     """
     if role == "model":
-        role = DEFAULT_MODEL_ROLE
+        role = GOOGLE_GENAI_DEFAULT_MODEL_ROLE
 
     message: Dict[str, Any] = {"role": role}
     if isinstance(part, str):
@@ -187,3 +210,76 @@ def extract_message_from_part_google_genai(part, role: str) -> Dict[str, Any]:
         return message
 
     return {"content": "Unsupported file type: {}".format(type(part)), "role": role}
+
+
+def llmobs_get_metadata_gemini_vertexai(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_gemini_vertexai(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_system_instructions_gemini_vertexai(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

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