refactor: LangChainModelRunner and LangChainAgentRunner formally inherit Runner

- LangChainModelRunner: replaces invoke_model/invoke_structured_model with
  run(input, output_type=None); returns RunnerResult
- LangChainAgentRunner: replaces AgentResult with RunnerResult; run()
  signature gains optional output_type parameter
- Tests updated to call run() and assert result.content / result.parsed

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

@@ -1,30 +1,31 @@
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, Optional
 
 from ldai import log
+from ldai.providers.runner import Runner
 from ldai.providers.types import LDAIMetrics, RunnerResult
 
 from ldai_langchain.langchain_helper import (
     extract_last_message_content,
-    get_tool_calls_from_response,
     sum_token_usage_from_messages,
 )
 
 
-class LangChainAgentRunner:
+class LangChainAgentRunner(Runner):
     """
     CAUTION:
     This feature is experimental and should NOT be considered ready for production use.
     It may change or be removed without notice and is not subject to backwards
     compatibility guarantees.
 
-    Runner implementation for a single LangChain agent.
+    Runner implementation for LangChain agents.
 
     Wraps a compiled LangChain agent graph (from ``langchain.agents.create_agent``)
     and delegates execution to it. Tool calling and loop management are handled
     internally by the graph.
-    Returned by ``LangChainRunnerFactory.create_agent(config, tools)``.
+    Returned by LangChainRunnerFactory.create_agent(config, tools).
 
-    Implements the unified :class:`~ldai.providers.runner.Runner` protocol.
+    Implements the unified :class:`~ldai.providers.runner.Runner` protocol via
+    :meth:`run`.
     """
 
     def __init__(self, agent: Any):
@@ -36,7 +37,7 @@ async def run(
         output_type: Optional[Dict[str, Any]] = None,
     ) -> RunnerResult:
         """
-        Run the agent with the given input.
+        Run the agent with the given input string.
 
         Delegates to the compiled LangChain agent, which handles
         the tool-calling loop internally.
@@ -45,21 +46,19 @@ async def run(
         :param output_type: Reserved for future structured output support;
             currently ignored.
         :return: :class:`RunnerResult` with ``content``, ``raw`` response, and
-            metrics including aggregated token usage and observed ``tool_calls``.
+            aggregated metrics.
         """
         try:
             result = await self._agent.ainvoke({
                 "messages": [{"role": "user", "content": str(input)}]
             })
-            messages: List[Any] = result.get("messages", [])
-            content = extract_last_message_content(messages)
-            tool_calls = self._extract_tool_calls(messages)
+            messages = result.get("messages", [])
+            output = extract_last_message_content(messages)
             return RunnerResult(
-                content=content,
+                content=output,
                 metrics=LDAIMetrics(
                     success=True,
                     usage=sum_token_usage_from_messages(messages),
-                    tool_calls=tool_calls if tool_calls else None,
                 ),
                 raw=result,
             )
@@ -70,14 +69,6 @@ async def run(
                 metrics=LDAIMetrics(success=False, usage=None),
             )
 
-    @staticmethod
-    def _extract_tool_calls(messages: List[Any]) -> List[str]:
-        """Collect tool call names from all messages in the agent output."""
-        names: List[str] = []
-        for msg in messages:
-            names.extend(get_tool_calls_from_response(msg))
-        return names
-
     def get_agent(self) -> Any:
         """Return the underlying compiled LangChain agent."""
         return self._agent

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

@@ -3,6 +3,7 @@
 from langchain_core.language_models.chat_models import BaseChatModel
 from langchain_core.messages import BaseMessage
 from ldai import LDMessage, log
+from ldai.providers.runner import Runner
 from ldai.providers.types import LDAIMetrics, RunnerResult
 
 from ldai_langchain.langchain_helper import (
@@ -12,12 +13,12 @@
 )
 
 
-class LangChainModelRunner:
+class LangChainModelRunner(Runner):
     """
     Runner implementation for LangChain chat models.
 
     Holds a fully-configured BaseChatModel.
-    Returned by ``LangChainRunnerFactory.create_model(config)``.
+    Returned by LangChainRunnerFactory.create_model(config).
 
     Implements the unified :class:`~ldai.providers.runner.Runner` protocol via
     :meth:`run`.
@@ -45,11 +46,12 @@ async def run(
         :param input: A string prompt or a list of :class:`LDMessage` objects
         :param output_type: Optional JSON schema dict requesting structured output.
             When provided, ``parsed`` on the returned :class:`RunnerResult` is
-            populated with the structured data.
+            populated with the parsed JSON document.
         :return: :class:`RunnerResult` containing ``content``, ``metrics``,
             ``raw`` and (when ``output_type`` is set) ``parsed``.
         """
         messages = self._coerce_input(input)
+
         if output_type is not None:
             return await self._run_structured(messages, output_type)
         return await self._run_completion(messages)
@@ -93,11 +95,13 @@ async def _run_completion(self, messages: List[LDMessage]) -> RunnerResult:
             )
 
     async def _run_structured(
-        self, messages: List[LDMessage], response_structure: Dict[str, Any]
+        self,
+        messages: List[LDMessage],
+        output_type: Dict[str, Any],
     ) -> RunnerResult:
         try:
             langchain_messages = convert_messages_to_langchain(messages)
-            structured_llm = self._llm.with_structured_output(response_structure, include_raw=True)
+            structured_llm = self._llm.with_structured_output(output_type, include_raw=True)
             response = await structured_llm.ainvoke(langchain_messages)
 
             if not isinstance(response, dict):
@@ -108,8 +112,12 @@ async def _run_structured(
                 )
 
             raw_response = response.get('raw')
-            usage = get_ai_usage_from_response(raw_response) if raw_response is not None else None
-            raw_content = raw_response.content if raw_response is not None and hasattr(raw_response, 'content') else ''
+            usage = None
+            raw_content = ''
+            if raw_response is not None:
+                if hasattr(raw_response, 'content'):
+                    raw_content = raw_response.content or ''
+                usage = get_ai_usage_from_response(raw_response)
 
             if response.get('parsing_error'):
                 log.warning('LangChain structured model invocation had a parsing error')
@@ -132,4 +140,3 @@ async def _run_structured(
                 content='',
                 metrics=LDAIMetrics(success=False, usage=None),
             )
-

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

@@ -220,7 +220,7 @@ def test_returns_provider_name_unchanged_for_unmapped_providers(self):
 
 
 class TestRunCompletion:
-    """Tests for the unified run() method (chat-completion path)."""
+    """Tests for run() without structured output."""
 
     @pytest.fixture
     def mock_llm(self):
@@ -268,7 +268,7 @@ async def test_returns_success_false_when_model_invocation_throws_error(self, mo
 
 
 class TestRunStructured:
-    """Tests for the unified run() method (structured-output path)."""
+    """Tests for run() with structured output."""
 
     @pytest.fixture
     def mock_llm(self):
@@ -307,7 +307,7 @@ async def test_returns_success_false_when_structured_model_invocation_throws_err
 
         assert result.metrics.success is False
         assert result.parsed is None
-        assert result.content == ''
+        assert result.raw is None
         assert result.metrics.usage is None