fix: pass AI Config model parameters through to every provider handler

packages/claude-agents/src/launchdarkly_ai_claude_agents/handler.py

@@ -41,7 +41,9 @@
     create_handler,
     end_span_once,
     end_unfinished_spans,
+    model_parameters,
     parse_template,
+    select_forwarded_parameters,
     set_conversation_id_if_absent,
     set_input_content_attributes,
     set_output_content_attributes,
@@ -66,6 +68,64 @@
     tool_display_name,
 )
 
+#: Every field ``ClaudeAgentOptions`` declares, classified by hand into exactly one of: forwarded
+#: (below), handler-owned (``model``, ``allowed_tools``, ``mcp_servers``, ``hooks``, ``tools``,
+#: ``system_prompt``, popped after the filter runs, at each call site), or excluded
+#: (``extra_args``, a raw CLI-argument escape hatch, is client/connection configuration and is never
+#: forwarded). ``TestClaudeAgentOptionsAcceptsExactlyTheseFields`` in this package's tests asserts
+#: this classification stays exhaustive as the SDK's own dataclass changes.
+#:
+#: The SDK offers no ``temperature``/``top_p``/``top_k``/``max_tokens``/``stop_sequences``/
+#: ``tool_choice``/``metadata``, all of which the LaunchDarkly UI's model parameters panel offers
+#: for other providers; forwarding one of those unfiltered raised ``TypeError`` before this filter
+#: existed.
+_CLAUDE_AGENT_OPTIONS_FORWARDED_KEYS = frozenset(
+    {
+        "add_dirs",
+        "agents",
+        "betas",
+        "can_use_tool",
+        "cli_path",
+        "continue_conversation",
+        "cwd",
+        "debug_stderr",
+        "disallowed_tools",
+        "effort",
+        "enable_file_checkpointing",
+        "env",
+        "fallback_model",
+        "fork_session",
+        "include_hook_events",
+        "include_partial_messages",
+        "load_timeout_ms",
+        "max_budget_usd",
+        "max_buffer_size",
+        "max_thinking_tokens",
+        "max_turns",
+        "output_format",
+        "permission_mode",
+        "permission_prompt_tool_name",
+        "plugins",
+        "resume",
+        "sandbox",
+        "session_id",
+        "session_store",
+        "session_store_flush",
+        "setting_sources",
+        "settings",
+        "skills",
+        "stderr",
+        "strict_mcp_config",
+        "task_budget",
+        "thinking",
+        "user",
+    }
+)
+
+#: Named for the drift test and for review, not read at runtime: the forwarded list above already
+#: leaves this out, so nothing needs to subtract it again.
+_CLAUDE_AGENT_OPTIONS_EXCLUDED_KEYS = frozenset({"extra_args"})
+
 # ---------------------------------------------------------------------------
 # Tool wiring
 # ---------------------------------------------------------------------------
@@ -479,7 +539,20 @@ def _build_query_options(
     **extra: Any,
 ) -> ClaudeAgentOptions:
     all_allowed = [*mcp_allowed_tools, *native_tool_names]
+    params = select_forwarded_parameters(
+        model_parameters(config), _CLAUDE_AGENT_OPTIONS_FORWARDED_KEYS
+    )
+    for _owned_key in (
+        "model",
+        "allowed_tools",
+        "mcp_servers",
+        "hooks",
+        "tools",
+        "system_prompt",
+    ):
+        params.pop(_owned_key, None)
     kwargs: dict[str, Any] = {
+        **params,
         "model": config["model"]["name"],
         "allowed_tools": all_allowed if all_allowed else [],
         "mcp_servers": {TOOL_MCP_NAME: tool_mcp} if tool_mcp else {},

packages/claude-agents/src/launchdarkly_ai_claude_agents/native_graph.py

@@ -18,6 +18,8 @@
     NativeTool,
     get_client,
     make_track_data,
+    model_parameters,
+    select_forwarded_parameters,
     to_ld_context,
 )
 
@@ -30,6 +32,7 @@
     _HAS_OTEL = False
 
 from launchdarkly_ai_claude_agents.handler import (
+    _CLAUDE_AGENT_OPTIONS_FORWARDED_KEYS,
     _build_hooks,
     build_prompt,
     build_query_prompt,
@@ -149,7 +152,21 @@ async def _run_query(
 
     hooks = _build_hooks(native_tool_map)
 
+    params = select_forwarded_parameters(
+        model_parameters(node.config), _CLAUDE_AGENT_OPTIONS_FORWARDED_KEYS
+    )
+    for _owned_key in (
+        "model",
+        "tools",
+        "allowed_tools",
+        "mcp_servers",
+        "hooks",
+        "system_prompt",
+    ):
+        params.pop(_owned_key, None)
+
     options = ClaudeAgentOptions(
+        **params,
         # Explicitly set the available built-in tools (empty list disables all).
         # When no native tools are needed, disable built-in tools so Claude
         # cannot call WebSearch/Bash/etc. and get stuck waiting for permission

packages/claude-agents/tests/test_handler.py

@@ -1442,6 +1442,121 @@ async def test_ld_span_attributes_land_on_root_only(
         assert [e.name for e in root().events] == ["feature_flag"]
 
 
+class TestModelParametersForwarding:
+    async def _run_and_capture_options(
+        self, config: dict[str, Any], monkeypatch: pytest.MonkeyPatch
+    ) -> Any:
+        captured: dict[str, Any] = {}
+
+        async def _query(**kwargs: Any) -> AsyncIterator[Any]:
+            captured["options"] = kwargs["options"]
+            yield assistant_message()
+            yield result_message()
+
+        monkeypatch.setattr(handler_mod, "query", _query)
+        await create_claude_agents_handler()(config, "q")
+        return captured["options"]
+
+    async def test_max_turns_from_config_reaches_options(
+        self, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        config = {
+            **BASE_CONFIG,
+            "model": {**BASE_CONFIG["model"], "parameters": {"max_turns": 3}},
+        }
+        options = await self._run_and_capture_options(config, monkeypatch)
+        assert options.max_turns == 3
+
+    async def test_config_cannot_override_model_or_system_prompt(
+        self, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        config = {
+            **BASE_CONFIG,
+            "model": {
+                **BASE_CONFIG["model"],
+                "parameters": {
+                    "model": "not-the-real-model",
+                    "system_prompt": "not-the-real-prompt",
+                },
+            },
+        }
+        options = await self._run_and_capture_options(config, monkeypatch)
+        assert options.model == BASE_CONFIG["model"]["name"]
+        assert options.system_prompt != "not-the-real-prompt"
+
+    async def test_unset_when_no_parameters(
+        self, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        options = await self._run_and_capture_options(BASE_CONFIG, monkeypatch)
+        assert options.max_turns is None
+
+    async def test_ui_keys_the_sdk_rejects_are_dropped_without_raising(
+        self, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        """``ClaudeAgentOptions`` has no ``temperature``/``top_p``/``top_k``/``max_tokens``/
+        ``stop_sequences``/``tool_choice``/``metadata`` fields, all of which the LaunchDarkly UI's
+        model parameters panel offers for other providers. Forwarding one unfiltered raises
+        ``TypeError`` before any request is made; the filter must drop them instead.
+        """
+        config = {
+            **BASE_CONFIG,
+            "model": {
+                **BASE_CONFIG["model"],
+                "parameters": {
+                    "temperature": 0.2,
+                    "top_p": 0.5,
+                    "top_k": 10,
+                    "max_tokens": 256,
+                    "stop_sequences": ["STOP"],
+                    "tool_choice": "auto",
+                    "metadata": {"user_id": "u1"},
+                    "max_turns": 3,
+                },
+            },
+        }
+        options = await self._run_and_capture_options(config, monkeypatch)
+        assert options.max_turns == 3
+        for rejected in (
+            "temperature",
+            "top_p",
+            "top_k",
+            "max_tokens",
+            "stop_sequences",
+            "tool_choice",
+            "metadata",
+        ):
+            assert not hasattr(options, rejected) or getattr(options, rejected) is None
+
+    async def test_transport_key_is_never_forwarded(
+        self, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        config = {
+            **BASE_CONFIG,
+            "model": {
+                **BASE_CONFIG["model"],
+                "parameters": {"extra_body": {"secret": "value"}, "max_turns": 2},
+            },
+        }
+        options = await self._run_and_capture_options(config, monkeypatch)
+        assert options.max_turns == 2
+        assert not hasattr(options, "extra_body") or options.extra_body is None
+
+    async def test_temperature_top_p_and_max_turns_run_without_type_error(
+        self, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        """A realistic combination of UI-offered keys must not raise, and the one real field
+        (``max_turns``) must still land."""
+        config = {
+            **BASE_CONFIG,
+            "model": {
+                **BASE_CONFIG["model"],
+                "parameters": {"temperature": 0.3, "top_p": 0.8, "max_turns": 5},
+            },
+        }
+        options = await self._run_and_capture_options(config, monkeypatch)
+        assert options.max_turns == 5
+
+
 class TestFinishReasonMapping:
     async def test_tool_use_maps_to_tool_calls(
         self, monkeypatch: pytest.MonkeyPatch

packages/claude-agents/tests/test_parameter_forwarding.py

@@ -0,0 +1,54 @@
+"""
+Drift test for the ``ClaudeAgentOptions`` parameter classification in ``handler.py``.
+
+``_CLAUDE_AGENT_OPTIONS_FORWARDED_KEYS`` is a literal, hand-maintained list. This test reads
+``ClaudeAgentOptions``'s own dataclass fields and asserts every field it declares is classified in
+exactly one of forwarded, handler-owned, or excluded, so an SDK field nobody has classified yet
+fails loudly by name, and so does a list entry that is not a real SDK field.
+"""
+
+from __future__ import annotations
+
+import dataclasses
+
+from claude_agent_sdk import ClaudeAgentOptions
+
+from launchdarkly_ai_claude_agents.handler import (
+    _CLAUDE_AGENT_OPTIONS_EXCLUDED_KEYS as _EXCLUDED_KEYS,
+)
+from launchdarkly_ai_claude_agents.handler import _CLAUDE_AGENT_OPTIONS_FORWARDED_KEYS
+
+#: Handler-owned: popped from the filtered params before ``ClaudeAgentOptions(**kwargs)`` is
+#: constructed, at every call site (``handler.py`` and ``native_graph.py``).
+_OWNED_KEYS = frozenset(
+    {"model", "allowed_tools", "mcp_servers", "hooks", "tools", "system_prompt"}
+)
+
+
+class TestClaudeAgentOptionsAcceptsExactlyTheseFields:
+    def test_every_field_is_classified_exactly_once(self) -> None:
+        accepted = frozenset(f.name for f in dataclasses.fields(ClaudeAgentOptions))
+        classified = _CLAUDE_AGENT_OPTIONS_FORWARDED_KEYS | _OWNED_KEYS | _EXCLUDED_KEYS
+
+        unclassified = accepted - classified
+        assert not unclassified, (
+            f"ClaudeAgentOptions now declares {sorted(unclassified)}, not classified as "
+            "forwarded, handler-owned, or excluded in claude-agents handler.py"
+        )
+
+        overlap = (
+            (_CLAUDE_AGENT_OPTIONS_FORWARDED_KEYS & _OWNED_KEYS)
+            | (_CLAUDE_AGENT_OPTIONS_FORWARDED_KEYS & _EXCLUDED_KEYS)
+            | (_OWNED_KEYS & _EXCLUDED_KEYS)
+        )
+        assert not overlap, f"fields classified more than once: {sorted(overlap)}"
+
+    def test_every_classified_field_is_real(self) -> None:
+        accepted = frozenset(f.name for f in dataclasses.fields(ClaudeAgentOptions))
+        stale = (
+            _CLAUDE_AGENT_OPTIONS_FORWARDED_KEYS | _OWNED_KEYS | _EXCLUDED_KEYS
+        ) - accepted
+        assert not stale, (
+            f"{sorted(stale)} classified in claude-agents handler.py but "
+            "ClaudeAgentOptions does not declare them"
+        )