Import AITURK IDE 1.0.0-beta.1 from Hermes 63279301; preserve MIT license

tests/run_agent/test_fallback_reasoning_override.py

@@ -0,0 +1,137 @@
+"""Tests for per-model reasoning_effort override during fallback activation.
+
+Tests that try_activate_fallback re-resolves reasoning_config when
+swapping to a fallback model, so per-model overrides are honored even
+during error recovery.
+"""
+
+import pytest
+from unittest.mock import MagicMock, patch
+
+
+class TestFallbackReasoningOverride:
+    """Test try_activate_fallback re-resolves reasoning_config."""
+
+    def test_fallback_re_resolves_reasoning_config(self):
+        """When fallback activates, reasoning_config should be re-resolved.
+
+        We test the resolution logic directly rather than spinning up a
+        full try_activate_fallback (which requires extensive agent setup).
+        The production code calls resolve_per_model_reasoning_effort with
+        the fallback model string — we verify that works correctly.
+        """
+        from hermes_constants import resolve_per_model_reasoning_effort
+
+        # Simulate: primary was gemini-flash (medium), fallback to claude-opus-4.5 (xhigh)
+        overrides = {
+            "claude-opus-4.5": "xhigh",
+            "gemini-flash": "medium",
+        }
+
+        # Fallback model lookup
+        fb_result = resolve_per_model_reasoning_effort("claude-opus-4.5", overrides)
+        assert fb_result is not None
+        assert fb_result["effort"] == "xhigh"
+
+        # Primary model lookup (for comparison)
+        primary_result = resolve_per_model_reasoning_effort("gemini-flash", overrides)
+        assert primary_result is not None
+        assert primary_result["effort"] == "medium"
+
+        # The key point: fallback result differs from primary
+        assert fb_result["effort"] != primary_result["effort"]
+
+    def test_fallback_to_model_without_override_uses_global(self):
+        """Fallback to a model with no override should resolve to None (→ global)."""
+        from hermes_constants import resolve_per_model_reasoning_effort
+
+        overrides = {"claude-opus-4.5": "xhigh"}
+
+        # Fallback to gpt-5 which has no override
+        result = resolve_per_model_reasoning_effort("gpt-5", overrides)
+        assert result is None  # caller falls back to global
+
+
+    def test_fallback_recovery_restores_primary_reasoning(self):
+        """After fallback + restore_primary_runtime, reasoning_config returns to primary's value.
+
+        This tests the integration of Task 6 (_primary_runtime snapshot) with
+        Task 6b (fallback re-resolution). The full cycle:
+        1. Primary model = gemini-flash, reasoning = medium
+        2. /model switch → _primary_runtime captures reasoning_config
+        3. Fallback activates → reasoning re-resolved for fallback model
+        4. restore_primary_runtime → reasoning_config restored from snapshot
+        """
+        from agent.agent_runtime_helpers import restore_primary_runtime
+
+        agent = MagicMock()
+        # Simulate: _primary_runtime was captured during /model switch
+        agent._primary_runtime = {
+            "model": "gemini-flash",
+            "provider": "google",
+            "base_url": "",
+            "api_mode": "openai",
+            "api_key": "key",
+            "client_kwargs": {},
+            "use_prompt_caching": False,
+            "use_native_cache_layout": False,
+            "runtime_capabilities": {"native_compaction": True},
+            "reasoning_config": {"enabled": True, "effort": "medium"},
+            "compressor_model": "gemini-flash",
+            "compressor_base_url": "",
+            "compressor_api_key": "",
+            "compressor_provider": "",
+            "compressor_context_length": 0,
+            "compressor_api_mode": "",
+            "compressor_threshold_tokens": 0,
+        }
+        agent._fallback_activated = True
+        agent._fallback_index = 0
+        agent._fallback_chain = []
+        agent._fallback_model = None
+        agent._transport_cache = {}
+        agent._config_context_length = None
+        agent._rate_limited_until = 0
+        # During fallback, reasoning was changed to xhigh (fallback model's override)
+        agent.model = "claude-opus-4.5"
+        agent.provider = "anthropic"
+        agent.reasoning_config = {"enabled": True, "effort": "xhigh"}
+        agent.runtime_capabilities = {"native_compaction": False}
+        agent.context_compressor = MagicMock()
+        agent.base_url = ""
+        agent._anthropic_prompt_cache_policy = MagicMock(return_value=(False, False))
+        agent._create_openai_client = MagicMock(return_value=MagicMock())
+        agent._ensure_lmstudio_runtime_loaded = MagicMock()
+
+        result = restore_primary_runtime(agent)
+        assert result is True
+        # reasoning_config should be restored to primary's value (medium)
+        assert agent.reasoning_config == {"enabled": True, "effort": "medium"}
+        assert agent.runtime_capabilities == {"native_compaction": True}
+
+    def test_fallback_global_fallback_with_yaml_false(self):
+        """Fallback global fallback must not coerce YAML boolean False.
+
+        Regression: ``or ""`` turned False into "", silently re-enabling
+        thinking. The raw value must pass through so
+        parse_reasoning_effort(False) returns {'enabled': False}.
+
+        The production code in try_activate_fallback does:
+            _fb_global_effort = _fb_agent_cfg.get("reasoning_effort", "")
+            agent.reasoning_config = parse_reasoning_effort(_fb_global_effort)
+        We verify that passing the raw False (not coerced "") produces
+        the disabled config.
+        """
+        from hermes_constants import parse_reasoning_effort
+
+        # Simulate: no per-model override matches, global is YAML False
+        _fb_agent_cfg = {"reasoning_effort": False}
+
+        # This is the exact line from try_activate_fallback's else branch.
+        # The bug was: _fb_global_effort = _fb_agent_cfg.get(...) or ""
+        # which turned False into "". The fix passes the raw value.
+        _fb_global_effort = _fb_agent_cfg.get("reasoning_effort", "")
+        result = parse_reasoning_effort(_fb_global_effort)
+
+        assert result is not None
+        assert result.get("enabled") is False