autobyteus 1.2.0__py3-none-any.whl → 1.2.3__py3-none-any.whl

autobyteus/llm/llm_factory.py

@@ -8,9 +8,9 @@ from autobyteus.llm.providers import LLMProvider
 from autobyteus.llm.runtimes import LLMRuntime
 from autobyteus.llm.utils.llm_config import LLMConfig, TokenPricingConfig
 from autobyteus.llm.base_llm import BaseLLM
+from autobyteus.utils.parameter_schema import ParameterSchema, ParameterDefinition, ParameterType
 
 from autobyteus.llm.api.claude_llm import ClaudeLLM
-from autobyteus.llm.api.bedrock_llm import BedrockLLM
 from autobyteus.llm.api.mistral_llm import MistralLLM
 from autobyteus.llm.api.openai_llm import OpenAILLM
 from autobyteus.llm.api.deepseek_llm import DeepSeekLLM
@@ -19,6 +19,7 @@ from autobyteus.llm.api.grok_llm import GrokLLM
 from autobyteus.llm.api.kimi_llm import KimiLLM
 from autobyteus.llm.api.qwen_llm import QwenLLM
 from autobyteus.llm.api.zhipu_llm import ZhipuLLM
+from autobyteus.llm.api.minimax_llm import MinimaxLLM
 from autobyteus.llm.ollama_provider import OllamaModelProvider
 from autobyteus.llm.lmstudio_provider import LMStudioModelProvider
 from autobyteus.utils.singleton import SingletonMeta
@@ -52,191 +53,207 @@ class LLMFactory(metaclass=SingletonMeta):
         """Initializes the registry with built-in models and discovers runtime models."""
         # Hardcoded direct-API models. Runtime defaults to API.
         supported_models = [
-            # OPENAI Provider Models
+            # OPENAI Provider Models (latest generation only)
             LLMModel(
-                name="gpt-4o",
-                value="gpt-4o",
+                name="gpt-5.2",
+                value="gpt-5.2",
                 provider=LLMProvider.OPENAI,
                 llm_class=OpenAILLM,
-                canonical_name="gpt-4o",
+                canonical_name="gpt-5.2",
                 default_config=LLMConfig(
-                    rate_limit=40, 
-                    token_limit=8192,
-                    pricing_config=TokenPricingConfig(2.50, 10.00)
-                )
-            ),
-            LLMModel(
-                name="gpt-5",
-                value="gpt-5",
-                provider=LLMProvider.OPENAI,
-                llm_class=OpenAILLM,
-                canonical_name="gpt-5",
-                default_config=LLMConfig(
-                    uses_max_completion_tokens=True,
-                    pricing_config=TokenPricingConfig(1.25, 10.00)
-                )
-            ),
-            LLMModel(
-                name="gpt-5-mini",
-                value="gpt-5-mini",
-                provider=LLMProvider.OPENAI,
-                llm_class=OpenAILLM,
-                canonical_name="gpt-5-mini",
-                default_config=LLMConfig(
-                    uses_max_completion_tokens=True,
-                    pricing_config=TokenPricingConfig(0.25, 2.00)
-                )
-            ),
-            LLMModel(
-                name="gpt-5-nano",
-                value="gpt-5-nano",
-                provider=LLMProvider.OPENAI,
-                llm_class=OpenAILLM,
-                canonical_name="gpt-5-nano",
-                default_config=LLMConfig(
-                    uses_max_completion_tokens=True,
-                    pricing_config=TokenPricingConfig(0.05, 0.40)
-                )
+                    pricing_config=TokenPricingConfig(1.75, 14.00)
+                ),
+                config_schema=ParameterSchema(parameters=[
+                    ParameterDefinition(
+                        name="reasoning_effort",
+                        param_type=ParameterType.ENUM,
+                        description="Controls how hard the model thinks. Higher effort improves quality but can increase latency and cost.",
+                        required=False,
+                        default_value="none",
+                        enum_values=["none", "low", "medium", "high", "xhigh"]
+                    ),
+                    ParameterDefinition(
+                        name="reasoning_summary",
+                        param_type=ParameterType.ENUM,
+                        description="Include a reasoning summary in the response when supported.",
+                        required=False,
+                        default_value="none",
+                        enum_values=["none", "auto", "concise", "detailed"]
+                    )
+                ])
             ),
             LLMModel(
-                name="gpt-5-chat-latest",
-                value="gpt-5-chat-latest",
+                name="gpt-5.2-chat-latest",
+                value="gpt-5.2-chat-latest",
                 provider=LLMProvider.OPENAI,
                 llm_class=OpenAILLM,
-                canonical_name="gpt-5-chat-latest",
+                canonical_name="gpt-5.2-chat-latest",
                 default_config=LLMConfig(
-                    uses_max_completion_tokens=True,
-                    pricing_config=TokenPricingConfig(1.25, 10.00)
-                )
+                    pricing_config=TokenPricingConfig(1.75, 14.00)
+                ),
+                config_schema=ParameterSchema(parameters=[
+                    ParameterDefinition(
+                        name="reasoning_effort",
+                        param_type=ParameterType.ENUM,
+                        description="Controls how hard the model thinks. Higher effort improves quality but can increase latency and cost.",
+                        required=False,
+                        default_value="none",
+                        enum_values=["none", "low", "medium", "high", "xhigh"]
+                    ),
+                    ParameterDefinition(
+                        name="reasoning_summary",
+                        param_type=ParameterType.ENUM,
+                        description="Include a reasoning summary in the response when supported.",
+                        required=False,
+                        default_value="none",
+                        enum_values=["none", "auto", "concise", "detailed"]
+                    )
+                ])
             ),
+            # MISTRAL Provider Models
             LLMModel(
-                name="gpt-4.1",
-                value="gpt-4.1",
-                provider=LLMProvider.OPENAI,
-                llm_class=OpenAILLM,
-                canonical_name="gpt-4.1",
+                name="mistral-large",
+                value="mistral-large-latest",
+                provider=LLMProvider.MISTRAL,
+                llm_class=MistralLLM,
+                canonical_name="mistral-large",
                 default_config=LLMConfig(
-                    uses_max_completion_tokens=True,
-                    pricing_config=TokenPricingConfig(2.00, 8.00)
+                    pricing_config=TokenPricingConfig(2.00, 6.00)
                 )
             ),
             LLMModel(
-                name="gpt-4.1-mini",
-                value="gpt-4.1-mini",
-                provider=LLMProvider.OPENAI,
-                llm_class=OpenAILLM,
-                canonical_name="gpt-4.1-mini",
+                name="devstral-2",
+                value="devstral-2512",
+                provider=LLMProvider.MISTRAL,
+                llm_class=MistralLLM,
+                canonical_name="devstral-2",
                 default_config=LLMConfig(
-                    uses_max_completion_tokens=True,
-                    pricing_config=TokenPricingConfig(0.40, 1.60)
+                    # Pricing from Mistral launch: $0.40 input / $2.00 output per MTokens.
+                    pricing_config=TokenPricingConfig(0.40, 2.00)
                 )
             ),
+            # GROK Provider Models (latest flagship + fast)
             LLMModel(
-                name="gpt-4.1-nano",
-                value="gpt-4.1-nano",
-                provider=LLMProvider.OPENAI,
-                llm_class=OpenAILLM,
-                canonical_name="gpt-4.1-nano",
+                name="grok-4",
+                value="grok-4",
+                provider=LLMProvider.GROK,
+                llm_class=GrokLLM,
+                canonical_name="grok-4",
                 default_config=LLMConfig(
-                    uses_max_completion_tokens=True,
-                    pricing_config=TokenPricingConfig(0.10, 0.40)
+                    pricing_config=TokenPricingConfig(3.00, 15.00)
                 )
             ),
             LLMModel(
-                name="o3",
-                value="o3",
-                provider=LLMProvider.OPENAI,
-                llm_class=OpenAILLM,
-                canonical_name="o3",
+                name="grok-4-1-fast-reasoning",
+                value="grok-4-1-fast-reasoning",
+                provider=LLMProvider.GROK,
+                llm_class=GrokLLM,
+                canonical_name="grok-4-1-fast-reasoning",
                 default_config=LLMConfig(
-                    uses_max_completion_tokens=True,
-                    pricing_config=TokenPricingConfig(15.00, 60.00)
+                    pricing_config=TokenPricingConfig(0.20, 0.50)
                 )
             ),
             LLMModel(
-                name="o4-mini",
-                value="o4-mini",
-                provider=LLMProvider.OPENAI,
-                llm_class=OpenAILLM,
-                canonical_name="o4-mini",
+                name="grok-4-1-fast-non-reasoning",
+                value="grok-4-1-fast-non-reasoning",
+                provider=LLMProvider.GROK,
+                llm_class=GrokLLM,
+                canonical_name="grok-4-1-fast-non-reasoning",
                 default_config=LLMConfig(
-                    uses_max_completion_tokens=True,
-                    pricing_config=TokenPricingConfig(1.0, 4.00)
+                    pricing_config=TokenPricingConfig(0.20, 0.50)
                 )
             ),
-            # MISTRAL Provider Models
             LLMModel(
-                name="mistral-large",
-                value="mistral-large-latest",
-                provider=LLMProvider.MISTRAL,
-                llm_class=MistralLLM,
-                canonical_name="mistral-large",
+                name="grok-code-fast-1",
+                value="grok-code-fast-1",
+                provider=LLMProvider.GROK,
+                llm_class=GrokLLM,
+                canonical_name="grok-code-fast-1",
                 default_config=LLMConfig(
-                    pricing_config=TokenPricingConfig(2.00, 6.00)
+                    pricing_config=TokenPricingConfig(0.20, 1.50)
                 )
             ),
             # ANTHROPIC Provider Models
             LLMModel(
-                name="claude-4-opus",
-                value="claude-opus-4-20250514",
+                name="claude-4.5-opus",
+                value="claude-opus-4-5-20251101",
                 provider=LLMProvider.ANTHROPIC,
                 llm_class=ClaudeLLM,
-                canonical_name="claude-4-opus",
+                canonical_name="claude-4.5-opus",
                 default_config=LLMConfig(
-                    pricing_config=TokenPricingConfig(15.00, 75.00)
-                )
-            ),
-            LLMModel(
-                name="claude-4.1-opus",
-                value="claude-opus-4-1-20250805",
-                provider=LLMProvider.ANTHROPIC,
-                llm_class=ClaudeLLM,
-                canonical_name="claude-4.1-opus",
-                default_config=LLMConfig(
-                    # NOTE: Pricing is assumed to be the same as claude-4-opus
-                    pricing_config=TokenPricingConfig(15.00, 75.00)
-                )
+                    pricing_config=TokenPricingConfig(5.00, 25.00)
+                ),
+                config_schema=ParameterSchema(parameters=[
+                    ParameterDefinition(
+                        name="thinking_enabled",
+                        param_type=ParameterType.BOOLEAN,
+                        description="Enable extended thinking summaries in Claude responses",
+                        required=False,
+                        default_value=False
+                    ),
+                    ParameterDefinition(
+                        name="thinking_budget_tokens",
+                        param_type=ParameterType.INTEGER,
+                        description="Token budget for extended thinking (min 1024)",
+                        required=False,
+                        default_value=1024,
+                        min_value=1024
+                    )
+                ])
             ),
             LLMModel(
-                name="claude-4-sonnet",
-                value="claude-sonnet-4-20250514",
+                name="claude-4.5-sonnet",
+                value="claude-sonnet-4-5-20250929",
                 provider=LLMProvider.ANTHROPIC,
                 llm_class=ClaudeLLM,
-                canonical_name="claude-4-sonnet",
+                canonical_name="claude-4.5-sonnet",
                 default_config=LLMConfig(
                     pricing_config=TokenPricingConfig(3.00, 15.00)
-                )
-            ),
-            LLMModel(
-                name="bedrock-claude-4-opus",
-                value="anthropic.claude-opus-4-20250514-v1:0",
-                provider=LLMProvider.ANTHROPIC,
-                llm_class=BedrockLLM,
-                canonical_name="claude-4-opus",
-                default_config=LLMConfig(
-                    pricing_config=TokenPricingConfig(15.00, 75.00)
-                )
-            ),
-            LLMModel(
-                name="bedrock-claude-4.1-opus",
-                value="anthropic.claude-opus-4-1-20250805-v1:0",
-                provider=LLMProvider.ANTHROPIC,
-                llm_class=BedrockLLM,
-                canonical_name="claude-4.1-opus",
-                default_config=LLMConfig(
-                    # NOTE: Pricing is assumed to be the same as claude-4-opus
-                    pricing_config=TokenPricingConfig(15.00, 75.00)
-                )
+                ),
+                config_schema=ParameterSchema(parameters=[
+                    ParameterDefinition(
+                        name="thinking_enabled",
+                        param_type=ParameterType.BOOLEAN,
+                        description="Enable extended thinking summaries in Claude responses",
+                        required=False,
+                        default_value=False
+                    ),
+                    ParameterDefinition(
+                        name="thinking_budget_tokens",
+                        param_type=ParameterType.INTEGER,
+                        description="Token budget for extended thinking (min 1024)",
+                        required=False,
+                        default_value=1024,
+                        min_value=1024
+                    )
+                ])
             ),
             LLMModel(
-                name="bedrock-claude-4-sonnet",
-                value="anthropic.claude-sonnet-4-20250514-v1:0",
+                name="claude-4.5-haiku",
+                value="claude-haiku-4-5-20251001",
                 provider=LLMProvider.ANTHROPIC,
-                llm_class=BedrockLLM,
-                canonical_name="claude-4-sonnet",
+                llm_class=ClaudeLLM,
+                canonical_name="claude-4.5-haiku",
                 default_config=LLMConfig(
-                    pricing_config=TokenPricingConfig(3.00, 15.00)
-                )
+                    pricing_config=TokenPricingConfig(1.00, 5.00)
+                ),
+                config_schema=ParameterSchema(parameters=[
+                    ParameterDefinition(
+                        name="thinking_enabled",
+                        param_type=ParameterType.BOOLEAN,
+                        description="Enable extended thinking summaries in Claude responses",
+                        required=False,
+                        default_value=False
+                    ),
+                    ParameterDefinition(
+                        name="thinking_budget_tokens",
+                        param_type=ParameterType.INTEGER,
+                        description="Token budget for extended thinking (min 1024)",
+                        required=False,
+                        default_value=1024,
+                        min_value=1024
+                    )
+                ])
             ),
             # DEEPSEEK Provider Models
             LLMModel(
@@ -266,34 +283,60 @@ class LLMFactory(metaclass=SingletonMeta):
             ),
             # GEMINI Provider Models
             LLMModel(
-                name="gemini-2.5-pro",
-                value="gemini-2.5-pro",
-                provider=LLMProvider.GEMINI,
-                llm_class=GeminiLLM,
-                canonical_name="gemini-2.5-pro",
-                default_config=LLMConfig(
-                    pricing_config=TokenPricingConfig(2.50, 15.00)
-                )
-            ),
-            LLMModel(
-                name="gemini-2.5-flash",
-                value="gemini-2.5-flash",
+                name="gemini-3-pro-preview",
+                value="gemini-3-pro-preview",
                 provider=LLMProvider.GEMINI,
                 llm_class=GeminiLLM,
-                canonical_name="gemini-2.5-flash",
+                canonical_name="gemini-3-pro",
                 default_config=LLMConfig(
-                    pricing_config=TokenPricingConfig(0.30, 2.50)
-                )
+                    # Pricing from Gemini 3 Pro preview launch (per 1M tokens).
+                    pricing_config=TokenPricingConfig(2.00, 12.00)
+                ),
+                config_schema=ParameterSchema(parameters=[
+                    ParameterDefinition(
+                        name="thinking_level",
+                        param_type=ParameterType.ENUM,
+                        description="How deeply the model should reason before responding",
+                        required=False,
+                        default_value="minimal",
+                        enum_values=["minimal", "low", "medium", "high"]
+                    ),
+                    ParameterDefinition(
+                        name="include_thoughts",
+                        param_type=ParameterType.BOOLEAN,
+                        description="Include model thought summaries in responses",
+                        required=False,
+                        default_value=False
+                    )
+                ])
             ),
             LLMModel(
-                name="gemini-2.5-flash-lite",
-                value="gemini-2.5-flash-lite",
+                name="gemini-3-flash-preview",
+                value="gemini-3-flash-preview",
                 provider=LLMProvider.GEMINI,
                 llm_class=GeminiLLM,
-                canonical_name="gemini-2.5-flash-lite",
+                canonical_name="gemini-3-flash",
                 default_config=LLMConfig(
-                    pricing_config=TokenPricingConfig(0.10, 0.40)
-                )
+                    # Pricing from Gemini 3 Flash preview launch (per 1M tokens).
+                    pricing_config=TokenPricingConfig(0.50, 3.00)
+                ),
+                config_schema=ParameterSchema(parameters=[
+                    ParameterDefinition(
+                        name="thinking_level",
+                        param_type=ParameterType.ENUM,
+                        description="How deeply the model should reason before responding",
+                        required=False,
+                        default_value="minimal",
+                        enum_values=["minimal", "low", "medium", "high"]
+                    ),
+                    ParameterDefinition(
+                        name="include_thoughts",
+                        param_type=ParameterType.BOOLEAN,
+                        description="Include model thought summaries in responses",
+                        required=False,
+                        default_value=False
+                    )
+                ])
             ),
             # KIMI Provider Models
             LLMModel(
@@ -363,24 +406,34 @@ class LLMFactory(metaclass=SingletonMeta):
             ),
             # ZHIPU Provider Models
             LLMModel(
-                name="glm-4.6",
-                value="glm-4.6",
+                name="glm-4.7",
+                value="glm-4.7",
                 provider=LLMProvider.ZHIPU,
                 llm_class=ZhipuLLM,
-                canonical_name="glm-4.6",
+                canonical_name="glm-4.7",
                 default_config=LLMConfig(
                     pricing_config=TokenPricingConfig(13.8, 13.8)
-                )
+                ),
+                config_schema=ParameterSchema(parameters=[
+                    ParameterDefinition(
+                        name="thinking_type",
+                        param_type=ParameterType.ENUM,
+                        description="Enable or disable deep thinking",
+                        required=False,
+                        default_value="enabled",
+                        enum_values=["enabled", "disabled"]
+                    )
+                ])
             ),
+            # MINIMAX Provider Models
             LLMModel(
-                name="glm-4.6-thinking",
-                value="glm-4.6",
-                provider=LLMProvider.ZHIPU,
-                llm_class=ZhipuLLM,
-                canonical_name="glm-4.6-thinking",
+                name="minimax-m2.1",
+                value="MiniMax-M2.1",
+                provider=LLMProvider.MINIMAX,
+                llm_class=MinimaxLLM,
+                canonical_name="minimax-m2.1",
                 default_config=LLMConfig(
-                    pricing_config=TokenPricingConfig(13.8, 13.8),
-                    extra_params={ "extra_body": { "thinking": { "type": "enabled" } } }
+                    pricing_config=TokenPricingConfig(0.15, 0.45)
                 )
             ),
         ]
@@ -439,18 +492,7 @@ class LLMFactory(metaclass=SingletonMeta):
         """Returns a list of all available models with their detailed info."""
         LLMFactory.ensure_initialized()
         models = sorted(LLMFactory._models_by_identifier.values(), key=lambda m: m.model_identifier)
-        return [
-            ModelInfo(
-                model_identifier=m.model_identifier,
-                display_name=m.name,
-                value=m.value,
-                canonical_name=m.canonical_name,
-                provider=m.provider.value,
-                runtime=m.runtime.value,
-                host_url=m.host_url
-            )
-            for m in models
-        ]
+        return [m.to_model_info() for m in models]
 
     @staticmethod
     def list_models_by_provider(provider: LLMProvider) -> List[ModelInfo]:
@@ -460,18 +502,7 @@ class LLMFactory(metaclass=SingletonMeta):
             [m for m in LLMFactory._models_by_identifier.values() if m.provider == provider],
             key=lambda m: m.model_identifier
         )
-        return [
-            ModelInfo(
-                model_identifier=m.model_identifier,
-                display_name=m.name,
-                value=m.value,
-                canonical_name=m.canonical_name,
-                provider=m.provider.value,
-                runtime=m.runtime.value,
-                host_url=m.host_url
-            )
-            for m in provider_models
-        ]
+        return [m.to_model_info() for m in provider_models]
 
     @staticmethod
     def list_models_by_runtime(runtime: LLMRuntime) -> List[ModelInfo]:
@@ -481,18 +512,7 @@ class LLMFactory(metaclass=SingletonMeta):
             [m for m in LLMFactory._models_by_identifier.values() if m.runtime == runtime],
             key=lambda m: m.model_identifier
         )
-        return [
-            ModelInfo(
-                model_identifier=m.model_identifier,
-                display_name=m.name,
-                value=m.value,
-                canonical_name=m.canonical_name,
-                provider=m.provider.value,
-                runtime=m.runtime.value,
-                host_url=m.host_url
-            )
-            for m in runtime_models
-        ]
+        return [m.to_model_info() for m in runtime_models]
 
     @staticmethod
     def get_canonical_name(model_identifier: str) -> Optional[str]:
@@ -507,4 +527,62 @@ class LLMFactory(metaclass=SingletonMeta):
         logger.warning(f"Could not find model with identifier '{model_identifier}' to get its canonical name.")
         return None
 
+    @staticmethod
+    def reload_models(provider: LLMProvider) -> int:
+        """
+        Reloads models for a specific provider.
+        Strategy: Clear-Then-Discover (Fail Fast).
+        
+        1. Clears all existing models for the provider.
+        2. Fetches fresh models.
+        3. Registers them.
+        
+        If step 2 fails, the registry for this provider remains empty, correctly reflecting 
+        that the server is unreachable or returning no models.
+        """
+        LLMFactory.ensure_initialized()
+        
+        provider_handlers = {
+            LLMProvider.LMSTUDIO: LMStudioModelProvider,
+            LLMProvider.AUTOBYTEUS: AutobyteusModelProvider,
+            LLMProvider.OLLAMA: OllamaModelProvider,
+        }
+
+        handler = provider_handlers.get(provider)
+        if not handler:
+            logger.warning(f"Reloading is not supported for provider: {provider}")
+            return len(LLMFactory._models_by_provider.get(provider, []))
+
+        # 1. Clear old models for this provider immediately
+        current_provider_models = LLMFactory._models_by_provider.get(provider, [])
+        ids_to_remove = [m.model_identifier for m in current_provider_models]
+        
+        logger.info(f"Clearing {len(ids_to_remove)} models for provider {provider} before discovery.")
+        
+        for mid in ids_to_remove:
+            if mid in LLMFactory._models_by_identifier:
+                del LLMFactory._models_by_identifier[mid]
+        
+        if provider in LLMFactory._models_by_provider:
+            del LLMFactory._models_by_provider[provider]
+
+        # 2. Fetch new models
+        try:
+            # We assume the handler has a static .get_models() method
+            if not hasattr(handler, 'get_models'):
+                logger.error(f"Provider handler {handler} does not implement get_models()")
+                return 0 # We already cleared everything
+
+            new_models: List[LLMModel] = handler.get_models()
+        except Exception as e:
+            logger.error(f"Failed to fetch models for {provider} during reload. Registry for this provider is now empty. Error: {e}")
+            return 0
+
+        # 3. Register new models
+        logger.info(f"Registering {len(new_models)} new models for provider {provider}.")
+        for model in new_models:
+            LLMFactory.register_model(model)
+
+        return len(new_models)
+
 default_llm_factory = LLMFactory()