refactor: remove deprecated ModelResponse, StructuredResponse, AgentResult and compat shims

Author: jsonbailey

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

@@ -34,12 +34,7 @@
 from ldai.providers import (
     AgentGraphResult,
     AgentGraphRunner,
-    AgentGraphRunnerResult,
-    AgentResult,
     AgentRunner,
-    GraphMetrics,
-    GraphMetricSummary,
-    ManagedGraphResult,
     ManagedResult,
     Runner,
     RunnerResult,
@@ -53,12 +48,7 @@
     'Evaluator',
     'AgentRunner',
     'AgentGraphRunner',
-    'AgentResult',
     'AgentGraphResult',
-    'AgentGraphRunnerResult',
-    'GraphMetrics',
-    'GraphMetricSummary',
-    'ManagedGraphResult',
     'ManagedResult',
     'Runner',
     'RunnerResult',

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

@@ -3,16 +3,15 @@
 from typing import Any
 
 from ldai.providers import AgentGraphResult, AgentGraphRunner
-from ldai.providers.types import GraphMetricSummary, ManagedGraphResult
 
 
 class ManagedAgentGraph:
     """
     LaunchDarkly managed wrapper for AI agent graph execution.
 
-    Holds an AgentGraphRunner. Wraps the runner result in a
-    :class:`~ldai.providers.types.ManagedGraphResult` and builds a
-    :class:`~ldai.providers.types.GraphMetricSummary` from the runner's metrics.
+    Holds an AgentGraphRunner. Auto-tracking of path,
+    tool calls, handoffs, latency, and invocation success/failure is handled
+    by the runner implementation.
 
     Obtain an instance via ``LDAIClient.create_agent_graph()``.
     """
@@ -28,33 +27,17 @@ def __init__(
         """
         self._runner = runner
 
-    async def run(self, input: Any) -> ManagedGraphResult:
+    async def run(self, input: Any) -> AgentGraphResult:
         """
         Run the agent graph with the given input.
 
+        Delegates to the underlying AgentGraphRunner, which handles
+        execution and all auto-tracking internally.
+
         :param input: The input prompt or structured input for the graph
-        :return: ManagedGraphResult containing the content, metric summary, raw response,
-            and an optional evaluations task (currently always ``None`` for graphs —
-            per-graph evaluations will be added in a future PR).
+        :return: AgentGraphResult containing the output, raw response, and metrics
         """
-        result: AgentGraphResult = await self._runner.run(input)
-
-        # Build a GraphMetricSummary from the runner result's LDAIMetrics.
-        # path and node_metrics will be populated once graph runners are migrated
-        # to return AgentGraphRunnerResult with GraphMetrics (PR 11).
-        metrics = result.metrics
-        summary = GraphMetricSummary(
-            success=metrics.success,
-            usage=metrics.usage,
-            duration_ms=getattr(metrics, 'duration_ms', None),
-        )
-
-        return ManagedGraphResult(
-            content=result.output,
-            metrics=summary,
-            raw=result.raw,
-            evaluations=None,
-        )
+        return await self._runner.run(input)
 
     def get_agent_graph_runner(self) -> AgentGraphRunner:
         """

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

@@ -4,7 +4,7 @@
 from ldai import log
 from ldai.models import AICompletionConfig, LDMessage
 from ldai.providers.runner import Runner
-from ldai.providers.types import JudgeResult, ManagedResult
+from ldai.providers.types import JudgeResult, ManagedResult, RunnerResult
 from ldai.tracker import LDAIConfigTracker
 
 
@@ -46,7 +46,7 @@ async def run(self, prompt: str) -> ManagedResult:
         config_messages = self._ai_config.messages or []
         all_messages = config_messages + self._messages
 
-        result = await tracker.track_metrics_of_async(
+        result: RunnerResult = await tracker.track_metrics_of_async(
             lambda r: r.metrics,
             lambda: self._model_runner.run(all_messages),
         )

packages/sdk/server-ai/src/ldai/providers/__init__.py

@@ -6,38 +6,24 @@
 from ldai.providers.runner_factory import RunnerFactory
 from ldai.providers.types import (
     AgentGraphResult,
-    AgentGraphRunnerResult,
-    AgentResult,
-    GraphMetrics,
-    GraphMetricSummary,
     JudgeResult,
     LDAIMetrics,
-    ManagedGraphResult,
     ManagedResult,
-    ModelResponse,
     RunnerResult,
-    StructuredResponse,
     ToolRegistry,
 )
 
 __all__ = [
     'AIProvider',
     'AgentGraphResult',
     'AgentGraphRunner',
-    'AgentGraphRunnerResult',
-    'AgentResult',
     'AgentRunner',
-    'GraphMetrics',
-    'GraphMetricSummary',
     'JudgeResult',
     'LDAIMetrics',
-    'ManagedGraphResult',
     'ManagedResult',
-    'ModelResponse',
     'ModelRunner',
     'Runner',
     'RunnerFactory',
     'RunnerResult',
-    'StructuredResponse',
     'ToolRegistry',
 ]

packages/sdk/server-ai/src/ldai/providers/agent_runner.py

@@ -1,6 +1,6 @@
 from typing import Any, Protocol, runtime_checkable
 
-from ldai.providers.types import AgentResult
+from ldai.providers.types import RunnerResult
 
 
 @runtime_checkable
@@ -18,11 +18,11 @@ class AgentRunner(Protocol):
     the caller just passes input.
     """
 
-    async def run(self, input: Any) -> AgentResult:
+    async def run(self, input: Any) -> RunnerResult:
         """
         Run the agent with the given input.
 
         :param input: The input to the agent (string prompt or structured input)
-        :return: AgentResult containing the output, raw response, and metrics
+        :return: RunnerResult containing the agent's content, metrics, and optional raw/parsed fields
         """
         ...

packages/sdk/server-ai/src/ldai/providers/ai_provider.py

@@ -1,9 +1,8 @@
 from abc import ABC
-from typing import Any, Dict, List, Optional
+from typing import Any, Optional
 
 from ldai import log
-from ldai.models import LDMessage
-from ldai.providers.types import ModelResponse, StructuredResponse, ToolRegistry
+from ldai.providers.types import ToolRegistry
 
 
 class AIProvider(ABC):
@@ -16,51 +15,6 @@ class AIProvider(ABC):
     create_model(), create_agent(), and create_agent_graph().
     """
 
-    async def invoke_model(self, messages: List[LDMessage]) -> ModelResponse:
-        """
-        Invoke the chat model with an array of messages.
-
-        Default implementation takes no action and returns a placeholder response.
-        Provider implementations should override this method.
-
-        :param messages: Array of LDMessage objects representing the conversation
-        :return: ModelResponse containing the model's response
-        """
-        log.warning('invoke_model not implemented by this provider')
-
-        from ldai.models import LDMessage
-        from ldai.providers.types import LDAIMetrics
-
-        return ModelResponse(
-            message=LDMessage(role='assistant', content=''),
-            metrics=LDAIMetrics(success=False, usage=None),
-        )
-
-    async def invoke_structured_model(
-        self,
-        messages: List[LDMessage],
-        response_structure: Dict[str, Any],
-    ) -> StructuredResponse:
-        """
-        Invoke the chat model with structured output support.
-
-        Default implementation takes no action and returns a placeholder response.
-        Provider implementations should override this method.
-
-        :param messages: Array of LDMessage objects representing the conversation
-        :param response_structure: Dictionary of output configurations keyed by output name
-        :return: StructuredResponse containing the structured data
-        """
-        log.warning('invoke_structured_model not implemented by this provider')
-
-        from ldai.providers.types import LDAIMetrics
-
-        return StructuredResponse(
-            data={},
-            raw_response='',
-            metrics=LDAIMetrics(success=False, usage=None),
-        )
-
     def create_model(self, config: Any) -> Optional[Any]:
         """
         Create a configured model executor for the given AI config.

packages/sdk/server-ai/src/ldai/providers/model_runner.py

@@ -1,7 +1,7 @@
-from typing import Any, Dict, List, Protocol, runtime_checkable
+from typing import List, Protocol, runtime_checkable
 
 from ldai.models import LDMessage
-from ldai.providers.types import ModelResponse, StructuredResponse
+from ldai.providers.types import RunnerResult
 
 
 @runtime_checkable
@@ -14,25 +14,11 @@ class ModelRunner(Protocol):
     and with what parameters — the caller just passes messages.
     """
 
-    async def invoke_model(self, messages: List[LDMessage]) -> ModelResponse:
+    async def invoke_model(self, messages: List[LDMessage]) -> RunnerResult:
         """
         Invoke the model with an array of messages.
 
         :param messages: Array of LDMessage objects representing the conversation
-        :return: ModelResponse containing the model's response and metrics
-        """
-        ...
-
-    async def invoke_structured_model(
-        self,
-        messages: List[LDMessage],
-        response_structure: Dict[str, Any],
-    ) -> StructuredResponse:
-        """
-        Invoke the model with structured output support.
-
-        :param messages: Array of LDMessage objects representing the conversation
-        :param response_structure: Dictionary defining the JSON schema for output structure
-        :return: StructuredResponse containing the structured data
+        :return: RunnerResult containing the model's response and metrics
         """
         ...