abstractcore 2.4.6__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/session.py

@@ -760,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

@@ -186,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/huggingface_provider.py

@@ -863,6 +863,9 @@ class HuggingFaceProvider(BaseProvider):
                 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,
@@ -874,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()
@@ -885,34 +890,41 @@ 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,

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:
@@ -225,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()
 
@@ -252,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

@@ -266,6 +266,9 @@ class MLXProvider(BaseProvider):
             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
@@ -288,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()
 
@@ -295,21 +300,25 @@ 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, seed: Optional[int] = None) -> Iterator[GenerateResponse]:

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

@@ -225,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()
 
@@ -246,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

abstractcore/providers/openai_provider.py

@@ -169,8 +169,14 @@ class OpenAIProvider(BaseProvider):
             if stream:
                 return self._stream_response(call_params, tools)
             else:
+                # Track generation time
+                start_time = time.time()
                 response = self.client.chat.completions.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 OpenAI native responses
                 if tools and formatted.has_tool_calls():
@@ -216,13 +222,16 @@ class OpenAIProvider(BaseProvider):
                     "arguments": tc.function.arguments
                 })
 
-        # Build usage dict with detailed breakdown
+        # Build usage dict with consistent terminology
         usage = None
         if hasattr(response, 'usage'):
             usage = {
+                "input_tokens": response.usage.prompt_tokens,
+                "output_tokens": response.usage.completion_tokens,
+                "total_tokens": response.usage.total_tokens,
+                # Keep legacy keys for backward compatibility
                 "prompt_tokens": response.usage.prompt_tokens,
-                "completion_tokens": response.usage.completion_tokens,
-                "total_tokens": response.usage.total_tokens
+                "completion_tokens": response.usage.completion_tokens
             }
 
             # Add detailed token breakdown for reasoning models

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.6"
+__version__ = "2.4.7"

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: abstractcore
-Version: 2.4.6
+Version: 2.4.7
 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>
@@ -29,6 +29,7 @@ License-File: LICENSE
 Requires-Dist: pydantic<3.0.0,>=2.0.0
 Requires-Dist: httpx<1.0.0,>=0.24.0
 Requires-Dist: tiktoken<1.0.0,>=0.5.0
+Requires-Dist: requests<3.0.0,>=2.25.0
 Provides-Extra: openai
 Requires-Dist: openai<2.0.0,>=1.0.0; extra == "openai"
 Provides-Extra: anthropic
@@ -46,6 +47,11 @@ Provides-Extra: embeddings
 Requires-Dist: sentence-transformers<4.0.0,>=2.7.0; extra == "embeddings"
 Requires-Dist: numpy<2.0.0,>=1.20.0; extra == "embeddings"
 Provides-Extra: processing
+Provides-Extra: tools
+Requires-Dist: beautifulsoup4<5.0.0,>=4.12.0; extra == "tools"
+Requires-Dist: lxml<6.0.0,>=4.9.0; extra == "tools"
+Requires-Dist: duckduckgo-search<4.0.0,>=3.8.0; extra == "tools"
+Requires-Dist: psutil<6.0.0,>=5.9.0; extra == "tools"
 Provides-Extra: media
 Requires-Dist: Pillow<12.0.0,>=10.0.0; extra == "media"
 Requires-Dist: pymupdf4llm<1.0.0,>=0.0.20; extra == "media"
@@ -60,9 +66,9 @@ Requires-Dist: abstractcore[huggingface]; extra == "heavy-providers"
 Provides-Extra: all-providers
 Requires-Dist: abstractcore[anthropic,embeddings,huggingface,lmstudio,mlx,ollama,openai]; extra == "all-providers"
 Provides-Extra: all
-Requires-Dist: abstractcore[anthropic,dev,docs,embeddings,huggingface,lmstudio,media,mlx,ollama,openai,processing,server,test]; extra == "all"
+Requires-Dist: abstractcore[anthropic,dev,docs,embeddings,huggingface,lmstudio,media,mlx,ollama,openai,processing,server,test,tools]; extra == "all"
 Provides-Extra: lightweight
-Requires-Dist: abstractcore[anthropic,embeddings,lmstudio,media,ollama,openai,processing,server]; extra == "lightweight"
+Requires-Dist: abstractcore[anthropic,embeddings,lmstudio,media,ollama,openai,processing,server,tools]; extra == "lightweight"
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0.0; extra == "dev"
 Requires-Dist: pytest-asyncio>=0.21.0; extra == "dev"
@@ -89,7 +95,7 @@ Requires-Dist: mkdocs-material>=9.0.0; extra == "docs"
 Requires-Dist: mkdocstrings[python]>=0.22.0; extra == "docs"
 Requires-Dist: mkdocs-autorefs>=0.4.0; extra == "docs"
 Provides-Extra: full-dev
-Requires-Dist: abstractcore[all-providers,dev,docs,test]; extra == "full-dev"
+Requires-Dist: abstractcore[all-providers,dev,docs,test,tools]; extra == "full-dev"
 Dynamic: license-file
 
 # AbstractCore
@@ -155,6 +161,45 @@ response = llm.generate(
 print(response.content)
 ```
 
+### Response Object (GenerateResponse)
+
+Every LLM generation returns a **GenerateResponse** object with consistent structure across all providers:
+
+```python
+from abstractcore import create_llm
+
+llm = create_llm("openai", model="gpt-4o-mini")
+response = llm.generate("Explain quantum computing in simple terms")
+
+# Core response data
+print(f"Content: {response.content}")               # Generated text
+print(f"Model: {response.model}")                   # Model used
+print(f"Finish reason: {response.finish_reason}")   # Why generation stopped
+
+# Consistent token access across ALL providers (NEW in v2.4.7)
+print(f"Input tokens: {response.input_tokens}")     # Always available
+print(f"Output tokens: {response.output_tokens}")   # Always available  
+print(f"Total tokens: {response.total_tokens}")     # Always available
+
+# Generation time tracking (NEW in v2.4.7)
+print(f"Generation time: {response.gen_time}ms")    # Always available (rounded to 1 decimal)
+
+# Advanced access
+print(f"Tool calls: {response.tool_calls}")         # Tools executed (if any)
+print(f"Raw usage: {response.usage}")               # Provider-specific token data
+print(f"Metadata: {response.metadata}")             # Additional context
+
+# Comprehensive summary
+print(f"Summary: {response.get_summary()}")         # "Model: gpt-4o-mini | Tokens: 117 | Time: 1234.5ms"
+```
+
+**Token Count Sources:**
+- **Provider APIs**: OpenAI, Anthropic, LMStudio (native API token counts)
+- **AbstractCore Calculation**: MLX, HuggingFace, Mock (using `token_utils.py`)
+- **Mixed Sources**: Ollama (combination of provider and calculated tokens)
+
+**Backward Compatibility**: Legacy `prompt_tokens` and `completion_tokens` keys remain available in `response.usage` dictionary.
+
 ### Built-in Tools
 
 AbstractCore includes a comprehensive set of ready-to-use tools for common tasks:
@@ -271,6 +316,7 @@ response = llm.generate(
 - **Session Management**: Persistent conversations with metadata, analytics, and complete serialization
 - **Structured Responses**: Clean, predictable output formats with Pydantic
 - **Streaming Support**: Real-time token generation for interactive experiences
+- **Consistent Token Terminology**: Unified `input_tokens`, `output_tokens`, `total_tokens` across all providers
 - **Embeddings**: Built-in support for semantic search and RAG applications
 - **Universal Server**: Optional OpenAI-compatible API server with `/v1/responses` endpoint
 

{abstractcore-2.4.6.dist-info → abstractcore-2.4.7.dist-info}/RECORD

@@ -1,4 +1,4 @@
-abstractcore/__init__.py,sha256=7ucTDQXINslx23n-vaFOeFzRAYi76Enqak2S3rjaZLU,1861
+abstractcore/__init__.py,sha256=A7Gbn_C-robdWLLQXjtTyWsoaXDGIblSFmLRV_ni6O8,1934
 abstractcore/apps/__init__.py,sha256=sgNOv3lYyOWNBC-w6GnRN6aILGCbdkQtNcuQdJz5ghE,31
 abstractcore/apps/__main__.py,sha256=041daYkoIE1VLEO19IZC5nNIDOQZWNgpB7ogJ3SOlsE,1585
 abstractcore/apps/app_config_utils.py,sha256=GygjtkianBktRvirHya1KbXuB2r5OUDJM6ilvybQWvk,875
@@ -10,7 +10,7 @@ abstractcore/architectures/detection.py,sha256=Cxap1pL6qOJjyY22Vc4hzbLALTuuBisPT
 abstractcore/architectures/enums.py,sha256=9vIv2vDBEKhxwzwH9iaSAyf-iVj3p8y9loMeN_mYTJ8,3821
 abstractcore/assets/architecture_formats.json,sha256=CIf6SaR_IJs1D7Uvd1K3zWngIXJ_yq3DM_IE3wnpCHY,16076
 abstractcore/assets/model_capabilities.json,sha256=iUkDiljyZUZzPlpYCOFgStXyc6e7dvOfReYQ0HFrX9Q,49703
-abstractcore/assets/session_schema.json,sha256=b6HTAWxRVlVhAzA7FqaKpunK1yO6jilBOsD5sQkqJTo,10580
+abstractcore/assets/session_schema.json,sha256=hMCVrq3KSyVExrMGzuykf7bU-z6WyIVuEGU8du9_zUY,10570
 abstractcore/cli/__init__.py,sha256=rUjLjZSK3wENSw4g_iN43Bc2i5cggcEmj4NPXBMohdc,241
 abstractcore/cli/main.py,sha256=QD38nnfrInavO452WbkXCI37SVsdIu9VhvjEOojXBGY,31834
 abstractcore/cli/vision_config.py,sha256=jJzO4zBexh8SqSKp6YKOXdMDSv4AL4Ztl5Xi-5c4KyY,17869
@@ -19,8 +19,8 @@ abstractcore/core/enums.py,sha256=BhkVnHC-X1_377JDmqd-2mnem9GdBLqixWlYzlP_FJU,69
 abstractcore/core/factory.py,sha256=UdrNwQAvifvFS3LMjF5KO87m-2n1bJBryTs9pvesYcI,2804
 abstractcore/core/interface.py,sha256=-VAY0nlsTnWN_WghiuMC7iE7xUdZfYOg6KlgrAPi14Y,14086
 abstractcore/core/retry.py,sha256=wNlUAxfmvdO_uVWb4iqkhTqd7O1oRwXxqvVQaLXQOw0,14538
-abstractcore/core/session.py,sha256=cYmQv9m69ivpZXfR-a2xasbBRiP4IZt-9QDuuT6eHKw,36462
-abstractcore/core/types.py,sha256=KT9Gf9ei4t0QnWBH72fFa8vR7UZSKI-CJyQjU9ynE8g,3642
+abstractcore/core/session.py,sha256=fdqhnufCWrV022RjQ-Xfb1KFv_s9-GzetSSR-QuXv-Q,36452
+abstractcore/core/types.py,sha256=jj44i07kMjdg9FQ3mA_fK6r_M0Lcgt1RQpy1Ra5w-eI,4578
 abstractcore/embeddings/__init__.py,sha256=hR3xZyqcRm4c2pq1dIa5lxj_-Bk70Zad802JQN4joWo,637
 abstractcore/embeddings/manager.py,sha256=uFVbRPHx_R-kVMVA7N7_7EzeUmCJCeN9Dv0EV8Jko24,52245
 abstractcore/embeddings/models.py,sha256=bsPAzL6gv57AVii8O15PT0kxfwRkOml3f3njJN4UDi4,4874
@@ -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=4DsHpfJ5iVnIB6gOL4iZGRjoR0R5kJhKdO5jG06iUmo,21287
+abstractcore/providers/anthropic_provider.py,sha256=R87Z_DNNdeA4LMSxx84pqo8saKFz38dHCJMBpc-rL70,21552
 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=7p4BcCZ0UJabjw_lHzBqjQvtoEJYOj_NI511QjjWaSc,21361
-abstractcore/providers/openai_provider.py,sha256=3cm0TG2gbuoBDkoQmsliH9SBZCwL7hnKuzzDmwU3K4E,22853
+abstractcore/providers/huggingface_provider.py,sha256=pgpeSwpwyNB_5GDyLEz2OSTu9me-GAJzQ116dGtpCvQ,49012
+abstractcore/providers/lmstudio_provider.py,sha256=odT6luVR3POVcq2ZqkINLyLoCAu_YGpLLj3fEddNliU,21021
+abstractcore/providers/mlx_provider.py,sha256=sDgxf_kVJJwxprQWVef9w2CLOu2dLES8D0Vf5tY6PzE,18463
+abstractcore/providers/mock_provider.py,sha256=x-frlBLxlqx6jlMoPnZN4aNv1pHacRYW_jlp0peI9FA,6168
+abstractcore/providers/ollama_provider.py,sha256=1bE80NCj_TQADxRCiu9luyLuI_gZe2EO5pCKoC4VhQM,21740
+abstractcore/providers/openai_provider.py,sha256=1s7JJalyIBOvLB7UAUwXbTc2aYrYSWg7hJjKGnCX1qU,23313
 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
@@ -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=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,,
+abstractcore/utils/version.py,sha256=ktMUN5ql9UjgEbvyoT7ilNbOyvAiVtrcRN8hl3eQSvc,605
+abstractcore-2.4.7.dist-info/licenses/LICENSE,sha256=PI2v_4HMvd6050uDD_4AY_8PzBnu2asa3RKbdDjowTA,1078
+abstractcore-2.4.7.dist-info/METADATA,sha256=NZiFyhk87Pq3Pe-L7E0xo37RawH6YlFhhBiYp26Ocmc,31913
+abstractcore-2.4.7.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+abstractcore-2.4.7.dist-info/entry_points.txt,sha256=UdVmchBC_Lt3H4Vlkt5js-QDAkVlBbkCu1yCsswk-KE,454
+abstractcore-2.4.7.dist-info/top_level.txt,sha256=DiNHBI35SIawW3N9Z-z0y6cQYNbXd32pvBkW0RLfScs,13
+abstractcore-2.4.7.dist-info/RECORD,,