fix: backfill available tool using tool definitions if available

Author: liramon2

src/strands_evals/mappers/generic_gen_ai_session_mapper.py

@@ -337,20 +337,7 @@ def _convert_agent_invocation_span(self, span: dict, span_info: SpanInfo) -> Age
 
         user_prompt = ""
         agent_response = ""
-        available_tools: list[ToolConfig] = []
-
-        # Parse available tools from gen_ai.agent.tools or gen_ai.tool.definitions
-        try:
-            tools_json = attrs.get("gen_ai.agent.tools", "") or attrs.get("gen_ai.tool.definitions", "[]")
-            tool_list = json.loads(str(tools_json)) if isinstance(tools_json, str) else tools_json
-            if isinstance(tool_list, list):
-                for item in tool_list:
-                    if isinstance(item, str):
-                        available_tools.append(ToolConfig(name=item))
-                    elif isinstance(item, dict):
-                        available_tools.append(ToolConfig(name=item.get("name", "")))
-        except (json.JSONDecodeError, TypeError):
-            pass
+        available_tools = self._parse_tool_definitions(attrs)
 
         # Extract from span_events (manual instrumentation format)
         for event in span.get("span_events", []):
@@ -444,6 +431,31 @@ def _convert_agent_invocation_span(self, span: dict, span_info: SpanInfo) -> Age
     # Content Processing Helpers
     # =========================================================================
 
+    @staticmethod
+    def _parse_tool_definitions(attributes: dict) -> list[ToolConfig]:
+        """Parse available tools from a span's gen_ai.agent.tools or gen_ai.tool.definitions."""
+        raw = attributes.get("gen_ai.agent.tools", "") or attributes.get("gen_ai.tool.definitions", "[]")
+        try:
+            tool_list = json.loads(raw) if isinstance(raw, str) else raw
+        except (json.JSONDecodeError, TypeError):
+            return []
+        if not isinstance(tool_list, list):
+            return []
+
+        configs: list[ToolConfig] = []
+        for item in tool_list:
+            if isinstance(item, str):
+                if item:
+                    configs.append(ToolConfig(name=item))
+            elif isinstance(item, dict):
+                fn = item["function"] if isinstance(item.get("function"), dict) else item
+                name = fn.get("name", "")
+                if name:
+                    configs.append(
+                        ToolConfig(name=name, description=fn.get("description"), parameters=fn.get("parameters"))
+                    )
+        return configs
+
     def _convert_message_list_from_event(self, event_attrs: dict) -> list[UserMessage | AssistantMessage]:
         """Parse operation.details event attrs and return typed messages via _convert_message_list."""
         messages: list[UserMessage | AssistantMessage] = []
@@ -636,23 +648,16 @@ def _enrich_openai_agent_spans(self, trace: Trace, raw_spans: list[dict]) -> Non
 
         This enriches by:
         1. Re-parenting sub-agents using ``agent_handoff`` spans.
-        2. Deriving each agent's ``available_tools`` from its owned tool spans.
+        2. Backfilling ``user_prompt`` / ``agent_response`` from child chat spans.
+        3. Deriving each agent's ``available_tools`` from child spans
         """
         agent_spans = {
             s.span_info.span_id: s for s in trace.spans if isinstance(s, AgentInvocationSpan) and s.span_info.span_id
         }
 
         self._reparent_by_handoff(agent_spans, raw_spans)
-
         self._backfill_agent_prompts(trace, agent_spans)
-
-        for span in trace.spans:
-            if isinstance(span, ToolExecutionSpan) and span.tool_call.name:
-                owner_id = span.agent_span_id
-                if owner_id and owner_id in agent_spans:
-                    agent = agent_spans[owner_id]
-                    if not any(t.name == span.tool_call.name for t in agent.available_tools):
-                        agent.available_tools.append(ToolConfig(name=span.tool_call.name))
+        self._backfill_agent_tools(trace, agent_spans, raw_spans)
 
     def _reparent_by_handoff(
         self,
@@ -689,6 +694,32 @@ def _reparent_by_handoff(
             if from_span and to_span and from_span.span_info.span_id:
                 to_span.span_info.parent_span_id = from_span.span_info.span_id
 
+    def _backfill_agent_tools(
+        self,
+        trace: Trace,
+        agent_spans: dict[str, AgentInvocationSpan],
+        raw_spans: list[dict],
+    ) -> None:
+        """Populate available_tools on agent spans using their child spans"""
+        # Fill agent spans' available tools from child chat spans' tool definitions.
+        raw_attrs_by_id = {raw.get("span_id"): raw.get("attributes", {}) for raw in raw_spans}
+        for span in trace.spans:
+            if not isinstance(span, InferenceSpan):
+                continue
+            agent = agent_spans.get(span.span_info.parent_span_id or "")
+            if agent is None or agent.available_tools:
+                continue
+            configs = self._parse_tool_definitions(raw_attrs_by_id.get(span.span_info.span_id, {}))
+            if configs:
+                agent.available_tools = list(configs)
+
+        # Fallback: get the names of tools the agents called.
+        for span in trace.spans:
+            if isinstance(span, ToolExecutionSpan) and span.tool_call.name:
+                agent = agent_spans.get(span.agent_span_id or "")
+                if agent and not any(t.name == span.tool_call.name for t in agent.available_tools):
+                    agent.available_tools.append(ToolConfig(name=span.tool_call.name))
+
     def _backfill_agent_prompts(
         self,
         trace: Trace,