fix: resolve lint errors from rebase onto main

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: jsonbailey

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

@@ -2,10 +2,16 @@
 
 from typing import Any, Dict, List
 
+from langchain_core.messages import (
+    AIMessage,
+    BaseMessage,
+    HumanMessage,
+    SystemMessage,
+    ToolMessage,
+)
 from ldai import log
 from ldai.providers import AgentResult, AgentRunner, ToolRegistry
 from ldai.providers.types import LDAIMetrics
-from langchain_core.messages import AIMessage, BaseMessage, HumanMessage, SystemMessage, ToolMessage
 
 from ldai_langchain.langchain_helper import get_ai_metrics_from_response
 

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

@@ -88,11 +88,11 @@ def get_ai_usage_from_response(response: Any) -> Optional[TokenUsage]:
     :return: TokenUsage or None if unavailable
     """
     if hasattr(response, 'usage_metadata') and response.usage_metadata:
-        return TokenUsage(
-            total=response.usage_metadata.get('total_tokens', 0),
-            input=response.usage_metadata.get('input_tokens', 0),
-            output=response.usage_metadata.get('output_tokens', 0),
-        )
+        total = response.usage_metadata.get('total_tokens', 0)
+        inp = response.usage_metadata.get('input_tokens', 0)
+        out = response.usage_metadata.get('output_tokens', 0)
+        if total or inp or out:
+            return TokenUsage(total=total, input=inp, output=out)
     if hasattr(response, 'response_metadata') and response.response_metadata:
         token_usage = (
             response.response_metadata.get('tokenUsage')

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

@@ -1,8 +1,11 @@
-from typing import Any
+from typing import TYPE_CHECKING, Any
 
 from ldai.models import AIConfigKind
 from ldai.providers import AIProvider, ToolRegistry
 
+if TYPE_CHECKING:
+    from ldai_langchain.langchain_agent_runner import LangChainAgentRunner
+
 from ldai_langchain.langchain_helper import create_langchain_model
 from ldai_langchain.langchain_model_runner import LangChainModelRunner
 
@@ -49,5 +52,5 @@ def create_agent(self, config: Any, tools: Any) -> 'LangChainAgentRunner':
         tool_definitions = parameters.pop('tools', []) or []
         instructions = config.instructions or '' if hasattr(config, 'instructions') else ''
 
-        llm = LangChainHelper.create_langchain_model(config)
+        llm = create_langchain_model(config)
         return LangChainAgentRunner(llm, instructions, tool_definitions, tools or {})

packages/ai-providers/server-ai-langchain/tests/test_langchain_provider.py

@@ -12,6 +12,7 @@
     LangChainRunnerFactory,
     convert_messages_to_langchain,
     get_ai_metrics_from_response,
+    get_ai_usage_from_response,
     get_tool_calls_from_response,
     map_provider,
     sum_token_usage_from_messages,
@@ -142,7 +143,7 @@ def test_usage_metadata_preferred_over_response_metadata(self):
                 'completionTokens': 499,
             },
         }
-        usage = LangChainHelper.get_ai_usage_from_response(mock_response)
+        usage = get_ai_usage_from_response(mock_response)
         assert usage is not None
         assert usage.total == 10
         assert usage.input == 4
@@ -154,43 +155,43 @@ class TestGetAIUsageFromResponse:
 
     def test_returns_none_when_no_usage(self):
         msg = AIMessage(content='hi')
-        assert LangChainHelper.get_ai_usage_from_response(msg) is None
+        assert get_ai_usage_from_response(msg) is None
 
     def test_returns_none_when_all_zeros_in_metadata(self):
         msg = AIMessage(content='hi')
         msg.usage_metadata = {'total_tokens': 0, 'input_tokens': 0, 'output_tokens': 0}
-        assert LangChainHelper.get_ai_usage_from_response(msg) is None
+        assert get_ai_usage_from_response(msg) is None
 
 
 class TestGetToolCallsFromResponse:
     """Tests for LangChainHelper.get_tool_calls_from_response."""
 
     def test_returns_empty_when_no_tool_calls(self):
         msg = AIMessage(content='hi')
-        assert LangChainHelper.get_tool_calls_from_response(msg) == []
+        assert get_tool_calls_from_response(msg) == []
 
     def test_returns_empty_when_tool_calls_not_a_sequence(self):
         msg = AIMessage(content='hi')
         msg.tool_calls = None  # type: ignore
-        assert LangChainHelper.get_tool_calls_from_response(msg) == []
+        assert get_tool_calls_from_response(msg) == []
 
     def test_extracts_names_from_dict_tool_calls(self):
         msg = AIMessage(content='')
         msg.tool_calls = [  # type: ignore
             {'name': 'search', 'args': {}, 'id': '1'},
             {'name': 'calc', 'args': {}, 'id': '2'},
         ]
-        assert LangChainHelper.get_tool_calls_from_response(msg) == ['search', 'calc']
+        assert get_tool_calls_from_response(msg) == ['search', 'calc']
 
     def test_returns_empty_when_tool_calls_is_not_a_list(self):
         msg = AIMessage(content='hi')
         msg.tool_calls = ()  # type: ignore
-        assert LangChainHelper.get_tool_calls_from_response(msg) == []
+        assert get_tool_calls_from_response(msg) == []
 
     def test_skips_entries_without_name(self):
         msg = AIMessage(content='')
         msg.tool_calls = [{'name': 'a', 'id': '1'}, {}, {'name': 'b', 'id': '2'}]  # type: ignore
-        assert LangChainHelper.get_tool_calls_from_response(msg) == ['a', 'b']
+        assert get_tool_calls_from_response(msg) == ['a', 'b']
 
 
 class TestMapProvider:
@@ -419,7 +420,7 @@ def test_creates_agent_runner_with_instructions_and_tool_definitions(self):
             'provider': {'name': 'openai'},
         }
 
-        with patch.object(LangChainHelper, 'create_langchain_model') as mock_create:
+        with patch('ldai_langchain.langchain_runner_factory.create_langchain_model') as mock_create:
             mock_llm = MagicMock()
             mock_create.return_value = mock_llm
 
@@ -442,7 +443,7 @@ def test_creates_agent_runner_with_no_tools(self):
             'provider': {'name': 'openai'},
         }
 
-        with patch.object(LangChainHelper, 'create_langchain_model') as mock_create:
+        with patch('ldai_langchain.langchain_runner_factory.create_langchain_model') as mock_create:
             mock_create.return_value = MagicMock()
 
             factory = LangChainRunnerFactory()

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

@@ -28,11 +28,11 @@ def get_ai_usage_from_response(response: Any) -> Optional[TokenUsage]:
     """
     if hasattr(response, 'usage') and response.usage:
         u = response.usage
-        return TokenUsage(
-            total=getattr(u, 'total_tokens', None) or 0,
-            input=getattr(u, 'prompt_tokens', None) or 0,
-            output=getattr(u, 'completion_tokens', None) or 0,
-        )
+        total = getattr(u, 'total_tokens', None) or 0
+        inp = getattr(u, 'prompt_tokens', None) or 0
+        out = getattr(u, 'completion_tokens', None) or 0
+        if total or inp or out:
+            return TokenUsage(total=total, input=inp, output=out)
     return None
 
 

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

@@ -1,12 +1,15 @@
 import os
-from typing import Any, Optional
+from typing import TYPE_CHECKING, Any, Optional
 
 from ldai.models import AIConfigKind
 from ldai.providers import AIProvider, ToolRegistry
 from openai import AsyncOpenAI
 
 from ldai_openai.openai_model_runner import OpenAIModelRunner
 
+if TYPE_CHECKING:
+    from ldai_openai.openai_agent_runner import OpenAIAgentRunner
+
 
 class OpenAIRunnerFactory(AIProvider):
     """OpenAI ``AIProvider`` implementation for the LaunchDarkly AI SDK."""

packages/ai-providers/server-ai-openai/tests/test_openai_provider.py

@@ -5,7 +5,7 @@
 
 from ldai import LDMessage
 
-from ldai_openai import OpenAIModelRunner, OpenAIRunnerFactory, get_ai_metrics_from_response
+from ldai_openai import OpenAIModelRunner, OpenAIRunnerFactory, get_ai_metrics_from_response, get_ai_usage_from_response
 
 
 class TestGetAIUsageFromResponse:
@@ -17,7 +17,7 @@ def test_returns_usage_when_present(self):
         mock_response.usage.prompt_tokens = 50
         mock_response.usage.completion_tokens = 50
         mock_response.usage.total_tokens = 100
-        u = OpenAIHelper.get_ai_usage_from_response(mock_response)
+        u = get_ai_usage_from_response(mock_response)
         assert u is not None
         assert u.total == 100
         assert u.input == 50
@@ -26,15 +26,15 @@ def test_returns_usage_when_present(self):
     def test_returns_none_when_usage_missing(self):
         mock_response = MagicMock()
         mock_response.usage = None
-        assert OpenAIHelper.get_ai_usage_from_response(mock_response) is None
+        assert get_ai_usage_from_response(mock_response) is None
 
     def test_returns_none_when_all_counts_zero(self):
         mock_response = MagicMock()
         mock_response.usage = MagicMock()
         mock_response.usage.total_tokens = 0
         mock_response.usage.prompt_tokens = 0
         mock_response.usage.completion_tokens = 0
-        assert OpenAIHelper.get_ai_usage_from_response(mock_response) is None
+        assert get_ai_usage_from_response(mock_response) is None
 
 
 class TestGetAIMetricsFromResponse:

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

@@ -425,7 +425,7 @@ async def create_agent(
         if not config.enabled or not config.tracker:
             return None
 
-        runner = await RunnerFactory.create_agent(config, tools or {}, default_ai_provider)
+        runner = RunnerFactory.create_agent(config, tools or {}, default_ai_provider)
         if not runner:
             return None
 

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

@@ -1,8 +1,7 @@
 """ManagedAgent — LaunchDarkly managed wrapper for agent invocations."""
 
 from ldai.models import AIAgentConfig
-from ldai.runners.agent_runner import AgentRunner
-from ldai.runners.types import AgentResult
+from ldai.providers import AgentResult, AgentRunner
 from ldai.tracker import LDAIConfigTracker
 
 

packages/sdk/server-ai/tests/test_managed_agent.py

@@ -6,7 +6,7 @@
 from ldai import LDAIClient, ManagedAgent
 from ldai.managed_agent import ManagedAgent
 from ldai.models import AIAgentConfig, AIAgentConfigDefault, ModelConfig, ProviderConfig
-from ldai.runners.types import AgentResult
+from ldai.providers import AgentResult
 from ldai.providers.types import LDAIMetrics
 
 from ldclient import Config, Context, LDClient
@@ -56,7 +56,7 @@ async def test_run_delegates_to_agent_runner(self):
         """Should delegate run() to the underlying AgentRunner."""
         mock_config = MagicMock(spec=AIAgentConfig)
         mock_tracker = MagicMock()
-        mock_tracker.track_metrics_of = AsyncMock(
+        mock_tracker.track_metrics_of_async = AsyncMock(
             return_value=AgentResult(
                 output="Test response",
                 raw=None,
@@ -77,7 +77,7 @@ async def test_run_delegates_to_agent_runner(self):
 
         assert result.output == "Test response"
         assert result.metrics.success is True
-        mock_tracker.track_metrics_of.assert_called_once()
+        mock_tracker.track_metrics_of_async.assert_called_once()
 
     def test_get_agent_runner_returns_runner(self):
         """Should return the underlying AgentRunner."""
@@ -119,7 +119,7 @@ async def test_returns_none_when_provider_unavailable(self, ldai_client: LDAICli
         context = Context.create('user-key')
 
         original = rf.RunnerFactory.create_agent
-        rf.RunnerFactory.create_agent = AsyncMock(return_value=None)
+        rf.RunnerFactory.create_agent = MagicMock(return_value=None)
         try:
             result = await ldai_client.create_agent('customer-support-agent', context)
             assert result is None
@@ -138,7 +138,7 @@ async def test_returns_managed_agent_when_runner_available(self, ldai_client: LD
         )
 
         original = rf.RunnerFactory.create_agent
-        rf.RunnerFactory.create_agent = AsyncMock(return_value=mock_runner)
+        rf.RunnerFactory.create_agent = MagicMock(return_value=mock_runner)
         try:
             result = await ldai_client.create_agent('customer-support-agent', context)
             assert isinstance(result, ManagedAgent)