openevolve 0.3.0__tar.gz → 0.3.2__tar.gz

{openevolve-0.3.0/openevolve.egg-info → openevolve-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openevolve
-Version: 0.3.0
+Version: 0.3.2
 Summary: Open-source implementation of AlphaEvolve
 Author: codelion
 License: Apache-2.0
@@ -34,9 +34,8 @@ Dynamic: license-file
 *Turn your LLMs into autonomous code optimizers that discover breakthrough algorithms*
 
 <p align="center">
-  <a href="https://github.com/algorithmicsuperintelligence/openevolve/stargazers"><img src="https://img.shields.io/github/stars/algorithmicsuperintelligence/openevolve?style=social" alt="GitHub stars"></a>
   <a href="https://pypi.org/project/openevolve/"><img src="https://img.shields.io/pypi/v/openevolve" alt="PyPI version"></a>
-  <a href="https://pypi.org/project/openevolve/"><img src="https://img.shields.io/pypi/dm/openevolve" alt="PyPI downloads"></a>
+  <a href="https://pepy.tech/projects/openevolve"><img src="https://static.pepy.tech/personalized-badge/openevolve?period=monthly&units=INTERNATIONAL_SYSTEM&left_color=GREY&right_color=GREEN&left_text=downloads%2Fmonth" alt="PyPI Downloads"></a>
   <a href="https://github.com/algorithmicsuperintelligence/openevolve/blob/main/LICENSE"><img src="https://img.shields.io/github/license/algorithmicsuperintelligence/openevolve" alt="License"></a>
 </p>
 
@@ -227,7 +226,7 @@ OpenEvolve implements a sophisticated **evolutionary coding pipeline** that goes
 <details>
 <summary><b>Advanced LLM Integration</b></summary>
 
-- **Universal API**: Works with OpenAI, Google, local models, and proxies
+- **Universal API**: Works with OpenAI, Google, Claude Code CLI, local models, and proxies
 - **Intelligent Ensembles**: Weighted combinations with sophisticated fallback
 - **Test-Time Compute**: Enhanced reasoning through proxy systems (see [OptiLLM setup](#llm-provider-setup))
 - **Plugin Ecosystem**: Support for advanced reasoning plugins
@@ -258,7 +257,7 @@ OpenEvolve implements a sophisticated **evolutionary coding pipeline** that goes
 
 ### Requirements
 - **Python**: 3.10+ 
-- **LLM Access**: Any OpenAI-compatible API
+- **LLM Access**: Any OpenAI-compatible API, or [Claude Code CLI](https://docs.anthropic.com/en/docs/claude-code)
 - **Optional**: Docker for containerized runs
 
 ### Installation Options
@@ -381,6 +380,35 @@ llm:
 
 </details>
 
+<details>
+<summary><b>🔮 Claude Code CLI (No API Key)</b></summary>
+
+Use the [Claude Code CLI](https://docs.anthropic.com/en/docs/claude-code) as the LLM backend — no API keys needed, authentication uses the CLI's OAuth session.
+
+```bash
+# Install and authenticate
+npm install -g @anthropic-ai/claude-code
+claude login
+```
+
+```yaml
+# config.yaml
+llm:
+  provider: "claude_code"
+  models:
+    - name: "sonnet"
+      weight: 0.8
+      max_tokens: 16000
+      max_budget_usd: 1.0
+    - name: "haiku"
+      weight: 0.2
+      max_tokens: 8000
+```
+
+See the [Claude Code quickstart example](examples/claude_code_quickstart/) for a complete walkthrough.
+
+</details>
+
 ## Examples Gallery
 
 <div align="center">
@@ -489,6 +517,10 @@ database:
   migration_interval: 20
   feature_dimensions: ["complexity", "diversity", "performance"]
 
+  # Optional novelty filtering with Gemini embeddings
+  embedding_model: "gemini-embedding-001"
+  similarity_threshold: 0.99
+
 evaluator:
   enable_artifacts: true      # Error feedback to LLM
   cascade_evaluation: true    # Multi-stage testing
@@ -505,6 +537,9 @@ prompt:
   use_template_stochasticity: true  # Randomized prompts
 ```
 
+For Gemini embeddings, set `GEMINI_API_KEY`. `GOOGLE_API_KEY` is also supported
+as a fallback. OpenEvolve uses Google's OpenAI-compatible endpoint automatically.
+
 <details>
 <summary><b>🎯 Feature Engineering</b></summary>
 

{openevolve-0.3.0 → openevolve-0.3.2}/README.md

@@ -9,9 +9,8 @@
 *Turn your LLMs into autonomous code optimizers that discover breakthrough algorithms*
 
 <p align="center">
-  <a href="https://github.com/algorithmicsuperintelligence/openevolve/stargazers"><img src="https://img.shields.io/github/stars/algorithmicsuperintelligence/openevolve?style=social" alt="GitHub stars"></a>
   <a href="https://pypi.org/project/openevolve/"><img src="https://img.shields.io/pypi/v/openevolve" alt="PyPI version"></a>
-  <a href="https://pypi.org/project/openevolve/"><img src="https://img.shields.io/pypi/dm/openevolve" alt="PyPI downloads"></a>
+  <a href="https://pepy.tech/projects/openevolve"><img src="https://static.pepy.tech/personalized-badge/openevolve?period=monthly&units=INTERNATIONAL_SYSTEM&left_color=GREY&right_color=GREEN&left_text=downloads%2Fmonth" alt="PyPI Downloads"></a>
   <a href="https://github.com/algorithmicsuperintelligence/openevolve/blob/main/LICENSE"><img src="https://img.shields.io/github/license/algorithmicsuperintelligence/openevolve" alt="License"></a>
 </p>
 
@@ -202,7 +201,7 @@ OpenEvolve implements a sophisticated **evolutionary coding pipeline** that goes
 <details>
 <summary><b>Advanced LLM Integration</b></summary>
 
-- **Universal API**: Works with OpenAI, Google, local models, and proxies
+- **Universal API**: Works with OpenAI, Google, Claude Code CLI, local models, and proxies
 - **Intelligent Ensembles**: Weighted combinations with sophisticated fallback
 - **Test-Time Compute**: Enhanced reasoning through proxy systems (see [OptiLLM setup](#llm-provider-setup))
 - **Plugin Ecosystem**: Support for advanced reasoning plugins
@@ -233,7 +232,7 @@ OpenEvolve implements a sophisticated **evolutionary coding pipeline** that goes
 
 ### Requirements
 - **Python**: 3.10+ 
-- **LLM Access**: Any OpenAI-compatible API
+- **LLM Access**: Any OpenAI-compatible API, or [Claude Code CLI](https://docs.anthropic.com/en/docs/claude-code)
 - **Optional**: Docker for containerized runs
 
 ### Installation Options
@@ -356,6 +355,35 @@ llm:
 
 </details>
 
+<details>
+<summary><b>🔮 Claude Code CLI (No API Key)</b></summary>
+
+Use the [Claude Code CLI](https://docs.anthropic.com/en/docs/claude-code) as the LLM backend — no API keys needed, authentication uses the CLI's OAuth session.
+
+```bash
+# Install and authenticate
+npm install -g @anthropic-ai/claude-code
+claude login
+```
+
+```yaml
+# config.yaml
+llm:
+  provider: "claude_code"
+  models:
+    - name: "sonnet"
+      weight: 0.8
+      max_tokens: 16000
+      max_budget_usd: 1.0
+    - name: "haiku"
+      weight: 0.2
+      max_tokens: 8000
+```
+
+See the [Claude Code quickstart example](examples/claude_code_quickstart/) for a complete walkthrough.
+
+</details>
+
 ## Examples Gallery
 
 <div align="center">
@@ -464,6 +492,10 @@ database:
   migration_interval: 20
   feature_dimensions: ["complexity", "diversity", "performance"]
 
+  # Optional novelty filtering with Gemini embeddings
+  embedding_model: "gemini-embedding-001"
+  similarity_threshold: 0.99
+
 evaluator:
   enable_artifacts: true      # Error feedback to LLM
   cascade_evaluation: true    # Multi-stage testing
@@ -480,6 +512,9 @@ prompt:
   use_template_stochasticity: true  # Randomized prompts
 ```
 
+For Gemini embeddings, set `GEMINI_API_KEY`. `GOOGLE_API_KEY` is also supported
+as a fallback. OpenEvolve uses Google's OpenAI-compatible endpoint automatically.
+
 <details>
 <summary><b>🎯 Feature Engineering</b></summary>
 

{openevolve-0.3.0 → openevolve-0.3.2}/openevolve/_version.py

@@ -1,3 +1,3 @@
 """Version information for openevolve package."""
 
-__version__ = "0.3.0"
+__version__ = "0.3.2"

{openevolve-0.3.0 → openevolve-0.3.2}/openevolve/api.py

@@ -37,6 +37,8 @@ def run_evolution(
     iterations: Optional[int] = None,
     output_dir: Optional[str] = None,
     cleanup: bool = True,
+    target_score: Optional[float] = None,
+    checkpoint_path: Optional[str] = None,
 ) -> EvolutionResult:
     """
     Run evolution with flexible inputs - the main library API
@@ -90,7 +92,7 @@ def run_evolution(
         )
     """
     return asyncio.run(
-        _run_evolution_async(initial_program, evaluator, config, iterations, output_dir, cleanup)
+        _run_evolution_async(initial_program, evaluator, config, iterations, output_dir, cleanup, target_score, checkpoint_path)
     )
 
 
@@ -101,6 +103,8 @@ async def _run_evolution_async(
     iterations: Optional[int],
     output_dir: Optional[str],
     cleanup: bool,
+    target_score: Optional[float] = None,
+    checkpoint_path: Optional[str] = None,
 ) -> EvolutionResult:
     """Async implementation of run_evolution"""
 
@@ -156,7 +160,7 @@ async def _run_evolution_async(
             output_dir=actual_output_dir,
         )
 
-        best_program = await controller.run(iterations=iterations)
+        best_program = await controller.run(iterations=iterations,target_score=target_score,checkpoint_path=checkpoint_path)
 
         # Prepare result
         best_score = 0.0

{openevolve-0.3.0 → openevolve-0.3.2}/openevolve/config.py

@@ -56,6 +56,9 @@ class LLMModelConfig:
     api_key: Optional[str] = None
     name: str = None
 
+    # LLM provider: "openai" (default), "claude_code" (Claude Code CLI)
+    provider: Optional[str] = None
+
     # Custom LLM client
     init_client: Optional[Callable] = None
 
@@ -79,6 +82,9 @@ class LLMModelConfig:
     # Reasoning parameters
     reasoning_effort: Optional[str] = None
 
+    # Claude Code CLI budget per call (USD)
+    max_budget_usd: Optional[float] = None
+
     # Manual mode (human-in-the-loop)
     manual_mode: Optional[bool] = None
     _manual_queue_dir: Optional[str] = None
@@ -168,6 +174,12 @@ class LLMConfig(LLMModelConfig):
 
         # Update models with shared configuration values
         shared_config = {
+            # `provider` must be shared: without it a top-level `llm.provider`
+            # (e.g. "claude_code") never reaches the per-model configs, every model
+            # keeps provider=None, and LLMEnsemble silently routes them all to the
+            # OpenAI backend. Propagation uses overwrite=False, so an explicit
+            # per-model provider still wins.
+            "provider": self.provider,
             "api_base": self.api_base,
             "api_key": self.api_key,
             "temperature": self.temperature,
@@ -222,6 +234,9 @@ class LLMConfig(LLMModelConfig):
 
         # Update models with shared configuration values
         shared_config = {
+            # See the note in __post_init__: `provider` has to be propagated here too,
+            # or rebuilding the models drops a top-level provider back to None.
+            "provider": self.provider,
             "api_base": self.api_base,
             "api_key": self.api_key,
             "temperature": self.temperature,

{openevolve-0.3.0 → openevolve-0.3.2}/openevolve/controller.py

@@ -25,34 +25,6 @@ from openevolve.utils.format_utils import format_improvement_safe, format_metric
 logger = logging.getLogger(__name__)
 
 
-def _format_metrics(metrics: Dict[str, Any]) -> str:
-    """Safely format metrics, handling both numeric and string values"""
-    formatted_parts = []
-    for name, value in metrics.items():
-        if isinstance(value, (int, float)) and not isinstance(value, bool):
-            try:
-                formatted_parts.append(f"{name}={value:.4f}")
-            except (ValueError, TypeError):
-                formatted_parts.append(f"{name}={value}")
-        else:
-            formatted_parts.append(f"{name}={value}")
-    return ", ".join(formatted_parts)
-
-
-def _format_improvement(improvement: Dict[str, Any]) -> str:
-    """Safely format improvement metrics"""
-    formatted_parts = []
-    for name, diff in improvement.items():
-        if isinstance(diff, (int, float)) and not isinstance(diff, bool):
-            try:
-                formatted_parts.append(f"{name}={diff:+.4f}")
-            except (ValueError, TypeError):
-                formatted_parts.append(f"{name}={diff}")
-        else:
-            formatted_parts.append(f"{name}={diff}")
-    return ", ".join(formatted_parts)
-
-
 class OpenEvolve:
     """
     Main controller for OpenEvolve
@@ -268,7 +240,6 @@ class OpenEvolve:
             Best program found
         """
         max_iterations = iterations or self.config.max_iterations
-
         # Determine starting iteration
         start_iteration = 0
         if checkpoint_path and os.path.exists(checkpoint_path):

{openevolve-0.3.0 → openevolve-0.3.2}/openevolve/database.py

@@ -467,21 +467,13 @@ class ProgramDatabase:
             parent = self._sample_from_island_weighted(island_id)
             sampling_mode = "weighted"
 
-        # Select inspirations from the same island
+        # Select inspirations using the same elite/diversity-aware strategy as sample().
+        # Pass the requested island explicitly so parallel workers remain isolated even
+        # if an archive fallback returns a parent whose metadata points elsewhere.
         if num_inspirations is None:
             num_inspirations = 5  # Default for backward compatibility
 
-        # Get other programs from the island for inspirations
-        other_programs = [pid for pid in island_programs if pid != parent.id]
-
-        if len(other_programs) < num_inspirations:
-            # Not enough programs in island, use what we have
-            inspiration_ids = other_programs
-        else:
-            # Sample inspirations
-            inspiration_ids = random.sample(other_programs, num_inspirations)
-
-        inspirations = [self.programs[pid] for pid in inspiration_ids if pid in self.programs]
+        inspirations = self._sample_inspirations(parent, n=num_inspirations, island_id=island_id)
 
         logger.debug(
             f"Sampled parent {parent.id} and {len(inspirations)} inspirations from island {island_id} "
@@ -1569,7 +1561,9 @@ class ProgramDatabase:
             parent_id = random.choice(valid_archive)
             return self.programs[parent_id]
 
-    def _sample_inspirations(self, parent: Program, n: int = 5) -> List[Program]:
+    def _sample_inspirations(
+        self, parent: Program, n: int = 5, island_id: Optional[int] = None
+    ) -> List[Program]:
         """
         Sample inspiration programs for the next evolution step.
 
@@ -1579,14 +1573,23 @@ class ProgramDatabase:
         Args:
             parent: Parent program
             n: Number of inspirations to sample
+            island_id: Explicit island to sample from. If omitted, use the
+                parent program's island metadata.
 
         Returns:
             List of inspiration programs from the current island
         """
         inspirations = []
 
-        # Get the parent's island (should be current_island)
-        parent_island = parent.metadata.get("island", self.current_island)
+        # Prefer an explicitly requested island. This matters for
+        # sample_from_island(), where archive fallback may return a parent whose
+        # metadata belongs to a different island.
+        if island_id is None:
+            parent_island = parent.metadata.get("island", self.current_island)
+        else:
+            parent_island = island_id
+
+        parent_island %= len(self.islands)
 
         # Get all programs from the current island
         island_program_ids = list(self.islands[parent_island])

{openevolve-0.3.0 → openevolve-0.3.2}/openevolve/embedding.py

@@ -3,10 +3,11 @@ Adapted from SakanaAI/ShinkaEvolve (Apache-2.0 License)
 Original source: https://github.com/SakanaAI/ShinkaEvolve/blob/main/shinka/llm/embedding.py
 """
 
+import logging
 import os
+from typing import List, Union
+
 import openai
-from typing import Union, List
-import logging
 
 logger = logging.getLogger(__name__)
 
@@ -22,6 +23,10 @@ AZURE_EMBEDDING_MODELS = [
     "azure-text-embedding-3-large",
 ]
 
+GEMINI_EMBEDDING_MODELS = [
+    "gemini-embedding-001",
+]
+
 OPENAI_EMBEDDING_COSTS = {
     "text-embedding-3-small": 0.02 / M,
     "text-embedding-3-large": 0.13 / M,
@@ -53,6 +58,13 @@ class EmbeddingClient:
                 api_version=os.getenv("AZURE_API_VERSION"),
                 azure_endpoint=os.getenv("AZURE_API_ENDPOINT"),
             )
+        elif model_name in GEMINI_EMBEDDING_MODELS:
+            gemini_api_key = os.getenv("GEMINI_API_KEY") or os.getenv("GOOGLE_API_KEY")
+            client = openai.OpenAI(
+                api_key=gemini_api_key,
+                base_url="https://generativelanguage.googleapis.com/v1beta/openai/",
+            )
+            model_to_use = model_name
         else:
             raise ValueError(f"Invalid embedding model: {model_name}")
 

openevolve-0.3.2/openevolve/llm/__init__.py

@@ -0,0 +1,16 @@
+"""
+LLM module initialization
+"""
+
+from openevolve.llm.base import LLMInterface
+from openevolve.llm.ensemble import LLMEnsemble
+from openevolve.llm.openai import OpenAILLM
+from openevolve.llm.claude_code import ClaudeCodeLLM, init_claude_code_client
+
+__all__ = [
+    "LLMInterface",
+    "OpenAILLM",
+    "ClaudeCodeLLM",
+    "init_claude_code_client",
+    "LLMEnsemble",
+]

openevolve-0.3.2/openevolve/llm/claude_code.py

@@ -0,0 +1,138 @@
+"""
+Claude Code CLI interface for LLMs.
+
+Uses the Claude Code CLI (`claude -p`) as a non-interactive LLM backend,
+enabling OpenEvolve to run with Anthropic's Claude models without requiring
+direct API keys — authentication is handled by the CLI's OAuth session.
+
+Usage in config.yaml:
+    llm:
+      provider: "claude_code"
+      models:
+        - name: "sonnet"
+          weight: 1.0
+          max_tokens: 16000
+          timeout: 300
+
+Or inject programmatically:
+    from openevolve.llm.claude_code import init_claude_code_client
+    for model_cfg in config.llm.models:
+        model_cfg.init_client = init_claude_code_client
+"""
+
+import asyncio
+import logging
+import subprocess
+from typing import Dict, List, Optional
+
+from openevolve.llm.base import LLMInterface
+
+logger = logging.getLogger(__name__)
+
+
+class ClaudeCodeLLM(LLMInterface):
+    """LLM interface that uses the Claude Code CLI for generation.
+
+    Requires `claude` CLI to be installed and authenticated
+    (run `claude login` first).
+    """
+
+    def __init__(self, model_cfg=None):
+        self.model = getattr(model_cfg, "name", "sonnet")
+        self.system_message = getattr(model_cfg, "system_message", None)
+        self.max_tokens = getattr(model_cfg, "max_tokens", 16000)
+        self.timeout = getattr(model_cfg, "timeout", 300)
+        self.weight = getattr(model_cfg, "weight", 1.0)
+        self.retries = getattr(model_cfg, "retries", 3)
+        self.retry_delay = getattr(model_cfg, "retry_delay", 5)
+        self.max_budget_usd = getattr(model_cfg, "max_budget_usd", 1.0)
+        self.cwd = getattr(model_cfg, "cwd", None)
+        logger.info(f"Initialized ClaudeCodeLLM with model: {self.model}")
+
+    async def generate(self, prompt: str, **kwargs) -> str:
+        sys_msg = kwargs.pop("system_message", self.system_message) or ""
+        return await self.generate_with_context(
+            system_message=sys_msg,
+            messages=[{"role": "user", "content": prompt}],
+            **kwargs,
+        )
+
+    async def generate_with_context(
+        self, system_message: str, messages: List[Dict[str, str]], **kwargs
+    ) -> str:
+        user_content = "\n\n".join(
+            m.get("content", "") for m in messages if m.get("role") == "user"
+        )
+
+        cmd = [
+            "claude",
+            "-p",
+            "--model",
+            self.model,
+            "--no-session-persistence",
+            "--output-format",
+            "text",
+        ]
+        if system_message:
+            cmd.extend(["--system-prompt", system_message])
+
+        budget = kwargs.get("max_budget_usd", self.max_budget_usd)
+        cmd.extend(["--max-budget-usd", str(budget)])
+
+        cmd.append(user_content)
+
+        timeout = kwargs.get("timeout", self.timeout)
+        retries = kwargs.get("retries", self.retries)
+        retry_delay = kwargs.get("retry_delay", self.retry_delay)
+
+        loop = asyncio.get_event_loop()
+        for attempt in range(retries + 1):
+            try:
+                result = await asyncio.wait_for(
+                    loop.run_in_executor(None, lambda: self._run_cli(cmd, timeout)),
+                    timeout=timeout + 30,
+                )
+                return result
+            except asyncio.TimeoutError:
+                if attempt < retries:
+                    logger.warning(
+                        f"Claude Code CLI timeout on attempt {attempt + 1}/{retries + 1}. Retrying..."
+                    )
+                    await asyncio.sleep(retry_delay)
+                else:
+                    logger.error(f"All {retries + 1} attempts failed with timeout")
+                    raise
+            except Exception as e:
+                if attempt < retries:
+                    logger.warning(
+                        f"Claude Code CLI error on attempt {attempt + 1}/{retries + 1}: {e}. Retrying..."
+                    )
+                    await asyncio.sleep(retry_delay)
+                else:
+                    logger.error(f"All {retries + 1} attempts failed with error: {e}")
+                    raise
+
+    def _run_cli(self, cmd: list, timeout: int) -> str:
+        try:
+            result = subprocess.run(
+                cmd,
+                capture_output=True,
+                text=True,
+                timeout=timeout,
+                cwd=self.cwd,
+            )
+            if result.returncode != 0:
+                stderr = result.stderr.strip()
+                if stderr:
+                    logger.warning(f"Claude CLI stderr: {stderr[:500]}")
+            output = result.stdout.strip()
+            if not output:
+                raise RuntimeError(f"Empty response from Claude CLI. stderr: {result.stderr[:500]}")
+            return output
+        except subprocess.TimeoutExpired:
+            raise asyncio.TimeoutError("Claude CLI subprocess timed out")
+
+
+def init_claude_code_client(model_cfg):
+    """Factory function compatible with OpenEvolve's init_client config hook."""
+    return ClaudeCodeLLM(model_cfg)

{openevolve-0.3.0 → openevolve-0.3.2}/openevolve/llm/ensemble.py

@@ -13,6 +13,25 @@ from openevolve.config import LLMModelConfig
 
 logger = logging.getLogger(__name__)
 
+_PROVIDER_REGISTRY = {
+    "openai": lambda cfg: OpenAILLM(cfg),
+}
+
+try:
+    from openevolve.llm.claude_code import ClaudeCodeLLM
+    _PROVIDER_REGISTRY["claude_code"] = lambda cfg: ClaudeCodeLLM(cfg)
+except ImportError:
+    pass
+
+
+def _create_model(model_cfg: LLMModelConfig) -> LLMInterface:
+    if model_cfg.init_client:
+        return model_cfg.init_client(model_cfg)
+    provider = getattr(model_cfg, "provider", None)
+    if provider and provider in _PROVIDER_REGISTRY:
+        return _PROVIDER_REGISTRY[provider](model_cfg)
+    return OpenAILLM(model_cfg)
+
 
 class LLMEnsemble:
     """Ensemble of LLMs"""
@@ -21,10 +40,7 @@ class LLMEnsemble:
         self.models_cfg = models_cfg
 
         # Initialize models from the configuration
-        self.models = [
-            model_cfg.init_client(model_cfg) if model_cfg.init_client else OpenAILLM(model_cfg)
-            for model_cfg in models_cfg
-        ]
+        self.models = [_create_model(model_cfg) for model_cfg in models_cfg]
 
         # Extract and normalize model weights
         self.weights = [model.weight for model in models_cfg]

{openevolve-0.3.0 → openevolve-0.3.2}/openevolve/llm/openai.py

@@ -155,9 +155,11 @@ class OpenAILLM(LLMInterface):
                 "model": self.model,
                 "messages": formatted_messages,
                 "temperature": kwargs.get("temperature", self.temperature),
-                "top_p": kwargs.get("top_p", self.top_p),
                 "max_tokens": kwargs.get("max_tokens", self.max_tokens),
             }
+            top_p = kwargs.get("top_p", self.top_p)
+            if top_p is not None:
+                params["top_p"] = top_p
 
             # Handle reasoning_effort for open source reasoning models.
             reasoning_effort = kwargs.get("reasoning_effort", self.reasoning_effort)