abstractcore 2.4.5__py3-none-any.whl → 2.4.7__py3-none-any.whl

abstractcore/__init__.py

@@ -44,6 +44,9 @@ except ImportError:
 from .processing import BasicSummarizer, SummaryStyle, SummaryLength, BasicExtractor
 _has_processing = True
 
+# Tools module (core functionality)
+from .tools import tool
+
 __all__ = [
     'create_llm',
     'BasicSession',
@@ -54,7 +57,8 @@ __all__ = [
     'MessageRole',
     'ModelNotFoundError',
     'ProviderAPIError',
-    'AuthenticationError'
+    'AuthenticationError',
+    'tool'
 ]
 
 if _has_embeddings:

abstractcore/assets/session_schema.json

@@ -109,7 +109,7 @@
                 "tokens_before": { "type": "integer" },
                 "tokens_after": { "type": "integer" },
                 "compression_ratio": { "type": "number" },
-                "generation_time_ms": { "type": "number" }
+                "gen_time": { "type": "number" }
               }
             }
           },

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/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,
@@ -735,7 +760,7 @@ class BasicSession:
                 "tokens_before": original_tokens,
                 "tokens_after": self._estimate_tokens_for_summary(summary_result.summary),
                 "compression_ratio": self._calculate_compression_ratio(original_tokens, summary_result.summary),
-                "generation_time_ms": duration_ms
+                "gen_time": duration_ms
             }
         }
         

abstractcore/core/types.py

@@ -91,6 +91,7 @@ class GenerateResponse:
     usage: Optional[Dict[str, int]] = None
     tool_calls: Optional[List[Dict[str, Any]]] = None
     metadata: Optional[Dict[str, Any]] = None
+    gen_time: Optional[float] = None  # Generation time in milliseconds
 
     def has_tool_calls(self) -> bool:
         """Check if response contains tool calls"""
@@ -109,6 +110,29 @@ class GenerateResponse:
             parts.append(f"Model: {self.model}")
         if self.usage:
             parts.append(f"Tokens: {self.usage.get('total_tokens', 'unknown')}")
+        if self.gen_time:
+            parts.append(f"Time: {self.gen_time:.1f}ms")
         if self.tool_calls:
             parts.append(f"Tools: {len(self.tool_calls)} executed")
-        return " | ".join(parts)
+        return " | ".join(parts)
+    
+    @property
+    def input_tokens(self) -> Optional[int]:
+        """Get input tokens with consistent terminology (prompt_tokens or input_tokens)."""
+        if not self.usage:
+            return None
+        return self.usage.get('input_tokens') or self.usage.get('prompt_tokens')
+    
+    @property
+    def output_tokens(self) -> Optional[int]:
+        """Get output tokens with consistent terminology (completion_tokens or output_tokens)."""
+        if not self.usage:
+            return None
+        return self.usage.get('output_tokens') or self.usage.get('completion_tokens')
+    
+    @property
+    def total_tokens(self) -> Optional[int]:
+        """Get total tokens."""
+        if not self.usage:
+            return None
+        return self.usage.get('total_tokens')

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:
@@ -174,8 +186,14 @@ class AnthropicProvider(BaseProvider):
             if stream:
                 return self._stream_response(call_params, tools)
             else:
+                # Track generation time
+                start_time = time.time()
                 response = self.client.messages.create(**call_params)
+                gen_time = round((time.time() - start_time) * 1000, 1)
+                
                 formatted = self._format_response(response)
+                # Add generation time to response
+                formatted.gen_time = gen_time
 
                 # Handle tool execution for Anthropic responses
                 if tools and (formatted.has_tool_calls() or

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/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,19 @@ 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)
+
+            # Track generation time
+            start_time = time.time()
+            
             outputs = self.pipeline(
                 input_text,
                 max_new_tokens=max_new_tokens,
@@ -860,6 +877,8 @@ class HuggingFaceProvider(BaseProvider):
                 truncation=True,
                 return_full_text=False
             )
+            
+            gen_time = round((time.time() - start_time) * 1000, 1)
 
             if outputs and len(outputs) > 0:
                 response_text = outputs[0]['generated_text'].strip()
@@ -871,42 +890,49 @@ class HuggingFaceProvider(BaseProvider):
                     content=response_text,
                     model=self.model,
                     finish_reason="stop",
-                    usage=usage
+                    usage=usage,
+                    gen_time=gen_time
                 )
             else:
                 return GenerateResponse(
                     content="",
                     model=self.model,
-                    finish_reason="stop"
+                    finish_reason="stop",
+                    gen_time=gen_time
                 )
 
         except Exception as e:
+            gen_time = round((time.time() - start_time) * 1000, 1) if 'start_time' in locals() else 0.0
             return GenerateResponse(
                 content=f"Error: {str(e)}",
                 model=self.model,
-                finish_reason="error"
+                finish_reason="error",
+                gen_time=gen_time
             )
 
     def _calculate_usage(self, prompt: str, response: str) -> Dict[str, int]:
         """Calculate token usage using centralized token utilities."""
         from ..utils.token_utils import TokenUtils
 
-        prompt_tokens = TokenUtils.estimate_tokens(prompt, self.model)
-        completion_tokens = TokenUtils.estimate_tokens(response, self.model)
-        total_tokens = prompt_tokens + completion_tokens
+        input_tokens = TokenUtils.estimate_tokens(prompt, self.model)
+        output_tokens = TokenUtils.estimate_tokens(response, self.model)
+        total_tokens = input_tokens + output_tokens
 
         return {
-            "prompt_tokens": prompt_tokens,
-            "completion_tokens": completion_tokens,
-            "total_tokens": total_tokens
+            "input_tokens": input_tokens,
+            "output_tokens": output_tokens,
+            "total_tokens": total_tokens,
+            # Keep legacy keys for backward compatibility
+            "prompt_tokens": input_tokens,
+            "completion_tokens": output_tokens
         }
 
     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 +1065,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/providers/lmstudio_provider.py

@@ -4,6 +4,7 @@ LM Studio provider implementation (OpenAI-compatible API).
 
 import httpx
 import json
+import time
 from typing import List, Dict, Any, Optional, Union, Iterator, Type
 
 try:
@@ -196,11 +197,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)
@@ -220,12 +226,15 @@ class LMStudioProvider(BaseProvider):
             if not hasattr(self, 'client') or self.client is None:
                 raise ProviderAPIError("HTTP client not initialized")
 
+            # Track generation time
+            start_time = time.time()
             response = self.client.post(
                 f"{self.base_url}/chat/completions",
                 json=payload,
                 headers={"Content-Type": "application/json"}
             )
             response.raise_for_status()
+            gen_time = round((time.time() - start_time) * 1000, 1)
 
             result = response.json()
 
@@ -247,10 +256,14 @@ class LMStudioProvider(BaseProvider):
                 finish_reason=finish_reason,
                 raw_response=result,
                 usage={
+                    "input_tokens": usage.get("prompt_tokens", 0),
+                    "output_tokens": usage.get("completion_tokens", 0),
+                    "total_tokens": usage.get("total_tokens", 0),
+                    # Keep legacy keys for backward compatibility
                     "prompt_tokens": usage.get("prompt_tokens", 0),
-                    "completion_tokens": usage.get("completion_tokens", 0),
-                    "total_tokens": usage.get("total_tokens", 0)
-                }
+                    "completion_tokens": usage.get("completion_tokens", 0)
+                },
+                gen_time=gen_time
             )
 
         except AttributeError as e:

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,18 @@ 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")
+
+        # Track generation time
+        start_time = time.time()
+        
         # Try different MLX API signatures
         try:
             # Try new mlx-lm API
@@ -281,6 +291,8 @@ class MLXProvider(BaseProvider):
                 # Fallback to basic response
                 response_text = prompt + " I am an AI assistant powered by MLX on Apple Silicon."
 
+        gen_time = round((time.time() - start_time) * 1000, 1)
+        
         # Use the full response as-is - preserve all content including thinking
         generated = response_text.strip()
 
@@ -288,26 +300,36 @@ class MLXProvider(BaseProvider):
             content=generated,
             model=self.model,
             finish_reason="stop",
-            usage=self._calculate_usage(prompt, generated)
+            usage=self._calculate_usage(prompt, generated),
+            gen_time=gen_time
         )
 
     def _calculate_usage(self, prompt: str, response: str) -> Dict[str, int]:
         """Calculate token usage using centralized token utilities."""
         from ..utils.token_utils import TokenUtils
         
-        prompt_tokens = TokenUtils.estimate_tokens(prompt, self.model)
-        completion_tokens = TokenUtils.estimate_tokens(response, self.model)
-        total_tokens = prompt_tokens + completion_tokens
+        input_tokens = TokenUtils.estimate_tokens(prompt, self.model)
+        output_tokens = TokenUtils.estimate_tokens(response, self.model)
+        total_tokens = input_tokens + output_tokens
         
         return {
-            "prompt_tokens": prompt_tokens,
-            "completion_tokens": completion_tokens,
-            "total_tokens": total_tokens
+            "input_tokens": input_tokens,
+            "output_tokens": output_tokens,
+            "total_tokens": total_tokens,
+            # Keep legacy keys for backward compatibility
+            "prompt_tokens": input_tokens,
+            "completion_tokens": output_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 +388,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/providers/mock_provider.py

@@ -48,6 +48,12 @@ class MockProvider(BaseProvider):
 
     def _single_response(self, prompt: str, response_model: Optional[Type[BaseModel]] = None) -> GenerateResponse:
         """Generate single mock response"""
+        import time
+        
+        # Simulate generation time (10-100ms for mock)
+        start_time = time.time()
+        time.sleep(0.01 + (len(prompt) % 10) * 0.01)  # 10-100ms based on prompt length
+        gen_time = round((time.time() - start_time) * 1000, 1)
 
         if response_model and PYDANTIC_AVAILABLE:
             # Generate valid JSON for structured output
@@ -59,21 +65,25 @@ class MockProvider(BaseProvider):
             content=content,
             model=self.model,
             finish_reason="stop",
-            usage=self._calculate_mock_usage(prompt, content)
+            usage=self._calculate_mock_usage(prompt, content),
+            gen_time=gen_time
         )
 
     def _calculate_mock_usage(self, prompt: str, response: str) -> Dict[str, int]:
         """Calculate mock token usage using centralized token utilities."""
         from ..utils.token_utils import TokenUtils
         
-        prompt_tokens = TokenUtils.estimate_tokens(prompt, self.model)
-        completion_tokens = TokenUtils.estimate_tokens(response, self.model)
-        total_tokens = prompt_tokens + completion_tokens
+        input_tokens = TokenUtils.estimate_tokens(prompt, self.model)
+        output_tokens = TokenUtils.estimate_tokens(response, self.model)
+        total_tokens = input_tokens + output_tokens
         
         return {
-            "prompt_tokens": prompt_tokens,
-            "completion_tokens": completion_tokens, 
-            "total_tokens": total_tokens
+            "input_tokens": input_tokens,
+            "output_tokens": output_tokens,
+            "total_tokens": total_tokens,
+            # Keep legacy keys for backward compatibility
+            "prompt_tokens": input_tokens,
+            "completion_tokens": output_tokens
         }
 
     def _stream_response(self, prompt: str) -> Iterator[GenerateResponse]:

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()
@@ -220,11 +225,14 @@ class OllamaProvider(BaseProvider):
     def _single_generate(self, endpoint: str, payload: Dict[str, Any], tools: Optional[List[Dict[str, Any]]] = None) -> GenerateResponse:
         """Generate single response"""
         try:
+            # Track generation time
+            start_time = time.time()
             response = self.client.post(
                 f"{self.base_url}{endpoint}",
                 json=payload
             )
             response.raise_for_status()
+            gen_time = round((time.time() - start_time) * 1000, 1)
 
             result = response.json()
 
@@ -241,10 +249,14 @@ class OllamaProvider(BaseProvider):
                 finish_reason="stop",
                 raw_response=result,
                 usage={
+                    "input_tokens": result.get("prompt_eval_count", 0),
+                    "output_tokens": result.get("eval_count", 0),
+                    "total_tokens": result.get("prompt_eval_count", 0) + result.get("eval_count", 0),
+                    # Keep legacy keys for backward compatibility
                     "prompt_tokens": result.get("prompt_eval_count", 0),
-                    "completion_tokens": result.get("eval_count", 0),
-                    "total_tokens": result.get("prompt_eval_count", 0) + result.get("eval_count", 0)
-                }
+                    "completion_tokens": result.get("eval_count", 0)
+                },
+                gen_time=gen_time
             )
 
             # Execute tools if enabled and tools are present