fix: Fall back to model.parameters.tools when root tools absent (#146)

Author: jsonbailey

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

@@ -56,8 +56,10 @@
 def _parse_tools(tools_data: Optional[Dict[str, Any]]) -> Optional[Dict[str, LDTool]]:
     """Parse the root-level tools map from a flag variation dict."""
     if not isinstance(tools_data, dict):
+        if tools_data is not None:
+            log.warning('Skipping tools: expected a dict, got %s', type(tools_data).__name__)
         return None
-    result = {}
+    result: Dict[str, LDTool] = {}
     for tool_name, tool_dict in tools_data.items():
         if not isinstance(tool_dict, dict):
             log.warning('Skipping tool "%s": expected a dict, got %s', tool_name, type(tool_dict).__name__)
@@ -72,6 +74,25 @@ def _parse_tools(tools_data: Optional[Dict[str, Any]]) -> Optional[Dict[str, LDT
     return result or None
 
 
+def _resolve_tools(variation: Dict[str, Any]) -> Optional[Dict[str, LDTool]]:
+    if 'tools' in variation:
+        return _parse_tools(variation['tools'])
+
+    model = variation.get('model')
+    if not isinstance(model, dict):
+        return None
+    parameters = model.get('parameters')
+    if not isinstance(parameters, dict):
+        return None
+    tools_data = parameters.get('tools')
+    if not isinstance(tools_data, dict):
+        if tools_data is not None:
+            log.warning('Skipping model.parameters.tools: expected a dict, got %s', type(tools_data).__name__)
+        return None
+
+    return _parse_tools(tools_data)
+
+
 class LDAIClient:
     """The LaunchDarkly AI SDK client object."""
 
@@ -117,7 +138,7 @@ def _completion_config(
         )
 
         evaluator = self._build_evaluator(judge_configuration, context, default_ai_provider, variables)
-        tools = _parse_tools(variation.get('tools'))
+        tools = _resolve_tools(variation)
 
         config = AICompletionConfig(
             key=key,
@@ -946,7 +967,7 @@ def __evaluate_agent(
         effective_judge_configuration = judge_configuration or JudgeConfiguration(judges=[])
 
         evaluator = self._build_evaluator(effective_judge_configuration, context, default_ai_provider, variables)
-        tools = _parse_tools(variation.get('tools'))
+        tools = _resolve_tools(variation)
 
         return AIAgentConfig(
             key=key,

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

@@ -60,6 +60,101 @@ def td() -> TestData:
         .variation_for_all(0)
     )
 
+    td.update(
+        td.flag('completion-tools-in-model-params')
+        .variations(
+            {
+                'model': {
+                    'name': 'gpt-5',
+                    'parameters': {
+                        'temperature': 0.5,
+                        'tools': {
+                            'param-tool': {
+                                'name': 'param-tool',
+                                'type': 'function',
+                                'description': 'A tool from model params',
+                                'parameters': {'type': 'object'},
+                            }
+                        },
+                    },
+                },
+                'messages': [{'role': 'user', 'content': 'Hello'}],
+                '_ldMeta': {'enabled': True, 'variationKey': 'v1', 'version': 1},
+            },
+        )
+        .variation_for_all(0)
+    )
+
+    td.update(
+        td.flag('completion-root-and-model-params-tools')
+        .variations(
+            {
+                'model': {
+                    'name': 'gpt-5',
+                    'parameters': {
+                        'tools': {
+                            'model-param-tool': {
+                                'name': 'model-param-tool',
+                                'type': 'function',
+                            }
+                        },
+                    },
+                },
+                'messages': [{'role': 'user', 'content': 'Hello'}],
+                'tools': {
+                    'root-tool': {
+                        'name': 'root-tool',
+                        'type': 'function',
+                    }
+                },
+                '_ldMeta': {'enabled': True, 'variationKey': 'v1', 'version': 1},
+            },
+        )
+        .variation_for_all(0)
+    )
+
+    td.update(
+        td.flag('completion-model-params-tools-as-list')
+        .variations(
+            {
+                'model': {
+                    'name': 'gpt-5',
+                    'parameters': {
+                        'tools': [
+                            {'name': 'list-tool', 'type': 'function'},
+                        ],
+                    },
+                },
+                'messages': [{'role': 'user', 'content': 'Hello'}],
+                '_ldMeta': {'enabled': True, 'variationKey': 'v1', 'version': 1},
+            },
+        )
+        .variation_for_all(0)
+    )
+
+    td.update(
+        td.flag('completion-model-params-tools-missing-name')
+        .variations(
+            {
+                'model': {
+                    'name': 'gpt-5',
+                    'parameters': {
+                        'tools': {
+                            'valid-tool': {
+                                'name': 'valid-tool',
+                                'type': 'function',
+                            },
+                            'bad-entry': 'not-a-dict',
+                        },
+                    },
+                },
+                'messages': [{'role': 'user', 'content': 'Hello'}],
+                '_ldMeta': {'enabled': True, 'variationKey': 'v1', 'version': 1},
+            },
+        )
+        .variation_for_all(0)
+    )
+
     return td
 
 
@@ -133,3 +228,36 @@ def test_aitool_to_dict_omits_none_fields():
     d = tool.to_dict()
 
     assert d == {'name': 'bare-tool'}
+
+
+def test_completion_config_tools_from_model_params_when_no_root_tools(client, context):
+    result = client.completion_config('completion-tools-in-model-params', context, AICompletionConfigDefault())
+
+    assert result.tools is not None
+    assert 'param-tool' in result.tools
+    tool = result.tools['param-tool']
+    assert tool.name == 'param-tool'
+    assert tool.type == 'function'
+    assert tool.description == 'A tool from model params'
+
+
+def test_completion_config_root_tools_take_priority_over_model_params(client, context):
+    result = client.completion_config('completion-root-and-model-params-tools', context, AICompletionConfigDefault())
+
+    assert result.tools is not None
+    assert 'root-tool' in result.tools
+    assert 'model-param-tool' not in result.tools
+
+
+def test_completion_config_model_params_tools_as_list_returns_none(client, context):
+    result = client.completion_config('completion-model-params-tools-as-list', context, AICompletionConfigDefault())
+
+    assert result.tools is None
+
+
+def test_completion_config_model_params_tools_skips_bad_entries_silently(client, context):
+    result = client.completion_config('completion-model-params-tools-missing-name', context, AICompletionConfigDefault())
+
+    assert result.tools is not None
+    assert 'valid-tool' in result.tools
+    assert 'bad-entry' not in result.tools