abstractcore 2.4.6__py3-none-any.whl → 2.4.8__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/factory.py

@@ -12,7 +12,7 @@ def create_llm(provider: str, model: Optional[str] = None, **kwargs) -> Abstract
     Create an LLM provider instance with unified token parameter support.
 
     Args:
-        provider: Provider name (openai, anthropic, ollama, huggingface, mlx, lmstudio, mock)
+        provider: Provider name (openai, anthropic, ollama, huggingface, mlx, lmstudio)
         model: Model name (optional, will use provider default)
         **kwargs: Additional configuration including token parameters
 

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/__init__.py

@@ -7,7 +7,6 @@ from .ollama_provider import OllamaProvider
 from .lmstudio_provider import LMStudioProvider
 from .huggingface_provider import HuggingFaceProvider
 from .mlx_provider import MLXProvider
-from .mock_provider import MockProvider
 
 # Provider registry for centralized provider discovery and management
 from .registry import (
@@ -32,7 +31,6 @@ __all__ = [
     'LMStudioProvider',
     'HuggingFaceProvider',
     'MLXProvider',
-    'MockProvider',
 
     # Provider registry
     'ProviderRegistry',

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/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/providers/registry.py

@@ -136,19 +136,6 @@ class ProviderRegistry:
             import_path="..providers.huggingface_provider"
         ))
 
-        # Mock Provider
-        self.register_provider(ProviderInfo(
-            name="mock",
-            display_name="Mock",
-            provider_class=None,
-            description="Testing provider for development and unit tests",
-            default_model="mock-model",
-            supported_features=["chat", "completion", "embeddings", "prompted_tools", "streaming", "testing"],
-            authentication_required=False,
-            local_provider=True,
-            installation_extras=None,
-            import_path="..providers.mock_provider"
-        ))
 
     def register_provider(self, provider_info: ProviderInfo):
         """Register a provider in the registry."""
@@ -182,10 +169,7 @@ class ProviderRegistry:
     def _load_provider_class(self, provider_info: ProviderInfo):
         """Dynamically load a provider class."""
         try:
-            if provider_info.name == "mock":
-                from ..providers.mock_provider import MockProvider
-                return MockProvider
-            elif provider_info.name == "openai":
+            if provider_info.name == "openai":
                 from ..providers.openai_provider import OpenAIProvider
                 return OpenAIProvider
             elif provider_info.name == "anthropic":

abstractcore/server/app.py

@@ -1101,7 +1101,6 @@ async def list_providers():
     - **LMStudio**: Local model development and testing platform
     - **MLX**: Apple Silicon optimized local inference
     - **HuggingFace**: Access to HuggingFace models (transformers and embeddings)
-    - **Mock**: Testing provider for development
 
     **Use Cases:**
     - Discover available providers before making requests

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.8"

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: abstractcore
-Version: 2.4.6
+Version: 2.4.8
 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 (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.8.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,17 +10,17 @@ 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
 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/factory.py,sha256=ec7WGW2JKK-dhDplziTAeRkebEUFymtEEZ_bS5qkpqY,2798
 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
@@ -47,19 +47,18 @@ abstractcore/processing/__init__.py,sha256=t6hiakQjcZROT4pw9ZFt2q6fF3vf5VpdMKG2E
 abstractcore/processing/basic_extractor.py,sha256=3x-3BdIHgLvqLnLF6K1-P4qVaLIpAnNIIutaJi7lDQM,49832
 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/__init__.py,sha256=n-2RMNm3QpKxHw9EOjv8icRMRnfJp5Xg0uSVzHCW3BI,1222
+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/registry.py,sha256=c0hxp9RRa-uipGotaAu48fHXc_HGlLcOxC1k763mzhU,16596
+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/ollama_provider.py,sha256=1bE80NCj_TQADxRCiu9luyLuI_gZe2EO5pCKoC4VhQM,21740
+abstractcore/providers/openai_provider.py,sha256=1s7JJalyIBOvLB7UAUwXbTc2aYrYSWg7hJjKGnCX1qU,23313
+abstractcore/providers/registry.py,sha256=fKFrN6Z3o5Gi0dfwvXDPtrrJXDjx9oPSfjWjZf-NJBc,15883
 abstractcore/providers/streaming.py,sha256=VnffBV_CU9SAKzghL154OoFyEdDsiLwUNXPahyU41Bw,31342
 abstractcore/server/__init__.py,sha256=1DSAz_YhQtnKv7sNi5TMQV8GFujctDOabgvAdilQE0o,249
-abstractcore/server/app.py,sha256=2ChRxdpMyGVCjsQPWWpPNtqdtfIIhbpF3uLuTCiF6lo,96629
+abstractcore/server/app.py,sha256=7pG5ZkZqYNnyby4jyvp3_NKl5nNDmZpOhv_-F8Jruy4,96580
 abstractcore/structured/__init__.py,sha256=VXRQHGcm-iaYnLOBPin2kyhvhhQA0kaGt_pcNDGsE_8,339
 abstractcore/structured/handler.py,sha256=Vb15smiR81JGDXX2RLkY2Exuj67J7a6C-xwVrZoXp0I,17134
 abstractcore/structured/retry.py,sha256=BN_PvrWybyU1clMy2cult1-TVxFSMaVqiCPmmXvA5aI,3805
@@ -77,10 +76,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=4vhW55aGVOlb2i9Zm_ZxoGAPd5qtSm6ZN1WmH15tBYs,605
+abstractcore-2.4.8.dist-info/licenses/LICENSE,sha256=PI2v_4HMvd6050uDD_4AY_8PzBnu2asa3RKbdDjowTA,1078
+abstractcore-2.4.8.dist-info/METADATA,sha256=UfLD0Zi-Mco6B9NkoWuypgHZuUPJeGYyJVJjBBPlpsA,31907
+abstractcore-2.4.8.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+abstractcore-2.4.8.dist-info/entry_points.txt,sha256=UdVmchBC_Lt3H4Vlkt5js-QDAkVlBbkCu1yCsswk-KE,454
+abstractcore-2.4.8.dist-info/top_level.txt,sha256=DiNHBI35SIawW3N9Z-z0y6cQYNbXd32pvBkW0RLfScs,13
+abstractcore-2.4.8.dist-info/RECORD,,

abstractcore/providers/mock_provider.py

@@ -1,157 +0,0 @@
-"""
-Mock provider for testing purposes.
-"""
-
-from typing import List, Dict, Any, Optional, Union, Iterator, Type
-
-try:
-    from pydantic import BaseModel
-    PYDANTIC_AVAILABLE = True
-except ImportError:
-    PYDANTIC_AVAILABLE = False
-    BaseModel = None
-
-from .base import BaseProvider
-from ..core.types import GenerateResponse
-
-
-class MockProvider(BaseProvider):
-    """Simple mock provider for testing core functionality."""
-
-    def __init__(self, model: str = "mock-model", **kwargs):
-        super().__init__(model, **kwargs)
-        
-        # Handle timeout parameter for mock provider
-        self._handle_timeout_parameter(kwargs)
-        
-        # Mock provider uses prompted strategy for structured output
-        self.model_capabilities = {"structured_output": "prompted"}
-
-    def generate(self, *args, **kwargs):
-        """Public generate method that includes telemetry"""
-        return self.generate_with_telemetry(*args, **kwargs)
-
-    def _generate_internal(self,
-                          prompt: str,
-                          messages: Optional[List[Dict[str, str]]] = None,
-                          system_prompt: Optional[str] = None,
-                          tools: Optional[List[Dict[str, Any]]] = None,
-                          stream: bool = False,
-                          response_model: Optional[Type[BaseModel]] = None,
-                          **kwargs) -> Union[GenerateResponse, Iterator[GenerateResponse]]:
-        """Mock generation implementation"""
-
-        if stream:
-            return self._stream_response(prompt)
-        else:
-            return self._single_response(prompt, response_model)
-
-    def _single_response(self, prompt: str, response_model: Optional[Type[BaseModel]] = None) -> GenerateResponse:
-        """Generate single mock response"""
-
-        if response_model and PYDANTIC_AVAILABLE:
-            # Generate valid JSON for structured output
-            content = self._generate_mock_json(response_model)
-        else:
-            content = f"Mock response to: {prompt}"
-
-        return GenerateResponse(
-            content=content,
-            model=self.model,
-            finish_reason="stop",
-            usage=self._calculate_mock_usage(prompt, content)
-        )
-
-    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
-        
-        return {
-            "prompt_tokens": prompt_tokens,
-            "completion_tokens": completion_tokens, 
-            "total_tokens": total_tokens
-        }
-
-    def _stream_response(self, prompt: str) -> Iterator[GenerateResponse]:
-        """Generate streaming mock responses"""
-        words = f"Mock response to: {prompt}".split()
-        for i, word in enumerate(words):
-            yield GenerateResponse(
-                content=word + (" " if i < len(words) - 1 else ""),
-                model=self.model,
-                finish_reason="stop" if i == len(words) - 1 else None
-            )
-
-    def _generate_mock_json(self, model_class: Type[BaseModel]) -> str:
-        """Generate valid JSON for Pydantic model"""
-        import json
-
-        # Create mock data based on field types
-        mock_data = {}
-        for field_name, field_info in model_class.model_fields.items():
-            field_type = field_info.annotation
-
-            # Handle basic types
-            if field_type == str:
-                mock_data[field_name] = f"mock_{field_name}"
-            elif field_type == int:
-                mock_data[field_name] = 42
-            elif field_type == float:
-                mock_data[field_name] = 3.14
-            elif field_type == bool:
-                mock_data[field_name] = True
-            else:
-                # For complex types, provide reasonable defaults
-                mock_data[field_name] = f"mock_{field_name}"
-
-        return json.dumps(mock_data)
-
-    def _handle_timeout_parameter(self, kwargs: Dict[str, Any]) -> None:
-        """
-        Handle timeout parameter for Mock provider.
-        
-        Mock provider simulates responses instantly, so timeout parameters
-        don't apply. If a non-None timeout is provided, it's accepted but
-        has no effect on mock generation.
-        
-        Args:
-            kwargs: Initialization kwargs that may contain timeout
-        """
-        timeout_value = kwargs.get('timeout')
-        if timeout_value is not None:
-            # For mock provider, we accept timeout but it has no effect
-            # No warning needed since this is for testing
-            self._timeout = timeout_value
-        else:
-            # Keep None value 
-            self._timeout = None
-
-    def _update_http_client_timeout(self) -> None:
-        """
-        Mock provider doesn't use HTTP clients.
-        Timeout changes have no effect on mock responses.
-        """
-        # No-op for mock provider - no HTTP clients used
-        pass
-
-    def get_capabilities(self) -> List[str]:
-        """Get mock capabilities"""
-        return ["tools", "streaming", "vision"]
-
-    def validate_config(self) -> bool:
-        """Validate mock provider configuration"""
-        return True
-
-    def list_available_models(self, **kwargs) -> List[str]:
-        """List available mock models for testing."""
-        return [
-            "mock-model",
-            "mock-chat-model",
-            "mock-streaming-model",
-            "mock-structured-model",
-            "mock-vision-model"
-        ]