spaik-sdk 0.6.2__py3-none-any.whl

spaik_sdk/models/model_registry.py

@@ -0,0 +1,156 @@
+import re
+from typing import Dict, Set
+
+from spaik_sdk.models.llm_families import LLMFamilies
+from spaik_sdk.models.llm_model import LLMModel
+
+
+class ModelRegistry:
+    """Registry containing all built-in models with extensibility support."""
+
+    # Anthropic models
+    CLAUDE_3_7_SONNET_FEB_2025 = LLMModel(family=LLMFamilies.ANTHROPIC, name="claude-3-7-sonnet-20250219", prompt_caching=True)
+    CLAUDE_3_7_SONNET = LLMModel(family=LLMFamilies.ANTHROPIC, name="claude-3-7-sonnet-latest", prompt_caching=True)
+    CLAUDE_4_SONNET = LLMModel(family=LLMFamilies.ANTHROPIC, name="claude-sonnet-4-20250514", prompt_caching=True)
+    CLAUDE_4_OPUS = LLMModel(family=LLMFamilies.ANTHROPIC, name="claude-opus-4-20250514", prompt_caching=True)
+    CLAUDE_4_1_OPUS = LLMModel(family=LLMFamilies.ANTHROPIC, name="claude-opus-4-1-20250805", prompt_caching=True)
+    CLAUDE_4_SONNET_MAY_2025 = LLMModel(family=LLMFamilies.ANTHROPIC, name="claude-sonnet-4-20250514", prompt_caching=True)
+    CLAUDE_4_OPUS_MAY_2025 = LLMModel(family=LLMFamilies.ANTHROPIC, name="claude-opus-4-20250514", prompt_caching=True)
+    CLAUDE_4_5_SONNET = LLMModel(family=LLMFamilies.ANTHROPIC, name="claude-sonnet-4-5-20250929", prompt_caching=True)
+    CLAUDE_4_5_HAIKU = LLMModel(family=LLMFamilies.ANTHROPIC, name="claude-haiku-4-5-20251001", prompt_caching=True)
+    CLAUDE_4_5_OPUS = LLMModel(family=LLMFamilies.ANTHROPIC, name="claude-opus-4-5-20251101", prompt_caching=True)
+
+    # OpenAI models
+    GPT_4_1 = LLMModel(family=LLMFamilies.OPENAI, name="gpt-4.1", reasoning=False, prompt_caching=True)
+    GPT_4O = LLMModel(family=LLMFamilies.OPENAI, name="gpt-4o", reasoning=False, prompt_caching=True)
+    O4_MINI = LLMModel(family=LLMFamilies.OPENAI, name="o4-mini")
+    O4_MINI_APRIL_2025 = LLMModel(family=LLMFamilies.OPENAI, name="o4-mini-2025-04-16")
+    GPT_5 = LLMModel(family=LLMFamilies.OPENAI, name="gpt-5", reasoning=True, prompt_caching=True)
+    GPT_5_MINI = LLMModel(family=LLMFamilies.OPENAI, name="gpt-5-mini", reasoning=True, prompt_caching=True)
+    GPT_5_NANO = LLMModel(family=LLMFamilies.OPENAI, name="gpt-5-nano", reasoning=True, prompt_caching=True)
+    GPT_5_1 = LLMModel(family=LLMFamilies.OPENAI, name="gpt-5.1", reasoning=True, prompt_caching=True)
+    GPT_5_1_CODEX = LLMModel(family=LLMFamilies.OPENAI, name="gpt-5.1-codex", reasoning=True, prompt_caching=True)
+    GPT_5_1_CODEX_MINI = LLMModel(family=LLMFamilies.OPENAI, name="gpt-5.1-codex-mini", reasoning=True, prompt_caching=True)
+    GPT_5_1_CODEX_MAX = LLMModel(family=LLMFamilies.OPENAI, name="gpt-5.1-codex-max", reasoning=True, prompt_caching=True)
+    GPT_5_2 = LLMModel(family=LLMFamilies.OPENAI, name="gpt-5.2", reasoning=True, prompt_caching=True)
+    GPT_5_2_PRO = LLMModel(family=LLMFamilies.OPENAI, name="gpt-5.2-pro", reasoning=True, prompt_caching=True)
+
+    # Google models
+    GEMINI_2_5_FLASH = LLMModel(family=LLMFamilies.GOOGLE, name="gemini-2.5-flash", prompt_caching=True)
+    GEMINI_2_5_PRO = LLMModel(family=LLMFamilies.GOOGLE, name="gemini-2.5-pro", prompt_caching=True)
+    GEMINI_2_5_FLASH_MAY_2025 = LLMModel(family=LLMFamilies.GOOGLE, name="gemini-2.5-flash", prompt_caching=True)
+    GEMINI_2_5_PRO_MAY_2025 = LLMModel(family=LLMFamilies.GOOGLE, name="gemini-2.5-pro", prompt_caching=True)
+    GEMINI_3_FLASH = LLMModel(family=LLMFamilies.GOOGLE, name="gemini-3-flash-preview", prompt_caching=True)
+    GEMINI_3_PRO = LLMModel(family=LLMFamilies.GOOGLE, name="gemini-3-pro-preview", prompt_caching=True)
+
+    # Registry for custom models
+    _custom_models: Set[LLMModel] = set()
+
+    @classmethod
+    def register_custom(cls, model: LLMModel) -> LLMModel:
+        """Register a custom model."""
+        cls._custom_models.add(model)
+        return model
+
+    @classmethod
+    def get_all_built_in(cls) -> Set[LLMModel]:
+        """Get all built-in models."""
+        built_ins = set()
+        for attr_name in dir(cls):
+            if not attr_name.startswith("_") and not callable(getattr(cls, attr_name)):
+                attr = getattr(cls, attr_name)
+                if isinstance(attr, LLMModel):
+                    built_ins.add(attr)
+        return built_ins
+
+    @classmethod
+    def get_all(cls) -> Set[LLMModel]:
+        """Get all models (built-in + custom)."""
+        return cls.get_all_built_in().union(cls._custom_models)
+
+    @classmethod
+    def get_by_family(cls, family: str) -> Set[LLMModel]:
+        """Get all models for a specific family."""
+        return {model for model in cls.get_all() if model.family == family}
+
+    @classmethod
+    def from_name(cls, name: str) -> LLMModel:
+        """Find model by name with alias support."""
+        return _find_model_by_name(name, cls._get_aliases())
+
+    @classmethod
+    def _get_aliases(cls) -> Dict[str, LLMModel]:
+        """Get aliases mapping."""
+        return {
+            "sonnet": cls.CLAUDE_4_SONNET,
+            "sonnet 3.7": cls.CLAUDE_3_7_SONNET,
+            "sonnet 4.5": cls.CLAUDE_4_5_SONNET,
+            "haiku": cls.CLAUDE_4_5_HAIKU,
+            "haiku 4.5": cls.CLAUDE_4_5_HAIKU,
+            "opus": cls.CLAUDE_4_5_OPUS,
+            "opus 4.1": cls.CLAUDE_4_1_OPUS,
+            "opus 4.5": cls.CLAUDE_4_5_OPUS,
+            "claude 4.1 opus": cls.CLAUDE_4_1_OPUS,
+            "claude opus 4.1": cls.CLAUDE_4_1_OPUS,
+            "claude 4.5 opus": cls.CLAUDE_4_5_OPUS,
+            "claude opus 4.5": cls.CLAUDE_4_5_OPUS,
+            "claude": cls.CLAUDE_4_SONNET,
+            "claude 3.7 sonnet": cls.CLAUDE_3_7_SONNET,
+            "claude 4 sonnet": cls.CLAUDE_4_SONNET,
+            "claude 4.5 sonnet": cls.CLAUDE_4_5_SONNET,
+            "claude 4.5 haiku": cls.CLAUDE_4_5_HAIKU,
+            "claude 4 opus": cls.CLAUDE_4_OPUS,
+            "o4 mini": cls.O4_MINI,
+            "o4 mini 2025-04-16": cls.O4_MINI_APRIL_2025,
+            "gpt 4.1": cls.GPT_4_1,
+            "gpt 4o": cls.GPT_4O,
+            "gpt 5": cls.GPT_5,
+            "gpt 5 mini": cls.GPT_5_MINI,
+            "gpt 5 nano": cls.GPT_5_NANO,
+            "gpt 5.1": cls.GPT_5_1,
+            "gpt 5.1 codex": cls.GPT_5_1_CODEX,
+            "gpt 5.1 codex mini": cls.GPT_5_1_CODEX_MINI,
+            "gpt 5.1 codex max": cls.GPT_5_1_CODEX_MAX,
+            "gpt 5.2": cls.GPT_5_2,
+            "gpt 5.2 pro": cls.GPT_5_2_PRO,
+            "gemini 2.5 flash": cls.GEMINI_2_5_FLASH,
+            "gemini 2.5 pro": cls.GEMINI_2_5_PRO,
+            "gemini 3 flash": cls.GEMINI_3_FLASH,
+            "gemini 3.0 flash": cls.GEMINI_3_FLASH,
+            "gemini 3 pro": cls.GEMINI_3_PRO,
+            "gemini 3.0 pro": cls.GEMINI_3_PRO,
+        }
+
+
+def _normalize_name(name: str) -> str:
+    """Normalize name by keeping only alphanumeric characters and converting to lowercase."""
+    return re.sub(r"[^a-zA-Z0-9]", "", name.lower())
+
+
+def _find_model_by_name(name: str, aliases: Dict[str, LLMModel]) -> LLMModel:
+    """Find model by name with alias support."""
+    # Check for exact match in aliases first (case-insensitive, ignoring non-alphanumeric)
+    normalized_name = _normalize_name(name)
+    for alias_key, alias_value in aliases.items():
+        if _normalize_name(alias_key) == normalized_name:
+            return alias_value
+
+    # Check for exact match in all models
+    all_models = ModelRegistry.get_all()
+    for model in all_models:
+        if model.name == name:
+            return model
+
+    # Check for starts-with matches in all models
+    matches = []
+    for model in all_models:
+        if model.name.startswith(name):
+            matches.append(model)
+
+    if len(matches) == 0:
+        raise ValueError(f"No LLMModel found starting with '{name}'")
+    elif len(matches) == 1:
+        return matches[0]
+    else:
+        match_names = [m.name for m in matches]
+        raise ValueError(f"Ambiguous LLMModel name '{name}'. Could match: {', '.join(match_names)}")

spaik_sdk/models/providers/anthropic_provider.py

@@ -0,0 +1,29 @@
+from typing import Any, Collection, Dict
+
+from langchain_anthropic import ChatAnthropic
+from langchain_core.language_models.chat_models import BaseChatModel
+
+from spaik_sdk.config.get_credentials_provider import credentials_provider
+from spaik_sdk.models.factories.anthropic_factory import AnthropicModelFactory
+from spaik_sdk.models.llm_config import LLMConfig
+from spaik_sdk.models.llm_model import LLMModel
+from spaik_sdk.models.providers.base_provider import BaseProvider
+
+
+class AnthropicProvider(BaseProvider):
+    def get_supported_models(self) -> Collection[LLMModel]:
+        """Get list of models supported by Anthropic provider."""
+        return AnthropicModelFactory.MODELS
+
+    def get_model_config(self, config: LLMConfig) -> Dict[str, Any]:
+        """Get Anthropic provider configuration (provider-specific only)."""
+        return {
+            "anthropic_api_key": credentials_provider.get_provider_key("anthropic"),
+            "model_kwargs": {
+                "extra_headers": {"anthropic-beta": "prompt-caching-2024-07-31"}  # TODO add output length header
+            },
+        }
+
+    def create_langchain_model(self, config: LLMConfig, full_config: Dict[str, Any]) -> BaseChatModel:
+        """Create Anthropic langchain model with complete configuration."""
+        return ChatAnthropic(**full_config)

spaik_sdk/models/providers/azure_provider.py

@@ -0,0 +1,31 @@
+from typing import Any, Collection, Dict
+
+from langchain_core.language_models.chat_models import BaseChatModel
+from langchain_openai import AzureChatOpenAI
+
+from spaik_sdk.config.env import env_config
+from spaik_sdk.models.factories.openai_factory import OpenAIModelFactory
+from spaik_sdk.models.llm_config import LLMConfig
+from spaik_sdk.models.llm_model import LLMModel
+from spaik_sdk.models.providers.base_provider import BaseProvider
+
+
+class AzureProvider(BaseProvider):
+    def get_supported_models(self) -> Collection[LLMModel]:
+        """Get list of models supported by Azure provider."""
+        return OpenAIModelFactory.MODELS
+
+    def get_model_config(self, config: LLMConfig) -> Dict[str, Any]:
+        """Get Azure AI Foundry provider configuration (provider-specific only)."""
+        return {
+            "api_key": env_config.get_azure_keys()["api_key"],
+            "api_version": env_config.get_azure_keys()["api_version"],
+            "azure_endpoint": env_config.get_azure_keys()["endpoint"],
+        }
+
+    def create_langchain_model(self, config: LLMConfig, full_config: Dict[str, Any]) -> BaseChatModel:
+        """Create Azure langchain model with complete configuration and model-specific deployments."""
+        # Add Azure provider-specific deployment configuration
+        full_config["deployment_name"] = env_config.get_azure_keys()[f"{config.model.name.lower()}_deployment"]
+
+        return AzureChatOpenAI(**full_config)

spaik_sdk/models/providers/base_provider.py

@@ -0,0 +1,62 @@
+from abc import ABC, abstractmethod
+from typing import TYPE_CHECKING, Any, Collection, Dict, Optional
+
+from langchain_core.language_models.chat_models import BaseChatModel
+
+if TYPE_CHECKING:
+    from spaik_sdk.models.llm_config import LLMConfig
+
+from spaik_sdk.config.env import env_config
+from spaik_sdk.models.llm_model import LLMModel
+from spaik_sdk.models.providers.provider_type import ProviderType
+
+
+class BaseProvider(ABC):
+    @abstractmethod
+    def get_supported_models(self) -> Collection[LLMModel]:
+        """Get list of models supported by this provider."""
+        pass
+
+    def supports_model(self, model: LLMModel) -> bool:
+        return model in self.get_supported_models()
+
+    @abstractmethod
+    def get_model_config(self, config: "LLMConfig") -> Dict[str, Any]:
+        """Get model configuration based on model and provider type."""
+        pass
+
+    @abstractmethod
+    def create_langchain_model(self, config: "LLMConfig", full_config: Dict[str, Any]) -> BaseChatModel:
+        """Create the langchain model instance with complete configuration and model info."""
+        pass
+
+    @classmethod
+    def create_provider(cls, provider_type: Optional[ProviderType] = None) -> "BaseProvider":
+        """Factory method to create appropriate provider instance."""
+
+        if provider_type is None:
+            provider_type = env_config.get_provider_type()
+
+        # Import here to avoid circular imports
+        if provider_type == ProviderType.ANTHROPIC:
+            from spaik_sdk.models.providers.anthropic_provider import AnthropicProvider
+
+            return AnthropicProvider()
+        elif provider_type == ProviderType.AZURE_AI_FOUNDRY:
+            from spaik_sdk.models.providers.azure_provider import AzureProvider
+
+            return AzureProvider()
+        elif provider_type == ProviderType.OPENAI_DIRECT:
+            from spaik_sdk.models.providers.openai_provider import OpenAIProvider
+
+            return OpenAIProvider()
+        elif provider_type == ProviderType.GOOGLE:
+            from spaik_sdk.models.providers.google_provider import GoogleProvider
+
+            return GoogleProvider()
+        elif provider_type == ProviderType.OLLAMA:
+            from spaik_sdk.models.providers.ollama_provider import OllamaProvider
+
+            return OllamaProvider()
+        else:
+            raise ValueError(f"Unsupported provider type: {provider_type}")

spaik_sdk/models/providers/google_provider.py

@@ -0,0 +1,26 @@
+from typing import Any, Collection, Dict
+
+from langchain_core.language_models.chat_models import BaseChatModel
+from langchain_google_genai import ChatGoogleGenerativeAI  # type: ignore
+
+from spaik_sdk.config.get_credentials_provider import credentials_provider
+from spaik_sdk.models.factories.google_factory import GoogleModelFactory
+from spaik_sdk.models.llm_config import LLMConfig
+from spaik_sdk.models.llm_model import LLMModel
+from spaik_sdk.models.providers.base_provider import BaseProvider
+
+
+class GoogleProvider(BaseProvider):
+    def get_supported_models(self) -> Collection[LLMModel]:
+        """Get list of models supported by Google provider."""
+        return GoogleModelFactory.MODELS
+
+    def get_model_config(self, config: LLMConfig) -> Dict[str, Any]:
+        """Get Google provider configuration (provider-specific only)."""
+        return {
+            "google_api_key": credentials_provider.get_provider_key("google"),
+        }
+
+    def create_langchain_model(self, config: LLMConfig, full_config: Dict[str, Any]) -> BaseChatModel:
+        """Create Google langchain model with complete configuration."""
+        return ChatGoogleGenerativeAI(**full_config)

spaik_sdk/models/providers/ollama_provider.py

@@ -0,0 +1,26 @@
+from typing import Any, Collection, Dict
+
+from langchain_core.language_models.chat_models import BaseChatModel
+from langchain_ollama import ChatOllama
+
+from spaik_sdk.config.get_credentials_provider import credentials_provider
+from spaik_sdk.models.factories.ollama_factory import OllamaModelFactory
+from spaik_sdk.models.llm_config import LLMConfig
+from spaik_sdk.models.llm_model import LLMModel
+from spaik_sdk.models.providers.base_provider import BaseProvider
+from spaik_sdk.utils.init_logger import init_logger
+
+logger = init_logger(__name__)
+
+
+class OllamaProvider(BaseProvider):
+    def get_supported_models(self) -> Collection[LLMModel]:
+        return OllamaModelFactory.MODELS
+
+    def get_model_config(self, config: LLMConfig) -> Dict[str, Any]:
+        provider_config = {}
+        provider_config["base_url"] = credentials_provider.get_key("OLLAMA_BASE_URL", "http://localhost:11434")
+        return provider_config
+
+    def create_langchain_model(self, config: LLMConfig, full_config: Dict[str, Any]) -> BaseChatModel:
+        return ChatOllama(model=config.model.name, **full_config)

spaik_sdk/models/providers/openai_provider.py

@@ -0,0 +1,26 @@
+from typing import Any, Collection, Dict
+
+from langchain_core.language_models.chat_models import BaseChatModel
+from langchain_openai import ChatOpenAI
+
+from spaik_sdk.config.get_credentials_provider import credentials_provider
+from spaik_sdk.models.factories.openai_factory import OpenAIModelFactory
+from spaik_sdk.models.llm_config import LLMConfig
+from spaik_sdk.models.llm_model import LLMModel
+from spaik_sdk.models.providers.base_provider import BaseProvider
+
+
+class OpenAIProvider(BaseProvider):
+    def get_supported_models(self) -> Collection[LLMModel]:
+        """Get list of models supported by OpenAI provider."""
+        return OpenAIModelFactory.MODELS
+
+    def get_model_config(self, config: LLMConfig) -> Dict[str, Any]:
+        """Get OpenAI provider configuration (provider-specific only)."""
+        return {
+            "api_key": credentials_provider.get_provider_key("openai"),
+        }
+
+    def create_langchain_model(self, config: LLMConfig, full_config: Dict[str, Any]) -> BaseChatModel:
+        """Create OpenAI langchain model with complete configuration."""
+        return ChatOpenAI(**full_config)

spaik_sdk/models/providers/provider_type.py

@@ -0,0 +1,90 @@
+import re
+from enum import Enum
+from typing import Dict, Type, TypeVar
+
+
+class ProviderType(Enum):
+    ANTHROPIC = "anthropic"
+    AZURE_AI_FOUNDRY = "azure_ai_foundry"
+    OPENAI_DIRECT = "openai"
+    GOOGLE = "google"
+    OLLAMA = "ollama"
+
+    @classmethod
+    def from_name(cls, name: str) -> "ProviderType":
+        return _find_enum_by_name(cls, name, PROVIDER_ALIASES)
+
+    @classmethod
+    def from_model_name(cls, model_name: str) -> "ProviderType":
+        if model_name.startswith("claude"):
+            return cls.ANTHROPIC
+        elif model_name.startswith("gemini"):
+            return cls.GOOGLE
+        elif model_name.startswith("gpt") or model_name.startswith("o3") or model_name.startswith("o4"):
+            return cls.OPENAI_DIRECT
+        else:
+            # For ollama models, we can't determine from name alone since they're arbitrary
+            # Users will need to specify family="ollama" when creating LLMModel
+            raise ValueError(f"Cant determine provider type from model name: {model_name}")
+
+    @classmethod
+    def from_family(cls, family: str) -> "ProviderType":
+        """Get provider type from model family."""
+        family_lower = family.lower()
+        if family_lower == "anthropic":
+            return cls.ANTHROPIC
+        elif family_lower == "openai":
+            return cls.OPENAI_DIRECT
+        elif family_lower == "google":
+            return cls.GOOGLE
+        elif family_lower == "ollama":
+            return cls.OLLAMA
+        else:
+            raise ValueError(f"Unknown model family: {family}")
+
+
+PROVIDER_ALIASES = {
+    "claude": ProviderType.ANTHROPIC,
+    "ollama": ProviderType.OLLAMA,
+    "azure": ProviderType.AZURE_AI_FOUNDRY,
+    "foundry": ProviderType.AZURE_AI_FOUNDRY,
+    "openai": ProviderType.OPENAI_DIRECT,
+    "google": ProviderType.GOOGLE,
+    "gemini": ProviderType.GOOGLE,
+}
+
+
+T = TypeVar("T", bound=Enum)
+
+
+def _normalize_name(name: str) -> str:
+    """Normalize name by keeping only alphanumeric characters and converting to lowercase."""
+    return re.sub(r"[^a-zA-Z0-9]", "", name.lower())
+
+
+def _find_enum_by_name(enum_cls: Type[T], name: str, aliases: Dict[str, T]) -> T:
+    """Shared logic for finding enum members by name with alias support."""
+    # Check for exact match in aliases first (case-insensitive, ignoring non-alphanumeric)
+    normalized_name = _normalize_name(name)
+    for alias_key, alias_value in aliases.items():
+        if _normalize_name(alias_key) == normalized_name:
+            return alias_value
+
+    # Check for exact match in enum values
+    for item in enum_cls:
+        if item.value == name:
+            return item
+
+    # Check for starts-with matches in enum values
+    matches = []
+    for item in enum_cls:
+        if item.value.startswith(name):
+            matches.append(item)
+
+    if len(matches) == 0:
+        raise ValueError(f"No {enum_cls.__name__} found starting with '{name}'")
+    elif len(matches) == 1:
+        return matches[0]
+    else:
+        match_names = [m.value for m in matches]
+        raise ValueError(f"Ambiguous {enum_cls.__name__} name '{name}'. Could match: {', '.join(match_names)}")

spaik_sdk/orchestration/__init__.py

@@ -0,0 +1,24 @@
+from spaik_sdk.orchestration.base_orchestrator import BaseOrchestrator, SimpleOrchestrator
+from spaik_sdk.orchestration.checkpoint import (
+    CheckpointProvider,
+    DictCheckpointProvider,
+    InMemoryCheckpointProvider,
+)
+from spaik_sdk.orchestration.models import (
+    OrchestratorEvent,
+    ProgressUpdate,
+    StepInfo,
+    StepStatus,
+)
+
+__all__ = [
+    "BaseOrchestrator",
+    "SimpleOrchestrator",
+    "CheckpointProvider",
+    "InMemoryCheckpointProvider",
+    "DictCheckpointProvider",
+    "OrchestratorEvent",
+    "ProgressUpdate",
+    "StepInfo",
+    "StepStatus",
+]