feat!: Remove config.tracker field — use create_tracker() instead

BREAKING CHANGE: The `tracker` field has been removed from all config
dataclasses (AICompletionConfig, AIJudgeConfig, AIAgentConfig). Users
must now call `config.create_tracker()` to obtain a tracker instance.

ManagedModel and ManagedAgent no longer accept a tracker constructor
parameter — they call `create_tracker()` from the config on each
invocation. The `__evaluate` return tuple no longer includes a
pre-created tracker.

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

Author: jsonbailey

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

@@ -84,7 +84,7 @@ def _completion_config(
         default: AICompletionConfigDefault,
         variables: Optional[Dict[str, Any]] = None,
     ) -> AICompletionConfig:
-        (model, provider, messages, instructions, tracker,
+        (model, provider, messages, instructions,
          tracker_factory, enabled, judge_configuration, _) = self.__evaluate(
             key, context, default.to_dict(), variables
         )
@@ -95,7 +95,6 @@ def _completion_config(
             model=model,
             messages=messages,
             provider=provider,
-            tracker=tracker,
             create_tracker=tracker_factory,
             judge_configuration=judge_configuration,
         )
@@ -152,7 +151,7 @@ def _judge_config(
         default: AIJudgeConfigDefault,
         variables: Optional[Dict[str, Any]] = None,
     ) -> AIJudgeConfig:
-        (model, provider, messages, instructions, tracker,
+        (model, provider, messages, instructions,
          tracker_factory, enabled, judge_configuration, variation) = self.__evaluate(
             key, context, default.to_dict(), variables
         )
@@ -181,7 +180,6 @@ def _extract_evaluation_metric_key(variation: Dict[str, Any]) -> Optional[str]:
             model=model,
             messages=messages,
             provider=provider,
-            tracker=tracker,
             create_tracker=tracker_factory,
         )
 
@@ -381,7 +379,7 @@ async def create_model(
                 default_ai_provider,
             )
 
-        return ManagedModel(config, config.create_tracker(), runner, judges)
+        return ManagedModel(config, runner, judges)
 
     async def create_chat(
         self,
@@ -455,7 +453,7 @@ async def create_agent(
         if not runner:
             return None
 
-        return ManagedAgent(config, config.create_tracker(), runner)
+        return ManagedAgent(config, runner)
 
     def agent_config(
         self,
@@ -485,7 +483,8 @@ def agent_config(
 
             if agent.enabled:
                 research_result = agent.instructions  # Interpolated instructions
-                agent.tracker.track_success()
+                tracker = agent.create_tracker()
+                tracker.track_success()
 
         :param key: The agent configuration key.
         :param context: The context to evaluate the agent configuration in.
@@ -555,7 +554,8 @@ def agent_configs(
             ], context)
 
             research_result = agents["research_agent"].instructions
-            agents["research_agent"].tracker.track_success()
+            tracker = agents["research_agent"].create_tracker()
+            tracker.track_success()
 
         :param agent_configs: List of agent configurations to retrieve.
         :param context: The context to evaluate the agent configurations in.
@@ -774,7 +774,7 @@ def __evaluate(
         graph_key: Optional[str] = None,
     ) -> Tuple[
         Optional[ModelConfig], Optional[ProviderConfig], Optional[List[LDMessage]],
-        Optional[str], LDAIConfigTracker, Callable[[], LDAIConfigTracker], bool, Optional[Any], Dict[str, Any]
+        Optional[str], Callable[[], LDAIConfigTracker], bool, Optional[Any], Dict[str, Any]
     ]:
         """
         Internal method to evaluate a configuration and extract components.
@@ -784,7 +784,8 @@ def __evaluate(
         :param default_dict: Default configuration as dictionary.
         :param variables: Variables for interpolation.
         :param graph_key: When set, passed to the tracker so all events include ``graphKey``.
-        :return: Tuple of (model, provider, messages, instructions, tracker, enabled, judge_configuration, variation).
+        :return: Tuple of (model, provider, messages, instructions,
+            tracker_factory, enabled, judge_configuration, variation).
         """
         variation = self._client.variation(key, context, default_dict)
 
@@ -844,8 +845,6 @@ def tracker_factory() -> LDAIConfigTracker:
                 graph_key=graph_key,
             )
 
-        tracker = tracker_factory()
-
         enabled = variation.get('_ldMeta', {}).get('enabled', False)
 
         judge_configuration = None
@@ -864,7 +863,7 @@ def tracker_factory() -> LDAIConfigTracker:
                     judge_configuration = JudgeConfiguration(judges=judges)
 
         return (
-            model, provider_config, messages, instructions, tracker,
+            model, provider_config, messages, instructions,
             tracker_factory, enabled, judge_configuration, variation,
         )
 
@@ -886,7 +885,7 @@ def __evaluate_agent(
         :param graph_key: When set, passed to the tracker so all events include ``graphKey``.
         :return: Configured AIAgentConfig instance.
         """
-        (model, provider, messages, instructions, tracker,
+        (model, provider, messages, instructions,
          tracker_factory, enabled, judge_configuration, _) = self.__evaluate(
             key, context, default.to_dict(), variables, graph_key=graph_key
         )
@@ -900,7 +899,6 @@ def __evaluate_agent(
             model=model or default.model,
             provider=provider or default.provider,
             instructions=final_instructions,
-            tracker=tracker,
             create_tracker=tracker_factory,
             judge_configuration=judge_configuration or default.judge_configuration,
         )

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

@@ -2,25 +2,22 @@
 
 from ldai.models import AIAgentConfig
 from ldai.providers import AgentResult, AgentRunner
-from ldai.tracker import LDAIConfigTracker
 
 
 class ManagedAgent:
     """
     LaunchDarkly managed wrapper for AI agent invocations.
 
-    Holds an AgentRunner and an LDAIConfigTracker. Handles tracking automatically.
+    Holds an AgentRunner. Handles tracking automatically via ``create_tracker()``.
     Obtain an instance via ``LDAIClient.create_agent()``.
     """
 
     def __init__(
         self,
         ai_config: AIAgentConfig,
-        tracker: LDAIConfigTracker,
         agent_runner: AgentRunner,
     ):
         self._ai_config = ai_config
-        self._tracker = tracker
         self._agent_runner = agent_runner
 
     async def run(self, input: str) -> AgentResult:
@@ -47,7 +44,3 @@ def get_agent_runner(self) -> AgentRunner:
     def get_config(self) -> AIAgentConfig:
         """Return the AI agent config."""
         return self._ai_config
-
-    def get_tracker(self) -> LDAIConfigTracker:
-        """Return the config tracker."""
-        return self._tracker

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

@@ -13,20 +13,18 @@ class ManagedModel:
     """
     LaunchDarkly managed wrapper for AI model invocations.
 
-    Holds a ModelRunner and an LDAIConfigTracker. Handles conversation
-    management, judge evaluation dispatch, and tracking automatically.
+    Holds a ModelRunner. Handles conversation management, judge evaluation
+    dispatch, and tracking automatically via ``create_tracker()``.
     Obtain an instance via ``LDAIClient.create_model()``.
     """
 
     def __init__(
         self,
         ai_config: AICompletionConfig,
-        tracker: LDAIConfigTracker,
         model_runner: ModelRunner,
         judges: Optional[Dict[str, Judge]] = None,
     ):
         self._ai_config = ai_config
-        self._tracker = tracker
         self._model_runner = model_runner
         self._judges = judges or {}
         self._messages: List[LDMessage] = []
@@ -119,10 +117,6 @@ def get_config(self) -> AICompletionConfig:
         """Return the AI completion config."""
         return self._ai_config
 
-    def get_tracker(self) -> LDAIConfigTracker:
-        """Return the config tracker."""
-        return self._tracker
-
     def get_judges(self) -> Dict[str, Judge]:
         """Return the judges associated with this model."""
         return self._judges

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

@@ -180,7 +180,6 @@ class AIConfig:
     enabled: bool
     model: Optional[ModelConfig] = None
     provider: Optional[ProviderConfig] = None
-    tracker: Optional[Any] = None
     create_tracker: Callable[[], Any] = lambda: None
 
     def _base_to_dict(self) -> Dict[str, Any]:

packages/sdk/server-ai/tests/test_agent_graph.py

@@ -396,8 +396,9 @@ def test_agent_graph_node_trackers_have_graph_key(ldai_client: LDAIClient):
                  graph.get_node("multi-context-agent"),
                  graph.get_node("minimal-agent")]:
         config = node.get_config()
-        assert config.tracker is not None
-        assert config.tracker._graph_key == "test-agent-graph"
+        assert callable(config.create_tracker)
+        tracker = config.create_tracker()
+        assert tracker._graph_key == "test-agent-graph"
 
 
 def test_agent_graph_handoff(ldai_client: LDAIClient):

packages/sdk/server-ai/tests/test_agents.py

@@ -140,7 +140,7 @@ def test_single_agent_method(ldai_client: LDAIClient):
     assert agent.provider is not None
     assert agent.provider.name == 'openai'
     assert agent.instructions == 'You are a research assistant specializing in quantum computing. Your expertise level should match advanced.'
-    assert agent.tracker is not None
+    assert callable(agent.create_tracker)
 
 
 def test_single_agent_with_defaults(ldai_client: LDAIClient):
@@ -164,7 +164,7 @@ def test_single_agent_with_defaults(ldai_client: LDAIClient):
     assert agent.model is not None and agent.model.get_parameter('temp') == 0.8
     assert agent.provider is not None and agent.provider.name == 'default-provider'
     assert agent.instructions == "You are a default assistant for general assistance."
-    assert agent.tracker is not None
+    assert callable(agent.create_tracker)
 
 
 def test_agents_method_with_configs(ldai_client: LDAIClient):
@@ -275,7 +275,7 @@ def test_disabled_agent_single_method(ldai_client: LDAIClient):
     agent = ldai_client.agent(config, context)
 
     assert agent.enabled is False
-    assert agent.tracker is not None
+    assert callable(agent.create_tracker)
 
 
 def test_disabled_agent_multiple_method(ldai_client: LDAIClient):
@@ -313,7 +313,7 @@ def test_agent_with_missing_metadata(ldai_client: LDAIClient):
     assert agent.enabled is True  # From flag
     assert agent.instructions == 'Minimal agent configuration.'
     assert agent.model == config.default.model  # Falls back to default
-    assert agent.tracker is not None
+    assert callable(agent.create_tracker)
 
 
 def test_agent_config_dataclass():

packages/sdk/server-ai/tests/test_managed_agent.py

@@ -73,15 +73,16 @@ async def test_run_delegates_to_agent_runner(self):
             )
         )
 
-        agent = ManagedAgent(mock_config, mock_tracker, mock_runner)
+        agent = ManagedAgent(mock_config, mock_runner)
         result = await agent.run("Hello")
 
         assert result.output == "Test response"
         assert result.metrics.success is True
+        mock_config.create_tracker.assert_called_once()
         mock_tracker.track_metrics_of_async.assert_called_once()
 
     @pytest.mark.asyncio
-    async def test_run_uses_create_tracker_when_available(self):
+    async def test_run_uses_create_tracker_for_fresh_tracker(self):
         """Should use create_tracker() factory for a fresh tracker per invocation."""
         mock_config = MagicMock(spec=AIAgentConfig)
         fresh_tracker = MagicMock()
@@ -94,38 +95,29 @@ async def test_run_uses_create_tracker_when_available(self):
         )
         mock_config.create_tracker = MagicMock(return_value=fresh_tracker)
 
-        old_tracker = MagicMock()
         mock_runner = MagicMock()
 
-        agent = ManagedAgent(mock_config, old_tracker, mock_runner)
+        agent = ManagedAgent(mock_config, mock_runner)
         result = await agent.run("Hello")
 
         assert result.output == "Fresh tracker response"
         mock_config.create_tracker.assert_called_once()
         fresh_tracker.track_metrics_of_async.assert_called_once()
-        old_tracker.track_metrics_of_async.assert_not_called()
 
     def test_get_agent_runner_returns_runner(self):
         """Should return the underlying AgentRunner."""
         mock_runner = MagicMock()
-        agent = ManagedAgent(MagicMock(), MagicMock(), mock_runner)
+        agent = ManagedAgent(MagicMock(), mock_runner)
 
         assert agent.get_agent_runner() is mock_runner
 
     def test_get_config_returns_config(self):
         """Should return the AI agent config."""
         mock_config = MagicMock()
-        agent = ManagedAgent(mock_config, MagicMock(), MagicMock())
+        agent = ManagedAgent(mock_config, MagicMock())
 
         assert agent.get_config() is mock_config
 
-    def test_get_tracker_returns_tracker(self):
-        """Should return the tracker."""
-        mock_tracker = MagicMock()
-        agent = ManagedAgent(MagicMock(), mock_tracker, MagicMock())
-
-        assert agent.get_tracker() is mock_tracker
-
 
 class TestLDAIClientCreateAgent:
     """Tests for LDAIClient.create_agent."""