feat!: split track_metrics_of into sync and async (track_metrics_of_async) variants

feat: add optional graph_key to all LDAIConfigTracker track_* methods for graph correlation
feat: add track_tool_call/track_tool_calls to LDAIConfigTracker
feat: add graph_key property to AIGraphTracker
feat: make AIGraphTracker.track_total_tokens accept Optional[TokenUsage], skip when None or total <= 0
feat: add LangChainHelper.get_tool_calls_from_response and sum_token_usage_from_messages
feat: extract OpenAIHelper.get_ai_usage_from_response; delegate get_ai_metrics_from_response to it
refactor: remove node-scoped methods from AIGraphTracker (track_node_invocation, track_tool_call, track_node_judge_response)
refactor: use time.time_ns() for sub-millisecond precision in duration calculations

Author: jsonbailey

packages/ai-providers/server-ai-langchain/src/ldai_langchain/langchain_helper.py

@@ -114,6 +114,44 @@ def get_ai_usage_from_response(response: Any) -> Optional[TokenUsage]:
                 )
         return None
 
+    @staticmethod
+    def get_tool_calls_from_response(response: Any) -> List[str]:
+        """
+        Get tool call names from a LangChain provider response.
+
+        :param response: The response from the LangChain model
+        :return: List of tool names in order, or empty list if none
+        """
+        names: List[str] = []
+        if hasattr(response, 'tool_calls') and response.tool_calls:
+            for tc in response.tool_calls:
+                n = tc.get('name')
+                if n:
+                    names.append(str(n))
+        return names
+
+    @staticmethod
+    def sum_token_usage_from_messages(messages: List[Any]) -> Optional[TokenUsage]:
+        """
+        Sum token usage across LangChain messages using :meth:`get_ai_usage_from_response` per message.
+
+        :param messages: List of message objects (e.g. from a graph state)
+        :return: Aggregated TokenUsage, or None if no usage on any message
+        """
+        in_sum = 0
+        out_sum = 0
+        total_sum = 0
+        for m in messages:
+            u = LangChainHelper.get_ai_usage_from_response(m)
+            if u is None:
+                continue
+            in_sum += u.input
+            out_sum += u.output
+            total_sum += u.total
+        if in_sum == 0 and out_sum == 0 and total_sum == 0:
+            return None
+        return TokenUsage(total=total_sum, input=in_sum, output=out_sum)
+
     @staticmethod
     def get_ai_metrics_from_response(response: Any) -> LDAIMetrics:
         """

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

@@ -26,6 +26,26 @@ def convert_messages_to_openai(messages: List[LDMessage]) -> Iterable[ChatComple
             [{'role': msg.role, 'content': msg.content} for msg in messages],
         )
 
+    @staticmethod
+    def get_ai_usage_from_response(response: Any) -> Optional[TokenUsage]:
+        """
+        Get token usage from an OpenAI provider response.
+
+        :param response: The response from the OpenAI model
+        :return: TokenUsage if any usage data is present, else None
+        """
+        usage: Optional[TokenUsage] = None
+        if hasattr(response, 'usage') and response.usage is not None:
+            u = response.usage
+            usage = TokenUsage(
+                total=getattr(u, 'total_tokens', 0),
+                input=getattr(u, 'prompt_tokens', 0),
+                output=getattr(u, 'completion_tokens', 0),
+            )
+        if usage is not None and usage.total == 0 and usage.input == 0 and usage.output == 0:
+            return None
+        return usage
+
     @staticmethod
     def get_ai_metrics_from_response(response: Any) -> LDAIMetrics:
         """
@@ -34,11 +54,5 @@ def get_ai_metrics_from_response(response: Any) -> LDAIMetrics:
         :param response: The response from the OpenAI chat completions API
         :return: LDAIMetrics with success status and token usage
         """
-        usage: Optional[TokenUsage] = None
-        if hasattr(response, 'usage') and response.usage:
-            usage = TokenUsage(
-                total=response.usage.total_tokens or 0,
-                input=response.usage.prompt_tokens or 0,
-                output=response.usage.completion_tokens or 0,
-            )
+        usage = OpenAIHelper.get_ai_usage_from_response(response)
         return LDAIMetrics(success=True, usage=usage)

packages/sdk/server-ai/README.md

@@ -150,8 +150,8 @@ async def main():
     # Create LangChain model from configuration
     llm = await LangChainProvider.create_langchain_model(ai_config)
 
-    # Use with tracking
-    response = await ai_config.tracker.track_metrics_of(
+    # Use with tracking (sync invoke)
+    response = ai_config.tracker.track_metrics_of(
         lambda: llm.invoke(messages),
         lambda result: LangChainProvider.get_ai_metrics_from_response(result)
     )
@@ -190,7 +190,7 @@ async def main():
             temperature=ai_config.model.get_parameter('temperature') if ai_config.model else 0.5,
         )
 
-    result = await ai_config.tracker.track_metrics_of(
+    result = await ai_config.tracker.track_metrics_of_async(
         call_custom_provider,
         map_custom_provider_metrics
     )

packages/sdk/server-ai/src/ldai/judge/__init__.py

@@ -71,7 +71,7 @@ async def evaluate(
             messages = self._construct_evaluation_messages(input_text, output_text)
             assert self._evaluation_response_structure is not None
 
-            response = await self._ai_config_tracker.track_metrics_of(
+            response = await self._ai_config_tracker.track_metrics_of_async(
                 lambda: self._model_runner.invoke_structured_model(messages, self._evaluation_response_structure),
                 lambda result: result.metrics,
             )

packages/sdk/server-ai/src/ldai/managed_model.py

@@ -48,7 +48,7 @@ async def invoke(self, prompt: str) -> ModelResponse:
         config_messages = self._ai_config.messages or []
         all_messages = config_messages + self._messages
 
-        response = await self._tracker.track_metrics_of(
+        response = await self._tracker.track_metrics_of_async(
             lambda: self._model_runner.invoke_model(all_messages),
             lambda result: result.metrics,
         )

packages/sdk/server-ai/src/ldai/providers/runner_factory.py

@@ -77,7 +77,7 @@ def _with_fallback(
                     continue
                 result = fn(provider_factory)
                 if result is not None:
-                    log.debug(f"Successfully created capability using provider '{provider_type}'")
+                    log.debug(f"Successfully invoked create function with provider '{provider_type}'")
                     return result
             except Exception as exc:
                 log.warning(f"Provider '{provider_type}' failed: {exc}")