npm - @ngocsangairvds/vsaf - Versions diffs - 3.2.13 → 3.2.15 - Mend

@ngocsangairvds/vsaf 3.2.13 → 3.2.15

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (1441) hide show

package/tools/vds-scripts/audit_orchestrator/tests/test_llm/test_reasoning_effort_validation.py DELETED Viewed

@@ -1,565 +0,0 @@
-"""Isolated validation tests for the reasoning effort pass-through approach.
-These tests validate the complete chain from VDS config → PydanticAI ModelSettings
-→ OpenAI SDK wire format, proving the approach works end-to-end without making
-any real API calls.
-Key validation targets:
-1. PydanticAI + OpenAI SDK type parity (all 6 values accepted natively)
-2. VDS config layer validation (normalize, reject invalid, case-insensitive)
-3. Profile layer env-var mapping and validation
-4. Injection path correctness across all 5 agent model-settings builders
-5. "none" string vs Python None semantics
-6. PydanticAI internal propagation (Chat Completions + Responses API paths)
-Reference: Package DDD (FR-347..FR-349), DD-238, AG-DDD.1..AG-DDD.12
-Validated against: PydanticAI v1.63.0, OpenAI SDK v2.24.0 (2026-03-04)
-"""
-from __future__ import annotations
-import inspect
-import os
-import typing
-import pytest
-from vds_agent_core.profiles import (
-    _DEFAULT_MODEL_POLICY_LLM_ENV_MAP as _MODEL_POLICY_LLM_ENV_MAP,
-)
-from vds_agent_core.profiles import (
-    _LLM_REASONING_EFFORT_VALUES,
-)
-from vds_audit_orchestrator.config import (
-    LLM_REASONING_EFFORT_VALUES,
-    LLMConfig,
-    LLMProtocolType,
-    normalize_reasoning_effort,
-)
-# ---------------------------------------------------------------------------
-# 1. PydanticAI + OpenAI SDK type parity
-# ---------------------------------------------------------------------------
-EXPECTED_VALUES = ("none", "minimal", "low", "medium", "high", "xhigh")
-class TestLibraryTypeParity:
-    """Validate that PydanticAI and OpenAI SDK accept all 6 Codex CLI values."""
-    def test_pydantic_ai_chat_model_settings_has_openai_reasoning_effort(self) -> None:
-        from pydantic_ai.models.openai import OpenAIChatModelSettings
-        hints = typing.get_type_hints(OpenAIChatModelSettings)
-        assert "openai_reasoning_effort" in hints, "OpenAIChatModelSettings must have openai_reasoning_effort field"
-    def test_pydantic_ai_responses_model_settings_has_openai_reasoning_effort(self) -> None:
-        from pydantic_ai.models.openai import OpenAIResponsesModelSettings
-        hints = typing.get_type_hints(OpenAIResponsesModelSettings)
-        assert "openai_reasoning_effort" in hints, (
-            "OpenAIResponsesModelSettings must have openai_reasoning_effort field"
-        )
-    def test_pydantic_ai_reasoning_effort_type_accepts_all_6_values(self) -> None:
-        from pydantic_ai.models.openai import OpenAIChatModelSettings
-        hints = typing.get_type_hints(OpenAIChatModelSettings)
-        re_type = hints["openai_reasoning_effort"]
-        # Type is Literal['none', 'minimal', 'low', 'medium', 'high', 'xhigh'] | None
-        type_args = typing.get_args(re_type)
-        # Union args: (Literal[...], NoneType)
-        literal_type = type_args[0] if len(type_args) >= 2 else re_type
-        literal_values = set(typing.get_args(literal_type))
-        assert literal_values == set(EXPECTED_VALUES), (
-            f"PydanticAI expected {set(EXPECTED_VALUES)}, got {literal_values}"
-        )
-    def test_openai_sdk_reasoning_effort_type_accepts_all_6_values(self) -> None:
-        from openai.types.shared import ReasoningEffort as OpenAIReasoningEffort
-        type_args = typing.get_args(OpenAIReasoningEffort)
-        # Union args: (Literal[...], NoneType)
-        literal_type = type_args[0] if len(type_args) >= 2 else OpenAIReasoningEffort
-        literal_values = set(typing.get_args(literal_type))
-        assert literal_values == set(EXPECTED_VALUES), (
-            f"OpenAI SDK expected {set(EXPECTED_VALUES)}, got {literal_values}"
-        )
-    def test_pydantic_ai_and_openai_sdk_types_match(self) -> None:
-        from openai.types.shared import ReasoningEffort as OpenAIReasoningEffort
-        from pydantic_ai.models.openai import OpenAIChatModelSettings
-        hints = typing.get_type_hints(OpenAIChatModelSettings)
-        pydantic_type = hints["openai_reasoning_effort"]
-        # String representation should match
-        assert str(pydantic_type) == str(OpenAIReasoningEffort), (
-            f"Type mismatch: PydanticAI={pydantic_type} vs SDK={OpenAIReasoningEffort}"
-        )
-    def test_chat_and_responses_model_settings_types_match(self) -> None:
-        from pydantic_ai.models.openai import (
-            OpenAIChatModelSettings,
-            OpenAIResponsesModelSettings,
-        )
-        chat_hints = typing.get_type_hints(OpenAIChatModelSettings)
-        resp_hints = typing.get_type_hints(OpenAIResponsesModelSettings)
-        assert str(chat_hints["openai_reasoning_effort"]) == str(resp_hints["openai_reasoning_effort"]), (
-            "Chat and Responses model settings should have identical reasoning effort types"
-        )
-# ---------------------------------------------------------------------------
-# 2. PydanticAI internal propagation paths
-# ---------------------------------------------------------------------------
-class TestPydanticAIPropagation:
-    """Validate PydanticAI internally passes reasoning effort to the API correctly."""
-    def test_chat_completions_passes_reasoning_effort_kwarg(self) -> None:
-        """Chat Completions API path: openai_reasoning_effort → reasoning_effort kwarg."""
-        from pydantic_ai.models.openai import OpenAIChatModel
-        src = inspect.getsource(OpenAIChatModel._completions_create)
-        assert "reasoning_effort=self._translate_thinking(model_settings, model_request_parameters)" in src, (
-            "Chat Completions must pass reasoning_effort using _translate_thinking"
-        )
-        src_translate = inspect.getsource(OpenAIChatModel._translate_thinking)
-        assert "model_settings.get('openai_reasoning_effort')" in src_translate, (
-            "_translate_thinking must check for openai_reasoning_effort"
-        )
-    def test_responses_api_passes_reasoning_effort_to_reasoning_dict(self) -> None:
-        """Responses API path: openai_reasoning_effort → reasoning_effort."""
-        # Pydantic AI 1.80 refactored this logic away from Responses API
-        pass
-    def test_responses_get_reasoning_truthiness_preserves_none_string(self) -> None:
-        """The string 'none' is truthy, so _get_reasoning will include it in the dict."""
-        # Simulate the _get_reasoning logic for "none" string
-        settings: dict[str, object] = {"openai_reasoning_effort": "none"}
-        reasoning_effort = settings.get("openai_reasoning_effort")
-        reasoning: dict[str, object] = {}
-        if reasoning_effort:
-            reasoning["effort"] = reasoning_effort
-        assert reasoning == {"effort": "none"}, "String 'none' is truthy and must be included in reasoning dict"
-    def test_responses_get_reasoning_omits_when_python_none(self) -> None:
-        """Python None (unset) should result in empty reasoning dict."""
-        settings: dict[str, object] = {}
-        reasoning_effort = settings.get("openai_reasoning_effort")
-        reasoning: dict[str, object] = {}
-        if reasoning_effort:
-            reasoning["effort"] = reasoning_effort
-        assert reasoning == {}, "Python None should omit reasoning.effort entirely"
-    @pytest.mark.parametrize("value", EXPECTED_VALUES)
-    def test_responses_get_reasoning_propagates_all_6_values(self, value: str) -> None:
-        """Each of the 6 accepted values should propagate through _get_reasoning logic."""
-        settings: dict[str, object] = {"openai_reasoning_effort": value}
-        reasoning_effort = settings.get("openai_reasoning_effort")
-        reasoning: dict[str, object] = {}
-        if reasoning_effort:
-            reasoning["effort"] = reasoning_effort
-        assert reasoning["effort"] == value
-# ---------------------------------------------------------------------------
-# 3. VDS config layer (normalize_reasoning_effort + LLMConfig)
-# ---------------------------------------------------------------------------
-class TestVDSConfigLayer:
-    """Validate VDS config layer validation and normalization (AG-DDD.1, AG-DDD.2)."""
-    @pytest.mark.parametrize("value", EXPECTED_VALUES)
-    def test_normalize_accepts_all_6_lowercase_values(self, value: str) -> None:
-        assert normalize_reasoning_effort(value) == value
-    @pytest.mark.parametrize(
-        ("input_val", "expected"),
-        [
-            ("HIGH", "high"),
-            ("Medium", "medium"),
-            ("XHIGH", "xhigh"),
-            ("None", "none"),  # string "None" -> "none"
-            ("MINIMAL", "minimal"),
-            ("Low", "low"),
-        ],
-    )
-    def test_normalize_is_case_insensitive(self, input_val: str, expected: str) -> None:
-        assert normalize_reasoning_effort(input_val) == expected
-    def test_normalize_returns_none_for_python_none(self) -> None:
-        assert normalize_reasoning_effort(None) is None
-    @pytest.mark.parametrize("invalid", ["extreme", "very_high", "max", "1", "", "  "])
-    def test_normalize_rejects_invalid_values(self, invalid: str) -> None:
-        with pytest.raises(ValueError, match="Invalid"):
-            normalize_reasoning_effort(invalid)
-    def test_normalize_error_message_lists_accepted_values(self) -> None:
-        with pytest.raises(ValueError, match="none, minimal, low, medium, high, xhigh"):
-            normalize_reasoning_effort("bad")
-    def test_llm_config_field_default_is_none(self) -> None:
-        cfg = LLMConfig(protocol=LLMProtocolType.OPENAI, model_standard="gpt-4o")
-        assert cfg.reasoning_effort is None
-    @pytest.mark.parametrize("value", EXPECTED_VALUES)
-    def test_llm_config_accepts_all_6_values(self, value: str) -> None:
-        cfg = LLMConfig(
-            protocol=LLMProtocolType.OPENAI,
-            model_standard="gpt-4o",
-            reasoning_effort=value,
-        )
-        assert cfg.reasoning_effort == value
-    def test_llm_config_normalizes_case(self) -> None:
-        cfg = LLMConfig(
-            protocol=LLMProtocolType.OPENAI,
-            model_standard="gpt-4o",
-            reasoning_effort="HIGH",
-        )
-        assert cfg.reasoning_effort == "high"
-    def test_llm_config_rejects_invalid_value(self) -> None:
-        with pytest.raises(Exception):
-            LLMConfig(
-                protocol=LLMProtocolType.OPENAI,
-                model_standard="gpt-4o",
-                reasoning_effort="invalid",
-            )
-    def test_llm_config_none_string_preserved_distinct_from_python_none(self) -> None:
-        """AC-347.3: 'none' string is distinct from Python None."""
-        cfg_string = LLMConfig(
-            protocol=LLMProtocolType.OPENAI,
-            model_standard="gpt-4o",
-            reasoning_effort="none",
-        )
-        cfg_absent = LLMConfig(
-            protocol=LLMProtocolType.OPENAI,
-            model_standard="gpt-4o",
-            reasoning_effort=None,
-        )
-        assert cfg_string.reasoning_effort == "none"
-        assert cfg_absent.reasoning_effort is None
-        assert cfg_string.reasoning_effort is not None  # "none" != None
-    def test_llm_config_env_var_override(self, monkeypatch: pytest.MonkeyPatch) -> None:
-        """AC-347.4: VDS_AUDIT_LLM__REASONING_EFFORT env var sets reasoning effort."""
-        monkeypatch.setenv("VDS_AUDIT_LLM__REASONING_EFFORT", "xhigh")
-        result = normalize_reasoning_effort(
-            os.environ.get("VDS_AUDIT_LLM__REASONING_EFFORT"),
-        )
-        assert result == "xhigh"
-    def test_vds_constant_matches_expected_values(self) -> None:
-        assert set(LLM_REASONING_EFFORT_VALUES) == set(EXPECTED_VALUES)
-# ---------------------------------------------------------------------------
-# 4. Profile layer (runtime_profiles.py)
-# ---------------------------------------------------------------------------
-class TestProfileLayer:
-    """Validate profile-level reasoning effort support (AG-DDD.3, AG-DDD.4)."""
-    def test_model_policy_env_map_contains_reasoning_effort(self) -> None:
-        assert "reasoning_effort" in _MODEL_POLICY_LLM_ENV_MAP
-        assert _MODEL_POLICY_LLM_ENV_MAP["reasoning_effort"] == "VDS_AUDIT_LLM__REASONING_EFFORT"
-    def test_profile_reasoning_effort_values_match_config(self) -> None:
-        assert set(_LLM_REASONING_EFFORT_VALUES) == set(LLM_REASONING_EFFORT_VALUES)
-    def test_apply_profile_validates_reasoning_effort(self) -> None:
-        """Source code of _apply_profile_model_policy validates reasoning_effort."""
-        from vds_agent_core.profiles import _apply_profile_model_policy
-        src = inspect.getsource(_apply_profile_model_policy)
-        assert "reasoning_effort" in src
-        assert "_LLM_REASONING_EFFORT_VALUES" in src
-    def test_apply_profile_skips_reasoning_effort_in_tier_loop(self) -> None:
-        """reasoning_effort is handled separately, not in the model-tier loop."""
-        from vds_agent_core.profiles import _apply_profile_model_policy
-        src = inspect.getsource(_apply_profile_model_policy)
-        # The tier loop has an explicit skip for reasoning_effort
-        assert '"reasoning_effort"' in src
-    def test_model_policy_env_map_contains_agent_stream(self) -> None:
-        assert "agent_stream" in _MODEL_POLICY_LLM_ENV_MAP
-        assert _MODEL_POLICY_LLM_ENV_MAP["agent_stream"] == "VDS_AUDIT_LLM__AGENT_STREAM"
-    def test_model_policy_env_map_contains_row_failover_keys(self) -> None:
-        assert _MODEL_POLICY_LLM_ENV_MAP["row_failover_profiles"] == "VDS_AUDIT_LLM__ROW_FAILOVER_PROFILES"
-        assert (
-            _MODEL_POLICY_LLM_ENV_MAP["row_failover_max_provider_hops"]
-            == "VDS_AUDIT_LLM__ROW_FAILOVER_MAX_PROVIDER_HOPS"
-        )
-# ---------------------------------------------------------------------------
-# 5. Injection path validation (AG-DDD.5..AG-DDD.9)
-# ---------------------------------------------------------------------------
-class TestInjectionPaths:
-    """Validate reasoning effort injection across all 5 model-settings build paths."""
-    def test_inject_reasoning_effort_helper_uses_none_guard_and_openai_key(self) -> None:
-        """Central helper enforces the None guard and openai_reasoning_effort injection."""
-        from vds_audit_orchestrator.config import inject_reasoning_effort
-        src = inspect.getsource(inject_reasoning_effort)
-        assert "reasoning_effort is None" in src, "Helper must guard unset values explicitly"
-        assert "openai_reasoning_effort" in src, "Helper must inject OpenAI-compatible reasoning key"
-    def test_base_agent_build_model_settings_injects_reasoning_effort(self) -> None:
-        """AG-DDD.5: BaseAgent._build_model_settings includes openai_reasoning_effort."""
-        from vds_audit_orchestrator.agents.base import BaseAgent
-        src = inspect.getsource(BaseAgent._build_model_settings)
-        assert "inject_reasoning_effort(" in src, "Must call shared reasoning-effort injection helper"
-    def test_base_agent_build_run_model_settings_injects_reasoning_effort(self) -> None:
-        """AG-DDD.6: BaseAgent._build_run_model_settings includes openai_reasoning_effort."""
-        from vds_audit_orchestrator.agents.base import BaseAgent
-        src = inspect.getsource(BaseAgent._build_run_model_settings)
-        assert "inject_reasoning_effort(" in src, "Must call shared reasoning-effort injection helper"
-    def test_base_agent_codex_model_settings_preserves_reasoning_effort(self) -> None:
-        """AG-DDD.7: Codex model settings merge preserves openai_reasoning_effort."""
-        from vds_audit_orchestrator.agents.base import BaseAgent
-        src = inspect.getsource(BaseAgent._build_openai_codex_model_settings)
-        # The merge pattern should not strip openai_reasoning_effort
-        # It uses dict merge from base settings, so key is preserved transitively
-        assert "model_settings" in src.lower() or "_model_settings" in src
-    def test_create_audit_agent_injects_reasoning_effort(self) -> None:
-        """AG-DDD.8: pydantic_base.create_audit_agent includes openai_reasoning_effort."""
-        from vds_audit_orchestrator.agents.pydantic_base import create_audit_agent
-        src = inspect.getsource(create_audit_agent)
-        assert "inject_reasoning_effort(" in src, "Must call shared reasoning-effort injection helper"
-    def test_llm_row_evaluator_sync_injects_reasoning_effort(self) -> None:
-        """AG-DDD.9: LLMRowEvaluator._invoke_sync_agent includes openai_reasoning_effort."""
-        from vds_audit_orchestrator.engine.llm_row_evaluator import LLMRowEvaluator
-        src = inspect.getsource(LLMRowEvaluator._invoke_sync_agent)
-        assert "inject_reasoning_effort(" in src
-    def test_llm_row_evaluator_async_injects_reasoning_effort(self) -> None:
-        """AG-DDD.9: LLMRowEvaluator._invoke_async_agent includes openai_reasoning_effort."""
-        from vds_audit_orchestrator.engine.llm_row_evaluator import LLMRowEvaluator
-        src = inspect.getsource(LLMRowEvaluator._invoke_async_agent)
-        assert "inject_reasoning_effort(" in src
-    def test_all_injection_points_use_is_not_none_guard(self) -> None:
-        """Call sites must delegate to helper, where the explicit None guard is enforced."""
-        from vds_audit_orchestrator.agents.base import BaseAgent
-        from vds_audit_orchestrator.agents.pydantic_base import create_audit_agent
-        for func, name in [
-            (BaseAgent._build_model_settings, "_build_model_settings"),
-            (BaseAgent._build_run_model_settings, "_build_run_model_settings"),
-            (create_audit_agent, "create_audit_agent"),
-        ]:
-            src = inspect.getsource(func)
-            assert "inject_reasoning_effort(" in src, f"{name} must delegate to injection helper"
-# ---------------------------------------------------------------------------
-# 5b. Dual-provider reasoning effort injection (Anthropic + OpenAI)
-# ---------------------------------------------------------------------------
-class TestDualProviderReasoningEffortInjection:
-    """Validate inject_reasoning_effort routes to correct provider key."""
-    def test_openai_protocol_injects_openai_key(self) -> None:
-        from vds_audit_orchestrator.config import inject_reasoning_effort
-        s: dict[str, object] = {}
-        inject_reasoning_effort(s, "medium", "openai")
-        assert s == {"openai_reasoning_effort": "medium"}
-    def test_openai_codex_protocol_injects_openai_key(self) -> None:
-        from vds_audit_orchestrator.config import inject_reasoning_effort
-        s: dict[str, object] = {}
-        inject_reasoning_effort(s, "high", "openai-codex")
-        assert s == {"openai_reasoning_effort": "high"}
-    def test_anthropic_protocol_injects_anthropic_effort(self) -> None:
-        from vds_audit_orchestrator.config import inject_reasoning_effort
-        s: dict[str, object] = {}
-        inject_reasoning_effort(s, "medium", "anthropic")
-        assert s == {"anthropic_effort": "medium"}
-    def test_anthropic_xhigh_maps_to_max(self) -> None:
-        from vds_audit_orchestrator.config import inject_reasoning_effort
-        s: dict[str, object] = {}
-        inject_reasoning_effort(s, "xhigh", "anthropic")
-        assert s == {"anthropic_effort": "max"}
-    def test_anthropic_low_maps_to_low(self) -> None:
-        from vds_audit_orchestrator.config import inject_reasoning_effort
-        s: dict[str, object] = {}
-        inject_reasoning_effort(s, "low", "anthropic")
-        assert s == {"anthropic_effort": "low"}
-    def test_anthropic_high_maps_to_high(self) -> None:
-        from vds_audit_orchestrator.config import inject_reasoning_effort
-        s: dict[str, object] = {}
-        inject_reasoning_effort(s, "high", "anthropic")
-        assert s == {"anthropic_effort": "high"}
-    def test_anthropic_none_value_omits_key(self) -> None:
-        """'none' has no Anthropic equivalent; key is omitted."""
-        from vds_audit_orchestrator.config import inject_reasoning_effort
-        s: dict[str, object] = {}
-        inject_reasoning_effort(s, "none", "anthropic")
-        assert s == {}
-    def test_anthropic_minimal_value_omits_key(self) -> None:
-        """'minimal' has no Anthropic equivalent; key is omitted."""
-        from vds_audit_orchestrator.config import inject_reasoning_effort
-        s: dict[str, object] = {}
-        inject_reasoning_effort(s, "minimal", "anthropic")
-        assert s == {}
-    def test_none_effort_is_noop_for_any_protocol(self) -> None:
-        from vds_audit_orchestrator.config import inject_reasoning_effort
-        for proto in ("openai", "anthropic", "openai-codex", "gemini", None):
-            s: dict[str, object] = {}
-            inject_reasoning_effort(s, None, proto)
-            assert s == {}, f"Expected no-op for protocol={proto}"
-    def test_anthropic_protocol_enum_variant(self) -> None:
-        """Works with LLMProtocolType.ANTHROPIC enum, not just string."""
-        from vds_agent_core.config import LLMProtocolType
-        from vds_audit_orchestrator.config import inject_reasoning_effort
-        s: dict[str, object] = {}
-        inject_reasoning_effort(s, "high", LLMProtocolType.ANTHROPIC)
-        assert s == {"anthropic_effort": "high"}
-    def test_openai_protocol_enum_variant(self) -> None:
-        """Works with LLMProtocolType.OPENAI enum."""
-        from vds_agent_core.config import LLMProtocolType
-        from vds_audit_orchestrator.config import inject_reasoning_effort
-        s: dict[str, object] = {}
-        inject_reasoning_effort(s, "medium", LLMProtocolType.OPENAI)
-        assert s == {"openai_reasoning_effort": "medium"}
-    def test_helper_source_contains_anthropic_effort(self) -> None:
-        """Helper source must reference both provider keys."""
-        from vds_audit_orchestrator.config import inject_reasoning_effort
-        src = inspect.getsource(inject_reasoning_effort)
-        assert "anthropic_effort" in src
-        assert "openai_reasoning_effort" in src
-# ---------------------------------------------------------------------------
-# 6. None string vs Python None semantics
-# ---------------------------------------------------------------------------
-class TestNoneStringSemantics:
-    """Validate the critical distinction between 'none' (string) and None (Python)."""
-    def test_none_string_is_truthy(self) -> None:
-        """'none' is a non-empty string and therefore truthy in Python."""
-        assert bool("none") is True
-    def test_none_string_is_not_python_none(self) -> None:
-        assert "none" != None
-    def test_none_string_passes_is_not_none_check(self) -> None:
-        """The 'is not None' pattern correctly preserves 'none' string."""
-        value: str | None = "none"
-        settings: dict[str, str] = {}
-        if value is not None:
-            settings["openai_reasoning_effort"] = value
-        assert settings == {"openai_reasoning_effort": "none"}
-    def test_python_none_skips_injection(self) -> None:
-        """Python None correctly skips injection via 'is not None' pattern."""
-        value: str | None = None
-        settings: dict[str, str] = {}
-        if value is not None:
-            settings["openai_reasoning_effort"] = value
-        assert settings == {}
-    def test_config_none_string_roundtrips(self) -> None:
-        """'none' string survives config → normalize → inject chain."""
-        # Step 1: normalize
-        normalized = normalize_reasoning_effort("none")
-        assert normalized == "none"
-        # Step 2: config field
-        cfg = LLMConfig(
-            protocol=LLMProtocolType.OPENAI,
-            model_standard="gpt-4o",
-            reasoning_effort="none",
-        )
-        assert cfg.reasoning_effort == "none"
-        # Step 3: injection guard
-        settings: dict[str, str] = {}
-        if cfg.reasoning_effort is not None:
-            settings["openai_reasoning_effort"] = cfg.reasoning_effort
-        assert settings == {"openai_reasoning_effort": "none"}
-# ---------------------------------------------------------------------------
-# 7. Cross-provider consistency
-# ---------------------------------------------------------------------------
-class TestCrossProviderConsistency:
-    """Validate reasoning effort works identically for both providers."""
-    @pytest.mark.parametrize(
-        "protocol",
-        [LLMProtocolType.OPENAI, LLMProtocolType.OPENAI_CODEX],
-    )
-    @pytest.mark.parametrize("effort", [*EXPECTED_VALUES, None])
-    def test_config_accepts_all_values_for_both_protocols(self, protocol: LLMProtocolType, effort: str | None) -> None:
-        cfg = LLMConfig(
-            protocol=protocol,
-            model_standard="gpt-4o" if protocol == LLMProtocolType.OPENAI else "gpt-5.3-codex",
-            reasoning_effort=effort,
-        )
-        assert cfg.reasoning_effort == effort
-    def test_openai_chat_and_responses_both_have_reasoning_effort_field(self) -> None:
-        """Both PydanticAI model types (Chat + Responses) support the field."""
-        from pydantic_ai.models.openai import (
-            OpenAIChatModelSettings,
-            OpenAIResponsesModelSettings,
-        )
-        chat_annotations = set(OpenAIChatModelSettings.__annotations__)
-        resp_annotations = set(OpenAIResponsesModelSettings.__annotations__)
-        assert "openai_reasoning_effort" in chat_annotations
-        assert "openai_reasoning_effort" in resp_annotations