openevolve 0.2.2__tar.gz → 0.2.4__tar.gz

{openevolve-0.2.2 → openevolve-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openevolve
-Version: 0.2.2
+Version: 0.2.4
 Summary: Open-source implementation of AlphaEvolve
 Author: codelion
 License: Apache-2.0

{openevolve-0.2.2 → openevolve-0.2.4}/openevolve/_version.py

@@ -1,3 +1,3 @@
 """Version information for openevolve package."""
 
-__version__ = "0.2.2"
+__version__ = "0.2.4"

{openevolve-0.2.2 → openevolve-0.2.4}/openevolve/config.py

@@ -56,12 +56,7 @@ class LLMConfig(LLMModelConfig):
     retry_delay: int = 5
 
     # n-model configuration for evolution LLM ensemble
-    models: List[LLMModelConfig] = field(
-        default_factory=lambda: [
-            LLMModelConfig(name="gpt-4o-mini", weight=0.8),
-            LLMModelConfig(name="gpt-4o", weight=0.2),
-        ]
-    )
+    models: List[LLMModelConfig] = field(default_factory=list)
 
     # n-model configuration for evaluator LLM ensemble
     evaluator_models: List[LLMModelConfig] = field(default_factory=lambda: [])
@@ -75,24 +70,34 @@ class LLMConfig(LLMModelConfig):
     def __post_init__(self):
         """Post-initialization to set up model configurations"""
         # Handle backward compatibility for primary_model(_weight) and secondary_model(_weight).
-        if (self.primary_model or self.primary_model_weight) and len(self.models) < 1:
-            # Ensure we have a primary model
-            self.models.append(LLMModelConfig())
         if self.primary_model:
-            self.models[0].name = self.primary_model
-        if self.primary_model_weight:
-            self.models[0].weight = self.primary_model_weight
+            # Create primary model
+            primary_model = LLMModelConfig(
+                name=self.primary_model,
+                weight=self.primary_model_weight or 1.0
+            )
+            self.models.append(primary_model)
 
-        if (self.secondary_model or self.secondary_model_weight) and len(self.models) < 2:
-            # Ensure we have a second model
-            self.models.append(LLMModelConfig())
         if self.secondary_model:
-            self.models[1].name = self.secondary_model
-        if self.secondary_model_weight:
-            self.models[1].weight = self.secondary_model_weight
+            # Create secondary model (only if weight > 0)
+            if self.secondary_model_weight is None or self.secondary_model_weight > 0:
+                secondary_model = LLMModelConfig(
+                    name=self.secondary_model,
+                    weight=self.secondary_model_weight if self.secondary_model_weight is not None else 0.2
+                )
+                self.models.append(secondary_model)
+
+        # Only validate if this looks like a user config (has some model info)
+        # Don't validate during internal/default initialization
+        if (self.primary_model or self.secondary_model or 
+            self.primary_model_weight or self.secondary_model_weight) and not self.models:
+            raise ValueError(
+                "No LLM models configured. Please specify 'models' array or "
+                "'primary_model' in your configuration."
+            )
 
         # If no evaluator models are defined, use the same models as for evolution
-        if not self.evaluator_models or len(self.evaluator_models) < 1:
+        if not self.evaluator_models:
             self.evaluator_models = self.models.copy()
 
         # Update models with shared configuration values

{openevolve-0.2.2 → openevolve-0.2.4}/openevolve/llm/openai.py

@@ -66,14 +66,40 @@ class OpenAILLM(LLMInterface):
         formatted_messages.extend(messages)
 
         # Set up generation parameters
-        if self.api_base == "https://api.openai.com/v1" and str(self.model).lower().startswith("o"):
-            # For o-series models
+        # Define OpenAI reasoning models that require max_completion_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"
+        )
+
+        # Check if this is an OpenAI reasoning model
+        model_lower = str(self.model).lower()
+        is_openai_reasoning_model = (
+            self.api_base == "https://api.openai.com/v1" and 
+            model_lower.startswith(OPENAI_REASONING_MODEL_PREFIXES)
+        )
+
+        if is_openai_reasoning_model:
+            # For OpenAI reasoning models
             params = {
                 "model": self.model,
                 "messages": formatted_messages,
                 "max_completion_tokens": kwargs.get("max_tokens", self.max_tokens),
             }
+            # Add optional reasoning parameters if provided
+            if "reasoning_effort" in kwargs:
+                params["reasoning_effort"] = kwargs["reasoning_effort"]
+            if "verbosity" in kwargs:
+                params["verbosity"] = kwargs["verbosity"]
         else:
+            # Standard parameters for all other models
             params = {
                 "model": self.model,
                 "messages": formatted_messages,
@@ -82,6 +108,10 @@ class OpenAILLM(LLMInterface):
                 "max_tokens": kwargs.get("max_tokens", self.max_tokens),
             }
 
+            # Handle reasoning_effort for open source reasoning models.
+            if "reasoning_effort" in kwargs:
+                params["reasoning_effort"] = kwargs["reasoning_effort"]
+
         # Add seed parameter for reproducibility if configured
         # Skip seed parameter for Google AI Studio endpoint as it doesn't support it
         seed = kwargs.get("seed", self.random_seed)

{openevolve-0.2.2 → openevolve-0.2.4}/openevolve/process_parallel.py

@@ -178,12 +178,26 @@ def _run_iteration_worker(
         iteration_start = time.time()
 
         # Generate code modification (sync wrapper for async)
-        llm_response = asyncio.run(
-            _worker_llm_ensemble.generate_with_context(
-                system_message=prompt["system"],
-                messages=[{"role": "user", "content": prompt["user"]}],
+        try:
+            llm_response = asyncio.run(
+                _worker_llm_ensemble.generate_with_context(
+                    system_message=prompt["system"],
+                    messages=[{"role": "user", "content": prompt["user"]}],
+                )
+            )
+        except Exception as e:
+            logger.error(f"LLM generation failed: {e}")
+            return SerializableResult(
+                error=f"LLM generation failed: {str(e)}", 
+                iteration=iteration
+            )
+
+        # Check for None response
+        if llm_response is None:
+            return SerializableResult(
+                error="LLM returned None response", 
+                iteration=iteration
             )
-        )
 
         # Parse response based on evolution mode
         if _worker_config.diff_based_evolution:

{openevolve-0.2.2 → openevolve-0.2.4}/openevolve.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openevolve
-Version: 0.2.2
+Version: 0.2.4
 Summary: Open-source implementation of AlphaEvolve
 Author: codelion
 License: Apache-2.0

{openevolve-0.2.2 → openevolve-0.2.4}/openevolve.egg-info/SOURCES.txt

@@ -47,6 +47,8 @@ tests/test_island_tracking.py
 tests/test_iteration_counting.py
 tests/test_llm_ensemble.py
 tests/test_map_elites_features.py
+tests/test_model_parameter_demo.py
+tests/test_openai_model_detection.py
 tests/test_process_parallel.py
 tests/test_prompt_sampler.py
 tests/test_prompt_sampler_comprehensive.py

openevolve-0.2.4/tests/test_model_parameter_demo.py

@@ -0,0 +1,70 @@
+"""
+Demonstration of fixed OpenAI model parameter handling
+"""
+
+def demo_model_parameter_selection():
+    """Demonstrate how different models get different parameters"""
+    
+    # Mock the logic from openai.py
+    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 get_params_for_model(model_name, api_base="https://api.openai.com/v1"):
+        """Show what parameters would be used for each model"""
+        model_lower = str(model_name).lower()
+        is_openai_reasoning_model = (
+            api_base == "https://api.openai.com/v1" and 
+            model_lower.startswith(OPENAI_REASONING_MODEL_PREFIXES)
+        )
+        
+        if is_openai_reasoning_model:
+            return {
+                "type": "reasoning_model",
+                "uses": "max_completion_tokens",
+                "supports": ["reasoning_effort", "verbosity"],
+                "excludes": ["temperature", "top_p"]
+            }
+        else:
+            return {
+                "type": "standard_model", 
+                "uses": "max_tokens",
+                "supports": ["temperature", "top_p"],
+                "excludes": []
+            }
+    
+    print("🔧 OpenAI Model Parameter Selection Demo")
+    print("=" * 50)
+    
+    test_models = [
+        # Reasoning models
+        ("o1-mini", "✅ Reasoning"),
+        ("o1-preview", "✅ Reasoning"),
+        ("o3-mini-2025-01-31", "✅ Reasoning (with date)"),
+        ("gpt-5-nano", "✅ Reasoning (GPT-5 series)"),
+        
+        # Standard models  
+        ("gpt-4o-mini", "❌ Standard (not reasoning)"),
+        ("gpt-4o", "❌ Standard"),
+        ("gpt-4-turbo", "❌ Standard"),
+    ]
+    
+    for model, description in test_models:
+        params = get_params_for_model(model)
+        print(f"\n📋 Model: {model}")
+        print(f"   Type: {description}")
+        print(f"   Uses: {params['uses']}")
+        print(f"   Supports: {', '.join(params['supports'])}")
+        if params['excludes']:
+            print(f"   Excludes: {', '.join(params['excludes'])}")
+    
+    print("\n" + "=" * 50)
+    print("✅ Fix successful! No more false positives/negatives.")
+
+if __name__ == "__main__":
+    demo_model_parameter_selection()

openevolve-0.2.4/tests/test_openai_model_detection.py

@@ -0,0 +1,101 @@
+"""
+Test OpenAI reasoning model detection logic
+"""
+
+import unittest
+from unittest.mock import MagicMock
+
+
+class TestOpenAIReasoningModelDetection(unittest.TestCase):
+    """Test that OpenAI reasoning models are correctly identified"""
+
+    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
+            ("o1", True, "Base o1 model"),
+            ("o1-mini", True, "o1-mini model"),
+            ("o1-preview", True, "o1-preview model"),
+            ("o1-mini-2025-01-31", True, "o1-mini with date"),
+            ("o3", True, "Base o3 model"),
+            ("o3-mini", True, "o3-mini model"),
+            ("o3-pro", True, "o3-pro model"),
+            ("o4-mini", True, "o4-mini model"),
+            ("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-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
+            ("O1-MINI", True, "Uppercase o1-mini"),
+            ("GPT-5-MINI", True, "Uppercase gpt-5-mini"),
+        ]
+        
+        for model_name, expected, description in test_cases:
+            with self.subTest(model=model_name, desc=description):
+                result = is_reasoning_model(model_name)
+                self.assertEqual(
+                    result, 
+                    expected, 
+                    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),
+        ]
+        
+        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}"
+                )
+
+
+if __name__ == "__main__":
+    unittest.main()