feat: Introduce ManagedAgent and AgentRunner implementations

feat: Add OpenAIAgentRunner with agentic tool-calling loop
feat: Add LangChainAgentRunner with agentic tool-calling loop
feat: Add OpenAIRunnerFactory.create_agent(config, tools) -> OpenAIAgentRunner
feat: Add LangChainRunnerFactory.create_agent(config, tools) -> LangChainAgentRunner
feat: Add ManagedAgent wrapper holding AgentRunner and LDAIConfigTracker
feat: Add LDAIClient.create_agent() returning ManagedAgent

Author: jsonbailey

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

@@ -1,3 +1,4 @@
+from ldai_langchain.langchain_agent_runner import LangChainAgentRunner
 from ldai_langchain.langchain_helper import (
     convert_messages_to_langchain,
     create_langchain_model,
@@ -16,6 +17,7 @@
     '__version__',
     'LangChainRunnerFactory',
     'LangChainModelRunner',
+    'LangChainAgentRunner',
     'convert_messages_to_langchain',
     'create_langchain_model',
     'get_ai_metrics_from_response',

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

@@ -0,0 +1,121 @@
+"""LangChain agent runner for LaunchDarkly AI SDK."""
+
+from typing import Any, Dict, List
+
+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
+
+
+class LangChainAgentRunner(AgentRunner):
+    """
+    AgentRunner implementation for LangChain.
+
+    Executes a single-agent loop using a LangChain BaseChatModel with tool calling.
+    Returned by LangChainRunnerFactory.create_agent(config, tools).
+    """
+
+    def __init__(
+        self,
+        llm: Any,
+        instructions: str,
+        tool_definitions: List[Dict[str, Any]],
+        tools: ToolRegistry,
+    ):
+        self._llm = llm
+        self._instructions = instructions
+        self._tool_definitions = tool_definitions
+        self._tools = tools
+
+    async def run(self, input: Any) -> AgentResult:
+        """
+        Run the agent with the given input string.
+
+        Executes an agentic loop: calls the model, handles tool calls,
+        and continues until the model produces a final response.
+
+        :param input: The user prompt or input to the agent
+        :return: AgentResult with output, raw response, and aggregated metrics
+        """
+        messages: List[BaseMessage] = []
+        if self._instructions:
+            messages.append(SystemMessage(content=self._instructions))
+        messages.append(HumanMessage(content=str(input)))
+
+        openai_tools = self._build_openai_tools()
+        model = self._llm.bind_tools(openai_tools) if openai_tools else self._llm
+
+        raw_response = None
+
+        try:
+            while True:
+                response: AIMessage = await model.ainvoke(messages)
+                raw_response = response
+                messages.append(response)
+
+                tool_calls = getattr(response, 'tool_calls', None)
+
+                if not tool_calls:
+                    metrics = get_ai_metrics_from_response(response)
+                    content = response.content if isinstance(response.content, str) else ""
+                    return AgentResult(
+                        output=content,
+                        raw=raw_response,
+                        metrics=metrics,
+                    )
+
+                # Execute tool calls and append results
+                for tool_call in tool_calls:
+                    tool_name = tool_call["name"]
+                    tool_args = tool_call.get("args", {})
+                    tool_id = tool_call.get("id", "")
+
+                    tool_fn = self._tools.get(tool_name)
+                    if tool_fn:
+                        try:
+                            result = tool_fn(**tool_args)
+                            if hasattr(result, "__await__"):
+                                result = await result
+                            result_str = str(result)
+                        except Exception as error:
+                            log.warning(f"Tool '{tool_name}' execution failed: {error}")
+                            result_str = f"Tool execution failed: {error}"
+                    else:
+                        log.warning(f"Tool '{tool_name}' not found in registry")
+                        result_str = f"Tool '{tool_name}' not found"
+
+                    messages.append(ToolMessage(content=result_str, tool_call_id=tool_id))
+
+        except Exception as error:
+            log.warning(f"LangChain agent run failed: {error}")
+            return AgentResult(
+                output="",
+                raw=raw_response,
+                metrics=LDAIMetrics(success=False, usage=None),
+            )
+
+    def _build_openai_tools(self) -> List[Dict[str, Any]]:
+        """Convert LD tool definitions to OpenAI function-calling format for bind_tools."""
+        tools = []
+        for td in self._tool_definitions:
+            if not isinstance(td, dict):
+                continue
+            if "type" in td:
+                tools.append(td)
+            elif "name" in td:
+                tools.append({
+                    "type": "function",
+                    "function": {
+                        "name": td["name"],
+                        "description": td.get("description", ""),
+                        "parameters": td.get("parameters", {"type": "object", "properties": {}}),
+                    },
+                })
+        return tools
+
+    def get_llm(self) -> Any:
+        """Return the underlying LangChain LLM."""
+        return self._llm

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

@@ -1,3 +1,5 @@
+from typing import Any
+
 from ldai.models import AIConfigKind
 from ldai.providers import AIProvider
 
@@ -17,3 +19,22 @@ def create_model(self, config: AIConfigKind) -> LangChainModelRunner:
         """
         llm = create_langchain_model(config)
         return LangChainModelRunner(llm)
+
+    def create_agent(self, config: Any, tools: Any) -> 'LangChainAgentRunner':
+        """
+        Create a configured LangChainAgentRunner for the given AI agent config.
+
+        :param config: The LaunchDarkly AI agent configuration
+        :param tools: ToolRegistry mapping tool names to callables
+        :return: LangChainAgentRunner ready to run the agent
+        """
+        from ldai_langchain.langchain_agent_runner import LangChainAgentRunner
+
+        config_dict = config.to_dict()
+        model_dict = config_dict.get('model') or {}
+        parameters = dict(model_dict.get('parameters') or {})
+        tool_definitions = parameters.pop('tools', []) or []
+        instructions = config.instructions or '' if hasattr(config, 'instructions') else ''
+
+        llm = LangChainHelper.create_langchain_model(config)
+        return LangChainAgentRunner(llm, instructions, tool_definitions, tools or {})

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

@@ -330,3 +330,125 @@ def test_returns_underlying_llm(self):
         runner = LangChainModelRunner(mock_llm)
 
         assert runner.get_llm() is mock_llm
+
+
+class TestCreateAgent:
+    """Tests for LangChainRunnerFactory.create_agent."""
+
+    def test_creates_agent_runner_with_instructions_and_tool_definitions(self):
+        """Should create LangChainAgentRunner with instructions and tool definitions."""
+        from unittest.mock import patch
+        from ldai_langchain import LangChainAgentRunner
+
+        mock_ai_config = MagicMock()
+        mock_ai_config.instructions = "You are a helpful assistant."
+        mock_ai_config.to_dict.return_value = {
+            'model': {
+                'name': 'gpt-4',
+                'parameters': {
+                    'tools': [
+                        {'name': 'get-weather', 'description': 'Get weather', 'parameters': {}},
+                    ],
+                },
+            },
+            'provider': {'name': 'openai'},
+        }
+
+        with patch.object(LangChainHelper, 'create_langchain_model') as mock_create:
+            mock_llm = MagicMock()
+            mock_create.return_value = mock_llm
+
+            factory = LangChainRunnerFactory()
+            result = factory.create_agent(mock_ai_config, {'get-weather': lambda loc: 'sunny'})
+
+            assert isinstance(result, LangChainAgentRunner)
+            assert result._instructions == "You are a helpful assistant."
+            assert len(result._tool_definitions) == 1
+
+    def test_creates_agent_runner_with_no_tools(self):
+        """Should create LangChainAgentRunner with no tool definitions."""
+        from unittest.mock import patch
+        from ldai_langchain import LangChainAgentRunner
+
+        mock_ai_config = MagicMock()
+        mock_ai_config.instructions = "You are a helpful assistant."
+        mock_ai_config.to_dict.return_value = {
+            'model': {'name': 'gpt-4', 'parameters': {}},
+            'provider': {'name': 'openai'},
+        }
+
+        with patch.object(LangChainHelper, 'create_langchain_model') as mock_create:
+            mock_create.return_value = MagicMock()
+
+            factory = LangChainRunnerFactory()
+            result = factory.create_agent(mock_ai_config, {})
+
+            assert isinstance(result, LangChainAgentRunner)
+            assert result._tool_definitions == []
+
+
+class TestLangChainAgentRunner:
+    """Tests for LangChainAgentRunner.run."""
+
+    @pytest.mark.asyncio
+    async def test_runs_agent_and_returns_result_with_no_tool_calls(self):
+        """Should return AgentResult when model responds with no tool calls."""
+        from ldai_langchain import LangChainAgentRunner
+        from langchain_core.messages import AIMessage
+
+        mock_llm = MagicMock()
+        mock_response = AIMessage(content="The answer is 42.")
+        mock_llm.bind_tools = MagicMock(return_value=mock_llm)
+        mock_llm.ainvoke = AsyncMock(return_value=mock_response)
+
+        runner = LangChainAgentRunner(mock_llm, "You are helpful.", [], {})
+        result = await runner.run("What is the answer?")
+
+        assert result.output == "The answer is 42."
+        assert result.metrics.success is True
+
+    @pytest.mark.asyncio
+    async def test_executes_tool_calls_and_returns_final_response(self):
+        """Should execute tool calls and continue loop until final response."""
+        from ldai_langchain import LangChainAgentRunner
+        from langchain_core.messages import AIMessage
+
+        # First response: has a tool call
+        first_response = AIMessage(content="")
+        first_response.tool_calls = [
+            {"name": "get-weather", "args": {"location": "Paris"}, "id": "call_123"}
+        ]
+
+        # Second response: final answer
+        second_response = AIMessage(content="It is sunny in Paris.")
+
+        mock_llm = MagicMock()
+        mock_llm.bind_tools = MagicMock(return_value=mock_llm)
+        mock_llm.ainvoke = AsyncMock(side_effect=[first_response, second_response])
+
+        weather_fn = MagicMock(return_value="Sunny, 25°C")
+        runner = LangChainAgentRunner(
+            mock_llm, "You are helpful.",
+            [{'name': 'get-weather', 'description': 'Get weather', 'parameters': {}}],
+            {'get-weather': weather_fn},
+        )
+        result = await runner.run("What is the weather in Paris?")
+
+        assert result.output == "It is sunny in Paris."
+        assert result.metrics.success is True
+        weather_fn.assert_called_once_with(location="Paris")
+
+    @pytest.mark.asyncio
+    async def test_returns_failure_when_exception_thrown(self):
+        """Should return unsuccessful AgentResult when exception is thrown."""
+        from ldai_langchain import LangChainAgentRunner
+
+        mock_llm = MagicMock()
+        mock_llm.bind_tools = MagicMock(return_value=mock_llm)
+        mock_llm.ainvoke = AsyncMock(side_effect=Exception("LLM Error"))
+
+        runner = LangChainAgentRunner(mock_llm, "", [], {})
+        result = await runner.run("Hello")
+
+        assert result.output == ""
+        assert result.metrics.success is False

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

@@ -1,3 +1,4 @@
+from ldai_openai.openai_agent_runner import OpenAIAgentRunner
 from ldai_openai.openai_helper import (
     convert_messages_to_openai,
     get_ai_metrics_from_response,
@@ -9,6 +10,7 @@
 __all__ = [
     'OpenAIRunnerFactory',
     'OpenAIModelRunner',
+    'OpenAIAgentRunner',
     'convert_messages_to_openai',
     'get_ai_metrics_from_response',
     'get_ai_usage_from_response',