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

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,

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/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,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/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/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/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/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():

abstractcore/tools/common_tools.py

@@ -11,17 +11,29 @@ import os
 import subprocess
 import requests
 from pathlib import Path
-from typing import Optional
+from typing import Optional, Dict, Any, Union
 import logging
 import platform
 import re
 import time
+import json
+import base64
+from datetime import datetime
+from urllib.parse import urlparse, urljoin
+import mimetypes
 
 try:
     from bs4 import BeautifulSoup
     BS4_AVAILABLE = True
+    # Try to use lxml parser for better performance
+    try:
+        import lxml
+        BS4_PARSER = 'lxml'
+    except ImportError:
+        BS4_PARSER = 'html.parser'
 except ImportError:
     BS4_AVAILABLE = False
+    BS4_PARSER = None
 
 try:
     import psutil
@@ -995,6 +1007,643 @@ def web_search(query: str, num_results: int = 5, safe_search: str = "moderate",
         return f"Error searching internet: {str(e)}"
 
 
+@tool(
+    description="Fetch and intelligently parse content from URLs with automatic content type detection and metadata extraction",
+    tags=["web", "fetch", "url", "http", "content", "parse", "scraping"],
+    when_to_use="When you need to retrieve and analyze content from specific URLs, including web pages, APIs, documents, or media files",
+    examples=[
+        {
+            "description": "Fetch and parse HTML webpage",
+            "arguments": {
+                "url": "https://example.com/article.html"
+            }
+        },
+        {
+            "description": "Fetch JSON API response",
+            "arguments": {
+                "url": "https://api.github.com/repos/python/cpython",
+                "headers": {"Accept": "application/json"}
+            }
+        },
+        {
+            "description": "POST data to API endpoint",
+            "arguments": {
+                "url": "https://httpbin.org/post",
+                "method": "POST",
+                "data": {"key": "value", "test": "data"}
+            }
+        },
+        {
+            "description": "Fetch binary content with metadata",
+            "arguments": {
+                "url": "https://example.com/document.pdf",
+                "include_binary_preview": True
+            }
+        }
+    ]
+)
+def fetch_url(
+    url: str,
+    method: str = "GET",
+    headers: Optional[Dict[str, str]] = None,
+    data: Optional[Union[Dict[str, Any], str]] = None,
+    timeout: int = 30,
+    max_content_length: int = 10485760,  # 10MB default
+    follow_redirects: bool = True,
+    include_binary_preview: bool = False,
+    extract_links: bool = True,
+    user_agent: str = "AbstractCore-FetchTool/1.0"
+) -> str:
+    """
+    Fetch and intelligently parse content from URLs with comprehensive content type detection.
+    
+    This tool automatically detects content types (HTML, JSON, XML, images, etc.) and provides
+    appropriate parsing with metadata extraction including timestamps and response headers.
+    
+    Args:
+        url: The URL to fetch content from
+        method: HTTP method to use (default: "GET")
+        headers: Optional custom headers to send with the request
+        data: Optional data to send with POST/PUT requests (dict or string)
+        timeout: Request timeout in seconds (default: 30)
+        max_content_length: Maximum content length to fetch in bytes (default: 10MB)
+        follow_redirects: Whether to follow HTTP redirects (default: True)
+        include_binary_preview: Whether to include base64 preview for binary content (default: False)
+        extract_links: Whether to extract links from HTML content (default: True)
+        user_agent: User-Agent header to use (default: "AbstractCore-FetchTool/1.0")
+    
+    Returns:
+        Formatted string with parsed content, metadata, and analysis or error message
+        
+    Examples:
+        fetch_url("https://api.github.com/repos/python/cpython")  # Fetch and parse JSON API
+        fetch_url("https://example.com", headers={"Accept": "text/html"})  # Fetch HTML with custom headers
+        fetch_url("https://httpbin.org/post", method="POST", data={"test": "value"})  # POST request
+        fetch_url("https://example.com/image.jpg", include_binary_preview=True)  # Fetch image with preview
+    """
+    try:
+        # Validate URL
+        parsed_url = urlparse(url)
+        if not parsed_url.scheme or not parsed_url.netloc:
+            return f"❌ Invalid URL format: {url}"
+        
+        if parsed_url.scheme not in ['http', 'https']:
+            return f"❌ Unsupported URL scheme: {parsed_url.scheme}. Only HTTP and HTTPS are supported."
+        
+        # Prepare request headers
+        request_headers = {
+            'User-Agent': user_agent,
+            'Accept': '*/*',
+            'Accept-Encoding': 'gzip, deflate',
+            'Connection': 'keep-alive'
+        }
+        
+        if headers:
+            request_headers.update(headers)
+        
+        # Prepare request parameters
+        request_params = {
+            'url': url,
+            'method': method.upper(),
+            'headers': request_headers,
+            'timeout': timeout,
+            'allow_redirects': follow_redirects,
+            'stream': True  # Stream to check content length
+        }
+        
+        # Add data for POST/PUT requests
+        if data and method.upper() in ['POST', 'PUT', 'PATCH']:
+            if isinstance(data, dict):
+                # Try JSON first, fallback to form data
+                if request_headers.get('Content-Type', '').startswith('application/json'):
+                    request_params['json'] = data
+                else:
+                    request_params['data'] = data
+            else:
+                request_params['data'] = data
+        
+        # Record fetch timestamp
+        fetch_timestamp = datetime.now().isoformat()
+        
+        # Make the request with session for connection reuse
+        with requests.Session() as session:
+            session.headers.update(request_headers)
+            response = session.request(
+                method=method.upper(),
+                url=url,
+                timeout=timeout,
+                allow_redirects=follow_redirects,
+                stream=True,
+                json=request_params.get('json'),
+                data=request_params.get('data')
+            )
+        
+        # Check response status
+        if not response.ok:
+            return f"❌ HTTP Error {response.status_code}: {response.reason}\n" \
+                   f"URL: {url}\n" \
+                   f"Timestamp: {fetch_timestamp}\n" \
+                   f"Response headers: {dict(response.headers)}"
+        
+        # Get content info
+        content_type = response.headers.get('content-type', '').lower()
+        content_length = response.headers.get('content-length')
+        if content_length:
+            content_length = int(content_length)
+        
+        # Check content length before downloading
+        if content_length and content_length > max_content_length:
+            return f"⚠️  Content too large: {content_length:,} bytes (max: {max_content_length:,})\n" \
+                   f"URL: {url}\n" \
+                   f"Content-Type: {content_type}\n" \
+                   f"Timestamp: {fetch_timestamp}\n" \
+                   f"Use max_content_length parameter to increase limit if needed"
+        
+        # Download content with optimized chunking
+        content_chunks = []
+        downloaded_size = 0
+        
+        # Use larger chunks for better performance
+        chunk_size = 32768 if 'image/' in content_type or 'video/' in content_type else 16384
+        
+        for chunk in response.iter_content(chunk_size=chunk_size):
+            if chunk:
+                downloaded_size += len(chunk)
+                if downloaded_size > max_content_length:
+                    return f"⚠️  Content exceeded size limit during download: {downloaded_size:,} bytes (max: {max_content_length:,})\n" \
+                           f"URL: {url}\n" \
+                           f"Content-Type: {content_type}\n" \
+                           f"Timestamp: {fetch_timestamp}"
+                content_chunks.append(chunk)
+        
+        content_bytes = b''.join(content_chunks)
+        actual_size = len(content_bytes)
+        
+        # Detect content type and parse accordingly
+        parsed_content = _parse_content_by_type(content_bytes, content_type, url, extract_links, include_binary_preview)
+        
+        # Build comprehensive response
+        result_parts = []
+        result_parts.append(f"🌐 URL Fetch Results")
+        result_parts.append(f"📍 URL: {response.url}")  # Final URL after redirects
+        if response.url != url:
+            result_parts.append(f"🔄 Original URL: {url}")
+        result_parts.append(f"⏰ Timestamp: {fetch_timestamp}")
+        result_parts.append(f"✅ Status: {response.status_code} {response.reason}")
+        result_parts.append(f"📊 Content-Type: {content_type}")
+        result_parts.append(f"📏 Size: {actual_size:,} bytes")
+        
+        # Add important response headers
+        important_headers = ['server', 'last-modified', 'etag', 'cache-control', 'expires', 'location']
+        response_metadata = []
+        for header in important_headers:
+            value = response.headers.get(header)
+            if value:
+                response_metadata.append(f"  {header.title()}: {value}")
+        
+        if response_metadata:
+            result_parts.append(f"📋 Response Headers:")
+            result_parts.extend(response_metadata)
+        
+        # Add parsed content
+        result_parts.append(f"\n📄 Content Analysis:")
+        result_parts.append(parsed_content)
+        
+        return "\n".join(result_parts)
+        
+    except requests.exceptions.Timeout:
+        return f"⏰ Request timeout after {timeout} seconds\n" \
+               f"URL: {url}\n" \
+               f"Consider increasing timeout parameter"
+    
+    except requests.exceptions.ConnectionError as e:
+        return f"🔌 Connection error: {str(e)}\n" \
+               f"URL: {url}\n" \
+               f"Check network connectivity and URL validity"
+    
+    except requests.exceptions.TooManyRedirects:
+        return f"🔄 Too many redirects\n" \
+               f"URL: {url}\n" \
+               f"Try setting follow_redirects=False to see redirect chain"
+    
+    except requests.exceptions.RequestException as e:
+        return f"❌ Request error: {str(e)}\n" \
+               f"URL: {url}"
+    
+    except Exception as e:
+        return f"❌ Unexpected error fetching URL: {str(e)}\n" \
+               f"URL: {url}"
+
+
+def _parse_content_by_type(content_bytes: bytes, content_type: str, url: str, extract_links: bool = True, include_binary_preview: bool = False) -> str:
+    """
+    Parse content based on detected content type with intelligent fallbacks.
+    
+    This function provides robust content type detection and parsing for various formats
+    including HTML, JSON, XML, plain text, images, and other binary formats.
+    """
+    try:
+        # Normalize content type
+        main_type = content_type.split(';')[0].strip().lower()
+        
+        # Try to decode as text first for text-based formats
+        text_content = None
+        encoding = 'utf-8'
+        
+        # Detect encoding from content-type header
+        if 'charset=' in content_type:
+            try:
+                encoding = content_type.split('charset=')[1].split(';')[0].strip()
+            except:
+                encoding = 'utf-8'
+        
+        # Attempt text decoding for text-based content types with better encoding detection
+        text_based_types = [
+            'text/', 'application/json', 'application/xml', 'application/javascript',
+            'application/rss+xml', 'application/atom+xml', 'application/xhtml+xml'
+        ]
+        
+        is_text_based = any(main_type.startswith(t) for t in text_based_types)
+        
+        if is_text_based:
+            # Try multiple encoding strategies
+            for enc in [encoding, 'utf-8', 'iso-8859-1', 'windows-1252']:
+                try:
+                    text_content = content_bytes.decode(enc)
+                    break
+                except (UnicodeDecodeError, LookupError):
+                    continue
+            else:
+                # Final fallback with error replacement
+                text_content = content_bytes.decode('utf-8', errors='replace')
+        
+        # Parse based on content type
+        if main_type.startswith('text/html') or main_type.startswith('application/xhtml'):
+            return _parse_html_content(text_content, url, extract_links)
+        
+        elif main_type == 'application/json':
+            return _parse_json_content(text_content)
+        
+        elif main_type in ['application/xml', 'text/xml', 'application/rss+xml', 'application/atom+xml']:
+            return _parse_xml_content(text_content)
+        
+        elif main_type.startswith('text/'):
+            return _parse_text_content(text_content, main_type)
+        
+        elif main_type.startswith('image/'):
+            return _parse_image_content(content_bytes, main_type, include_binary_preview)
+        
+        elif main_type == 'application/pdf':
+            return _parse_pdf_content(content_bytes, include_binary_preview)
+        
+        else:
+            return _parse_binary_content(content_bytes, main_type, include_binary_preview)
+    
+    except Exception as e:
+        return f"❌ Error parsing content: {str(e)}\n" \
+               f"Content-Type: {content_type}\n" \
+               f"Content size: {len(content_bytes):,} bytes"
+
+
+def _parse_html_content(html_content: str, url: str, extract_links: bool = True) -> str:
+    """Parse HTML content and extract meaningful information."""
+    if not html_content:
+        return "❌ No HTML content to parse"
+    
+    result_parts = []
+    result_parts.append("🌐 HTML Document Analysis")
+    
+    # Use BeautifulSoup if available for better parsing
+    if BS4_AVAILABLE:
+        try:
+            soup = BeautifulSoup(html_content, BS4_PARSER)
+            
+            # Extract title
+            title = soup.find('title')
+            if title:
+                result_parts.append(f"📰 Title: {title.get_text().strip()}")
+            
+            # Extract meta description
+            meta_desc = soup.find('meta', attrs={'name': 'description'})
+            if meta_desc and meta_desc.get('content'):
+                result_parts.append(f"📝 Description: {meta_desc['content'][:200]}...")
+            
+            # Extract headings
+            headings = []
+            for i in range(1, 7):
+                h_tags = soup.find_all(f'h{i}')
+                for h in h_tags[:5]:  # Limit to first 5 of each level
+                    headings.append(f"H{i}: {h.get_text().strip()[:100]}")
+            
+            if headings:
+                result_parts.append(f"📋 Headings (first 5 per level):")
+                for heading in headings[:10]:  # Limit total headings
+                    result_parts.append(f"  • {heading}")
+            
+            # Extract links if requested
+            if extract_links:
+                links = []
+                for a in soup.find_all('a', href=True)[:20]:  # Limit to first 20 links
+                    href = a['href']
+                    text = a.get_text().strip()[:50]
+                    # Convert relative URLs to absolute
+                    if href.startswith('/'):
+                        href = urljoin(url, href)
+                    elif not href.startswith(('http://', 'https://')):
+                        href = urljoin(url, href)
+                    links.append(f"{text} → {href}")
+                
+                if links:
+                    result_parts.append(f"🔗 Links (first 20):")
+                    for link in links:
+                        result_parts.append(f"  • {link}")
+            
+            # Extract main text content with better cleaning
+            # Remove script, style, nav, footer, header elements for cleaner content
+            for element in soup(["script", "style", "nav", "footer", "header", "aside"]):
+                element.decompose()
+            
+            # Try to find main content area first
+            main_content = soup.find(['main', 'article']) or soup.find('div', class_=lambda x: x and any(word in x.lower() for word in ['content', 'article', 'post', 'main']))
+            content_soup = main_content if main_content else soup
+            
+            text = content_soup.get_text()
+            # Clean up text more efficiently
+            lines = (line.strip() for line in text.splitlines() if line.strip())
+            text = ' '.join(lines)
+            # Remove excessive whitespace
+            text = ' '.join(text.split())
+            
+            if text:
+                preview_length = 500
+                text_preview = text[:preview_length]
+                if len(text) > preview_length:
+                    text_preview += "..."
+                result_parts.append(f"📄 Text Content Preview:")
+                result_parts.append(f"{text_preview}")
+                result_parts.append(f"📊 Total text length: {len(text):,} characters")
+        
+        except Exception as e:
+            result_parts.append(f"⚠️  BeautifulSoup parsing error: {str(e)}")
+            result_parts.append(f"📄 Raw HTML Preview (first 1000 chars):")
+            result_parts.append(html_content[:1000] + ("..." if len(html_content) > 1000 else ""))
+    
+    else:
+        # Fallback parsing without BeautifulSoup
+        result_parts.append("⚠️  BeautifulSoup not available - using basic parsing")
+        
+        # Extract title with regex
+        import re
+        title_match = re.search(r'<title[^>]*>(.*?)</title>', html_content, re.IGNORECASE | re.DOTALL)
+        if title_match:
+            result_parts.append(f"📰 Title: {title_match.group(1).strip()}")
+        
+        # Show HTML preview
+        result_parts.append(f"📄 HTML Preview (first 1000 chars):")
+        result_parts.append(html_content[:1000] + ("..." if len(html_content) > 1000 else ""))
+    
+    return "\n".join(result_parts)
+
+
+def _parse_json_content(json_content: str) -> str:
+    """Parse JSON content and provide structured analysis."""
+    if not json_content:
+        return "❌ No JSON content to parse"
+    
+    result_parts = []
+    result_parts.append("📊 JSON Data Analysis")
+    
+    try:
+        data = json.loads(json_content)
+        
+        # Analyze JSON structure
+        result_parts.append(f"📋 Structure: {type(data).__name__}")
+        
+        if isinstance(data, dict):
+            result_parts.append(f"🔑 Keys ({len(data)}): {', '.join(list(data.keys())[:10])}")
+            if len(data) > 10:
+                result_parts.append(f"   ... and {len(data) - 10} more keys")
+        elif isinstance(data, list):
+            result_parts.append(f"📝 Array length: {len(data)}")
+            if data and isinstance(data[0], dict):
+                result_parts.append(f"🔑 First item keys: {', '.join(list(data[0].keys())[:10])}")
+        
+        # Pretty print JSON with smart truncation
+        json_str = json.dumps(data, indent=2, ensure_ascii=False, separators=(',', ': '))
+        preview_length = 1500  # Reduced for better readability
+        if len(json_str) > preview_length:
+            # Try to truncate at a logical point (end of object/array)
+            truncate_pos = json_str.rfind('\n', 0, preview_length)
+            if truncate_pos > preview_length - 200:  # If close to limit, use it
+                json_preview = json_str[:truncate_pos] + "\n... (truncated)"
+            else:
+                json_preview = json_str[:preview_length] + "\n... (truncated)"
+        else:
+            json_preview = json_str
+        
+        result_parts.append(f"📄 JSON Content:")
+        result_parts.append(json_preview)
+        result_parts.append(f"📊 Total size: {len(json_content):,} characters")
+    
+    except json.JSONDecodeError as e:
+        result_parts.append(f"❌ JSON parsing error: {str(e)}")
+        result_parts.append(f"📄 Raw content preview (first 1000 chars):")
+        result_parts.append(json_content[:1000] + ("..." if len(json_content) > 1000 else ""))
+    
+    return "\n".join(result_parts)
+
+
+def _parse_xml_content(xml_content: str) -> str:
+    """Parse XML content including RSS/Atom feeds."""
+    if not xml_content:
+        return "❌ No XML content to parse"
+    
+    result_parts = []
+    result_parts.append("📄 XML/RSS/Atom Analysis")
+    
+    try:
+        # Try to detect if it's RSS/Atom
+        if '<rss' in xml_content.lower() or '<feed' in xml_content.lower():
+            result_parts.append("📡 Detected: RSS/Atom Feed")
+        
+        # Basic XML structure analysis
+        import re
+        
+        # Find root element
+        root_match = re.search(r'<([^?\s/>]+)', xml_content)
+        if root_match:
+            result_parts.append(f"🏷️  Root element: <{root_match.group(1)}>")
+        
+        # Count elements (basic)
+        elements = re.findall(r'<([^/\s>]+)', xml_content)
+        if elements:
+            from collections import Counter
+            element_counts = Counter(elements[:50])  # Limit analysis
+            result_parts.append(f"📊 Top elements: {dict(list(element_counts.most_common(10)))}")
+        
+        # Show XML preview
+        preview_length = 1500
+        xml_preview = xml_content[:preview_length]
+        if len(xml_content) > preview_length:
+            xml_preview += "\n... (truncated)"
+        
+        result_parts.append(f"📄 XML Content Preview:")
+        result_parts.append(xml_preview)
+        result_parts.append(f"📊 Total size: {len(xml_content):,} characters")
+    
+    except Exception as e:
+        result_parts.append(f"❌ XML parsing error: {str(e)}")
+        result_parts.append(f"📄 Raw content preview (first 1000 chars):")
+        result_parts.append(xml_content[:1000] + ("..." if len(xml_content) > 1000 else ""))
+    
+    return "\n".join(result_parts)
+
+
+def _parse_text_content(text_content: str, content_type: str) -> str:
+    """Parse plain text content."""
+    if not text_content:
+        return "❌ No text content to parse"
+    
+    result_parts = []
+    result_parts.append(f"📝 Text Content Analysis ({content_type})")
+    
+    # Basic text statistics
+    lines = text_content.splitlines()
+    words = text_content.split()
+    
+    result_parts.append(f"📊 Statistics:")
+    result_parts.append(f"  • Lines: {len(lines):,}")
+    result_parts.append(f"  • Words: {len(words):,}")
+    result_parts.append(f"  • Characters: {len(text_content):,}")
+    
+    # Show text preview
+    preview_length = 2000
+    text_preview = text_content[:preview_length]
+    if len(text_content) > preview_length:
+        text_preview += "\n... (truncated)"
+    
+    result_parts.append(f"📄 Content Preview:")
+    result_parts.append(text_preview)
+    
+    return "\n".join(result_parts)
+
+
+def _parse_image_content(image_bytes: bytes, content_type: str, include_preview: bool = False) -> str:
+    """Parse image content and extract metadata."""
+    result_parts = []
+    result_parts.append(f"🖼️  Image Analysis ({content_type})")
+    
+    result_parts.append(f"📊 Size: {len(image_bytes):,} bytes")
+    
+    # Try to get image dimensions (basic approach)
+    try:
+        if content_type.startswith('image/jpeg') or content_type.startswith('image/jpg'):
+            # Basic JPEG header parsing for dimensions
+            if image_bytes.startswith(b'\xff\xd8\xff'):
+                result_parts.append("✅ Valid JPEG format detected")
+        elif content_type.startswith('image/png'):
+            # Basic PNG header parsing
+            if image_bytes.startswith(b'\x89PNG\r\n\x1a\n'):
+                result_parts.append("✅ Valid PNG format detected")
+        elif content_type.startswith('image/gif'):
+            if image_bytes.startswith(b'GIF87a') or image_bytes.startswith(b'GIF89a'):
+                result_parts.append("✅ Valid GIF format detected")
+    except Exception:
+        pass
+    
+    if include_preview:
+        # Provide base64 preview for small images
+        if len(image_bytes) <= 1048576:  # 1MB limit for preview
+            b64_preview = base64.b64encode(image_bytes[:1024]).decode('ascii')  # First 1KB
+            result_parts.append(f"🔍 Base64 Preview (first 1KB):")
+            result_parts.append(f"{b64_preview}...")
+        else:
+            result_parts.append("⚠️  Image too large for base64 preview")
+    
+    result_parts.append("💡 Use image processing tools for detailed analysis")
+    
+    return "\n".join(result_parts)
+
+
+def _parse_pdf_content(pdf_bytes: bytes, include_preview: bool = False) -> str:
+    """Parse PDF content and extract basic metadata."""
+    result_parts = []
+    result_parts.append("📄 PDF Document Analysis")
+    
+    result_parts.append(f"📊 Size: {len(pdf_bytes):,} bytes")
+    
+    # Check PDF header
+    if pdf_bytes.startswith(b'%PDF-'):
+        try:
+            version_line = pdf_bytes[:20].decode('ascii', errors='ignore')
+            result_parts.append(f"✅ Valid PDF format: {version_line.strip()}")
+        except:
+            result_parts.append("✅ Valid PDF format detected")
+    else:
+        result_parts.append("⚠️  Invalid PDF format - missing PDF header")
+    
+    if include_preview:
+        # Show hex preview of first few bytes
+        hex_preview = ' '.join(f'{b:02x}' for b in pdf_bytes[:64])
+        result_parts.append(f"🔍 Hex Preview (first 64 bytes):")
+        result_parts.append(hex_preview)
+    
+    result_parts.append("💡 Use PDF processing tools for text extraction and detailed analysis")
+    
+    return "\n".join(result_parts)
+
+
+def _parse_binary_content(binary_bytes: bytes, content_type: str, include_preview: bool = False) -> str:
+    """Parse generic binary content."""
+    result_parts = []
+    result_parts.append(f"📦 Binary Content Analysis ({content_type})")
+    
+    result_parts.append(f"📊 Size: {len(binary_bytes):,} bytes")
+    
+    # Detect file type by magic bytes
+    magic_signatures = {
+        b'\x50\x4b\x03\x04': 'ZIP archive',
+        b'\x50\x4b\x05\x06': 'ZIP archive (empty)',
+        b'\x50\x4b\x07\x08': 'ZIP archive (spanned)',
+        b'\x1f\x8b\x08': 'GZIP compressed',
+        b'\x42\x5a\x68': 'BZIP2 compressed',
+        b'\x37\x7a\xbc\xaf\x27\x1c': '7-Zip archive',
+        b'\x52\x61\x72\x21\x1a\x07': 'RAR archive',
+        b'\x89\x50\x4e\x47\x0d\x0a\x1a\x0a': 'PNG image',
+        b'\xff\xd8\xff': 'JPEG image',
+        b'\x47\x49\x46\x38': 'GIF image',
+        b'\x25\x50\x44\x46': 'PDF document',
+        b'\xd0\xcf\x11\xe0\xa1\xb1\x1a\xe1': 'Microsoft Office document',
+        b'\x4d\x5a': 'Windows executable'
+    }
+    
+    detected_type = None
+    for signature, file_type in magic_signatures.items():
+        if binary_bytes.startswith(signature):
+            detected_type = file_type
+            break
+    
+    if detected_type:
+        result_parts.append(f"🔍 Detected format: {detected_type}")
+    
+    if include_preview:
+        # Show hex preview
+        hex_preview = ' '.join(f'{b:02x}' for b in binary_bytes[:64])
+        result_parts.append(f"🔍 Hex Preview (first 64 bytes):")
+        result_parts.append(hex_preview)
+        
+        # Try to show any readable ASCII strings
+        try:
+            ascii_preview = ''.join(chr(b) if 32 <= b <= 126 else '.' for b in binary_bytes[:200])
+            if ascii_preview.strip():
+                result_parts.append(f"📝 ASCII Preview (first 200 bytes):")
+                result_parts.append(ascii_preview)
+        except:
+            pass
+    
+    result_parts.append("💡 Use specialized tools for detailed binary analysis")
+    
+    return "\n".join(result_parts)
 
 
 @tool(
@@ -1524,5 +2173,6 @@ __all__ = [
     'write_file',
     'edit_file',
     'web_search',
+    'fetch_url',
     'execute_command'
 ]

abstractcore/utils/version.py

@@ -11,4 +11,4 @@ including when the package is installed from PyPI where pyproject.toml is not av
 
 # Package version - update this when releasing new versions
 # This must be manually synchronized with the version in pyproject.toml
-__version__ = "2.4.5"
+__version__ = "2.4.6"

{abstractcore-2.4.5.dist-info → abstractcore-2.4.6.dist-info}/METADATA

@@ -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.dist-info → abstractcore-2.4.6.dist-info}/RECORD

@@ -17,9 +17,9 @@ abstractcore/cli/vision_config.py,sha256=jJzO4zBexh8SqSKp6YKOXdMDSv4AL4Ztl5Xi-5c
 abstractcore/core/__init__.py,sha256=2h-86U4QkCQ4gzZ4iRusSTMlkODiUS6tKjZHiEXz6rM,684
 abstractcore/core/enums.py,sha256=BhkVnHC-X1_377JDmqd-2mnem9GdBLqixWlYzlP_FJU,695
 abstractcore/core/factory.py,sha256=UdrNwQAvifvFS3LMjF5KO87m-2n1bJBryTs9pvesYcI,2804
-abstractcore/core/interface.py,sha256=XTvtP1YY_2dSlSdKWkkDK54VtEeUt97zIDR1tXTtn8Q,13876
+abstractcore/core/interface.py,sha256=-VAY0nlsTnWN_WghiuMC7iE7xUdZfYOg6KlgrAPi14Y,14086
 abstractcore/core/retry.py,sha256=wNlUAxfmvdO_uVWb4iqkhTqd7O1oRwXxqvVQaLXQOw0,14538
-abstractcore/core/session.py,sha256=iU_fU7f7E6HxwkV97QnSMJSF6rOIuJyT6sQGf547S6s,35347
+abstractcore/core/session.py,sha256=cYmQv9m69ivpZXfR-a2xasbBRiP4IZt-9QDuuT6eHKw,36462
 abstractcore/core/types.py,sha256=KT9Gf9ei4t0QnWBH72fFa8vR7UZSKI-CJyQjU9ynE8g,3642
 abstractcore/embeddings/__init__.py,sha256=hR3xZyqcRm4c2pq1dIa5lxj_-Bk70Zad802JQN4joWo,637
 abstractcore/embeddings/manager.py,sha256=uFVbRPHx_R-kVMVA7N7_7EzeUmCJCeN9Dv0EV8Jko24,52245
@@ -48,14 +48,14 @@ abstractcore/processing/basic_extractor.py,sha256=3x-3BdIHgLvqLnLF6K1-P4qVaLIpAn
 abstractcore/processing/basic_judge.py,sha256=tKWJrg_tY4vCHzWgXxz0ZjgLXBYYfpMcpG7vl03hJcM,32218
 abstractcore/processing/basic_summarizer.py,sha256=XHNxMQ_8aLStTeUo6_2JaThlct12Htpz7ORmm0iuJsg,25495
 abstractcore/providers/__init__.py,sha256=t8Kp4flH5GvZEC6dx-iYJSPeSxMODa2spXb8MqtlPy4,1282
-abstractcore/providers/anthropic_provider.py,sha256=tcOrARLd1kA4vRkH7MCgy99YIGVaegdCd3-Z8UaKP3Q,20705
-abstractcore/providers/base.py,sha256=5YR64kqTYiCvWtIUBul5QfO0XRZr6_Aiho4atpDOh0o,50579
-abstractcore/providers/huggingface_provider.py,sha256=mJGfi1lgsvjV3Lj4q7KCQZhQqw_o23af40i5WLg150o,47789
-abstractcore/providers/lmstudio_provider.py,sha256=oPL_Y4gkJMAniecdWQVaDi7WozCZumSRs0lE7uFgvQk,20406
-abstractcore/providers/mlx_provider.py,sha256=61i5VhpNw_QlhOwPcEcryaGbI45aYyL9q15TrpinIgs,17427
+abstractcore/providers/anthropic_provider.py,sha256=4DsHpfJ5iVnIB6gOL4iZGRjoR0R5kJhKdO5jG06iUmo,21287
+abstractcore/providers/base.py,sha256=YfrqM3c7wLT19vspL7goUO6Bv-z1691ZkCM2wxvQX4s,51501
+abstractcore/providers/huggingface_provider.py,sha256=v12JzpZ0Ra6OGD2aWcNdBMLxWytrW3gsSnzrr7F-rnA,48500
+abstractcore/providers/lmstudio_provider.py,sha256=NbhJMd3RjZ9nSIfy9lVmGAnxH8eGPz5ogRsN8YQfsl0,20629
+abstractcore/providers/mlx_provider.py,sha256=vbuv6lEfAURb6Dvcx7tpjV5woi5oZuZGsqwPBqiZ2EQ,18157
 abstractcore/providers/mock_provider.py,sha256=tIjA57Hlwu3vNODOZShNn0tY9HWvz1p4z-HyD_bsvbo,5741
-abstractcore/providers/ollama_provider.py,sha256=O77Nzx0erQw8D5TlyVaunIOjluaRwi8bgYVO95qK0L4,21129
-abstractcore/providers/openai_provider.py,sha256=gHurjXwwKvKQtkK5cqwokW_DUTY9_bsfNm06RPvQ39g,22683
+abstractcore/providers/ollama_provider.py,sha256=7p4BcCZ0UJabjw_lHzBqjQvtoEJYOj_NI511QjjWaSc,21361
+abstractcore/providers/openai_provider.py,sha256=3cm0TG2gbuoBDkoQmsliH9SBZCwL7hnKuzzDmwU3K4E,22853
 abstractcore/providers/registry.py,sha256=c0hxp9RRa-uipGotaAu48fHXc_HGlLcOxC1k763mzhU,16596
 abstractcore/providers/streaming.py,sha256=VnffBV_CU9SAKzghL154OoFyEdDsiLwUNXPahyU41Bw,31342
 abstractcore/server/__init__.py,sha256=1DSAz_YhQtnKv7sNi5TMQV8GFujctDOabgvAdilQE0o,249
@@ -64,7 +64,7 @@ abstractcore/structured/__init__.py,sha256=VXRQHGcm-iaYnLOBPin2kyhvhhQA0kaGt_pcN
 abstractcore/structured/handler.py,sha256=Vb15smiR81JGDXX2RLkY2Exuj67J7a6C-xwVrZoXp0I,17134
 abstractcore/structured/retry.py,sha256=BN_PvrWybyU1clMy2cult1-TVxFSMaVqiCPmmXvA5aI,3805
 abstractcore/tools/__init__.py,sha256=oh6vG0RdM1lqUtOp95mLrTsWLh9VmhJf5_FVjGIP5_M,2259
-abstractcore/tools/common_tools.py,sha256=jRVvu-TQbmXBOZHn00zEZb44nenaXVtdemhKmRmt1YY,64496
+abstractcore/tools/common_tools.py,sha256=GkUSnBum3zMm9M-Zd9LlJQmlDp1XDssC7z8ItUcbloc,91692
 abstractcore/tools/core.py,sha256=lUUGihyceiRYlKUFvEMig9jWFF563d574mSDbYYD3fM,4777
 abstractcore/tools/handler.py,sha256=GmDenXAJkhceWSGlhvuF90aMb2301tRTh6WxGwBQifc,12022
 abstractcore/tools/parser.py,sha256=1r5nmEEp1Rid3JU6ct-s3lP-eCln67fvXG5HCjqiRew,27740
@@ -77,10 +77,10 @@ abstractcore/utils/message_preprocessor.py,sha256=GdHkm6tmrgjm3PwHRSCjIsq1XLkbhy
 abstractcore/utils/self_fixes.py,sha256=QEDwNTW80iQM4ftfEY3Ghz69F018oKwLM9yeRCYZOvw,5886
 abstractcore/utils/structured_logging.py,sha256=Vm-HviSa42G9DJCWmaEv4a0QG3NMsADD3ictLOs4En0,19952
 abstractcore/utils/token_utils.py,sha256=eLwFmJ68p9WMFD_MHLMmeJRW6Oqx_4hKELB8FNQ2Mnk,21097
-abstractcore/utils/version.py,sha256=WKRMOS_TRIxsNu-vJqfCYHA335-rya9xBBMzhx_S-Z8,605
-abstractcore-2.4.5.dist-info/licenses/LICENSE,sha256=PI2v_4HMvd6050uDD_4AY_8PzBnu2asa3RKbdDjowTA,1078
-abstractcore-2.4.5.dist-info/METADATA,sha256=9w6Q7NZXePxhRYnmloyJ6Nd2DFQ7YY4294OMF-6QYuY,27596
-abstractcore-2.4.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-abstractcore-2.4.5.dist-info/entry_points.txt,sha256=UdVmchBC_Lt3H4Vlkt5js-QDAkVlBbkCu1yCsswk-KE,454
-abstractcore-2.4.5.dist-info/top_level.txt,sha256=DiNHBI35SIawW3N9Z-z0y6cQYNbXd32pvBkW0RLfScs,13
-abstractcore-2.4.5.dist-info/RECORD,,
+abstractcore/utils/version.py,sha256=r8Rzbfb6YwcUi9ek9BN0m6rVNtA2oImg_hOzRFnS2CE,605
+abstractcore-2.4.6.dist-info/licenses/LICENSE,sha256=PI2v_4HMvd6050uDD_4AY_8PzBnu2asa3RKbdDjowTA,1078
+abstractcore-2.4.6.dist-info/METADATA,sha256=agFFlRyASBw8uDKCAmchMdvggXjPydMHTfARd4GQqcU,29749
+abstractcore-2.4.6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+abstractcore-2.4.6.dist-info/entry_points.txt,sha256=UdVmchBC_Lt3H4Vlkt5js-QDAkVlBbkCu1yCsswk-KE,454
+abstractcore-2.4.6.dist-info/top_level.txt,sha256=DiNHBI35SIawW3N9Z-z0y6cQYNbXd32pvBkW0RLfScs,13
+abstractcore-2.4.6.dist-info/RECORD,,