Address review findings: clean up prefixes, update stale test, add gpt-oss coverage

- Remove redundant dash-prefixes (o1-, o3-, gpt-5-) already covered by base prefixes
- Replace gpt-oss-120b/gpt-oss-20b full names with gpt-oss- prefix
- Rewrite test_openai_model_detection.py to use real is_reasoning_model() function
  instead of duplicating logic with a non-existent api_base check
- Add test coverage for gpt-oss-* model family
- Add comment explaining intentional omission of is_reasoning_model from shared_config

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: MateoTTR

openevolve/config.py

@@ -172,6 +172,8 @@ def __post_init__(self):
             self.evaluator_models = self.models.copy()
 
         # Update models with shared configuration values
+        # Note: is_reasoning_model is intentionally excluded from shared_config.
+        # It is a per-model override, not a shared default.
         shared_config = {
             "api_base": self.api_base,
             "api_key": self.api_key,
@@ -226,6 +228,8 @@ def rebuild_models(self) -> None:
             self.evaluator_models = self.models.copy()
 
         # Update models with shared configuration values
+        # Note: is_reasoning_model is intentionally excluded from shared_config.
+        # It is a per-model override, not a shared default.
         shared_config = {
             "api_base": self.api_base,
             "api_key": self.api_key,

openevolve/llm/openai.py

@@ -22,19 +22,15 @@
 
 # OpenAI reasoning models that require max_completion_tokens instead of max_tokens.
 # These models don't support temperature/top_p and use different parameters.
-OPENAI_REASONING_MODEL_PREFIXES = (
-    # O-series reasoning models
-    "o1-",
-    "o1",  # o1, o1-mini, o1-preview
-    "o3-",
-    "o3",  # o3, o3-mini, o3-pro
-    "o4-",  # o4-mini
-    # GPT-5 series are also reasoning models
-    "gpt-5-",
-    "gpt-5",  # gpt-5, gpt-5-mini, gpt-5-nano
-    # The GPT OSS series are also reasoning models
-    "gpt-oss-120b",
-    "gpt-oss-20b",
+OPENAI_REASONING_MODEL_PREFIXES: tuple[str, ...] = (
+    # O-series reasoning models (o1, o1-mini, o1-preview, o3, o3-mini, o3-pro, o4-mini, etc.)
+    "o1",
+    "o3",
+    "o4-",
+    # GPT-5 series (gpt-5, gpt-5-mini, gpt-5-nano, etc.)
+    "gpt-5",
+    # GPT OSS series (gpt-oss-120b, gpt-oss-20b, etc.)
+    "gpt-oss-",
 )
 
 

tests/test_openai_model_detection.py

@@ -1,40 +1,22 @@
 """
 Test OpenAI reasoning model detection logic
+
+Updated to use the extracted is_reasoning_model() function instead of
+duplicating detection logic locally.
 """
 
 import unittest
-from unittest.mock import MagicMock
+
+from openevolve.llm.openai import OPENAI_REASONING_MODEL_PREFIXES, is_reasoning_model
 
 
 class TestOpenAIReasoningModelDetection(unittest.TestCase):
-    """Test that OpenAI reasoning models are correctly identified"""
+    """Test that OpenAI reasoning models are correctly identified via auto-detection"""
 
     def test_reasoning_model_detection(self):
         """Test various model names to ensure correct reasoning model detection"""
-
-        # Define the same constants as in the code
-        OPENAI_REASONING_MODEL_PREFIXES = (
-            # O-series reasoning models
-            "o1-",
-            "o1",  # o1, o1-mini, o1-preview
-            "o3-",
-            "o3",  # o3, o3-mini, o3-pro
-            "o4-",  # o4-mini
-            # GPT-5 series are also reasoning models
-            "gpt-5-",
-            "gpt-5",  # gpt-5, gpt-5-mini, gpt-5-nano
-        )
-
-        def is_reasoning_model(model_name, api_base="https://api.openai.com/v1"):
-            """Test function that mimics the logic in openai.py"""
-            model_lower = str(model_name).lower()
-            return api_base == "https://api.openai.com/v1" and model_lower.startswith(
-                OPENAI_REASONING_MODEL_PREFIXES
-            )
-
-        # Test cases: (model_name, expected_result, description)
         test_cases = [
-            # Reasoning models - should return True
+            # Reasoning models - should return True (auto-detect)
             ("o1", True, "Base o1 model"),
             ("o1-mini", True, "o1-mini model"),
             ("o1-preview", True, "o1-preview model"),
@@ -46,14 +28,16 @@ def is_reasoning_model(model_name, api_base="https://api.openai.com/v1"):
             ("gpt-5", True, "Base gpt-5 model"),
             ("gpt-5-mini", True, "gpt-5-mini model"),
             ("gpt-5-nano", True, "gpt-5-nano model"),
-            # Non-reasoning models - should return False
+            ("gpt-oss-120b", True, "gpt-oss-120b model"),
+            ("gpt-oss-20b", True, "gpt-oss-20b model"),
+            # Non-reasoning models - should return False (auto-detect)
             ("gpt-4o-mini", False, "gpt-4o-mini (not reasoning)"),
             ("gpt-4o", False, "gpt-4o (not reasoning)"),
             ("gpt-4", False, "gpt-4 (not reasoning)"),
             ("gpt-3.5-turbo", False, "gpt-3.5-turbo (not reasoning)"),
             ("claude-3", False, "Non-OpenAI model"),
             ("gemini-pro", False, "Non-OpenAI model"),
-            # Edge cases
+            # Case insensitivity
             ("O1-MINI", True, "Uppercase o1-mini"),
             ("GPT-5-MINI", True, "Uppercase gpt-5-mini"),
         ]
@@ -67,32 +51,29 @@ def is_reasoning_model(model_name, api_base="https://api.openai.com/v1"):
                     f"Model '{model_name}' ({description}): expected {expected}, got {result}",
                 )
 
-    def test_non_openai_api_base(self):
-        """Test that non-OpenAI API bases don't trigger reasoning model logic"""
-        OPENAI_REASONING_MODEL_PREFIXES = ("o1-", "o1", "o3-", "o3", "o4-", "gpt-5-", "gpt-5")
-
-        def is_reasoning_model(model_name, api_base):
-            model_lower = str(model_name).lower()
-            return api_base == "https://api.openai.com/v1" and model_lower.startswith(
-                OPENAI_REASONING_MODEL_PREFIXES
-            )
-
-        # Even reasoning model names should return False for non-OpenAI APIs
-        test_cases = [
-            ("o1-mini", "https://api.anthropic.com/v1", False),
-            ("gpt-5", "https://generativelanguage.googleapis.com/v1beta/openai/", False),
-            ("o3-mini", "https://api.deepseek.com/v1", False),
+    def test_non_openai_models_not_auto_detected(self):
+        """Non-OpenAI models should not be auto-detected as reasoning models"""
+        non_openai_models = [
+            "gemini-2.5-pro",
+            "gemini-2.5-flash",
+            "claude-sonnet-4-5-20250929",
+            "claude-opus-4-5-20251101",
+            "deepseek-r1",
         ]
-
-        for model_name, api_base, expected in test_cases:
-            with self.subTest(model=model_name, api=api_base):
-                result = is_reasoning_model(model_name, api_base)
-                self.assertEqual(
-                    result,
-                    expected,
-                    f"Model '{model_name}' with API '{api_base}' should return {expected}",
+        for model_name in non_openai_models:
+            with self.subTest(model=model_name):
+                self.assertFalse(
+                    is_reasoning_model(model_name),
+                    f"Non-OpenAI model '{model_name}' should not be auto-detected",
                 )
 
+    def test_explicit_override_ignores_api_base(self):
+        """Explicit config_flag overrides auto-detection regardless of model origin"""
+        # Even non-OpenAI models can be forced to reasoning mode
+        self.assertTrue(is_reasoning_model("gemini-2.5-flash", config_flag=True))
+        # Even OpenAI reasoning models can be forced to standard mode
+        self.assertFalse(is_reasoning_model("o3-mini", config_flag=False))
+
 
 if __name__ == "__main__":
     unittest.main()

tests/test_reasoning_model_detection.py

@@ -19,6 +19,11 @@ def test_openai_gpt5_auto_detected(self):
             with self.subTest(model=model):
                 self.assertTrue(is_reasoning_model(model))
 
+    def test_openai_gpt_oss_auto_detected(self):
+        for model in ["gpt-oss-120b", "gpt-oss-20b", "gpt-oss-30b"]:
+            with self.subTest(model=model):
+                self.assertTrue(is_reasoning_model(model))
+
     def test_openai_non_reasoning_not_detected(self):
         for model in ["gpt-4o", "gpt-4o-mini", "gpt-4", "gpt-3.5-turbo"]:
             with self.subTest(model=model):