abstractcore 2.4.7__tar.gz → 2.4.8__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: abstractcore
-Version: 2.4.7
+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>
@@ -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.8}/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.8}/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.8}/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.8}/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.8}/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.8}/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.8"

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: abstractcore
-Version: 2.4.7
+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>
@@ -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.8}/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.8}/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.8}/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.8}/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.8}/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.8}/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.8}/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.8}/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.8/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.8}/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.8}/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.8}/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.8}/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.8}/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 = [

{abstractcore-2.4.7 → abstractcore-2.4.8}/tests/test_retry_strategy.py

@@ -420,8 +420,8 @@ class TestRetryManager:
         # No retry_success event in minimal approach - success is implicit
 
 
-class MockProvider(BaseProvider):
-    """Mock provider for testing integration."""
+class TestRetryProvider(BaseProvider):
+    """Test provider for retry integration testing."""
 
     def __init__(self, model: str = "test-model", **kwargs):
         super().__init__(model, **kwargs)
@@ -452,11 +452,11 @@ class TestBaseProviderIntegration:
 
     def test_provider_initialization_with_retry(self):
         """Test provider initializes with retry manager."""
-        provider = MockProvider("test-model")
+        provider = TestRetryProvider("test-model")
 
         assert hasattr(provider, 'retry_manager')
         assert isinstance(provider.retry_manager, RetryManager)
-        assert provider.provider_key == "MockProvider:test-model"
+        assert provider.provider_key == "TestRetryProvider:test-model"
 
     def test_structured_output_retry_strategy_parameter(self):
         """Test passing retry_strategy parameter to generate method."""
@@ -467,7 +467,7 @@ class TestBaseProviderIntegration:
             name: str
             value: int
 
-        provider = MockProvider("test-model")
+        provider = TestRetryProvider("test-model")
         custom_retry = FeedbackRetry(max_attempts=5)
 
         # Test that we can pass retry_strategy parameter without error
@@ -500,7 +500,7 @@ class TestBaseProviderIntegration:
             name: str
             value: int
 
-        provider = MockProvider("test-model")
+        provider = TestRetryProvider("test-model")
 
         def mock_generate(*args, **kwargs):
             return GenerateResponse(
@@ -524,14 +524,14 @@ class TestBaseProviderIntegration:
     def test_provider_custom_retry_config(self):
         """Test provider with custom retry configuration."""
         custom_config = RetryConfig(max_attempts=5)
-        provider = MockProvider("test-model", retry_config=custom_config)
+        provider = TestRetryProvider("test-model", retry_config=custom_config)
 
         assert provider.retry_manager.config.max_attempts == 5
 
     @patch('abstractcore.providers.base.time.sleep')
     def test_provider_retry_on_failure(self, mock_sleep):
         """Test provider retries on API failures."""
-        provider = MockProvider("test-model")
+        provider = TestRetryProvider("test-model")
 
         # Mock _generate_internal to fail then succeed
         original_generate = provider._generate_internal
@@ -555,7 +555,7 @@ class TestBaseProviderIntegration:
 
     def test_provider_no_retry_on_auth_error(self):
         """Test provider doesn't retry on authentication errors."""
-        provider = MockProvider("test-model")
+        provider = TestRetryProvider("test-model")
 
         # Mock _generate_internal to always fail with auth error
         provider._generate_internal = Mock(side_effect=AuthenticationError("Invalid API key"))
@@ -569,7 +569,7 @@ class TestBaseProviderIntegration:
     @patch('abstractcore.events.emit_global')
     def test_provider_retry_events(self, mock_emit):
         """Test provider emits retry events."""
-        provider = MockProvider("test-model")
+        provider = TestRetryProvider("test-model")
 
         # Mock _generate_internal to fail once then succeed
         call_count = 0
@@ -688,7 +688,7 @@ class TestIntegrationScenarios:
     @patch('abstractcore.events.emit_global')
     def test_rate_limit_recovery_scenario(self, mock_emit, mock_sleep):
         """Test realistic rate limit recovery scenario."""
-        provider = MockProvider("gpt-4")
+        provider = TestRetryProvider("gpt-4")
 
         # Simulate rate limit that clears after retries
         call_count = 0
@@ -719,7 +719,7 @@ class TestIntegrationScenarios:
     def test_circuit_breaker_prevents_cascade_failure(self):
         """Test circuit breaker prevents cascade failures."""
         config = RetryConfig(failure_threshold=2, max_attempts=1)
-        provider = MockProvider("failing-model", retry_config=config)
+        provider = TestRetryProvider("failing-model", retry_config=config)
 
         # Mock to always fail
         provider._generate_internal = Mock(side_effect=ProviderAPIError("Service down"))
@@ -740,7 +740,7 @@ class TestIntegrationScenarios:
 
     def test_mixed_error_types_scenario(self):
         """Test handling of mixed error types in sequence."""
-        provider = MockProvider("mixed-errors")
+        provider = TestRetryProvider("mixed-errors")
 
         call_count = 0
         def mixed_errors(*args, **kwargs):

{abstractcore-2.4.7 → abstractcore-2.4.8}/tests/test_seed_determinism.py

@@ -252,12 +252,12 @@ def test_ollama_seed_determinism():
 
 def test_session_seed_persistence():
     """Test that session-level seed parameters work correctly"""
-    # Use mock provider for this test to avoid external dependencies
+    # Use OpenAI provider for this test if available
     try:
-        from abstractcore.providers.mock_provider import MockProvider
+        from abstractcore.providers.openai_provider import OpenAIProvider
         
         # Create session with seed
-        provider = MockProvider(model="mock-model", temperature=0.0, seed=42)
+        provider = OpenAIProvider(model="gpt-4o", temperature=0.0, seed=42)
         session = BasicSession(provider=provider, temperature=0.0, seed=42)
         
         # Generate multiple responses
@@ -266,11 +266,11 @@ def test_session_seed_persistence():
             response = session.generate("Test prompt")
             responses.append(response.content)
         
-        # Mock provider should be consistent
-        assert len(set(responses)) <= 2, "Session should maintain some consistency"
+        # With seed, responses should be deterministic
+        assert len(set(responses)) <= 2, "Session should maintain some consistency with seed"
         
     except ImportError:
-        pytest.skip("MockProvider not available")
+        pytest.skip("OpenAI provider not available")
 
 
 def test_temperature_zero_consistency():