spaik-sdk 0.6.5__tar.gz → 0.6.6__tar.gz

{spaik_sdk-0.6.5 → spaik_sdk-0.6.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: spaik-sdk
-Version: 0.6.5
+Version: 0.6.6
 Summary: Python SDK for building AI agents with multi-LLM support, streaming, and production-ready infrastructure
 Project-URL: Homepage, https://github.com/siilisolutions/spaik-sdk
 Project-URL: Repository, https://github.com/siilisolutions/spaik-sdk
@@ -24,12 +24,16 @@ Requires-Dist: dotenv>=0.9.9
 Requires-Dist: fastapi>=0.115.12
 Requires-Dist: httpx>=0.25.0
 Requires-Dist: langchain-anthropic>=1.3.0
+Requires-Dist: langchain-cohere>=0.5.0
 Requires-Dist: langchain-core>=1.2.0
+Requires-Dist: langchain-deepseek>=1.0.0
 Requires-Dist: langchain-google-genai>=4.0.0
 Requires-Dist: langchain-mcp-adapters>=0.2.1
+Requires-Dist: langchain-mistralai>=0.2.0
 Requires-Dist: langchain-ollama>=0.3.0
 Requires-Dist: langchain-openai>=1.1.0
 Requires-Dist: langchain-tavily>=0.2.15
+Requires-Dist: langchain-xai>=0.2.0
 Requires-Dist: langchain>=1.2.0
 Requires-Dist: langgraph>=1.0.0
 Requires-Dist: mcp>=1.9.2

{spaik_sdk-0.6.5 → spaik_sdk-0.6.6}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "spaik-sdk"
-version = "0.6.5"
+version = "0.6.6"
 description = "Python SDK for building AI agents with multi-LLM support, streaming, and production-ready infrastructure"
 readme = "README.md"
 license = "MIT"
@@ -28,10 +28,14 @@ dependencies = [
     "cryptography>=41.0.0", # Required for JWT RSA operations
     "langchain>=1.2.0",
     "langchain-anthropic>=1.3.0",
+    "langchain-cohere>=0.5.0",
     "langchain-core>=1.2.0",
+    "langchain-deepseek>=1.0.0",
     "langchain-google-genai>=4.0.0",
+    "langchain-mistralai>=0.2.0",
     "langchain-openai>=1.1.0",
     "langchain-ollama>=0.3.0",
+    "langchain-xai>=0.2.0",
     "langgraph>=1.0.0",
     "pandas>=2.0.3",
     "pandas-stubs",

{spaik_sdk-0.6.5 → spaik_sdk-0.6.6}/spaik_sdk/models/factories/anthropic_factory.py

@@ -21,7 +21,7 @@ class AnthropicModelFactory(BaseModelFactory):
         model_config: Dict[str, Any] = {
             "model_name": config.model.name,
             "streaming": config.streaming,
-            "max_tokens": config.max_output_tokens,
+            "max_tokens": config.max_output_tokens if config.max_output_tokens is not None else 8192,
         }
 
         # Handle thinking mode via model_kwargs for LangChain compatibility

{spaik_sdk-0.6.5 → spaik_sdk-0.6.6}/spaik_sdk/models/factories/base_model_factory.py

@@ -54,15 +54,27 @@ class BaseModelFactory(ABC):
         """Factory method to create appropriate factory instance."""
 
         from spaik_sdk.models.factories.anthropic_factory import AnthropicModelFactory
+        from spaik_sdk.models.factories.cohere_factory import CohereModelFactory
+        from spaik_sdk.models.factories.deepseek_factory import DeepSeekModelFactory
         from spaik_sdk.models.factories.google_factory import GoogleModelFactory
+        from spaik_sdk.models.factories.meta_factory import MetaModelFactory
+        from spaik_sdk.models.factories.mistral_factory import MistralModelFactory
+        from spaik_sdk.models.factories.moonshot_factory import MoonshotModelFactory
         from spaik_sdk.models.factories.ollama_factory import OllamaModelFactory
         from spaik_sdk.models.factories.openai_factory import OpenAIModelFactory
+        from spaik_sdk.models.factories.xai_factory import XAIModelFactory
 
         factories = [
             AnthropicModelFactory(),
             OpenAIModelFactory(),
             GoogleModelFactory(),
             OllamaModelFactory(),
+            DeepSeekModelFactory(),
+            XAIModelFactory(),
+            CohereModelFactory(),
+            MistralModelFactory(),
+            MetaModelFactory(),
+            MoonshotModelFactory(),
         ]
         for factory in factories:
             if factory.supports_model_config(config):

spaik_sdk-0.6.6/spaik_sdk/models/factories/cohere_factory.py

@@ -0,0 +1,24 @@
+from typing import Any, Dict, Optional
+
+from spaik_sdk.models.factories.base_model_factory import BaseModelFactory
+from spaik_sdk.models.llm_config import LLMConfig
+from spaik_sdk.models.llm_families import LLMFamilies
+from spaik_sdk.models.llm_model import LLMModel
+from spaik_sdk.models.model_registry import ModelRegistry
+
+
+class CohereModelFactory(BaseModelFactory):
+    MODELS = ModelRegistry.get_by_family(LLMFamilies.COHERE)
+
+    def supports_model(self, model: LLMModel) -> bool:
+        return model in CohereModelFactory.MODELS
+
+    def get_cache_control(self, config: LLMConfig) -> Optional[Dict[str, Any]]:
+        return None
+
+    def get_model_specific_config(self, config: LLMConfig) -> Dict[str, Any]:
+        model_config: Dict[str, Any] = {
+            "model": config.model.name,
+            "temperature": config.temperature,
+        }
+        return model_config

spaik_sdk-0.6.6/spaik_sdk/models/factories/deepseek_factory.py

@@ -0,0 +1,26 @@
+from typing import Any, Dict, Optional
+
+from spaik_sdk.models.factories.base_model_factory import BaseModelFactory
+from spaik_sdk.models.llm_config import LLMConfig
+from spaik_sdk.models.llm_families import LLMFamilies
+from spaik_sdk.models.llm_model import LLMModel
+from spaik_sdk.models.model_registry import ModelRegistry
+
+
+class DeepSeekModelFactory(BaseModelFactory):
+    MODELS = ModelRegistry.get_by_family(LLMFamilies.DEEPSEEK)
+
+    def supports_model(self, model: LLMModel) -> bool:
+        return model in DeepSeekModelFactory.MODELS
+
+    def get_cache_control(self, config: LLMConfig) -> Optional[Dict[str, Any]]:
+        return None
+
+    def get_model_specific_config(self, config: LLMConfig) -> Dict[str, Any]:
+        model_config: Dict[str, Any] = {
+            "model": config.model.name,
+            "temperature": config.temperature,
+        }
+        if config.max_output_tokens is not None:
+            model_config["max_tokens"] = config.max_output_tokens
+        return model_config

spaik_sdk-0.6.6/spaik_sdk/models/factories/meta_factory.py

@@ -0,0 +1,26 @@
+from typing import Any, Dict, Optional
+
+from spaik_sdk.models.factories.base_model_factory import BaseModelFactory
+from spaik_sdk.models.llm_config import LLMConfig
+from spaik_sdk.models.llm_families import LLMFamilies
+from spaik_sdk.models.llm_model import LLMModel
+from spaik_sdk.models.model_registry import ModelRegistry
+
+
+class MetaModelFactory(BaseModelFactory):
+    MODELS = ModelRegistry.get_by_family(LLMFamilies.META)
+
+    def supports_model(self, model: LLMModel) -> bool:
+        return model in MetaModelFactory.MODELS
+
+    def get_cache_control(self, config: LLMConfig) -> Optional[Dict[str, Any]]:
+        return None
+
+    def get_model_specific_config(self, config: LLMConfig) -> Dict[str, Any]:
+        model_config: Dict[str, Any] = {
+            "model": config.model.name,
+            "temperature": config.temperature,
+        }
+        if config.max_output_tokens is not None:
+            model_config["max_tokens"] = config.max_output_tokens
+        return model_config

spaik_sdk-0.6.6/spaik_sdk/models/factories/mistral_factory.py

@@ -0,0 +1,26 @@
+from typing import Any, Dict, Optional
+
+from spaik_sdk.models.factories.base_model_factory import BaseModelFactory
+from spaik_sdk.models.llm_config import LLMConfig
+from spaik_sdk.models.llm_families import LLMFamilies
+from spaik_sdk.models.llm_model import LLMModel
+from spaik_sdk.models.model_registry import ModelRegistry
+
+
+class MistralModelFactory(BaseModelFactory):
+    MODELS = ModelRegistry.get_by_family(LLMFamilies.MISTRAL)
+
+    def supports_model(self, model: LLMModel) -> bool:
+        return model in MistralModelFactory.MODELS
+
+    def get_cache_control(self, config: LLMConfig) -> Optional[Dict[str, Any]]:
+        return None
+
+    def get_model_specific_config(self, config: LLMConfig) -> Dict[str, Any]:
+        model_config: Dict[str, Any] = {
+            "model": config.model.name,
+            "temperature": config.temperature,
+        }
+        if config.max_output_tokens is not None:
+            model_config["max_tokens"] = config.max_output_tokens
+        return model_config

spaik_sdk-0.6.6/spaik_sdk/models/factories/moonshot_factory.py

@@ -0,0 +1,26 @@
+from typing import Any, Dict, Optional
+
+from spaik_sdk.models.factories.base_model_factory import BaseModelFactory
+from spaik_sdk.models.llm_config import LLMConfig
+from spaik_sdk.models.llm_families import LLMFamilies
+from spaik_sdk.models.llm_model import LLMModel
+from spaik_sdk.models.model_registry import ModelRegistry
+
+
+class MoonshotModelFactory(BaseModelFactory):
+    MODELS = ModelRegistry.get_by_family(LLMFamilies.MOONSHOT)
+
+    def supports_model(self, model: LLMModel) -> bool:
+        return model in MoonshotModelFactory.MODELS
+
+    def get_cache_control(self, config: LLMConfig) -> Optional[Dict[str, Any]]:
+        return None
+
+    def get_model_specific_config(self, config: LLMConfig) -> Dict[str, Any]:
+        model_config: Dict[str, Any] = {
+            "model": config.model.name,
+            "temperature": config.temperature,
+        }
+        if config.max_output_tokens is not None:
+            model_config["max_tokens"] = config.max_output_tokens
+        return model_config

spaik_sdk-0.6.6/spaik_sdk/models/factories/xai_factory.py

@@ -0,0 +1,26 @@
+from typing import Any, Dict, Optional
+
+from spaik_sdk.models.factories.base_model_factory import BaseModelFactory
+from spaik_sdk.models.llm_config import LLMConfig
+from spaik_sdk.models.llm_families import LLMFamilies
+from spaik_sdk.models.llm_model import LLMModel
+from spaik_sdk.models.model_registry import ModelRegistry
+
+
+class XAIModelFactory(BaseModelFactory):
+    MODELS = ModelRegistry.get_by_family(LLMFamilies.XAI)
+
+    def supports_model(self, model: LLMModel) -> bool:
+        return model in XAIModelFactory.MODELS
+
+    def get_cache_control(self, config: LLMConfig) -> Optional[Dict[str, Any]]:
+        return None
+
+    def get_model_specific_config(self, config: LLMConfig) -> Dict[str, Any]:
+        model_config: Dict[str, Any] = {
+            "model": config.model.name,
+            "temperature": config.temperature,
+        }
+        if config.max_output_tokens is not None:
+            model_config["max_tokens"] = config.max_output_tokens
+        return model_config

{spaik_sdk-0.6.5 → spaik_sdk-0.6.6}/spaik_sdk/models/llm_config.py

@@ -16,7 +16,7 @@ class LLMConfig:
     streaming: bool = True
     reasoning_summary: str = "detailed"  # Options: "auto", "concise", "detailed", None
     reasoning_effort: str = "medium"  # Options: "low", "medium", "high"
-    max_output_tokens: int = 8192
+    max_output_tokens: Optional[int] = None
     reasoning_budget_tokens: int = 4096
     temperature: float = 0.1
     structured_response: bool = False

{spaik_sdk-0.6.5 → spaik_sdk-0.6.6}/spaik_sdk/models/llm_families.py

@@ -5,3 +5,9 @@ class LLMFamilies:
     OPENAI = "openai"
     GOOGLE = "google"
     OLLAMA = "ollama"
+    DEEPSEEK = "deepseek"
+    MISTRAL = "mistral"
+    META = "meta"
+    COHERE = "cohere"
+    XAI = "xai"
+    MOONSHOT = "moonshot"

{spaik_sdk-0.6.5 → spaik_sdk-0.6.6}/spaik_sdk/models/model_registry.py

@@ -22,17 +22,32 @@ class ModelRegistry:
 
     # OpenAI models
     GPT_4_1 = LLMModel(family=LLMFamilies.OPENAI, name="gpt-4.1", reasoning=False, prompt_caching=True)
+    GPT_4_1_MINI = LLMModel(family=LLMFamilies.OPENAI, name="gpt-4.1-mini", reasoning=False, prompt_caching=True)
+    GPT_4_1_NANO = LLMModel(family=LLMFamilies.OPENAI, name="gpt-4.1-nano", reasoning=False, prompt_caching=True)
     GPT_4O = LLMModel(family=LLMFamilies.OPENAI, name="gpt-4o", reasoning=False, prompt_caching=True)
+    GPT_4O_MINI = LLMModel(family=LLMFamilies.OPENAI, name="gpt-4o-mini", reasoning=False, prompt_caching=True)
+    O1 = LLMModel(family=LLMFamilies.OPENAI, name="o1")
+    O1_MINI = LLMModel(family=LLMFamilies.OPENAI, name="o1-mini")
+    O3 = LLMModel(family=LLMFamilies.OPENAI, name="o3")
+    O3_MINI = LLMModel(family=LLMFamilies.OPENAI, name="o3-mini")
+    O3_PRO = LLMModel(family=LLMFamilies.OPENAI, name="o3-pro")
     O4_MINI = LLMModel(family=LLMFamilies.OPENAI, name="o4-mini")
     O4_MINI_APRIL_2025 = LLMModel(family=LLMFamilies.OPENAI, name="o4-mini-2025-04-16")
+    CODEX_MINI = LLMModel(family=LLMFamilies.OPENAI, name="codex-mini")
     GPT_5 = LLMModel(family=LLMFamilies.OPENAI, name="gpt-5", reasoning=True, reasoning_min_effort="minimal", prompt_caching=True)
     GPT_5_MINI = LLMModel(family=LLMFamilies.OPENAI, name="gpt-5-mini", reasoning=True, reasoning_min_effort="minimal", prompt_caching=True)
     GPT_5_NANO = LLMModel(family=LLMFamilies.OPENAI, name="gpt-5-nano", reasoning=True, reasoning_min_effort="minimal", prompt_caching=True)
+    GPT_5_CHAT = LLMModel(family=LLMFamilies.OPENAI, name="gpt-5-chat", reasoning=False, prompt_caching=True)
+    GPT_5_CODEX = LLMModel(family=LLMFamilies.OPENAI, name="gpt-5-codex", reasoning=True, prompt_caching=True)
+    GPT_5_PRO = LLMModel(family=LLMFamilies.OPENAI, name="gpt-5-pro", reasoning=True, prompt_caching=True)
     GPT_5_1 = LLMModel(family=LLMFamilies.OPENAI, name="gpt-5.1", reasoning=True, prompt_caching=True)
+    GPT_5_1_CHAT = LLMModel(family=LLMFamilies.OPENAI, name="gpt-5.1-chat", 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_CHAT = LLMModel(family=LLMFamilies.OPENAI, name="gpt-5.2-chat", reasoning=False, prompt_caching=True)
+    GPT_5_2_CODEX = LLMModel(family=LLMFamilies.OPENAI, name="gpt-5.2-codex", 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
@@ -43,6 +58,35 @@ class ModelRegistry:
     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)
 
+    # DeepSeek models
+    DEEPSEEK_V3 = LLMModel(family=LLMFamilies.DEEPSEEK, name="DeepSeek-V3-0324")
+    DEEPSEEK_V3_1 = LLMModel(family=LLMFamilies.DEEPSEEK, name="DeepSeek-V3.1")
+    DEEPSEEK_V3_2 = LLMModel(family=LLMFamilies.DEEPSEEK, name="DeepSeek-V3.2")
+    DEEPSEEK_V3_2_SPECIALE = LLMModel(family=LLMFamilies.DEEPSEEK, name="DeepSeek-V3.2-Speciale")
+    DEEPSEEK_R1 = LLMModel(family=LLMFamilies.DEEPSEEK, name="DeepSeek-R1")
+    DEEPSEEK_R1_0528 = LLMModel(family=LLMFamilies.DEEPSEEK, name="DeepSeek-R1-0528")
+
+    # Mistral models
+    MISTRAL_LARGE_3 = LLMModel(family=LLMFamilies.MISTRAL, name="Mistral-Large-3", reasoning=False)
+
+    # Meta Llama models
+    LLAMA_4_MAVERICK = LLMModel(family=LLMFamilies.META, name="Llama-4-Maverick-17B-128E-Instruct-FP8", reasoning=False)
+    LLAMA_3_3_70B = LLMModel(family=LLMFamilies.META, name="Llama-3.3-70B-Instruct", reasoning=False)
+
+    # Cohere models
+    COHERE_COMMAND_A = LLMModel(family=LLMFamilies.COHERE, name="Cohere-command-a", reasoning=False)
+
+    # xAI Grok models
+    GROK_3 = LLMModel(family=LLMFamilies.XAI, name="grok-3")
+    GROK_3_MINI = LLMModel(family=LLMFamilies.XAI, name="grok-3-mini")
+    GROK_4 = LLMModel(family=LLMFamilies.XAI, name="grok-4")
+    GROK_4_FAST_REASONING = LLMModel(family=LLMFamilies.XAI, name="grok-4-fast-reasoning")
+    GROK_4_FAST_NON_REASONING = LLMModel(family=LLMFamilies.XAI, name="grok-4-fast-non-reasoning", reasoning=False)
+    GROK_CODE_FAST_1 = LLMModel(family=LLMFamilies.XAI, name="grok-code-fast-1")
+
+    # Moonshot AI models
+    KIMI_K2_THINKING = LLMModel(family=LLMFamilies.MOONSHOT, name="Kimi-K2-Thinking")
+
     # Registry for custom models
     _custom_models: Set[LLMModel] = set()
 
@@ -82,6 +126,7 @@ class ModelRegistry:
     def _get_aliases(cls) -> Dict[str, LLMModel]:
         """Get aliases mapping."""
         return {
+            # Claude aliases
             "sonnet": cls.CLAUDE_4_SONNET,
             "sonnet 3.7": cls.CLAUDE_3_7_SONNET,
             "sonnet 4.5": cls.CLAUDE_4_5_SONNET,
@@ -100,25 +145,73 @@ class ModelRegistry:
             "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,
+            # OpenAI aliases
+            "o1": cls.O1,
+            "o1 mini": cls.O1_MINI,
+            "o3": cls.O3,
+            "o3 mini": cls.O3_MINI,
+            "o3 pro": cls.O3_PRO,
             "o4 mini": cls.O4_MINI,
             "o4 mini 2025-04-16": cls.O4_MINI_APRIL_2025,
+            "codex mini": cls.CODEX_MINI,
             "gpt 4.1": cls.GPT_4_1,
+            "gpt 4.1 mini": cls.GPT_4_1_MINI,
+            "gpt 4.1 nano": cls.GPT_4_1_NANO,
             "gpt 4o": cls.GPT_4O,
+            "gpt 4o mini": cls.GPT_4O_MINI,
             "gpt 5": cls.GPT_5,
             "gpt 5 mini": cls.GPT_5_MINI,
             "gpt 5 nano": cls.GPT_5_NANO,
+            "gpt 5 chat": cls.GPT_5_CHAT,
+            "gpt 5 codex": cls.GPT_5_CODEX,
+            "gpt 5 pro": cls.GPT_5_PRO,
             "gpt 5.1": cls.GPT_5_1,
+            "gpt 5.1 chat": cls.GPT_5_1_CHAT,
             "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 chat": cls.GPT_5_2_CHAT,
+            "gpt 5.2 codex": cls.GPT_5_2_CODEX,
             "gpt 5.2 pro": cls.GPT_5_2_PRO,
+            # Gemini aliases
             "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,
+            # DeepSeek aliases
+            "deepseek": cls.DEEPSEEK_V3_2,
+            "deepseek v3": cls.DEEPSEEK_V3,
+            "deepseek v3.1": cls.DEEPSEEK_V3_1,
+            "deepseek v3.2": cls.DEEPSEEK_V3_2,
+            "deepseek v3.2 speciale": cls.DEEPSEEK_V3_2_SPECIALE,
+            "deepseek r1": cls.DEEPSEEK_R1,
+            # Mistral aliases
+            "mistral": cls.MISTRAL_LARGE_3,
+            "mistral large": cls.MISTRAL_LARGE_3,
+            "mistral large 3": cls.MISTRAL_LARGE_3,
+            # Meta Llama aliases
+            "llama": cls.LLAMA_3_3_70B,
+            "llama 3.3": cls.LLAMA_3_3_70B,
+            "llama 3.3 70b": cls.LLAMA_3_3_70B,
+            "llama 4": cls.LLAMA_4_MAVERICK,
+            "llama 4 maverick": cls.LLAMA_4_MAVERICK,
+            # Cohere aliases
+            "cohere": cls.COHERE_COMMAND_A,
+            "cohere command": cls.COHERE_COMMAND_A,
+            "command a": cls.COHERE_COMMAND_A,
+            # xAI Grok aliases
+            "grok": cls.GROK_4,
+            "grok 3": cls.GROK_3,
+            "grok 3 mini": cls.GROK_3_MINI,
+            "grok 4": cls.GROK_4,
+            "grok 4 fast": cls.GROK_4_FAST_REASONING,
+            "grok code": cls.GROK_CODE_FAST_1,
+            # Moonshot aliases
+            "kimi": cls.KIMI_K2_THINKING,
+            "kimi k2": cls.KIMI_K2_THINKING,
         }
 
 

spaik_sdk-0.6.6/spaik_sdk/models/providers/azure_provider.py

@@ -0,0 +1,101 @@
+import os
+from typing import Any, Collection, Dict, Set
+
+from langchain_core.language_models.chat_models import BaseChatModel
+from langchain_openai import AzureChatOpenAI
+
+from spaik_sdk.models.llm_config import LLMConfig
+from spaik_sdk.models.llm_model import LLMModel
+from spaik_sdk.models.model_registry import ModelRegistry
+from spaik_sdk.models.providers.base_provider import BaseProvider
+
+# Model name -> Environment variable for Azure deployment name
+AZURE_DEPLOYMENT_ENV_VARS: Dict[str, str] = {
+    # OpenAI models
+    "gpt-4.1": "AZURE_GPT_4_1_DEPLOYMENT",
+    "gpt-4.1-mini": "AZURE_GPT_4_1_MINI_DEPLOYMENT",
+    "gpt-4.1-nano": "AZURE_GPT_4_1_NANO_DEPLOYMENT",
+    "gpt-4o": "AZURE_GPT_4O_DEPLOYMENT",
+    "gpt-4o-mini": "AZURE_GPT_4O_MINI_DEPLOYMENT",
+    "o1": "AZURE_O1_DEPLOYMENT",
+    "o1-mini": "AZURE_O1_MINI_DEPLOYMENT",
+    "o3": "AZURE_O3_DEPLOYMENT",
+    "o3-mini": "AZURE_O3_MINI_DEPLOYMENT",
+    "o3-pro": "AZURE_O3_PRO_DEPLOYMENT",
+    "o4-mini": "AZURE_O4_MINI_DEPLOYMENT",
+    "o4-mini-2025-04-16": "AZURE_O4_MINI_2025_04_16_DEPLOYMENT",
+    "codex-mini": "AZURE_CODEX_MINI_DEPLOYMENT",
+    "gpt-5": "AZURE_GPT_5_DEPLOYMENT",
+    "gpt-5-mini": "AZURE_GPT_5_MINI_DEPLOYMENT",
+    "gpt-5-nano": "AZURE_GPT_5_NANO_DEPLOYMENT",
+    "gpt-5-chat": "AZURE_GPT_5_CHAT_DEPLOYMENT",
+    "gpt-5-codex": "AZURE_GPT_5_CODEX_DEPLOYMENT",
+    "gpt-5-pro": "AZURE_GPT_5_PRO_DEPLOYMENT",
+    "gpt-5.1": "AZURE_GPT_5_1_DEPLOYMENT",
+    "gpt-5.1-chat": "AZURE_GPT_5_1_CHAT_DEPLOYMENT",
+    "gpt-5.1-codex": "AZURE_GPT_5_1_CODEX_DEPLOYMENT",
+    "gpt-5.1-codex-mini": "AZURE_GPT_5_1_CODEX_MINI_DEPLOYMENT",
+    "gpt-5.1-codex-max": "AZURE_GPT_5_1_CODEX_MAX_DEPLOYMENT",
+    "gpt-5.2": "AZURE_GPT_5_2_DEPLOYMENT",
+    "gpt-5.2-chat": "AZURE_GPT_5_2_CHAT_DEPLOYMENT",
+    "gpt-5.2-codex": "AZURE_GPT_5_2_CODEX_DEPLOYMENT",
+    "gpt-5.2-pro": "AZURE_GPT_5_2_PRO_DEPLOYMENT",
+    # DeepSeek models (Azure AI Foundry)
+    "DeepSeek-V3-0324": "AZURE_DEEPSEEK_V3_DEPLOYMENT",
+    "DeepSeek-V3.1": "AZURE_DEEPSEEK_V3_1_DEPLOYMENT",
+    "DeepSeek-V3.2": "AZURE_DEEPSEEK_V3_2_DEPLOYMENT",
+    "DeepSeek-V3.2-Speciale": "AZURE_DEEPSEEK_V3_2_SPECIALE_DEPLOYMENT",
+    "DeepSeek-R1": "AZURE_DEEPSEEK_R1_DEPLOYMENT",
+    "DeepSeek-R1-0528": "AZURE_DEEPSEEK_R1_0528_DEPLOYMENT",
+    # Mistral models (Azure AI Foundry)
+    "Mistral-Large-3": "AZURE_MISTRAL_LARGE_3_DEPLOYMENT",
+    # Meta Llama models (Azure AI Foundry)
+    "Llama-4-Maverick-17B-128E-Instruct-FP8": "AZURE_LLAMA_4_MAVERICK_DEPLOYMENT",
+    "Llama-3.3-70B-Instruct": "AZURE_LLAMA_3_3_70B_DEPLOYMENT",
+    # Cohere models (Azure AI Foundry)
+    "Cohere-command-a": "AZURE_COHERE_COMMAND_A_DEPLOYMENT",
+    # xAI Grok models (Azure AI Foundry)
+    "grok-3": "AZURE_GROK_3_DEPLOYMENT",
+    "grok-3-mini": "AZURE_GROK_3_MINI_DEPLOYMENT",
+    "grok-4": "AZURE_GROK_4_DEPLOYMENT",
+    "grok-4-fast-reasoning": "AZURE_GROK_4_FAST_REASONING_DEPLOYMENT",
+    "grok-4-fast-non-reasoning": "AZURE_GROK_4_FAST_NON_REASONING_DEPLOYMENT",
+    "grok-code-fast-1": "AZURE_GROK_CODE_FAST_1_DEPLOYMENT",
+    # Moonshot AI models (Azure AI Foundry)
+    "Kimi-K2-Thinking": "AZURE_KIMI_K2_THINKING_DEPLOYMENT",
+}
+
+
+class AzureProvider(BaseProvider):
+    def get_supported_models(self) -> Collection[LLMModel]:
+        supported: Set[LLMModel] = set()
+        for model_name in AZURE_DEPLOYMENT_ENV_VARS.keys():
+            try:
+                model = ModelRegistry.from_name(model_name)
+                supported.add(model)
+            except ValueError:
+                pass
+        return supported
+
+    def get_model_config(self, config: LLMConfig) -> Dict[str, Any]:
+        return {
+            "api_key": self._get_required_env("AZURE_API_KEY"),
+            "api_version": self._get_required_env("AZURE_API_VERSION"),
+            "azure_endpoint": self._get_required_env("AZURE_ENDPOINT"),
+        }
+
+    def create_langchain_model(self, config: LLMConfig, full_config: Dict[str, Any]) -> BaseChatModel:
+        full_config["deployment_name"] = self._get_deployment_name(config.model.name)
+        return AzureChatOpenAI(**full_config)
+
+    def _get_deployment_name(self, model_name: str) -> str:
+        env_var = AZURE_DEPLOYMENT_ENV_VARS.get(model_name)
+        if not env_var:
+            raise ValueError(f"Model '{model_name}' not supported on Azure. Add it to AZURE_DEPLOYMENT_ENV_VARS.")
+        return os.environ.get(env_var, model_name)
+
+    def _get_required_env(self, key: str) -> str:
+        value = os.environ.get(key)
+        if not value:
+            raise ValueError(f"Environment variable {key} is required but not set")
+        return value

{spaik_sdk-0.6.5 → spaik_sdk-0.6.6}/spaik_sdk/models/providers/base_provider.py

@@ -58,5 +58,21 @@ class BaseProvider(ABC):
             from spaik_sdk.models.providers.ollama_provider import OllamaProvider
 
             return OllamaProvider()
+        elif provider_type == ProviderType.DEEPSEEK:
+            from spaik_sdk.models.providers.deepseek_provider import DeepSeekProvider
+
+            return DeepSeekProvider()
+        elif provider_type == ProviderType.XAI:
+            from spaik_sdk.models.providers.xai_provider import XAIProvider
+
+            return XAIProvider()
+        elif provider_type == ProviderType.COHERE:
+            from spaik_sdk.models.providers.cohere_provider import CohereProvider
+
+            return CohereProvider()
+        elif provider_type == ProviderType.MISTRAL:
+            from spaik_sdk.models.providers.mistral_provider import MistralProvider
+
+            return MistralProvider()
         else:
             raise ValueError(f"Unsupported provider type: {provider_type}")

spaik_sdk-0.6.6/spaik_sdk/models/providers/cohere_provider.py

@@ -0,0 +1,23 @@
+from typing import Any, Collection, Dict
+
+from langchain_cohere import ChatCohere
+from langchain_core.language_models.chat_models import BaseChatModel
+
+from spaik_sdk.config.get_credentials_provider import credentials_provider
+from spaik_sdk.models.factories.cohere_factory import CohereModelFactory
+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 CohereProvider(BaseProvider):
+    def get_supported_models(self) -> Collection[LLMModel]:
+        return CohereModelFactory.MODELS
+
+    def get_model_config(self, config: LLMConfig) -> Dict[str, Any]:
+        return {
+            "cohere_api_key": credentials_provider.get_provider_key("cohere"),
+        }
+
+    def create_langchain_model(self, config: LLMConfig, full_config: Dict[str, Any]) -> BaseChatModel:
+        return ChatCohere(**full_config)

spaik_sdk-0.6.6/spaik_sdk/models/providers/deepseek_provider.py

@@ -0,0 +1,23 @@
+from typing import Any, Collection, Dict
+
+from langchain_core.language_models.chat_models import BaseChatModel
+from langchain_deepseek import ChatDeepSeek
+
+from spaik_sdk.config.get_credentials_provider import credentials_provider
+from spaik_sdk.models.factories.deepseek_factory import DeepSeekModelFactory
+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 DeepSeekProvider(BaseProvider):
+    def get_supported_models(self) -> Collection[LLMModel]:
+        return DeepSeekModelFactory.MODELS
+
+    def get_model_config(self, config: LLMConfig) -> Dict[str, Any]:
+        return {
+            "api_key": credentials_provider.get_provider_key("deepseek"),
+        }
+
+    def create_langchain_model(self, config: LLMConfig, full_config: Dict[str, Any]) -> BaseChatModel:
+        return ChatDeepSeek(**full_config)

spaik_sdk-0.6.6/spaik_sdk/models/providers/mistral_provider.py

@@ -0,0 +1,23 @@
+from typing import Any, Collection, Dict
+
+from langchain_core.language_models.chat_models import BaseChatModel
+from langchain_mistralai import ChatMistralAI
+
+from spaik_sdk.config.get_credentials_provider import credentials_provider
+from spaik_sdk.models.factories.mistral_factory import MistralModelFactory
+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 MistralProvider(BaseProvider):
+    def get_supported_models(self) -> Collection[LLMModel]:
+        return MistralModelFactory.MODELS
+
+    def get_model_config(self, config: LLMConfig) -> Dict[str, Any]:
+        return {
+            "api_key": credentials_provider.get_provider_key("mistral"),
+        }
+
+    def create_langchain_model(self, config: LLMConfig, full_config: Dict[str, Any]) -> BaseChatModel:
+        return ChatMistralAI(**full_config)

{spaik_sdk-0.6.5 → spaik_sdk-0.6.6}/spaik_sdk/models/providers/provider_type.py

@@ -9,6 +9,10 @@ class ProviderType(Enum):
     OPENAI_DIRECT = "openai"
     GOOGLE = "google"
     OLLAMA = "ollama"
+    DEEPSEEK = "deepseek"
+    XAI = "xai"
+    COHERE = "cohere"
+    MISTRAL = "mistral"
 
     @classmethod
     def from_name(cls, name: str) -> "ProviderType":
@@ -39,6 +43,14 @@ class ProviderType(Enum):
             return cls.GOOGLE
         elif family_lower == "ollama":
             return cls.OLLAMA
+        elif family_lower == "deepseek":
+            return cls.DEEPSEEK
+        elif family_lower == "xai":
+            return cls.XAI
+        elif family_lower == "cohere":
+            return cls.COHERE
+        elif family_lower == "mistral":
+            return cls.MISTRAL
         else:
             raise ValueError(f"Unknown model family: {family}")
 
@@ -51,6 +63,11 @@ PROVIDER_ALIASES = {
     "openai": ProviderType.OPENAI_DIRECT,
     "google": ProviderType.GOOGLE,
     "gemini": ProviderType.GOOGLE,
+    "deepseek": ProviderType.DEEPSEEK,
+    "xai": ProviderType.XAI,
+    "grok": ProviderType.XAI,
+    "cohere": ProviderType.COHERE,
+    "mistral": ProviderType.MISTRAL,
 }