attempt to fix openai native tool calls

Author: jsonbailey

packages/ai-providers/server-ai-openai/src/ldai_openai/openai_agent_graph_runner.py

@@ -14,6 +14,8 @@
     extract_usage_from_request_entry,
     get_ai_usage_from_response,
     get_tool_calls_from_run_items,
+    is_agent_tool_instance,
+    registry_value_to_agent_tool,
 )
 
 
@@ -46,7 +48,7 @@ def __init__(self, graph: AgentGraphDefinition, tools: ToolRegistry):
         Initialize the runner.
 
         :param graph: The AgentGraphDefinition to execute
-        :param tools: Registry mapping tool names to callables
+        :param tools: Registry mapping tool names to callables or native ``Tool`` instances
         """
         self._graph = graph
         self._tools = tools
@@ -128,8 +130,6 @@ def _build_agents(self, path: List[str], state: _RunState) -> Any:
             from agents import (
                 Agent,
                 Handoff,
-                Tool,
-                function_tool,
                 handoff,
             )
             from agents.extensions.handoff_prompt import RECOMMENDED_PROMPT_PREFIX
@@ -174,17 +174,21 @@ def build_node(node: AgentGraphNode, ctx: dict) -> Any:
                 )
 
             # --- tools ---
-            agent_tools: List[Tool] = []
+            agent_tools: List[Any] = []
             for tool_def in tool_defs:
                 tool_name = tool_def.get('name', '')
 
                 tool_fn = self._tools.get(tool_name)
                 if not tool_fn:
                     continue
 
-                # Map fn.__name__ → config key so tracked names match the AI config.
-                tool_name_map[tool_fn.__name__] = tool_name
-                agent_tools.append(function_tool(tool_fn))
+                # Map runtime tool name → LD config key for metrics (function __name__
+                # for callables; identity for native tool instances — see get_tool_calls_from_run_items).
+                if is_agent_tool_instance(tool_fn):
+                    tool_name_map[f'{tool_fn.name}_call'] = tool_name
+                else:
+                    tool_name_map[tool_fn.__name__] = tool_name
+                agent_tools.append(registry_value_to_agent_tool(tool_fn))
 
             return Agent(
                 name=sanitized_name,
@@ -286,6 +290,7 @@ def _track_tool_calls(self, result: Any, tracker: Any) -> None:
         """Track all tool calls from the run result, attributed to the node that called them."""
         gk = tracker.graph_key if tracker is not None else None
         for agent_name, tool_fn_name in get_tool_calls_from_run_items(result.new_items):
+            log.info(f"Tracking tool call: agent_name={agent_name}, tool_fn_name={tool_fn_name}")
             original_key = self._agent_name_map.get(agent_name, agent_name)
             tool_name = self._tool_name_map.get(tool_fn_name, '')
             node = self._graph.get_node(original_key)

packages/ai-providers/server-ai-openai/src/ldai_openai/openai_agent_runner.py

@@ -6,7 +6,7 @@
 from ldai.providers import AgentResult, AgentRunner, ToolRegistry
 from ldai.providers.types import LDAIMetrics
 
-from ldai_openai.openai_helper import get_ai_usage_from_response
+from ldai_openai.openai_helper import get_ai_usage_from_response, registry_value_to_agent_tool
 
 
 class OpenAIAgentRunner(AgentRunner):
@@ -81,8 +81,6 @@ async def run(self, input: Any) -> AgentResult:
 
     def _build_agent_tools(self) -> List[Any]:
         """Build tool instances from LD tool definitions and registry."""
-        from agents import function_tool
-
         tools = []
         for td in self._tool_definitions:
             if not isinstance(td, dict):
@@ -93,7 +91,7 @@ def _build_agent_tools(self) -> List[Any]:
 
             tool_fn = self._tools.get(name)
             if tool_fn:
-                tools.append(function_tool(tool_fn))
+                tools.append(registry_value_to_agent_tool(tool_fn))
                 continue
 
             log.warning(

packages/ai-providers/server-ai-openai/src/ldai_openai/openai_helper.py

@@ -1,3 +1,4 @@
+import typing
 from typing import Any, Dict, Iterable, List, Optional, Tuple, cast
 
 from ldai import LDMessage
@@ -113,6 +114,60 @@ def normalize_tool_types(tool_definitions: List[Any]) -> List[Dict[str, Any]]:
     'web_search': 'web_search_tool',
 }
 
+# ``agents.Tool`` is a typing.Union of concrete tool classes, not a runtime class.
+# Using ``isinstance(x, Tool)`` raises TypeError (subscripted generics / union checks).
+_AGENT_TOOL_TYPES: Optional[Tuple[type, ...]] = None
+
+
+def _concrete_agent_tool_types() -> Tuple[type, ...]:
+    """Resolve concrete classes behind ``agents.Tool`` (a Union alias)."""
+    try:
+        from agents import Tool as ToolUnion
+    except ImportError:
+        return ()
+    args = typing.get_args(ToolUnion)
+    if not args:
+        return ()
+    out: List[type] = []
+    for a in args:
+        origin = getattr(a, '__origin__', None)
+        if origin is not None and isinstance(origin, type):
+            out.append(origin)
+        elif isinstance(a, type):
+            out.append(a)
+    return tuple(out)
+
+
+def is_agent_tool_instance(value: Any) -> bool:
+    """True if ``value`` is already an openai-agents tool object (not a plain callable)."""
+    global _AGENT_TOOL_TYPES
+    if _AGENT_TOOL_TYPES is None:
+        _AGENT_TOOL_TYPES = _concrete_agent_tool_types()
+    if not _AGENT_TOOL_TYPES:
+        return False
+    return isinstance(value, _AGENT_TOOL_TYPES)
+
+
+def registry_value_to_agent_tool(value: Any) -> Any:
+    """
+    Turn a ToolRegistry value into an object the OpenAI Agents SDK accepts in ``Agent(tools=…)``.
+
+    Plain callables are wrapped with ``function_tool``. Values that are already
+    tool instances (e.g. ``WebSearchTool()``, ``FileSearchTool(...)``) are
+    returned unchanged so they are not double-wrapped.
+    """
+    try:
+        from agents import function_tool
+    except ImportError as exc:
+        raise ImportError(
+            "openai-agents is required for agent tools. "
+            "Install it with: pip install openai-agents"
+        ) from exc
+
+    if is_agent_tool_instance(value):
+        return value
+    return function_tool(value)
+
 
 def get_tool_calls_from_run_items(new_items: List[Any]) -> List[Tuple[str, str]]:
     """