feat: add ManagedAgentGraph, OpenAIAgentGraphRunner, LangGraphAgentGraphRunner

Implements PR 5 — ManagedAgentGraph + create_agent_graph():

ldai:
- managed_agent_graph.py: ManagedAgentGraph wrapper holding AgentGraphRunner
  + AIGraphTracker; exposes run(), get_agent_graph_runner(), get_tracker()
- LDAIClient.create_agent_graph(key, context, tools): resolves graph via
  agent_graph(), delegates to RunnerFactory, returns ManagedAgentGraph
- Exports ManagedAgentGraph from top-level ldai package

ldai_openai:
- OpenAIAgentGraphRunner(AgentGraphRunner): builds agents via reverse_traverse
  using the openai-agents SDK; auto-tracks path, tool calls, handoffs,
  latency, invocation success/failure
- OpenAIRunnerFactory.create_agent_graph(graph_def, tools) -> OpenAIAgentGraphRunner

ldai_langchain:
- LangGraphAgentGraphRunner(AgentGraphRunner): builds a LangGraph StateGraph
  via traverse(); auto-tracks latency and invocation success/failure
- LangChainRunnerFactory.create_agent_graph(graph_def, tools) -> LangGraphAgentGraphRunner

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

Author: jsonbailey

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

@@ -1,12 +1,14 @@
 from ldai_langchain.langchain_helper import LangChainHelper
 from ldai_langchain.langchain_model_runner import LangChainModelRunner
 from ldai_langchain.langchain_runner_factory import LangChainRunnerFactory
+from ldai_langchain.langgraph_agent_graph_runner import LangGraphAgentGraphRunner
 
 __version__ = "0.1.0"
 
 __all__ = [
     '__version__',
     'LangChainRunnerFactory',
+    'LangGraphAgentGraphRunner',
     'LangChainHelper',
     'LangChainModelRunner',
 ]

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

@@ -1,13 +1,26 @@
+from typing import Any
+
 from ldai.models import AIConfigKind
 from ldai.providers import AIProvider
-
+from ldai.runners.types import ToolRegistry
 from ldai_langchain.langchain_helper import LangChainHelper
 from ldai_langchain.langchain_model_runner import LangChainModelRunner
 
 
 class LangChainRunnerFactory(AIProvider):
     """LangChain ``AIProvider`` implementation for the LaunchDarkly AI SDK."""
 
+    def create_agent_graph(self, graph_def: Any, tools: ToolRegistry) -> Any:
+        """
+        Create a configured LangGraphAgentGraphRunner for the given graph definition.
+
+        :param graph_def: The AgentGraphDefinition to execute
+        :param tools: Registry mapping tool names to callables (langchain-compatible)
+        :return: LangGraphAgentGraphRunner ready to execute the graph
+        """
+        from ldai_langchain.langgraph_agent_graph_runner import LangGraphAgentGraphRunner
+        return LangGraphAgentGraphRunner(graph_def, tools)
+
     def create_model(self, config: AIConfigKind) -> LangChainModelRunner:
         """
         Create a configured LangChainModelRunner for the given AI config.

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

@@ -0,0 +1,138 @@
+"""LangGraph agent graph runner for LaunchDarkly AI SDK."""
+
+import operator
+import time
+from typing import Annotated, Any, List
+
+from ldai.agent_graph import AgentGraphDefinition, AgentGraphNode
+from ldai.providers.types import LDAIMetrics
+from ldai.runners.agent_graph_runner import AgentGraphRunner
+from ldai.runners.types import AgentGraphResult, ToolRegistry
+
+
+class LangGraphAgentGraphRunner(AgentGraphRunner):
+    """
+    AgentGraphRunner implementation for LangGraph.
+
+    Builds a LangGraph StateGraph from an AgentGraphDefinition and
+    ToolRegistry via traverse(), compiles it, and executes it with
+    ainvoke(). Auto-tracks latency and invocation success/failure via
+    the graph's AIGraphTracker.
+
+    Requires ``langgraph`` to be installed.
+    """
+
+    def __init__(self, graph: AgentGraphDefinition, tools: ToolRegistry):
+        """
+        Initialize the runner.
+
+        :param graph: The AgentGraphDefinition to execute
+        :param tools: Registry mapping tool names to callables (langchain-compatible)
+        """
+        self._graph = graph
+        self._tools = tools
+
+    async def run(self, input: Any) -> AgentGraphResult:
+        """
+        Run the agent graph with the given input.
+
+        Builds a LangGraph StateGraph from the AgentGraphDefinition, compiles
+        it, and invokes it. Tracks latency and invocation success/failure.
+
+        :param input: The string prompt to send to the agent graph
+        :return: AgentGraphResult with the final output and metrics
+        """
+        tracker = self._graph.get_tracker()
+        start_time = time.time()
+        try:
+            try:
+                from langchain.chat_models import init_chat_model
+                from langchain_core.messages import AnyMessage, HumanMessage
+                from langgraph.graph import END, START, StateGraph
+                from typing_extensions import TypedDict
+            except ImportError as exc:
+                raise ImportError(
+                    "langgraph is required for LangGraphAgentGraphRunner. "
+                    "Install it with: pip install langgraph"
+                ) from exc
+
+            class WorkflowState(TypedDict):
+                messages: Annotated[List[AnyMessage], operator.add]
+
+            agent_builder: StateGraph = StateGraph(WorkflowState)
+            root_node = self._graph.root()
+            root_key = root_node.get_key() if root_node else None
+            tools_ref = self._tools
+
+            def handle_traversal(node: AgentGraphNode, ctx: dict) -> None:
+                node_config = node.get_config()
+                node_key = node.get_key()
+
+                model = None
+                if node_config.model:
+                    lc_model = init_chat_model(model=node_config.model.name)
+                    tool_defs = node_config.model.get_parameter('tools') or []
+                    tool_fns = [
+                        tools_ref[t.get('name', '')]
+                        for t in tool_defs
+                        if t.get('name', '') in tools_ref
+                    ]
+                    if tool_fns:
+                        lc_model = lc_model.bind_tools(tool_fns)
+                    model = lc_model
+
+                def invoke(state: WorkflowState) -> WorkflowState:
+                    if model:
+                        response = model.invoke(state['messages'])
+                        return {'messages': [response]}
+                    return state
+
+                invoke.__name__ = node_key
+
+                agent_builder.add_node(name=node_key, node=invoke)
+
+                if node_key == root_key:
+                    agent_builder.add_edge(START, node_key)
+
+                if node.is_terminal():
+                    agent_builder.add_edge(node_key, END)
+
+                for edge in node.get_edges():
+                    agent_builder.add_edge(node_key, edge.target_config)
+
+                return None
+
+            self._graph.traverse(fn=handle_traversal)
+            compiled = agent_builder.compile()
+
+            result = await compiled.ainvoke(
+                {'messages': [HumanMessage(content=str(input))]}
+            )
+            duration = int((time.time() - start_time) * 1000)
+
+            output = ''
+            messages = result.get('messages', [])
+            if messages:
+                last = messages[-1]
+                if hasattr(last, 'content'):
+                    output = str(last.content)
+
+            if tracker:
+                tracker.track_latency(duration)
+                tracker.track_invocation_success()
+
+            return AgentGraphResult(
+                output=output,
+                raw=result,
+                metrics=LDAIMetrics(success=True),
+            )
+        except Exception:
+            duration = int((time.time() - start_time) * 1000)
+            if tracker:
+                tracker.track_latency(duration)
+                tracker.track_invocation_failure()
+            return AgentGraphResult(
+                output='',
+                raw=None,
+                metrics=LDAIMetrics(success=False),
+            )

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

@@ -0,0 +1,139 @@
+"""Tests for LangGraphAgentGraphRunner and LangChainRunnerFactory.create_agent_graph()."""
+
+import pytest
+from unittest.mock import AsyncMock, MagicMock, patch
+
+from ldai.agent_graph import AgentGraphDefinition
+from ldai.models import AIAgentGraphConfig, AIAgentConfig, ModelConfig, ProviderConfig
+from ldai.runners.types import AgentGraphResult, ToolRegistry
+from ldai_langchain.langgraph_agent_graph_runner import LangGraphAgentGraphRunner
+from ldai_langchain.langchain_runner_factory import LangChainRunnerFactory
+
+
+def _make_graph(enabled: bool = True) -> AgentGraphDefinition:
+    root_config = AIAgentConfig(
+        key='root-agent',
+        enabled=enabled,
+        model=ModelConfig(name='gpt-4'),
+        provider=ProviderConfig(name='openai'),
+        instructions='You are a helpful assistant.',
+        tracker=MagicMock(),
+    )
+    graph_config = AIAgentGraphConfig(
+        key='test-graph',
+        root_config_key='root-agent',
+        edges=[],
+        enabled=enabled,
+    )
+    nodes = AgentGraphDefinition.build_nodes(graph_config, {'root-agent': root_config})
+    return AgentGraphDefinition(
+        agent_graph=graph_config,
+        nodes=nodes,
+        context=MagicMock(),
+        enabled=enabled,
+        tracker=MagicMock(),
+    )
+
+
+# --- Factory ---
+
+def test_langchain_runner_factory_create_agent_graph_returns_runner():
+    graph = _make_graph()
+    tools: ToolRegistry = {'fetch_weather': lambda loc: f'weather in {loc}'}
+    factory = LangChainRunnerFactory()
+    runner = factory.create_agent_graph(graph, tools)
+    assert isinstance(runner, LangGraphAgentGraphRunner)
+
+
+def test_langchain_runner_factory_create_agent_graph_wires_graph_and_tools():
+    graph = _make_graph()
+    tools: ToolRegistry = {}
+    factory = LangChainRunnerFactory()
+    runner = factory.create_agent_graph(graph, tools)
+    assert runner._graph is graph
+    assert runner._tools is tools
+
+
+# --- LangGraphAgentGraphRunner ---
+
+def test_langgraph_runner_stores_graph_and_tools():
+    graph = _make_graph()
+    tools: ToolRegistry = {}
+    runner = LangGraphAgentGraphRunner(graph, tools)
+    assert runner._graph is graph
+    assert runner._tools is tools
+
+
+@pytest.mark.asyncio
+async def test_langgraph_runner_run_raises_when_langgraph_not_installed():
+    graph = _make_graph()
+    runner = LangGraphAgentGraphRunner(graph, {})
+
+    with patch.dict('sys.modules', {'langgraph': None, 'langgraph.graph': None}):
+        result = await runner.run("test")
+        assert isinstance(result, AgentGraphResult)
+        assert result.metrics.success is False
+
+
+@pytest.mark.asyncio
+async def test_langgraph_runner_run_tracks_failure_on_exception():
+    graph = _make_graph()
+    tracker = graph.get_tracker()
+    runner = LangGraphAgentGraphRunner(graph, {})
+
+    with patch.dict('sys.modules', {'langgraph': None, 'langgraph.graph': None}):
+        result = await runner.run("fail")
+
+    assert result.metrics.success is False
+    tracker.track_invocation_failure.assert_called_once()
+    tracker.track_latency.assert_called_once()
+
+
+@pytest.mark.asyncio
+async def test_langgraph_runner_run_success():
+    graph = _make_graph()
+    tracker = graph.get_tracker()
+
+    mock_message = MagicMock()
+    mock_message.content = "langgraph answer"
+
+    mock_compiled = MagicMock()
+    mock_compiled.ainvoke = AsyncMock(return_value={'messages': [mock_message]})
+
+    mock_state_graph_instance = MagicMock()
+    mock_state_graph_instance.add_node = MagicMock()
+    mock_state_graph_instance.add_edge = MagicMock()
+    mock_state_graph_instance.compile = MagicMock(return_value=mock_compiled)
+
+    mock_langgraph_graph = MagicMock()
+    mock_langgraph_graph.END = 'END'
+    mock_langgraph_graph.START = 'START'
+    mock_langgraph_graph.StateGraph = MagicMock(return_value=mock_state_graph_instance)
+
+    mock_human_message = MagicMock()
+    mock_lc_core_messages = MagicMock()
+    mock_lc_core_messages.HumanMessage = MagicMock(return_value=mock_human_message)
+    mock_lc_core_messages.AnyMessage = MagicMock()
+
+    mock_init_model = MagicMock()
+    mock_init_model.return_value = MagicMock()
+    mock_langchain_chat = MagicMock()
+    mock_langchain_chat.init_chat_model = mock_init_model
+
+    with patch.dict('sys.modules', {
+        'langgraph': MagicMock(),
+        'langgraph.graph': mock_langgraph_graph,
+        'langchain_core': MagicMock(),
+        'langchain_core.messages': mock_lc_core_messages,
+        'langchain': MagicMock(),
+        'langchain.chat_models': mock_langchain_chat,
+        'typing_extensions': __import__('typing_extensions'),
+    }):
+        runner = LangGraphAgentGraphRunner(graph, {})
+        result = await runner.run("find restaurants")
+
+    assert isinstance(result, AgentGraphResult)
+    assert result.output == "langgraph answer"
+    assert result.metrics.success is True
+    tracker.track_invocation_success.assert_called_once()
+    tracker.track_latency.assert_called_once()

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

@@ -1,9 +1,11 @@
+from ldai_openai.openai_agent_graph_runner import OpenAIAgentGraphRunner
 from ldai_openai.openai_helper import OpenAIHelper
 from ldai_openai.openai_model_runner import OpenAIModelRunner
 from ldai_openai.openai_runner_factory import OpenAIRunnerFactory
 
 __all__ = [
     'OpenAIRunnerFactory',
+    'OpenAIAgentGraphRunner',
     'OpenAIHelper',
     'OpenAIModelRunner',
 ]