update to supported ai client version and fix tests

Author: jsonbailey

packages/ai-providers/server-ai-langchain/pyproject.toml

@@ -24,7 +24,7 @@ packages = [{ include = "ldai_langchain", from = "src" }]
 
 [tool.poetry.dependencies]
 python = ">=3.9,<4"
-launchdarkly-server-sdk-ai = ">=0.11.0"
+launchdarkly-server-sdk-ai = ">=0.12.0"
 langchain-core = ">=0.2.0"
 langchain = ">=0.2.0"
 

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

@@ -53,7 +53,7 @@ async def invoke_model(self, messages: List[LDMessage]) -> ChatResponse:
             if isinstance(response.content, str):
                 content = response.content
             else:
-                log.warn(
+                log.warning(
                     f'Multimodal response not supported, expecting a string. '
                     f'Content type: {type(response.content)}, Content: {response.content}'
                 )
@@ -64,7 +64,7 @@ async def invoke_model(self, messages: List[LDMessage]) -> ChatResponse:
                 metrics=metrics,
             )
         except Exception as error:
-            log.warn(f'LangChain model invocation failed: {error}')
+            log.warning(f'LangChain model invocation failed: {error}')
 
             return ChatResponse(
                 message=LDMessage(role='assistant', content=''),
@@ -89,7 +89,7 @@ async def invoke_structured_model(
             response = await structured_llm.ainvoke(langchain_messages)
 
             if not isinstance(response, dict):
-                log.warn(
+                log.warning(
                     f'Structured output did not return a dict. '
                     f'Got: {type(response)}'
                 )
@@ -111,7 +111,7 @@ async def invoke_structured_model(
                 ),
             )
         except Exception as error:
-            log.warn(f'LangChain structured model invocation failed: {error}')
+            log.warning(f'LangChain structured model invocation failed: {error}')
 
             return StructuredResponse(
                 data={},

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

@@ -145,53 +145,45 @@ def mock_llm(self):
         """Create a mock LLM."""
         return MagicMock()
 
-    @pytest.fixture
-    def mock_logger(self):
-        """Create a mock logger."""
-        return MagicMock()
-
     @pytest.mark.asyncio
-    async def test_returns_success_true_for_string_content(self, mock_llm, mock_logger):
+    async def test_returns_success_true_for_string_content(self, mock_llm):
         """Should return success=True for string content."""
         mock_response = AIMessage(content='Test response')
         mock_llm.ainvoke = AsyncMock(return_value=mock_response)
-        provider = LangChainProvider(mock_llm, mock_logger)
+        provider = LangChainProvider(mock_llm)
 
         messages = [LDMessage(role='user', content='Hello')]
         result = await provider.invoke_model(messages)
 
         assert result.metrics.success is True
         assert result.message.content == 'Test response'
-        mock_logger.warn.assert_not_called()
 
     @pytest.mark.asyncio
-    async def test_returns_success_false_for_non_string_content_and_logs_warning(self, mock_llm, mock_logger):
+    async def test_returns_success_false_for_non_string_content_and_logs_warning(self, mock_llm):
         """Should return success=False for non-string content and log warning."""
         mock_response = AIMessage(content=[{'type': 'image', 'data': 'base64data'}])
         mock_llm.ainvoke = AsyncMock(return_value=mock_response)
-        provider = LangChainProvider(mock_llm, mock_logger)
+        provider = LangChainProvider(mock_llm)
 
         messages = [LDMessage(role='user', content='Hello')]
         result = await provider.invoke_model(messages)
 
         assert result.metrics.success is False
         assert result.message.content == ''
-        mock_logger.warn.assert_called_once()
 
     @pytest.mark.asyncio
-    async def test_returns_success_false_when_model_invocation_throws_error(self, mock_llm, mock_logger):
+    async def test_returns_success_false_when_model_invocation_throws_error(self, mock_llm):
         """Should return success=False when model invocation throws an error."""
         error = Exception('Model invocation failed')
         mock_llm.ainvoke = AsyncMock(side_effect=error)
-        provider = LangChainProvider(mock_llm, mock_logger)
+        provider = LangChainProvider(mock_llm)
 
         messages = [LDMessage(role='user', content='Hello')]
         result = await provider.invoke_model(messages)
 
         assert result.metrics.success is False
         assert result.message.content == ''
         assert result.message.role == 'assistant'
-        mock_logger.warn.assert_called()
 
 
 class TestInvokeStructuredModel:
@@ -202,36 +194,30 @@ def mock_llm(self):
         """Create a mock LLM."""
         return MagicMock()
 
-    @pytest.fixture
-    def mock_logger(self):
-        """Create a mock logger."""
-        return MagicMock()
-
     @pytest.mark.asyncio
-    async def test_returns_success_true_for_successful_invocation(self, mock_llm, mock_logger):
+    async def test_returns_success_true_for_successful_invocation(self, mock_llm):
         """Should return success=True for successful invocation."""
         mock_response = {'result': 'structured data'}
         mock_structured_llm = MagicMock()
         mock_structured_llm.ainvoke = AsyncMock(return_value=mock_response)
         mock_llm.with_structured_output = MagicMock(return_value=mock_structured_llm)
-        provider = LangChainProvider(mock_llm, mock_logger)
+        provider = LangChainProvider(mock_llm)
 
         messages = [LDMessage(role='user', content='Hello')]
         response_structure = {'type': 'object', 'properties': {}}
         result = await provider.invoke_structured_model(messages, response_structure)
 
         assert result.metrics.success is True
         assert result.data == mock_response
-        mock_logger.warn.assert_not_called()
 
     @pytest.mark.asyncio
-    async def test_returns_success_false_when_structured_model_invocation_throws_error(self, mock_llm, mock_logger):
+    async def test_returns_success_false_when_structured_model_invocation_throws_error(self, mock_llm):
         """Should return success=False when structured model invocation throws an error."""
         error = Exception('Structured invocation failed')
         mock_structured_llm = MagicMock()
         mock_structured_llm.ainvoke = AsyncMock(side_effect=error)
         mock_llm.with_structured_output = MagicMock(return_value=mock_structured_llm)
-        provider = LangChainProvider(mock_llm, mock_logger)
+        provider = LangChainProvider(mock_llm)
 
         messages = [LDMessage(role='user', content='Hello')]
         response_structure = {'type': 'object', 'properties': {}}
@@ -242,7 +228,6 @@ async def test_returns_success_false_when_structured_model_invocation_throws_err
         assert result.raw_response == ''
         assert result.metrics.usage is not None
         assert result.metrics.usage.total == 0
-        mock_logger.warn.assert_called()
 
 
 class TestGetChatModel: