abstractcore 2.4.5__tar.gz → 2.4.6__tar.gz

{abstractcore-2.4.5 → abstractcore-2.4.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: abstractcore
-Version: 2.4.5
+Version: 2.4.6
 Summary: Unified interface to all LLM providers with essential infrastructure for tool calling, streaming, and model management
 Author-email: Laurent-Philippe Albou <contact@abstractcore.ai>
 Maintainer-email: Laurent-Philippe Albou <contact@abstractcore.ai>
@@ -122,6 +122,21 @@ response = llm.generate("What is the capital of France?")
 print(response.content)
 ```
 
+### Deterministic Generation
+
+```python
+from abstractcore import create_llm
+
+# Deterministic outputs with seed + temperature=0
+llm = create_llm("openai", model="gpt-3.5-turbo", seed=42, temperature=0.0)
+
+# These will produce identical outputs
+response1 = llm.generate("Write exactly 3 words about coding")
+response2 = llm.generate("Write exactly 3 words about coding")
+print(f"Response 1: {response1.content}")  # "Innovative, challenging, rewarding."
+print(f"Response 2: {response2.content}")  # "Innovative, challenging, rewarding."
+```
+
 ### Tool Calling
 
 ```python
@@ -140,6 +155,39 @@ response = llm.generate(
 print(response.content)
 ```
 
+### Built-in Tools
+
+AbstractCore includes a comprehensive set of ready-to-use tools for common tasks:
+
+```python
+from abstractcore.tools.common_tools import fetch_url, search_files, read_file
+
+# Intelligent web content fetching with automatic parsing
+result = fetch_url("https://api.github.com/repos/python/cpython")
+# Automatically detects JSON, HTML, images, PDFs, etc. and provides structured analysis
+
+# File system operations
+files = search_files("def.*fetch", ".", file_pattern="*.py")  # Find function definitions
+content = read_file("config.json")  # Read file contents
+
+# Use with any LLM
+llm = create_llm("anthropic", model="claude-3-5-haiku-latest")
+response = llm.generate(
+    "Analyze this API response and summarize the key information",
+    tools=[fetch_url]
+)
+```
+
+**Available Tools:**
+- `fetch_url` - Intelligent web content fetching with automatic content type detection and parsing
+- `search_files` - Search for text patterns inside files using regex
+- `list_files` - Find and list files by names/paths using glob patterns  
+- `read_file` - Read file contents with optional line range selection
+- `write_file` - Write content to files with directory creation
+- `edit_file` - Edit files using pattern matching and replacement
+- `web_search` - Search the web using DuckDuckGo
+- `execute_command` - Execute shell commands safely with security controls
+
 ### Session Management
 
 ```python
@@ -228,14 +276,16 @@ response = llm.generate(
 
 ## Supported Providers
 
-| Provider | Status | Setup |
-|----------|--------|-------|
-| **OpenAI** | Full | [Get API key](docs/prerequisites.md#openai-setup) |
-| **Anthropic** | Full | [Get API key](docs/prerequisites.md#anthropic-setup) |
-| **Ollama** | Full | [Install guide](docs/prerequisites.md#ollama-setup) |
-| **LMStudio** | Full | [Install guide](docs/prerequisites.md#lmstudio-setup) |
-| **MLX** | Full | [Setup guide](docs/prerequisites.md#mlx-setup) |
-| **HuggingFace** | Full | [Setup guide](docs/prerequisites.md#huggingface-setup) |
+| Provider | Status | SEED Support | Setup |
+|----------|--------|-------------|-------|
+| **OpenAI** | Full | ✅ Native | [Get API key](docs/prerequisites.md#openai-setup) |
+| **Anthropic** | Full | ⚠️ Warning* | [Get API key](docs/prerequisites.md#anthropic-setup) |
+| **Ollama** | Full | ✅ Native | [Install guide](docs/prerequisites.md#ollama-setup) |
+| **LMStudio** | Full | ✅ Native | [Install guide](docs/prerequisites.md#lmstudio-setup) |
+| **MLX** | Full | ✅ Native | [Setup guide](docs/prerequisites.md#mlx-setup) |
+| **HuggingFace** | Full | ✅ Native | [Setup guide](docs/prerequisites.md#huggingface-setup) |
+
+*Anthropic doesn't support seed parameters but issues a warning when provided. Use `temperature=0.0` for more consistent outputs.
 
 ## Server Mode (Optional HTTP REST API)
 

{abstractcore-2.4.5 → abstractcore-2.4.6}/README.md

@@ -28,6 +28,21 @@ response = llm.generate("What is the capital of France?")
 print(response.content)
 ```
 
+### Deterministic Generation
+
+```python
+from abstractcore import create_llm
+
+# Deterministic outputs with seed + temperature=0
+llm = create_llm("openai", model="gpt-3.5-turbo", seed=42, temperature=0.0)
+
+# These will produce identical outputs
+response1 = llm.generate("Write exactly 3 words about coding")
+response2 = llm.generate("Write exactly 3 words about coding")
+print(f"Response 1: {response1.content}")  # "Innovative, challenging, rewarding."
+print(f"Response 2: {response2.content}")  # "Innovative, challenging, rewarding."
+```
+
 ### Tool Calling
 
 ```python
@@ -46,6 +61,39 @@ response = llm.generate(
 print(response.content)
 ```
 
+### Built-in Tools
+
+AbstractCore includes a comprehensive set of ready-to-use tools for common tasks:
+
+```python
+from abstractcore.tools.common_tools import fetch_url, search_files, read_file
+
+# Intelligent web content fetching with automatic parsing
+result = fetch_url("https://api.github.com/repos/python/cpython")
+# Automatically detects JSON, HTML, images, PDFs, etc. and provides structured analysis
+
+# File system operations
+files = search_files("def.*fetch", ".", file_pattern="*.py")  # Find function definitions
+content = read_file("config.json")  # Read file contents
+
+# Use with any LLM
+llm = create_llm("anthropic", model="claude-3-5-haiku-latest")
+response = llm.generate(
+    "Analyze this API response and summarize the key information",
+    tools=[fetch_url]
+)
+```
+
+**Available Tools:**
+- `fetch_url` - Intelligent web content fetching with automatic content type detection and parsing
+- `search_files` - Search for text patterns inside files using regex
+- `list_files` - Find and list files by names/paths using glob patterns  
+- `read_file` - Read file contents with optional line range selection
+- `write_file` - Write content to files with directory creation
+- `edit_file` - Edit files using pattern matching and replacement
+- `web_search` - Search the web using DuckDuckGo
+- `execute_command` - Execute shell commands safely with security controls
+
 ### Session Management
 
 ```python
@@ -134,14 +182,16 @@ response = llm.generate(
 
 ## Supported Providers
 
-| Provider | Status | Setup |
-|----------|--------|-------|
-| **OpenAI** | Full | [Get API key](docs/prerequisites.md#openai-setup) |
-| **Anthropic** | Full | [Get API key](docs/prerequisites.md#anthropic-setup) |
-| **Ollama** | Full | [Install guide](docs/prerequisites.md#ollama-setup) |
-| **LMStudio** | Full | [Install guide](docs/prerequisites.md#lmstudio-setup) |
-| **MLX** | Full | [Setup guide](docs/prerequisites.md#mlx-setup) |
-| **HuggingFace** | Full | [Setup guide](docs/prerequisites.md#huggingface-setup) |
+| Provider | Status | SEED Support | Setup |
+|----------|--------|-------------|-------|
+| **OpenAI** | Full | ✅ Native | [Get API key](docs/prerequisites.md#openai-setup) |
+| **Anthropic** | Full | ⚠️ Warning* | [Get API key](docs/prerequisites.md#anthropic-setup) |
+| **Ollama** | Full | ✅ Native | [Install guide](docs/prerequisites.md#ollama-setup) |
+| **LMStudio** | Full | ✅ Native | [Install guide](docs/prerequisites.md#lmstudio-setup) |
+| **MLX** | Full | ✅ Native | [Setup guide](docs/prerequisites.md#mlx-setup) |
+| **HuggingFace** | Full | ✅ Native | [Setup guide](docs/prerequisites.md#huggingface-setup) |
+
+*Anthropic doesn't support seed parameters but issues a warning when provided. Use `temperature=0.0` for more consistent outputs.
 
 ## Server Mode (Optional HTTP REST API)
 

{abstractcore-2.4.5 → abstractcore-2.4.6}/abstractcore/core/interface.py

@@ -70,6 +70,8 @@ class AbstractCoreInterface(ABC):
                  max_tokens: Optional[int] = None,
                  max_input_tokens: Optional[int] = None,
                  max_output_tokens: int = 2048,
+                 temperature: float = 0.7,
+                 seed: Optional[int] = None,
                  debug: bool = False,
                  **kwargs):
         self.model = model
@@ -79,6 +81,11 @@ class AbstractCoreInterface(ABC):
         self.max_tokens = max_tokens
         self.max_input_tokens = max_input_tokens
         self.max_output_tokens = max_output_tokens
+        
+        # Unified generation parameters
+        self.temperature = temperature
+        self.seed = seed
+        
         self.debug = debug
 
         # Validate token parameters

{abstractcore-2.4.5 → abstractcore-2.4.6}/abstractcore/core/session.py

@@ -32,8 +32,23 @@ class BasicSession:
                  tool_timeout: Optional[float] = None,
                  recovery_timeout: Optional[float] = None,
                  auto_compact: bool = False,
-                 auto_compact_threshold: int = 6000):
-        """Initialize basic session"""
+                 auto_compact_threshold: int = 6000,
+                 temperature: Optional[float] = None,
+                 seed: Optional[int] = None):
+        """Initialize basic session
+        
+        Args:
+            provider: LLM provider instance
+            system_prompt: System prompt for the session
+            tools: List of available tools
+            timeout: HTTP request timeout
+            tool_timeout: Tool execution timeout
+            recovery_timeout: Circuit breaker recovery timeout
+            auto_compact: Enable automatic conversation compaction
+            auto_compact_threshold: Token threshold for auto-compaction
+            temperature: Default temperature for generation (0.0-1.0)
+            seed: Default seed for deterministic generation
+        """
 
         self.provider = provider
         self.id = str(uuid.uuid4())
@@ -45,6 +60,10 @@ class BasicSession:
         self.auto_compact_threshold = auto_compact_threshold
         self._original_session = None  # Track if this is a compacted session
         
+        # Store session-level generation parameters
+        self.temperature = temperature
+        self.seed = seed
+        
         # Optional analytics fields
         self.summary = None
         self.assessment = None
@@ -189,6 +208,12 @@ class BasicSession:
         # Extract media parameter explicitly (fix for media parameter passing)
         media = kwargs.pop('media', None)
 
+        # Add session-level parameters if not overridden in kwargs
+        if 'temperature' not in kwargs and self.temperature is not None:
+            kwargs['temperature'] = self.temperature
+        if 'seed' not in kwargs and self.seed is not None:
+            kwargs['seed'] = self.seed
+
         # Call provider
         response = self.provider.generate(
             prompt=prompt,

{abstractcore-2.4.5 → abstractcore-2.4.6}/abstractcore/providers/anthropic_provider.py

@@ -47,8 +47,7 @@ class AnthropicProvider(BaseProvider):
         # Initialize tool handler
         self.tool_handler = UniversalToolHandler(model)
 
-        # Store configuration (remove duplicate max_tokens)
-        self.temperature = kwargs.get("temperature", 0.7)
+        # Store provider-specific configuration
         self.top_p = kwargs.get("top_p", 1.0)
         self.top_k = kwargs.get("top_k", None)
 
@@ -132,6 +131,19 @@ class AnthropicProvider(BaseProvider):
         if kwargs.get("top_k") or self.top_k:
             call_params["top_k"] = kwargs.get("top_k", self.top_k)
 
+        # Handle seed parameter (Anthropic doesn't support seed natively)
+        seed_value = kwargs.get("seed", self.seed)
+        if seed_value is not None:
+            import warnings
+            warnings.warn(
+                f"Seed parameter ({seed_value}) is not supported by Anthropic Claude API. "
+                f"For deterministic outputs, use temperature=0.0 which may provide more consistent results, "
+                f"though true determinism is not guaranteed.",
+                UserWarning,
+                stacklevel=3
+            )
+            self.logger.warning(f"Seed {seed_value} requested but not supported by Anthropic API")
+
         # Handle structured output using the "tool trick"
         structured_tool_name = None
         if response_model and PYDANTIC_AVAILABLE:

{abstractcore-2.4.5 → abstractcore-2.4.6}/abstractcore/providers/base.py

@@ -570,8 +570,32 @@ class BaseProvider(AbstractCoreInterface, ABC):
         result_kwargs = kwargs.copy()
         result_kwargs["max_output_tokens"] = effective_max_output
 
+        # Add unified generation parameters with fallback hierarchy: kwargs → instance → defaults
+        result_kwargs["temperature"] = result_kwargs.get("temperature", self.temperature)
+        if self.seed is not None:
+            result_kwargs["seed"] = result_kwargs.get("seed", self.seed)
+
         return result_kwargs
 
+    def _extract_generation_params(self, **kwargs) -> Dict[str, Any]:
+        """
+        Extract generation parameters with consistent fallback hierarchy.
+        
+        Returns:
+            Dict containing temperature, seed, and other generation parameters
+        """
+        params = {}
+        
+        # Temperature (always present)
+        params["temperature"] = kwargs.get("temperature", self.temperature)
+        
+        # Seed (only if not None)
+        seed_value = kwargs.get("seed", self.seed)
+        if seed_value is not None:
+            params["seed"] = seed_value
+            
+        return params
+
     def _get_provider_max_tokens_param(self, kwargs: Dict[str, Any]) -> int:
         """
         Extract the appropriate max tokens parameter for this provider.

{abstractcore-2.4.5 → abstractcore-2.4.6}/abstractcore/providers/huggingface_provider.py

@@ -68,6 +68,7 @@ class HuggingFaceProvider(BaseProvider):
         # Initialize tool handler
         self.tool_handler = UniversalToolHandler(model)
 
+        # Store provider-specific configuration
         self.n_gpu_layers = n_gpu_layers
         self.model_type = None  # Will be "transformers" or "gguf"
         self.device = device
@@ -537,14 +538,15 @@ class HuggingFaceProvider(BaseProvider):
         # Generation parameters using unified system
         generation_kwargs = self._prepare_generation_kwargs(**kwargs)
         max_new_tokens = self._get_provider_max_tokens_param(generation_kwargs)
-        temperature = kwargs.get("temperature", 0.7)
+        temperature = kwargs.get("temperature", self.temperature)
         top_p = kwargs.get("top_p", 0.9)
+        seed_value = kwargs.get("seed", self.seed)
 
         try:
             if stream:
-                return self._stream_generate_transformers_with_tools(input_text, max_new_tokens, temperature, top_p, tools, kwargs.get('tool_call_tags'))
+                return self._stream_generate_transformers_with_tools(input_text, max_new_tokens, temperature, top_p, tools, kwargs.get('tool_call_tags'), seed_value)
             else:
-                response = self._single_generate_transformers(input_text, max_new_tokens, temperature, top_p)
+                response = self._single_generate_transformers(input_text, max_new_tokens, temperature, top_p, seed_value)
 
                 # Handle tool execution for prompted models
                 if tools and self.tool_handler.supports_prompted and response.content:
@@ -651,11 +653,16 @@ class HuggingFaceProvider(BaseProvider):
         generation_kwargs = {
             "messages": chat_messages,
             "max_tokens": max_output_tokens,  # This is max_output_tokens for llama-cpp
-            "temperature": kwargs.get("temperature", 0.7),
+            "temperature": kwargs.get("temperature", self.temperature),
             "top_p": kwargs.get("top_p", 0.9),
             "stream": stream
         }
 
+        # Add seed if provided (GGUF/llama-cpp supports seed)
+        seed_value = kwargs.get("seed", self.seed)
+        if seed_value is not None:
+            generation_kwargs["seed"] = seed_value
+
         # Handle tools - both native and prompted support
         has_native_tools = False
         if tools:
@@ -846,9 +853,16 @@ class HuggingFaceProvider(BaseProvider):
                     )
 
     def _single_generate_transformers(self, input_text: str, max_new_tokens: int,
-                                     temperature: float, top_p: float) -> GenerateResponse:
+                                     temperature: float, top_p: float, seed: Optional[int] = None) -> GenerateResponse:
         """Generate single response using transformers (original implementation)"""
         try:
+            # Set seed for deterministic generation if provided
+            if seed is not None:
+                import torch
+                torch.manual_seed(seed)
+                if torch.cuda.is_available():
+                    torch.cuda.manual_seed_all(seed)
+
             outputs = self.pipeline(
                 input_text,
                 max_new_tokens=max_new_tokens,
@@ -902,11 +916,11 @@ class HuggingFaceProvider(BaseProvider):
         }
 
     def _stream_generate_transformers(self, input_text: str, max_new_tokens: int,
-                                     temperature: float, top_p: float, tool_call_tags: Optional[str] = None) -> Iterator[GenerateResponse]:
+                                     temperature: float, top_p: float, tool_call_tags: Optional[str] = None, seed: Optional[int] = None) -> Iterator[GenerateResponse]:
         """Stream response using transformers (simulated, original implementation) with tool tag rewriting support"""
         try:
             # HuggingFace doesn't have native streaming, so we simulate it
-            full_response = self._single_generate_transformers(input_text, max_new_tokens, temperature, top_p)
+            full_response = self._single_generate_transformers(input_text, max_new_tokens, temperature, top_p, seed)
 
             if full_response.content:
                 # Apply tool tag rewriting if enabled
@@ -1039,12 +1053,12 @@ class HuggingFaceProvider(BaseProvider):
     def _stream_generate_transformers_with_tools(self, input_text: str, max_new_tokens: int,
                                                temperature: float, top_p: float,
                                                tools: Optional[List[Dict[str, Any]]] = None,
-                                               tool_call_tags: Optional[str] = None) -> Iterator[GenerateResponse]:
+                                               tool_call_tags: Optional[str] = None, seed: Optional[int] = None) -> Iterator[GenerateResponse]:
         """Stream generate with tool execution at the end"""
         collected_content = ""
 
         # Stream the response content
-        for chunk in self._stream_generate_transformers(input_text, max_new_tokens, temperature, top_p, tool_call_tags):
+        for chunk in self._stream_generate_transformers(input_text, max_new_tokens, temperature, top_p, tool_call_tags, seed):
             collected_content += chunk.content
             yield chunk
 

{abstractcore-2.4.5 → abstractcore-2.4.6}/abstractcore/providers/lmstudio_provider.py

@@ -196,11 +196,16 @@ class LMStudioProvider(BaseProvider):
             "model": self.model,
             "messages": chat_messages,
             "stream": stream,
-            "temperature": kwargs.get("temperature", 0.7),
+            "temperature": kwargs.get("temperature", self.temperature),
             "max_tokens": max_output_tokens,  # LMStudio uses max_tokens for output tokens
             "top_p": kwargs.get("top_p", 0.9),
         }
 
+        # Add seed if provided (LMStudio supports seed via OpenAI-compatible API)
+        seed_value = kwargs.get("seed", self.seed)
+        if seed_value is not None:
+            payload["seed"] = seed_value
+
         if stream:
             # Return streaming response - BaseProvider will handle tag rewriting via UnifiedStreamProcessor
             return self._stream_generate(payload)

{abstractcore-2.4.5 → abstractcore-2.4.6}/abstractcore/providers/mlx_provider.py

@@ -189,14 +189,15 @@ class MLXProvider(BaseProvider):
         # MLX generation parameters using unified system
         generation_kwargs = self._prepare_generation_kwargs(**kwargs)
         max_tokens = self._get_provider_max_tokens_param(generation_kwargs)
-        temperature = kwargs.get("temperature", 0.7)
+        temperature = kwargs.get("temperature", self.temperature)
         top_p = kwargs.get("top_p", 0.9)
+        seed_value = kwargs.get("seed", self.seed)
 
         try:
             if stream:
-                return self._stream_generate_with_tools(full_prompt, max_tokens, temperature, top_p, tools, kwargs.get('tool_call_tags'))
+                return self._stream_generate_with_tools(full_prompt, max_tokens, temperature, top_p, tools, kwargs.get('tool_call_tags'), seed_value)
             else:
-                response = self._single_generate(full_prompt, max_tokens, temperature, top_p)
+                response = self._single_generate(full_prompt, max_tokens, temperature, top_p, seed_value)
 
                 # Handle tool execution for prompted models
                 if tools and self.tool_handler.supports_prompted and response.content:
@@ -256,9 +257,15 @@ class MLXProvider(BaseProvider):
 
         return full_prompt
 
-    def _single_generate(self, prompt: str, max_tokens: int, temperature: float, top_p: float) -> GenerateResponse:
+    def _single_generate(self, prompt: str, max_tokens: int, temperature: float, top_p: float, seed: Optional[int] = None) -> GenerateResponse:
         """Generate single response"""
 
+        # Handle seed parameter (MLX supports seed via mx.random.seed)
+        if seed is not None:
+            import mlx.core as mx
+            mx.random.seed(seed)
+            self.logger.debug(f"Set MLX random seed to {seed} for deterministic generation")
+
         # Try different MLX API signatures
         try:
             # Try new mlx-lm API
@@ -305,9 +312,15 @@ class MLXProvider(BaseProvider):
             "total_tokens": total_tokens
         }
 
-    def _stream_generate(self, prompt: str, max_tokens: int, temperature: float, top_p: float, tool_call_tags: Optional[str] = None) -> Iterator[GenerateResponse]:
+    def _stream_generate(self, prompt: str, max_tokens: int, temperature: float, top_p: float, tool_call_tags: Optional[str] = None, seed: Optional[int] = None) -> Iterator[GenerateResponse]:
         """Generate real streaming response using MLX stream_generate with tool tag rewriting support"""
         try:
+            # Handle seed parameter (MLX supports seed via mx.random.seed)
+            if seed is not None:
+                import mlx.core as mx
+                mx.random.seed(seed)
+                self.logger.debug(f"Set MLX random seed to {seed} for deterministic streaming generation")
+
             # Initialize tool tag rewriter if needed
             rewriter = None
             buffer = ""
@@ -366,12 +379,12 @@ class MLXProvider(BaseProvider):
     def _stream_generate_with_tools(self, full_prompt: str, max_tokens: int,
                                    temperature: float, top_p: float,
                                    tools: Optional[List[Dict[str, Any]]] = None,
-                                   tool_call_tags: Optional[str] = None) -> Iterator[GenerateResponse]:
+                                   tool_call_tags: Optional[str] = None, seed: Optional[int] = None) -> Iterator[GenerateResponse]:
         """Stream generate with tool execution at the end"""
         collected_content = ""
 
         # Stream the response content
-        for chunk in self._stream_generate(full_prompt, max_tokens, temperature, top_p, tool_call_tags):
+        for chunk in self._stream_generate(full_prompt, max_tokens, temperature, top_p, tool_call_tags, seed):
             collected_content += chunk.content
             yield chunk
 

{abstractcore-2.4.5 → abstractcore-2.4.6}/abstractcore/providers/ollama_provider.py

@@ -132,11 +132,16 @@ class OllamaProvider(BaseProvider):
             "model": self.model,
             "stream": stream,
             "options": {
-                "temperature": kwargs.get("temperature", 0.7),
+                "temperature": kwargs.get("temperature", self.temperature),
                 "num_predict": max_output_tokens,  # Ollama uses num_predict for max output tokens
             }
         }
 
+        # Add seed if provided (Ollama supports seed for deterministic outputs)
+        seed_value = kwargs.get("seed", self.seed)
+        if seed_value is not None:
+            payload["options"]["seed"] = seed_value
+
         # Add structured output support (Ollama native JSON schema)
         if response_model and PYDANTIC_AVAILABLE:
             json_schema = response_model.model_json_schema()

{abstractcore-2.4.5 → abstractcore-2.4.6}/abstractcore/providers/openai_provider.py

@@ -50,8 +50,7 @@ class OpenAIProvider(BaseProvider):
         # Preflight check: validate model exists
         self._validate_model_exists()
 
-        # Store configuration (remove duplicate max_tokens)
-        self.temperature = kwargs.get("temperature", 0.7)
+        # Store provider-specific configuration
         self.top_p = kwargs.get("top_p", 1.0)
         self.frequency_penalty = kwargs.get("frequency_penalty", 0.0)
         self.presence_penalty = kwargs.get("presence_penalty", 0.0)
@@ -125,6 +124,11 @@ class OpenAIProvider(BaseProvider):
             call_params["top_p"] = kwargs.get("top_p", self.top_p)
             call_params["frequency_penalty"] = kwargs.get("frequency_penalty", self.frequency_penalty)
             call_params["presence_penalty"] = kwargs.get("presence_penalty", self.presence_penalty)
+            
+            # Add seed if provided (OpenAI supports seed for deterministic outputs)
+            seed_value = kwargs.get("seed", self.seed)
+            if seed_value is not None:
+                call_params["seed"] = seed_value
 
         # Handle different token parameter names for different model families
         if self._uses_max_completion_tokens():