abstractcore 2.4.0__py3-none-any.whl → 2.4.2__py3-none-any.whl

abstractcore/core/factory.py

@@ -64,59 +64,10 @@ def create_llm(provider: str, model: Optional[str] = None, **kwargs) -> Abstract
         elif (".gguf" in model.lower() or "-gguf" in model.lower()) and provider.lower() == "mlx":
             provider = "huggingface"
 
-    # Mock provider for testing
-    if provider.lower() == "mock":
-        from ..providers.mock_provider import MockProvider
-        return MockProvider(model=model or "mock-model", **kwargs)
-
-    # Import providers dynamically to avoid hard dependencies
-    elif provider.lower() == "openai":
-        try:
-            from ..providers.openai_provider import OpenAIProvider
-            return OpenAIProvider(model=model or "gpt-5-nano-2025-08-07", **kwargs)
-        except ImportError:
-            raise ImportError("OpenAI dependencies not installed. Install with: pip install abstractcore[openai]")
-        except (ModelNotFoundError, AuthenticationError, ProviderAPIError) as e:
-            # Re-raise provider exceptions cleanly
-            raise e
-
-    elif provider.lower() == "anthropic":
-        try:
-            from ..providers.anthropic_provider import AnthropicProvider
-            return AnthropicProvider(model=model or "claude-3-5-haiku-latest", **kwargs)
-        except ImportError:
-            raise ImportError("Anthropic dependencies not installed. Install with: pip install abstractcore[anthropic]")
-        except (ModelNotFoundError, AuthenticationError, ProviderAPIError) as e:
-            # Re-raise provider exceptions cleanly
-            raise e
-
-    elif provider.lower() == "ollama":
-        try:
-            from ..providers.ollama_provider import OllamaProvider
-            return OllamaProvider(model=model or "qwen3-coder:30b", **kwargs)
-        except ImportError:
-            raise ImportError("Ollama dependencies not installed. Install with: pip install abstractcore[ollama]")
-
-    elif provider.lower() == "huggingface":
-        try:
-            from ..providers.huggingface_provider import HuggingFaceProvider
-            return HuggingFaceProvider(model=model or "Qwen/Qwen3-4B/", **kwargs)
-        except ImportError:
-            raise ImportError("HuggingFace dependencies not installed. Install with: pip install abstractcore[huggingface]")
-
-    elif provider.lower() == "mlx":
-        try:
-            from ..providers.mlx_provider import MLXProvider
-            return MLXProvider(model=model or "mlx-community/Qwen3-4B", **kwargs)
-        except ImportError:
-            raise ImportError("MLX dependencies not installed. Install with: pip install abstractcore[mlx]")
-
-    elif provider.lower() == "lmstudio":
-        try:
-            from ..providers.lmstudio_provider import LMStudioProvider
-            return LMStudioProvider(model=model or "qwen/qwen3-4b-2507", **kwargs)
-        except ImportError:
-            raise ImportError("LM Studio provider not available")
-
-    else:
-        raise ValueError(f"Unknown provider: {provider}. Available providers: openai, anthropic, ollama, huggingface, mlx, lmstudio, mock")
+    # Use centralized provider registry for all provider creation
+    try:
+        from ..providers.registry import create_provider
+        return create_provider(provider, model, **kwargs)
+    except (ModelNotFoundError, AuthenticationError, ProviderAPIError) as e:
+        # Re-raise provider exceptions cleanly
+        raise e

abstractcore/exceptions/__init__.py

@@ -0,0 +1,125 @@
+"""
+Custom exceptions for AbstractCore.
+"""
+
+
+class AbstractCoreError(Exception):
+    """Base exception for AbstractCore"""
+    pass
+
+
+class ProviderError(AbstractCoreError):
+    """Base exception for provider-related errors"""
+    pass
+
+
+class ProviderAPIError(ProviderError):
+    """API call to provider failed"""
+    pass
+
+
+class AuthenticationError(ProviderError):
+    """Authentication with provider failed"""
+    pass
+
+
+# Alias for backward compatibility with old AbstractCore
+Authentication = AuthenticationError
+
+
+class RateLimitError(ProviderError):
+    """Rate limit exceeded"""
+    pass
+
+
+class InvalidRequestError(ProviderError):
+    """Invalid request to provider"""
+    pass
+
+
+class UnsupportedFeatureError(AbstractCoreError):
+    """Feature not supported by provider"""
+    pass
+
+
+class FileProcessingError(AbstractCoreError):
+    """Error processing file or media"""
+    pass
+
+
+class ToolExecutionError(AbstractCoreError):
+    """Error executing tool"""
+    pass
+
+
+class SessionError(AbstractCoreError):
+    """Error with session management"""
+    pass
+
+
+class ConfigurationError(AbstractCoreError):
+    """Invalid configuration"""
+    pass
+
+
+class ModelNotFoundError(ProviderError):
+    """Model not found or invalid model name"""
+    pass
+
+
+def format_model_error(provider: str, invalid_model: str, available_models: list) -> str:
+    """
+    Format a helpful error message for model not found errors.
+
+    Args:
+        provider: Provider name (e.g., "OpenAI", "Anthropic")
+        invalid_model: The model name that was not found
+        available_models: List of available model names
+
+    Returns:
+        Formatted error message string
+    """
+    message = f"❌ Model '{invalid_model}' not found for {provider} provider.\n"
+
+    if available_models:
+        message += f"\n✅ Available models ({len(available_models)}):\n"
+        for model in available_models[:30]:  # Show max 30
+            message += f"  • {model}\n"
+        if len(available_models) > 30:
+            message += f"  ... and {len(available_models) - 30} more\n"
+    else:
+        # Show provider documentation when we can't fetch models
+        doc_links = {
+            "anthropic": "https://docs.anthropic.com/en/docs/about-claude/models",
+            "openai": "https://platform.openai.com/docs/models",
+            "ollama": "https://ollama.com/library",
+            "huggingface": "https://huggingface.co/models",
+            "mlx": "https://huggingface.co/mlx-community"
+        }
+
+        provider_lower = provider.lower()
+        if provider_lower in doc_links:
+            message += f"\n📚 See available models: {doc_links[provider_lower]}\n"
+        else:
+            message += f"\n⚠️  Could not fetch available models for {provider}.\n"
+
+    return message.rstrip()
+
+
+# Export all exceptions for easy importing
+__all__ = [
+    'AbstractCoreError',
+    'ProviderError', 
+    'ProviderAPIError',
+    'AuthenticationError',
+    'Authentication',  # Backward compatibility alias
+    'RateLimitError',
+    'InvalidRequestError',
+    'UnsupportedFeatureError',
+    'FileProcessingError',
+    'ToolExecutionError',
+    'SessionError',
+    'ConfigurationError',
+    'ModelNotFoundError',
+    'format_model_error'
+]

abstractcore/media/__init__.py

@@ -0,0 +1,151 @@
+"""
+Media handling for different providers.
+"""
+
+import base64
+from pathlib import Path
+from typing import Union, Dict, Any, Optional
+from enum import Enum
+
+
+class MediaType(Enum):
+    """Supported media types"""
+    IMAGE = "image"
+    AUDIO = "audio"
+    VIDEO = "video"
+    DOCUMENT = "document"
+
+
+class MediaHandler:
+    """Base class for media handling"""
+
+    @staticmethod
+    def encode_image(image_path: Union[str, Path]) -> str:
+        """
+        Encode an image file to base64.
+
+        Args:
+            image_path: Path to the image file
+
+        Returns:
+            Base64 encoded string
+        """
+        with open(image_path, "rb") as image_file:
+            return base64.b64encode(image_file.read()).decode('utf-8')
+
+    @staticmethod
+    def format_for_openai(image_path: Union[str, Path]) -> Dict[str, Any]:
+        """
+        Format image for OpenAI API.
+
+        Args:
+            image_path: Path to the image
+
+        Returns:
+            Formatted content for OpenAI
+        """
+        base64_image = MediaHandler.encode_image(image_path)
+        return {
+            "type": "image_url",
+            "image_url": {
+                "url": f"data:image/jpeg;base64,{base64_image}"
+            }
+        }
+
+    @staticmethod
+    def format_for_anthropic(image_path: Union[str, Path]) -> Dict[str, Any]:
+        """
+        Format image for Anthropic API.
+
+        Args:
+            image_path: Path to the image
+
+        Returns:
+            Formatted content for Anthropic
+        """
+        base64_image = MediaHandler.encode_image(image_path)
+
+        # Detect image type
+        path = Path(image_path)
+        media_type = "image/jpeg"
+        if path.suffix.lower() == ".png":
+            media_type = "image/png"
+        elif path.suffix.lower() == ".gif":
+            media_type = "image/gif"
+        elif path.suffix.lower() == ".webp":
+            media_type = "image/webp"
+
+        return {
+            "type": "image",
+            "source": {
+                "type": "base64",
+                "media_type": media_type,
+                "data": base64_image
+            }
+        }
+
+    @staticmethod
+    def format_for_provider(image_path: Union[str, Path], provider: str) -> Optional[Dict[str, Any]]:
+        """
+        Format media for a specific provider.
+
+        Args:
+            image_path: Path to the media file
+            provider: Provider name
+
+        Returns:
+            Formatted content or None if not supported
+        """
+        provider_lower = provider.lower()
+
+        if provider_lower == "openai":
+            return MediaHandler.format_for_openai(image_path)
+        elif provider_lower == "anthropic":
+            return MediaHandler.format_for_anthropic(image_path)
+        else:
+            # Local providers typically don't support images directly
+            return None
+
+    @staticmethod
+    def is_image_file(path: Union[str, Path]) -> bool:
+        """
+        Check if a file is an image.
+
+        Args:
+            path: Path to check
+
+        Returns:
+            True if the file is an image
+        """
+        image_extensions = {'.jpg', '.jpeg', '.png', '.gif', '.bmp', '.webp', '.ico', '.tiff'}
+        return Path(path).suffix.lower() in image_extensions
+
+    @staticmethod
+    def get_media_type(path: Union[str, Path]) -> MediaType:
+        """
+        Determine the media type of a file.
+
+        Args:
+            path: Path to the file
+
+        Returns:
+            MediaType enum value
+        """
+        path = Path(path)
+        extension = path.suffix.lower()
+
+        image_extensions = {'.jpg', '.jpeg', '.png', '.gif', '.bmp', '.webp'}
+        audio_extensions = {'.mp3', '.wav', '.m4a', '.ogg', '.flac'}
+        video_extensions = {'.mp4', '.avi', '.mov', '.mkv', '.webm'}
+        document_extensions = {'.pdf', '.doc', '.docx', '.txt', '.md'}
+
+        if extension in image_extensions:
+            return MediaType.IMAGE
+        elif extension in audio_extensions:
+            return MediaType.AUDIO
+        elif extension in video_extensions:
+            return MediaType.VIDEO
+        elif extension in document_extensions:
+            return MediaType.DOCUMENT
+        else:
+            return MediaType.DOCUMENT  # Default to document

abstractcore/providers/__init__.py

@@ -9,7 +9,22 @@ 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 (
+    ProviderRegistry,
+    ProviderInfo,
+    get_provider_registry,
+    list_available_providers,
+    get_provider_info,
+    is_provider_available,
+    get_all_providers_with_models,
+    get_all_providers_status,
+    create_provider,
+    get_available_models_for_provider
+)
+
 __all__ = [
+    # Provider classes
     'BaseProvider',
     'OpenAIProvider',
     'AnthropicProvider',
@@ -18,4 +33,16 @@ __all__ = [
     'HuggingFaceProvider',
     'MLXProvider',
     'MockProvider',
+
+    # Provider registry
+    'ProviderRegistry',
+    'ProviderInfo',
+    'get_provider_registry',
+    'list_available_providers',
+    'get_provider_info',
+    'is_provider_available',
+    'get_all_providers_with_models',
+    'get_all_providers_status',
+    'create_provider',
+    'get_available_models_for_provider',
 ]

abstractcore/providers/registry.py

@@ -0,0 +1,406 @@
+"""
+Provider Registry - Centralized provider discovery and metadata management.
+
+This module provides a single source of truth for all AbstractCore providers,
+eliminating the need for manual synchronization across factory.py, server/app.py,
+and __init__.py files.
+"""
+
+from typing import List, Dict, Any, Optional, Type, Callable
+from dataclasses import dataclass, field
+from abc import ABC
+import logging
+from ..utils.structured_logging import get_logger
+
+logger = get_logger("provider_registry")
+
+
+@dataclass
+class ProviderInfo:
+    """Information about a registered provider."""
+    name: str
+    display_name: str
+    provider_class: Type
+    description: str
+    provider_type: str = "llm"
+    default_model: Optional[str] = None
+    supported_features: List[str] = field(default_factory=list)
+    authentication_required: bool = True
+    local_provider: bool = False
+    installation_extras: Optional[str] = None
+    import_path: str = ""
+
+    def __post_init__(self):
+        """Set default values after initialization."""
+        if not self.import_path:
+            self.import_path = f"..providers.{self.name}_provider"
+
+
+class ProviderRegistry:
+    """
+    Centralized registry for all AbstractCore providers.
+
+    This registry serves as the single source of truth for provider discovery,
+    metadata, and instantiation across the entire AbstractCore system.
+    """
+
+    def __init__(self):
+        self._providers: Dict[str, ProviderInfo] = {}
+        self._logger = get_logger("ProviderRegistry")
+        self._register_all_providers()
+
+    def _register_all_providers(self):
+        """Register all available providers with their metadata."""
+
+        # OpenAI Provider
+        self.register_provider(ProviderInfo(
+            name="openai",
+            display_name="OpenAI",
+            provider_class=None,  # Will be set during lazy loading
+            description="Commercial API with GPT-4, GPT-3.5, and embedding models",
+            default_model="gpt-5-nano-2025-08-07",
+            supported_features=["chat", "completion", "embeddings", "native_tools", "streaming", "structured_output"],
+            authentication_required=True,
+            local_provider=False,
+            installation_extras="openai",
+            import_path="..providers.openai_provider"
+        ))
+
+        # Anthropic Provider
+        self.register_provider(ProviderInfo(
+            name="anthropic",
+            display_name="Anthropic",
+            provider_class=None,
+            description="Commercial API with Claude 3 family models",
+            default_model="claude-3-5-haiku-latest",
+            supported_features=["chat", "completion", "native_tools", "streaming", "structured_output"],
+            authentication_required=True,
+            local_provider=False,
+            installation_extras="anthropic",
+            import_path="..providers.anthropic_provider"
+        ))
+
+        # Ollama Provider
+        self.register_provider(ProviderInfo(
+            name="ollama",
+            display_name="Ollama",
+            provider_class=None,
+            description="Local LLM server for running open-source models",
+            default_model="qwen3-coder:30b",
+            supported_features=["chat", "completion", "embeddings", "prompted_tools", "streaming"],
+            authentication_required=False,
+            local_provider=True,
+            installation_extras="ollama",
+            import_path="..providers.ollama_provider"
+        ))
+
+        # LMStudio Provider
+        self.register_provider(ProviderInfo(
+            name="lmstudio",
+            display_name="LMStudio",
+            provider_class=None,
+            description="Local model development and testing platform",
+            default_model="qwen/qwen3-4b-2507",
+            supported_features=["chat", "completion", "embeddings", "prompted_tools", "streaming"],
+            authentication_required=False,
+            local_provider=True,
+            installation_extras=None,
+            import_path="..providers.lmstudio_provider"
+        ))
+
+        # MLX Provider
+        self.register_provider(ProviderInfo(
+            name="mlx",
+            display_name="MLX",
+            provider_class=None,
+            description="Apple Silicon optimized local inference",
+            default_model="mlx-community/Qwen3-4B",
+            supported_features=["chat", "completion", "prompted_tools", "streaming", "apple_silicon"],
+            authentication_required=False,
+            local_provider=True,
+            installation_extras="mlx",
+            import_path="..providers.mlx_provider"
+        ))
+
+        # HuggingFace Provider
+        self.register_provider(ProviderInfo(
+            name="huggingface",
+            display_name="HuggingFace",
+            provider_class=None,
+            description="Access to HuggingFace models (transformers and embeddings)",
+            default_model="Qwen/Qwen3-4B/",
+            supported_features=["chat", "completion", "embeddings", "prompted_tools", "local_models"],
+            authentication_required=False,  # Optional for public models
+            local_provider=True,
+            installation_extras="huggingface",
+            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."""
+        self._providers[provider_info.name] = provider_info
+        self._logger.debug(f"Registered provider: {provider_info.name}")
+
+    def get_provider_info(self, provider_name: str) -> Optional[ProviderInfo]:
+        """Get information about a specific provider."""
+        return self._providers.get(provider_name.lower())
+
+    def list_provider_names(self) -> List[str]:
+        """Get list of all registered provider names."""
+        return list(self._providers.keys())
+
+    def is_provider_available(self, provider_name: str) -> bool:
+        """Check if a provider is registered."""
+        return provider_name.lower() in self._providers
+
+    def get_provider_class(self, provider_name: str):
+        """Get the provider class, loading it lazily if needed."""
+        provider_info = self.get_provider_info(provider_name)
+        if not provider_info:
+            raise ValueError(f"Unknown provider: {provider_name}")
+
+        # Lazy loading of provider class
+        if provider_info.provider_class is None:
+            provider_info.provider_class = self._load_provider_class(provider_info)
+
+        return provider_info.provider_class
+
+    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":
+                from ..providers.openai_provider import OpenAIProvider
+                return OpenAIProvider
+            elif provider_info.name == "anthropic":
+                from ..providers.anthropic_provider import AnthropicProvider
+                return AnthropicProvider
+            elif provider_info.name == "ollama":
+                from ..providers.ollama_provider import OllamaProvider
+                return OllamaProvider
+            elif provider_info.name == "lmstudio":
+                from ..providers.lmstudio_provider import LMStudioProvider
+                return LMStudioProvider
+            elif provider_info.name == "mlx":
+                from ..providers.mlx_provider import MLXProvider
+                return MLXProvider
+            elif provider_info.name == "huggingface":
+                from ..providers.huggingface_provider import HuggingFaceProvider
+                return HuggingFaceProvider
+            else:
+                raise ImportError(f"No import logic for provider: {provider_info.name}")
+        except ImportError as e:
+            self._logger.warning(f"Failed to load provider {provider_info.name}: {e}")
+            raise ImportError(
+                f"{provider_info.display_name} dependencies not installed. "
+                f"Install with: pip install abstractcore[{provider_info.installation_extras}]"
+            ) from e
+
+    def get_available_models(self, provider_name: str, **kwargs) -> List[str]:
+        """
+        Get available models for a specific provider.
+
+        Args:
+            provider_name: Name of the provider
+            **kwargs: Provider-specific parameters (e.g., api_key, base_url)
+
+        Returns:
+            List of available model names
+        """
+        try:
+            provider_class = self.get_provider_class(provider_name)
+
+            # Handle providers that need instance for model listing
+            if provider_name in ["anthropic", "ollama", "lmstudio"]:
+                provider_info = self.get_provider_info(provider_name)
+                # Create minimal instance for API access
+                instance = provider_class(model=provider_info.default_model, **kwargs)
+                return instance.list_available_models(**kwargs)
+            else:
+                # Handle providers with static method or class method
+                try:
+                    # First try as static/class method
+                    return provider_class.list_available_models(**kwargs)
+                except TypeError:
+                    # If that fails (method needs 'self'), create temporary instance
+                    provider_info = self.get_provider_info(provider_name)
+                    instance = provider_class(model=provider_info.default_model, **kwargs)
+                    return instance.list_available_models(**kwargs)
+
+        except Exception as e:
+            self._logger.debug(f"Failed to get models from provider {provider_name}: {e}")
+            return []
+
+    def get_provider_status(self, provider_name: str) -> Dict[str, Any]:
+        """
+        Get detailed status information for a provider.
+
+        Returns provider information including availability, model count, etc.
+        This is used by the server /providers endpoint.
+        """
+        provider_info = self.get_provider_info(provider_name)
+        if not provider_info:
+            return {
+                "name": provider_name,
+                "status": "unknown",
+                "error": "Provider not registered"
+            }
+
+        try:
+            # Try to get models to test availability
+            models = self.get_available_models(provider_name)
+
+            return {
+                "name": provider_info.name,
+                "display_name": provider_info.display_name,
+                "type": provider_info.provider_type,
+                "model_count": len(models),
+                "status": "available" if models else "no_models",
+                "description": provider_info.description,
+                "local_provider": provider_info.local_provider,
+                "authentication_required": provider_info.authentication_required,
+                "supported_features": provider_info.supported_features,
+                "installation_extras": provider_info.installation_extras,
+                "models": models
+            }
+        except Exception as e:
+            return {
+                "name": provider_info.name,
+                "display_name": provider_info.display_name,
+                "type": provider_info.provider_type,
+                "model_count": 0,
+                "status": "error",
+                "description": provider_info.description,
+                "error": str(e),
+                "local_provider": provider_info.local_provider,
+                "authentication_required": provider_info.authentication_required,
+                "supported_features": provider_info.supported_features,
+                "installation_extras": provider_info.installation_extras
+            }
+
+    def get_all_providers_status(self) -> List[Dict[str, Any]]:
+        """Get status information for all registered providers."""
+        return [
+            self.get_provider_status(provider_name)
+            for provider_name in self.list_provider_names()
+        ]
+
+    def get_providers_with_models(self) -> List[Dict[str, Any]]:
+        """Get only providers that have available models."""
+        all_providers = self.get_all_providers_status()
+        return [
+            provider for provider in all_providers
+            if provider.get("status") == "available" and provider.get("model_count", 0) > 0
+        ]
+
+    def create_provider_instance(self, provider_name: str, model: Optional[str] = None, **kwargs):
+        """
+        Create a provider instance using the registry.
+
+        This is used by the factory to create provider instances.
+        """
+        provider_info = self.get_provider_info(provider_name)
+        if not provider_info:
+            available_providers = ", ".join(self.list_provider_names())
+            raise ValueError(f"Unknown provider: {provider_name}. Available providers: {available_providers}")
+
+        provider_class = self.get_provider_class(provider_name)
+        model = model or provider_info.default_model
+
+        try:
+            return provider_class(model=model, **kwargs)
+        except ImportError as e:
+            # Re-raise import errors with helpful message
+            if provider_info.installation_extras:
+                raise ImportError(
+                    f"{provider_info.display_name} dependencies not installed. "
+                    f"Install with: pip install abstractcore[{provider_info.installation_extras}]"
+                ) from e
+            else:
+                raise ImportError(f"{provider_info.display_name} provider not available") from e
+
+
+# Global registry instance
+_registry = None
+
+
+def get_provider_registry() -> ProviderRegistry:
+    """Get the global provider registry instance."""
+    global _registry
+    if _registry is None:
+        _registry = ProviderRegistry()
+    return _registry
+
+
+# Convenience functions for external use
+def list_available_providers() -> List[str]:
+    """Get list of all available provider names."""
+    return get_provider_registry().list_provider_names()
+
+
+def get_provider_info(provider_name: str) -> Optional[ProviderInfo]:
+    """Get information about a specific provider."""
+    return get_provider_registry().get_provider_info(provider_name)
+
+
+def is_provider_available(provider_name: str) -> bool:
+    """Check if a provider is available."""
+    return get_provider_registry().is_provider_available(provider_name)
+
+
+def get_all_providers_with_models() -> List[Dict[str, Any]]:
+    """
+    Get comprehensive information about all providers with available models.
+
+    This is the main function that should be used throughout AbstractCore
+    for provider discovery and information. It replaces the manual provider
+    lists in factory.py and server/app.py.
+
+    Returns:
+        List of provider dictionaries with comprehensive metadata including:
+        - name, display_name, type, description
+        - model_count, status, supported_features
+        - local_provider, authentication_required
+        - installation_extras, sample models
+    """
+    return get_provider_registry().get_providers_with_models()
+
+
+def get_all_providers_status() -> List[Dict[str, Any]]:
+    """
+    Get status information for all registered providers.
+
+    This includes providers that may not have models available,
+    useful for debugging and comprehensive provider listing.
+    """
+    return get_provider_registry().get_all_providers_status()
+
+
+def create_provider(provider_name: str, model: Optional[str] = None, **kwargs):
+    """
+    Create a provider instance using the centralized registry.
+
+    This replaces the factory logic and provides better error messages.
+    """
+    return get_provider_registry().create_provider_instance(provider_name, model, **kwargs)
+
+
+def get_available_models_for_provider(provider_name: str, **kwargs) -> List[str]:
+    """Get available models for a specific provider."""
+    return get_provider_registry().get_available_models(provider_name, **kwargs)

abstractcore/server/app.py

@@ -109,50 +109,14 @@ def is_embedding_model(model_name: str) -> bool:
     return any(pattern in model_lower for pattern in embedding_patterns)
 
 # ============================================================================
-# Provider Model Discovery
+# Provider Model Discovery (Using Centralized Registry)
 # ============================================================================
 
 def get_models_from_provider(provider_name: str) -> List[str]:
-    """Get available models from a specific provider using their list_available_models() method."""
+    """Get available models from a specific provider using the centralized provider registry."""
     try:
-        if provider_name == "openai":
-            from ..providers.openai_provider import OpenAIProvider
-            return OpenAIProvider.list_available_models()
-        elif provider_name == "anthropic":
-            from ..providers.anthropic_provider import AnthropicProvider
-            # Need minimal instance for API key access
-            try:
-                provider = AnthropicProvider(model="claude-3-haiku-20240307")
-                return provider.list_available_models()
-            except Exception:
-                return []
-        elif provider_name == "ollama":
-            from ..providers.ollama_provider import OllamaProvider
-            # Need minimal instance for HTTP client
-            try:
-                provider = OllamaProvider(model="llama2")
-                return provider.list_available_models()
-            except Exception:
-                return []
-        elif provider_name == "lmstudio":
-            from ..providers.lmstudio_provider import LMStudioProvider
-            # Need minimal instance for HTTP client
-            try:
-                provider = LMStudioProvider(model="local-model")
-                return provider.list_available_models()
-            except Exception:
-                return []
-        elif provider_name == "mlx":
-            from ..providers.mlx_provider import MLXProvider
-            return MLXProvider.list_available_models()
-        elif provider_name == "huggingface":
-            from ..providers.huggingface_provider import HuggingFaceProvider
-            return HuggingFaceProvider.list_available_models()
-        elif provider_name == "mock":
-            # Mock provider for testing
-            return ["mock-model-1", "mock-model-2", "mock-embedding-1"]
-        else:
-            return []
+        from ..providers.registry import get_available_models_for_provider
+        return get_available_models_for_provider(provider_name)
     except Exception as e:
         logger.debug(f"Failed to get models from provider {provider_name}: {e}")
         return []
@@ -508,7 +472,7 @@ async def list_models(
                         continue  # Skip non-embedding models
                     if type == ModelType.TEXT_GENERATION and is_embedding:
                         continue  # Skip embedding models
-                
+
                 model_id = f"{provider.lower()}/{model}"
                 models_data.append({
                     "id": model_id,
@@ -517,12 +481,13 @@ async def list_models(
                     "created": int(time.time()),
                     "permission": [{"allow_create_engine": False, "allow_sampling": True}]
                 })
-            
+
             filter_msg = f" (type={type.value})" if type else ""
             logger.info(f"Listed {len(models_data)} models for provider {provider}{filter_msg}")
         else:
-            # Get models from all providers
-            providers = ["openai", "anthropic", "ollama", "lmstudio", "mlx", "huggingface", "mock"]
+            # Get models from all providers using centralized registry
+            from ..providers.registry import list_available_providers
+            providers = list_available_providers()
             for prov in providers:
                 models = get_models_from_provider(prov)
                 for model in models:
@@ -533,7 +498,7 @@ async def list_models(
                             continue  # Skip non-embedding models
                         if type == ModelType.TEXT_GENERATION and is_embedding:
                             continue  # Skip embedding models
-                    
+
                     model_id = f"{prov}/{model}"
                     models_data.append({
                         "id": model_id,
@@ -542,7 +507,7 @@ async def list_models(
                         "created": int(time.time()),
                         "permission": [{"allow_create_engine": False, "allow_sampling": True}]
                     })
-            
+
             filter_msg = f" (type={type.value})" if type else ""
             logger.info(f"Listed {len(models_data)} models from all providers{filter_msg}")
 
@@ -562,13 +527,15 @@ async def list_models(
 async def list_providers():
     """
     List all available AbstractCore providers and their capabilities.
-    
-    Returns information about all registered LLM providers, including:
-    - Provider name and type
-    - Number of available models
-    - Current availability status
-    - Provider description
-    
+
+    Returns comprehensive information about all registered LLM providers, including:
+    - Provider name, display name, and type
+    - Number of available models and sample models
+    - Current availability status and detailed error information
+    - Provider description and supported features
+    - Authentication requirements and installation instructions
+    - Local vs. cloud provider designation
+
     **Supported Providers:**
     - **OpenAI**: Commercial API with GPT-4, GPT-3.5, and embedding models
     - **Anthropic**: Commercial API with Claude 3 family models
@@ -577,42 +544,47 @@ async def list_providers():
     - **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
     - Check provider availability and model counts
     - Build dynamic provider selection UIs
-    - Monitor provider status
-    
-    **Note:** Only providers with available models are included in the response.
-    
-    **Returns:** A list of provider objects with name, type, model count, status, and description.
+    - Monitor provider status and troubleshoot issues
+    - Get installation instructions for missing dependencies
+
+    **Enhanced Information:**
+    This endpoint now uses the centralized provider registry to provide
+    comprehensive information including supported features, authentication
+    requirements, and detailed status information.
+
+    **Returns:** A list of provider objects with comprehensive metadata.
     """
     try:
-        providers_info = []
-        providers = ["openai", "anthropic", "ollama", "lmstudio", "mlx", "huggingface", "mock"]
-
-        for provider_name in providers:
-            models = get_models_from_provider(provider_name)
-            if models:  # Only include providers that have models
-                providers_info.append({
-                    "name": provider_name,
-                    "type": "llm",  # Could be extended to include "embedding" type
-                    "model_count": len(models),
-                    "status": "available",
-                    "description": f"{provider_name.title()} provider with {len(models)} available models"
-                })
+        from ..providers.registry import get_all_providers_with_models, get_all_providers_status
+
+        # Get providers with models (available providers)
+        available_providers = get_all_providers_with_models()
+
+        # Optionally include all providers (even those with issues) for debugging
+        # Uncomment the next line if you want to see providers with errors too:
+        # all_providers = get_all_providers_status()
 
-        logger.info(f"Listed {len(providers_info)} available providers")
+        logger.info(f"Listed {len(available_providers)} available providers with models")
 
         return {
-            "providers": sorted(providers_info, key=lambda x: x["name"])
+            "providers": available_providers,
+            "total_providers": len(available_providers),
+            "registry_version": "2.0",  # Indicate this is using the new registry system
+            "note": "Provider information from centralized AbstractCore registry"
         }
 
     except Exception as e:
         logger.error(f"Failed to list providers: {e}")
         return {
-            "providers": []
+            "providers": [],
+            "total_providers": 0,
+            "error": str(e),
+            "registry_version": "2.0"
         }
 
 @app.post("/v1/responses")

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.0"
+__version__ = "2.4.2"

{abstractcore-2.4.0.dist-info → abstractcore-2.4.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: abstractcore
-Version: 2.4.0
+Version: 2.4.2
 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>

{abstractcore-2.4.0.dist-info → abstractcore-2.4.2.dist-info}/RECORD

@@ -12,7 +12,7 @@ abstractcore/assets/model_capabilities.json,sha256=mSfP5C68I1c4GNLgL0sCDjpSZA3ks
 abstractcore/assets/session_schema.json,sha256=b6HTAWxRVlVhAzA7FqaKpunK1yO6jilBOsD5sQkqJTo,10580
 abstractcore/core/__init__.py,sha256=2h-86U4QkCQ4gzZ4iRusSTMlkODiUS6tKjZHiEXz6rM,684
 abstractcore/core/enums.py,sha256=BhkVnHC-X1_377JDmqd-2mnem9GdBLqixWlYzlP_FJU,695
-abstractcore/core/factory.py,sha256=WqEfGae0ikyjpTsjlErgkmm58fnkXgaCKnp8pkWHIno,5242
+abstractcore/core/factory.py,sha256=UdrNwQAvifvFS3LMjF5KO87m-2n1bJBryTs9pvesYcI,2804
 abstractcore/core/interface.py,sha256=DIA46gR7JN33kLyKbtbAkoME7l7rixtKbFGAQgt7ilk,13693
 abstractcore/core/retry.py,sha256=wNlUAxfmvdO_uVWb4iqkhTqd7O1oRwXxqvVQaLXQOw0,14538
 abstractcore/core/session.py,sha256=Zjy_oo_Ha_Kufrf4ffE9Sxl2gVXcdpBaYl-IssqoBe4,35200
@@ -21,11 +21,13 @@ abstractcore/embeddings/__init__.py,sha256=hR3xZyqcRm4c2pq1dIa5lxj_-Bk70Zad802JQ
 abstractcore/embeddings/manager.py,sha256=QzDtSna4FDCPg1il7GGe_7p1VknuUHjXAFQa98PgU9A,50048
 abstractcore/embeddings/models.py,sha256=bsPAzL6gv57AVii8O15PT0kxfwRkOml3f3njJN4UDi4,4874
 abstractcore/events/__init__.py,sha256=UtbdTOeL05kvi7YP91yo4OEqs5UAbKylBvOOEkrUL5E,11065
+abstractcore/exceptions/__init__.py,sha256=h6y3sdZR6uFMh0iq7z85DfJi01zGQvjVOm1W7l86iVQ,3224
+abstractcore/media/__init__.py,sha256=BjWR8OIN2uxoOJBAlbM83VkyUtyDtiXM4AerYzhI9fU,4241
 abstractcore/processing/__init__.py,sha256=t6hiakQjcZROT4pw9ZFt2q6fF3vf5VpdMKG2EWlsFd8,540
 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=UTpR2Bf_ICFG7M--1kxUmNXs4gl026Tp-KI9zJlvMKU,574
+abstractcore/providers/__init__.py,sha256=t8Kp4flH5GvZEC6dx-iYJSPeSxMODa2spXb8MqtlPy4,1282
 abstractcore/providers/anthropic_provider.py,sha256=BM8Vu89c974yicvFwlsJ5C3N0wR9Kkt1pOszViWCwAQ,19694
 abstractcore/providers/base.py,sha256=AJa9KFJGLJvrNrhI-EHaVSzaF1ocOOYc98GnnCjLuag,42824
 abstractcore/providers/huggingface_provider.py,sha256=aucyfGFHi67NRU7_5vWp2TEXdBBjb710zz0lQjC_rWo,42283
@@ -34,9 +36,10 @@ abstractcore/providers/mlx_provider.py,sha256=eANGeexmJIS4KWn77fRBOJRkXvwgh7irAt
 abstractcore/providers/mock_provider.py,sha256=tIjA57Hlwu3vNODOZShNn0tY9HWvz1p4z-HyD_bsvbo,5741
 abstractcore/providers/ollama_provider.py,sha256=SkXD5gjuzeu9Thqnt4pRPSi-cjWxwuZGV2x5YMm26jo,19340
 abstractcore/providers/openai_provider.py,sha256=xGFrSkbCrsBnWnho1U2aMCBdzfCqf121wU1EFGmU3YQ,21678
+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
-abstractcore/server/app.py,sha256=lz6ys1rd2AmsQarwkcOxpLsYQ5xKsp0iskTiYKIC92s,44495
+abstractcore/server/app.py,sha256=DCzKEe2hzvIfdq3N410boU0kRocFipRoiFDnABEGkYs,43350
 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
@@ -53,10 +56,10 @@ abstractcore/utils/cli.py,sha256=8ua5Lu4bKSs9y1JB5W3kJ0OA-_dFpUHk6prH1U684xc,568
 abstractcore/utils/self_fixes.py,sha256=QEDwNTW80iQM4ftfEY3Ghz69F018oKwLM9yeRCYZOvw,5886
 abstractcore/utils/structured_logging.py,sha256=Y7TVkf1tP9BCOPNbBY1rQubBxcAxhhUOYMbrV2k50ZM,15830
 abstractcore/utils/token_utils.py,sha256=eLwFmJ68p9WMFD_MHLMmeJRW6Oqx_4hKELB8FNQ2Mnk,21097
-abstractcore/utils/version.py,sha256=IM2ECuDR2OHXGSdAqLdQib35efGRt7ZUzbD9SUnyky4,605
-abstractcore-2.4.0.dist-info/licenses/LICENSE,sha256=PI2v_4HMvd6050uDD_4AY_8PzBnu2asa3RKbdDjowTA,1078
-abstractcore-2.4.0.dist-info/METADATA,sha256=vqJTIn2uX7-YACF6DbTWCgZhDVCjMRR3VDuKf-HxdV4,19684
-abstractcore-2.4.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-abstractcore-2.4.0.dist-info/entry_points.txt,sha256=Ocy403YwzaOBT7D_vf7w6YFiIQ4nTbp0htjXfeI5IOo,315
-abstractcore-2.4.0.dist-info/top_level.txt,sha256=DiNHBI35SIawW3N9Z-z0y6cQYNbXd32pvBkW0RLfScs,13
-abstractcore-2.4.0.dist-info/RECORD,,
+abstractcore/utils/version.py,sha256=5z25ZawOKXC7_TsMUhliL7I_XUADAb5ums58hgtaXEc,605
+abstractcore-2.4.2.dist-info/licenses/LICENSE,sha256=PI2v_4HMvd6050uDD_4AY_8PzBnu2asa3RKbdDjowTA,1078
+abstractcore-2.4.2.dist-info/METADATA,sha256=AMCwg1STsdh8FmhmHw05GNK6ANM8nN1VDvusq7lFEFM,19684
+abstractcore-2.4.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+abstractcore-2.4.2.dist-info/entry_points.txt,sha256=Ocy403YwzaOBT7D_vf7w6YFiIQ4nTbp0htjXfeI5IOo,315
+abstractcore-2.4.2.dist-info/top_level.txt,sha256=DiNHBI35SIawW3N9Z-z0y6cQYNbXd32pvBkW0RLfScs,13
+abstractcore-2.4.2.dist-info/RECORD,,