abstractcore 2.4.7__tar.gz → 2.4.9__tar.gz

{abstractcore-2.4.7 → abstractcore-2.4.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: abstractcore
-Version: 2.4.7
+Version: 2.4.9
 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>
@@ -195,7 +195,7 @@ print(f"Summary: {response.get_summary()}")         # "Model: gpt-4o-mini | Toke
 
 **Token Count Sources:**
 - **Provider APIs**: OpenAI, Anthropic, LMStudio (native API token counts)
-- **AbstractCore Calculation**: MLX, HuggingFace, Mock (using `token_utils.py`)
+- **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.

{abstractcore-2.4.7 → abstractcore-2.4.9}/README.md

@@ -95,7 +95,7 @@ print(f"Summary: {response.get_summary()}")         # "Model: gpt-4o-mini | Toke
 
 **Token Count Sources:**
 - **Provider APIs**: OpenAI, Anthropic, LMStudio (native API token counts)
-- **AbstractCore Calculation**: MLX, HuggingFace, Mock (using `token_utils.py`)
+- **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.

{abstractcore-2.4.7 → abstractcore-2.4.9}/abstractcore/apps/app_config_utils.py

@@ -8,7 +8,7 @@ def get_app_defaults(app_name: str) -> tuple[str, str]:
         from ..config import get_config_manager
         config_manager = get_config_manager()
         return config_manager.get_app_default(app_name)
-    except Exception:
+    except (ImportError, Exception):
         # Fallback to hardcoded defaults if config unavailable
         hardcoded_defaults = {
             'summarizer': ('huggingface', 'unsloth/Qwen3-4B-Instruct-2507-GGUF'),

{abstractcore-2.4.7 → abstractcore-2.4.9}/abstractcore/cli/main.py

@@ -38,7 +38,13 @@ from typing import List, Optional
 # Add parent directory to path for imports
 sys.path.insert(0, str(Path(__file__).parent.parent.parent))
 
-from abstractcore.config import get_config_manager
+# Import config manager with fallback
+try:
+    from abstractcore.config import get_config_manager
+    CONFIG_AVAILABLE = True
+except ImportError:
+    CONFIG_AVAILABLE = False
+    get_config_manager = None
 
 def download_vision_model(model_name: str = "blip-base-caption") -> bool:
     """Download a vision model for local use."""
@@ -144,10 +150,12 @@ def download_vision_model(model_name: str = "blip-base-caption") -> bool:
         print(f"📁 Model saved to: {models_dir}")
 
         # Configure AbstractCore to use this model
-        from abstractcore.config import get_config_manager
-        config_manager = get_config_manager()
-        # Use the proper HuggingFace model identifier
-        config_manager.set_vision_provider("huggingface", hf_id)
+        if CONFIG_AVAILABLE:
+            config_manager = get_config_manager()
+            # Use the proper HuggingFace model identifier
+            config_manager.set_vision_provider("huggingface", hf_id)
+        else:
+            print("⚠️  Config system not available - manual configuration required")
 
         print(f"✅ Configured AbstractCore to use HuggingFace model: {hf_id}")
         print(f"🎯 Vision fallback is now enabled!")

{abstractcore-2.4.7 → abstractcore-2.4.9}/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-2.4.7 → abstractcore-2.4.9}/abstractcore/media/vision_fallback.py

@@ -31,14 +31,28 @@ class VisionFallbackHandler:
     def __init__(self, config_manager=None):
         """Initialize with configuration manager."""
         if config_manager is None:
-            from abstractcore.config import get_config_manager
-            self.config_manager = get_config_manager()
+            try:
+                from abstractcore.config import get_config_manager
+                self.config_manager = get_config_manager()
+            except ImportError:
+                # Config module not available - use fallback behavior
+                logger.warning("Config module not available, vision fallback disabled")
+                self.config_manager = None
         else:
             self.config_manager = config_manager
 
     @property
     def vision_config(self):
         """Get vision configuration from unified config system."""
+        if self.config_manager is None:
+            # Return a minimal config object when config system is not available
+            class FallbackVisionConfig:
+                strategy = "disabled"
+                caption_provider = None
+                caption_model = None
+                fallback_chain = []
+                local_models_path = None
+            return FallbackVisionConfig()
         return self.config_manager.config.vision
 
     def create_description(self, image_path: str, user_prompt: str = None) -> str:

{abstractcore-2.4.7 → abstractcore-2.4.9}/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-2.4.7 → abstractcore-2.4.9}/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-2.4.7 → abstractcore-2.4.9}/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-2.4.7 → abstractcore-2.4.9}/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.7"
+__version__ = "2.4.9"

{abstractcore-2.4.7 → abstractcore-2.4.9}/abstractcore.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: abstractcore
-Version: 2.4.7
+Version: 2.4.9
 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>
@@ -195,7 +195,7 @@ print(f"Summary: {response.get_summary()}")         # "Model: gpt-4o-mini | Toke
 
 **Token Count Sources:**
 - **Provider APIs**: OpenAI, Anthropic, LMStudio (native API token counts)
-- **AbstractCore Calculation**: MLX, HuggingFace, Mock (using `token_utils.py`)
+- **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.

{abstractcore-2.4.7 → abstractcore-2.4.9}/abstractcore.egg-info/SOURCES.txt

@@ -62,7 +62,6 @@ abstractcore/providers/base.py
 abstractcore/providers/huggingface_provider.py
 abstractcore/providers/lmstudio_provider.py
 abstractcore/providers/mlx_provider.py
-abstractcore/providers/mock_provider.py
 abstractcore/providers/ollama_provider.py
 abstractcore/providers/openai_provider.py
 abstractcore/providers/registry.py

{abstractcore-2.4.7 → abstractcore-2.4.9}/tests/test_basic_session.py

@@ -6,7 +6,7 @@ import pytest
 from datetime import datetime
 from abstractcore.core.session import BasicSession
 from abstractcore.core.types import Message
-from abstractcore.providers.mock_provider import MockProvider
+from abstractcore.providers.openai_provider import OpenAIProvider
 
 
 class TestBasicSession:
@@ -65,14 +65,17 @@ class TestBasicSession:
         session.clear_history(keep_system=False)
         assert len(session.messages) == 0
 
-    def test_generation_with_mock_provider(self):
-        """Test generation with mock provider"""
-        provider = MockProvider()
-        session = BasicSession(provider=provider)
+    def test_generation_with_openai_provider(self):
+        """Test generation with OpenAI provider"""
+        try:
+            provider = OpenAIProvider()
+            session = BasicSession(provider=provider)
+        except ImportError:
+            pytest.skip("OpenAI provider not available")
 
         response = session.generate("Hello")
         assert response.content is not None
-        assert "Mock response" in response.content
+        assert len(response.content) > 0
         assert len(session.messages) == 2  # user + assistant
 
     def test_persistence(self, tmp_path):

{abstractcore-2.4.7 → abstractcore-2.4.9}/tests/test_comprehensive_events.py

@@ -212,14 +212,17 @@ class TestEventHandlerPatterns:
 class TestProviderEvents:
     """Test events emitted by providers"""
 
-    def test_mock_provider_events(self, event_capture):
-        """Test that mock provider emits expected events"""
+    def test_openai_provider_events(self, event_capture):
+        """Test that OpenAI provider emits expected events"""
         # Register event listener for generation events only (PROVIDER_CREATED removed)
         on_global(EventType.GENERATION_STARTED, event_capture.capture_event)
         on_global(EventType.GENERATION_COMPLETED, event_capture.capture_event)
 
         # Create provider and generate response
-        llm = create_llm("mock", model="test-model")
+        try:
+            llm = create_llm("openai", model="gpt-4o")
+        except ImportError:
+            pytest.skip("OpenAI provider not available")
         response = llm.generate("Test prompt")
 
         # Verify generation events were emitted
@@ -302,7 +305,10 @@ class TestStructuredOutputEvents:
         on_global(EventType.VALIDATION_FAILED, event_capture.capture_event)
 
         # Create provider and generate structured response
-        llm = create_llm("mock", model="test-model")
+        try:
+            llm = create_llm("openai", model="gpt-4o")
+        except ImportError:
+            pytest.skip("OpenAI provider not available")
 
         # Test with invalid JSON to trigger validation failure
         with patch.object(llm, '_generate_internal') as mock_generate:

{abstractcore-2.4.7 → abstractcore-2.4.9}/tests/test_core_components.py

@@ -137,10 +137,13 @@ class TestBasicSession:
 class TestProviderFactory:
     """Test provider factory"""
 
-    def test_create_mock_provider(self):
-        """Test creating mock provider"""
-        provider = create_llm("mock")
-        assert provider is not None
+    def test_create_openai_provider(self):
+        """Test creating OpenAI provider"""
+        try:
+            provider = create_llm("openai")
+            assert provider is not None
+        except ImportError:
+            pytest.skip("OpenAI provider not available")
         assert isinstance(provider, AbstractCoreInterface)
 
     def test_create_ollama_provider(self):
@@ -303,9 +306,12 @@ class TestProviderIntegration:
         assert response.content is not None
 
     def test_session_with_provider(self):
-        """Test session with mock provider"""
-        provider = create_llm("mock")
-        session = BasicSession(provider=provider, system_prompt="Test system")
+        """Test session with OpenAI provider"""
+        try:
+            provider = create_llm("openai")
+            session = BasicSession(provider=provider, system_prompt="Test system")
+        except ImportError:
+            pytest.skip("OpenAI provider not available")
 
         response = session.generate("Hello")
         assert response is not None

{abstractcore-2.4.7 → abstractcore-2.4.9}/tests/test_embeddings_integration.py

@@ -204,7 +204,10 @@ class TestLLMEmbeddingIntegration:
                 mock_llm = mock_create_llm.return_value
                 mock_llm.generate.return_value = "Mock response"
 
-                llm = create_llm("mock", model="test")
+                try:
+                    llm = create_llm("openai", model="gpt-4o")
+                except ImportError:
+                    pytest.skip("OpenAI provider not available")
 
                 # Use both independently
                 embedding = embedder.embed("Test text")

{abstractcore-2.4.7 → abstractcore-2.4.9}/tests/test_embeddings_llm_integration.py

@@ -43,8 +43,11 @@ class TestEmbeddingsLLMIntegration:
             assert len(embedding) == 384
             assert all(isinstance(x, (int, float)) for x in embedding)
 
-            # Create LLM provider (mock to avoid API calls)
-            llm = create_llm("mock")
+            # Create LLM provider (OpenAI if available)
+            try:
+                llm = create_llm("openai")
+            except ImportError:
+                pytest.skip("OpenAI provider not available")
 
             # Verify both work independently
             similarity = embedder.compute_similarity("test 1", "test 2")
@@ -73,7 +76,10 @@ class TestEmbeddingsLLMIntegration:
                 model="sentence-transformers/all-MiniLM-L6-v2",
                 cache_dir=self.cache_dir
             )
-            llm = create_llm("mock")
+            try:
+                llm = create_llm("openai")
+            except ImportError:
+                pytest.skip("OpenAI provider not available")
 
             # Real knowledge base
             knowledge_base = [
@@ -221,7 +227,10 @@ Based on the provided context, please answer the question:"""
                 model="sentence-transformers/all-MiniLM-L6-v2",
                 cache_dir=self.cache_dir
             )
-            llm = create_llm("mock")
+            try:
+                llm = create_llm("openai")
+            except ImportError:
+                pytest.skip("OpenAI provider not available")
             session = BasicSession(llm)
 
             # Test session with embedding-enhanced prompts

{abstractcore-2.4.7 → abstractcore-2.4.9}/tests/test_embeddings_real.py

@@ -273,7 +273,7 @@ class TestLLMIntegrationReal:
             # Test that LLM creation doesn't interfere with embeddings
             try:
                 # This might fail if no LLM providers are configured, which is fine
-                llm = create_llm("mock")  # Use mock provider to avoid API calls
+                llm = create_llm("openai")  # Use OpenAI provider if available
                 print("✅ LLM and embeddings can coexist")
             except Exception:
                 print("✅ LLM creation failed as expected (no real providers configured)")

{abstractcore-2.4.7 → abstractcore-2.4.9}/tests/test_enhanced_prompt.py

@@ -20,7 +20,7 @@ def test_enhanced_prompt_structure():
         # Create a test LocalMediaHandler for text-only model
         handler = LocalMediaHandler("ollama", {"vision_support": False})
 
-        # Create mock MediaContent
+        # Create test MediaContent
         media_content = MediaContent(
             content="test-image-content",
             media_type=MediaType.IMAGE,
@@ -29,13 +29,13 @@ def test_enhanced_prompt_structure():
             metadata={"file_name": "arc_de_triomphe.jpg"}
         )
 
-        # Set a mock file path
+        # Set a test file path
         media_content.file_path = "/tmp/test_image.jpg"
 
         print("1. Testing prompt construction...")
         print("   User question: 'What is in this image?'")
 
-        # This would normally call the vision fallback, but we'll mock the result
+        # This would normally call the vision fallback, but we'll simulate the result
         # to show the prompt structure without actually processing an image
 
         print("\n2. Expected prompt structure sent to text-only model:")

abstractcore-2.4.9/tests/test_factory.py

@@ -0,0 +1,54 @@
+"""
+Test the factory function.
+"""
+
+import pytest
+from abstractcore import create_llm
+from abstractcore.providers.openai_provider import OpenAIProvider
+from abstractcore.providers.anthropic_provider import AnthropicProvider
+
+
+class TestFactory:
+    """Test create_llm factory function"""
+
+    def test_create_openai_provider(self):
+        """Test creating OpenAI provider"""
+        try:
+            llm = create_llm("openai")
+            assert isinstance(llm, OpenAIProvider)
+            assert llm.model == "gpt-5-nano-2025-08-07"  # Default model
+        except ImportError:
+            pytest.skip("OpenAI dependencies not available")
+
+    def test_create_anthropic_provider(self):
+        """Test creating Anthropic provider"""
+        try:
+            llm = create_llm("anthropic")
+            assert isinstance(llm, AnthropicProvider)
+            assert llm.model == "claude-3-5-haiku-latest"  # Default model
+        except ImportError:
+            pytest.skip("Anthropic dependencies not available")
+
+    def test_create_provider_with_custom_model(self):
+        """Test creating provider with custom model"""
+        try:
+            llm = create_llm("openai", model="gpt-4o")
+            assert llm.model == "gpt-4o"
+        except ImportError:
+            pytest.skip("OpenAI dependencies not available")
+
+    def test_unknown_provider_raises_error(self):
+        """Test unknown provider raises error"""
+        with pytest.raises(ValueError, match="Unknown provider"):
+            create_llm("nonexistent")
+
+    def test_provider_case_insensitive(self):
+        """Test provider names are case insensitive"""
+        try:
+            llm1 = create_llm("OPENAI")
+            llm2 = create_llm("OpenAI")
+            llm3 = create_llm("openai")
+            
+            assert all(isinstance(llm, OpenAIProvider) for llm in [llm1, llm2, llm3])
+        except ImportError:
+            pytest.skip("OpenAI dependencies not available")

{abstractcore-2.4.7 → abstractcore-2.4.9}/tests/test_provider_connectivity.py

@@ -88,11 +88,14 @@ class TestProviderConnectivity:
             else:
                 raise
 
-    def test_mock_connectivity(self):
-        """Test Mock provider can be created."""
-        provider = create_llm("mock", model="test-model")
-        assert provider is not None
-        assert provider.model == "test-model"
+    def test_openai_connectivity(self):
+        """Test OpenAI provider can be created."""
+        try:
+            provider = create_llm("openai", model="gpt-4o")
+            assert provider is not None
+        except ImportError:
+            pytest.skip("OpenAI provider not available")
+        assert provider.model == "gpt-4o"
 
 
 if __name__ == "__main__":

{abstractcore-2.4.7 → abstractcore-2.4.9}/tests/test_provider_simple_generation.py

@@ -148,9 +148,12 @@ class TestProviderSimpleGeneration:
             else:
                 raise
 
-    def test_mock_simple_generation(self):
-        """Test Mock provider simple generation."""
-        provider = create_llm("mock", model="test-model")
+    def test_openai_simple_generation(self):
+        """Test OpenAI provider simple generation."""
+        try:
+            provider = create_llm("openai", model="gpt-4o")
+        except ImportError:
+            pytest.skip("OpenAI provider not available")
 
         response = provider.generate("Who are you? Answer in one sentence.")
 

{abstractcore-2.4.7 → abstractcore-2.4.9}/tests/test_provider_streaming.py

@@ -197,9 +197,12 @@ class TestProviderStreaming:
             else:
                 raise
 
-    def test_mock_streaming_basic(self):
-        """Test Mock provider streaming functionality."""
-        provider = create_llm("mock", model="test-model")
+    def test_openai_streaming_basic(self):
+        """Test OpenAI provider streaming functionality."""
+        try:
+            provider = create_llm("openai", model="gpt-4o")
+        except ImportError:
+            pytest.skip("OpenAI provider not available")
 
         # Test streaming
         stream = provider.generate(
@@ -304,7 +307,10 @@ class TestProviderStreaming:
 
     def test_streaming_chunk_structure(self):
         """Test that streaming chunks have proper structure."""
-        provider = create_llm("mock", model="test-model")
+        try:
+            provider = create_llm("openai", model="gpt-4o")
+        except ImportError:
+            pytest.skip("OpenAI provider not available")
 
         stream = provider.generate("Test prompt", stream=True)
 
@@ -321,7 +327,10 @@ class TestProviderStreaming:
 
     def test_streaming_interruption(self):
         """Test that streaming can be interrupted gracefully."""
-        provider = create_llm("mock", model="test-model")
+        try:
+            provider = create_llm("openai", model="gpt-4o")
+        except ImportError:
+            pytest.skip("OpenAI provider not available")
 
         stream = provider.generate("Long response test", stream=True)
 
@@ -337,7 +346,10 @@ class TestProviderStreaming:
 
     def test_streaming_empty_response(self):
         """Test streaming behavior with empty or minimal responses."""
-        provider = create_llm("mock", model="test-model")
+        try:
+            provider = create_llm("openai", model="gpt-4o")
+        except ImportError:
+            pytest.skip("OpenAI provider not available")
 
         stream = provider.generate("", stream=True)  # Empty prompt
 

{abstractcore-2.4.7 → abstractcore-2.4.9}/tests/test_providers.py

@@ -1,6 +1,6 @@
 """
 Test all providers with real implementations.
-No mocking - test actual provider connections.
+No mocking - test actual provider connections and functionality.
 """
 
 import pytest

{abstractcore-2.4.7 → abstractcore-2.4.9}/tests/test_real_models_comprehensive.py

@@ -289,8 +289,8 @@ class TestRealLLMIntegration:
                 cache_dir=self.cache_dir
             )
 
-            # Use mock LLM to avoid API calls but test structure
-            llm = create_llm("mock")
+            # Use OpenAI LLM for testing structure
+            llm = create_llm("openai")
 
             # Real knowledge base
             knowledge_base = [