janito 2.7.0__py3-none-any.whl → 2.8.0__py3-none-any.whl

janito/formatting_token.py

@@ -25,7 +25,9 @@ def format_tokens(n, tag=None, use_rich=False):
     return val
 
 
-def format_token_message_summary(msg_count, usage, width=96, use_rich=False, elapsed=None):
+def format_token_message_summary(
+    msg_count, usage, width=96, use_rich=False, elapsed=None
+):
     """
     Returns a string (rich or pt markup) summarizing message count, last token usage, and elapsed time.
     """
@@ -40,16 +42,22 @@ def format_token_message_summary(msg_count, usage, width=96, use_rich=False, ela
             f"Completion: {format_tokens(completion_tokens, 'tokens_out', use_rich)}, "
             f"Total: {format_tokens(total_tokens, 'tokens_total', use_rich)}"
         )
-    elapsed_part = f" | Elapsed: [cyan]{elapsed:.2f}s[/cyan]" if elapsed is not None else ""
+    elapsed_part = (
+        f" | Elapsed: [cyan]{elapsed:.2f}s[/cyan]" if elapsed is not None else ""
+    )
     return f"{left}{tokens_part}{elapsed_part}"
 
 
-def print_token_message_summary(console, msg_count=None, usage=None, width=96, elapsed=None):
+def print_token_message_summary(
+    console, msg_count=None, usage=None, width=96, elapsed=None
+):
     """Prints the summary using rich markup, using defaults from perf_singleton if not given. Optionally includes elapsed time."""
     if usage is None:
         usage = performance_collector.get_last_request_usage()
     if msg_count is None:
         msg_count = performance_collector.get_total_turns() or 0
-    line = format_token_message_summary(msg_count, usage, width, use_rich=True, elapsed=elapsed)
+    line = format_token_message_summary(
+        msg_count, usage, width, use_rich=True, elapsed=elapsed
+    )
     if line.strip():
         console.print(Rule(line))

janito/llm/agent.py

@@ -97,6 +97,7 @@ class LLMAgent:
             # Refresh allowed_permissions in context before rendering
             from janito.tools.permissions import get_global_allowed_permissions
             from janito.tools.tool_base import ToolPermissions
+
             perms = get_global_allowed_permissions()
             if isinstance(perms, ToolPermissions):
                 perm_str = ""
@@ -171,7 +172,7 @@ class LLMAgent:
         )
 
     def _process_next_response(
-        self, poll_timeout: float = 1.0, max_wait_time: float = 300.0
+        self, poll_timeout: float = 1.0, max_wait_time: float = 600.0
     ):
         """
         Wait for a single event from the output queue (with timeout), process it, and return the result.
@@ -213,7 +214,6 @@ class LLMAgent:
             ]:
                 return (event, False)
 
-
     def _get_event_from_output_queue(self, poll_timeout):
         try:
             return self.output_queue.get(timeout=poll_timeout)
@@ -306,6 +306,7 @@ class LLMAgent:
             config = self.llm_provider.driver_config
         loop_count = 1
         import threading
+
         cancel_event = threading.Event()
         while True:
             self._print_verbose_chat_loop(loop_count)
@@ -317,7 +318,9 @@ class LLMAgent:
                 cancel_event.set()
                 raise
             if getattr(self, "verbose_agent", False):
-                print(f"[agent] [DEBUG] Returned from _process_next_response: result={result}, added_tool_results={added_tool_results}")
+                print(
+                    f"[agent] [DEBUG] Returned from _process_next_response: result={result}, added_tool_results={added_tool_results}"
+                )
             if self._should_exit_chat_loop(result, added_tool_results):
                 return result
             loop_count += 1
@@ -332,11 +335,15 @@ class LLMAgent:
     def _should_exit_chat_loop(self, result, added_tool_results):
         if result is None:
             if getattr(self, "verbose_agent", False):
-                print("[agent] [INFO] Exiting chat loop: _process_next_response returned None result (likely timeout or error). Returning (None, False).")
+                print(
+                    "[agent] [INFO] Exiting chat loop: _process_next_response returned None result (likely timeout or error). Returning (None, False)."
+                )
             return True
         if not added_tool_results:
             if getattr(self, "verbose_agent", False):
-                print(f"[agent] [INFO] Exiting chat loop: _process_next_response returned added_tool_results=False (final response or no more tool calls). Returning result: {result}")
+                print(
+                    f"[agent] [INFO] Exiting chat loop: _process_next_response returned added_tool_results=False (final response or no more tool calls). Returning result: {result}"
+                )
             return True
         return False
 
@@ -434,7 +441,9 @@ class LLMAgent:
         config.model = model_name
         config.temperature = self._safe_float(getattr(model_spec, "default_temp", None))
         config.max_tokens = self._safe_int(getattr(model_spec, "max_response", None))
-        config.max_completion_tokens = self._safe_int(getattr(model_spec, "max_cot", None))
+        config.max_completion_tokens = self._safe_int(
+            getattr(model_spec, "max_cot", None)
+        )
         config.top_p = None
         config.presence_penalty = None
         config.frequency_penalty = None

janito/llm/driver.py

@@ -55,6 +55,7 @@ class LLMDriver(ABC):
         # Validate all tool schemas before starting the thread
         if self.tools_adapter is not None:
             from janito.tools.tools_schema import ToolSchemaBase
+
             validator = ToolSchemaBase()
             for tool in self.tools_adapter.get_tools():
                 # Validate the tool's class (not instance)

janito/provider_registry.py

@@ -5,7 +5,6 @@ ProviderRegistry: Handles provider listing and selection logic for janito CLI.
 from rich.table import Table
 from janito.cli.console import shared_console
 from janito.providers.registry import LLMProviderRegistry
-from janito.providers.provider_static_info import STATIC_PROVIDER_METADATA
 from janito.llm.auth import LLMAuthManager
 import sys
 from janito.exceptions import MissingProviderSelectionException
@@ -21,7 +20,9 @@ class ProviderRegistry:
         self._print_table(table)
 
     def _get_provider_names(self):
-        return list(STATIC_PROVIDER_METADATA.keys())
+        from janito.providers.registry import LLMProviderRegistry
+
+        return LLMProviderRegistry.list_providers()
 
     def _create_table(self):
         table = Table(title="Supported LLM Providers")
@@ -71,77 +72,35 @@ class ProviderRegistry:
             print(ascii_row)
 
     def _get_provider_info(self, provider_name):
-        static_info = STATIC_PROVIDER_METADATA.get(provider_name, {})
-        maintainer_val = static_info.get("maintainer", "-")
-        maintainer = (
-            "[red]🚨 Needs maintainer[/red]"
-            if maintainer_val == "Needs maintainer"
-            else f"👤 {maintainer_val}"
-        )
-        model_names = "-"
-        unavailable_reason = None
+        provider_class = LLMProviderRegistry.get(provider_name)
+        maintainer = getattr(provider_class, "MAINTAINER", "-")
+        maintainer = f"👤 {maintainer}" if maintainer != "-" else maintainer
+        model_names = self._get_model_names(provider_name)
         skip = False
-        try:
-            provider_class = LLMProviderRegistry.get(provider_name)
-            creds = LLMAuthManager().get_credentials(provider_name)
-            provider_instance = None
-            instantiation_failed = False
-            try:
-                provider_instance = provider_class()
-            except NotImplementedError:
-                skip = True
-                unavailable_reason = "Not implemented"
-                model_names = f"[red]❌ Not implemented[/red]"
-            except Exception as e:
-                instantiation_failed = True
-                unavailable_reason = (
-                    f"Unavailable (import error or missing dependency): {str(e)}"
-                )
-                model_names = f"[red]❌ {unavailable_reason}[/red]"
-            if not instantiation_failed and provider_instance is not None:
-                available, unavailable_reason = self._get_availability(
-                    provider_instance
-                )
-                if (
-                    not available
-                    and unavailable_reason
-                    and "not implemented" in str(unavailable_reason).lower()
-                ):
-                    skip = True
-                if available:
-                    model_names = self._get_model_names(provider_name)
-                else:
-                    model_names = f"[red]❌ {unavailable_reason}[/red]"
-        except Exception as import_error:
-            model_names = f"[red]❌ Unavailable (cannot import provider module): {str(import_error)}[/red]"
         return (provider_name, maintainer, model_names, skip)
 
-    def _get_availability(self, provider_instance):
+    def _get_model_names(self, provider_name):
         try:
-            available = getattr(provider_instance, "available", True)
-            unavailable_reason = getattr(provider_instance, "unavailable_reason", None)
+            provider_class = LLMProviderRegistry.get(provider_name)
+            module_parts = provider_class.__module__.split(".")
+            # Build the correct import path: janito.providers.{provider}.model_info
+            model_info_module = f"janito.providers.{provider_name}.model_info"
+            model_info_mod = __import__(model_info_module, fromlist=["MODEL_SPECS"])
+
+            # Handle different model spec variable names
+            model_specs = None
+            if hasattr(model_info_mod, "MODEL_SPECS"):
+                model_specs = model_info_mod.MODEL_SPECS
+            elif hasattr(model_info_mod, "MOONSHOTAI_MODEL_SPECS"):
+                model_specs = model_info_mod.MOONSHOTAI_MODEL_SPECS
+
+            if provider_name == "groq":
+                return "<any> (must be provided)"
+            if model_specs:
+                return ", ".join(model_specs.keys())
+            return "-"
         except Exception as e:
-            available = False
-            unavailable_reason = f"Error reading runtime availability: {str(e)}"
-        return available, unavailable_reason
-
-    def _get_model_names(self, provider_name):
-        provider_to_specs = {
-            "openai": "janito.providers.openai.model_info",
-            "azure_openai": "janito.providers.azure_openai.model_info",
-            "google": "janito.providers.google.model_info",
-            "anthropic": "janito.providers.anthropic.model_info",
-            "deepseek": "janito.providers.deepseek.model_info",
-        }
-        if provider_name in provider_to_specs:
-            try:
-                mod = __import__(
-                    provider_to_specs[provider_name], fromlist=["MODEL_SPECS"]
-                )
-                return ", ".join(mod.MODEL_SPECS.keys())
-            except Exception:
-                return "(Error)"
-        return "-"
+            return "-"
 
     def _maintainer_sort_key(self, row):
         maint = row[1]
@@ -157,8 +116,10 @@ class ProviderRegistry:
             return None
         provider_class = LLMProviderRegistry.get(provider_name)
         if provider_class is None:
-            available = ', '.join(LLMProviderRegistry.list_providers())
-            print(f"Error: Provider '{provider_name}' is not recognized. Available providers: {available}.")
+            available = ", ".join(LLMProviderRegistry.list_providers())
+            print(
+                f"Error: Provider '{provider_name}' is not recognized. Available providers: {available}."
+            )
             return None
         return provider_class
 

janito/providers/__init__.py

@@ -5,3 +5,4 @@ import janito.providers.azure_openai.provider
 import janito.providers.anthropic.provider
 import janito.providers.deepseek.provider
 import janito.providers.moonshotai.provider
+import janito.providers.groq.provider

janito/providers/anthropic/model_info.py

@@ -38,4 +38,3 @@ MODEL_SPECS = {
         driver="OpenAIModelDriver",
     ),
 }
-

janito/providers/anthropic/provider.py

@@ -1,12 +1,3 @@
-from janito.llm.provider import LLMProvider
-from janito.llm.model import LLMModelInfo
-from janito.llm.auth import LLMAuthManager
-from janito.llm.driver_config import LLMDriverConfig
-from janito.tools import get_local_tools_adapter
-from janito.providers.registry import LLMProviderRegistry
-
-from .model_info import MODEL_SPECS
-
 from janito.llm.provider import LLMProvider
 from janito.llm.model import LLMModelInfo
 from janito.llm.auth import LLMAuthManager
@@ -16,9 +7,11 @@ from janito.providers.registry import LLMProviderRegistry
 from .model_info import MODEL_SPECS
 from janito.drivers.openai.driver import OpenAIModelDriver
 
+
 class AnthropicProvider(LLMProvider):
     name = "anthropic"
-    maintainer = "Needs maintainer"
+    NAME = "anthropic"
+    MAINTAINER = "Alberto Minetti <alberto.minetti@gmail.com>"
     MODEL_SPECS = MODEL_SPECS
     DEFAULT_MODEL = "claude-3-7-sonnet-20250219"
 
@@ -27,10 +20,10 @@ class AnthropicProvider(LLMProvider):
     ):
         self._tools_adapter = get_local_tools_adapter()
         self.auth_manager = auth_manager or LLMAuthManager()
-        self._api_key = self.auth_manager.get_credentials(type(self).name)
+        self._api_key = self.auth_manager.get_credentials(type(self).NAME)
         self._tools_adapter = get_local_tools_adapter()
         self._driver_config = config or LLMDriverConfig(model=None)
-        if not getattr(self._driver_config, 'model', None):
+        if not getattr(self._driver_config, "model", None):
             self._driver_config.model = self.DEFAULT_MODEL
         if not self._driver_config.api_key:
             self._driver_config.api_key = self._api_key
@@ -42,7 +35,9 @@ class AnthropicProvider(LLMProvider):
     @property
     def driver(self) -> OpenAIModelDriver:
         if not self.available:
-            raise ImportError(f"AnthropicProvider unavailable: {self.unavailable_reason}")
+            raise ImportError(
+                f"AnthropicProvider unavailable: {self.unavailable_reason}"
+            )
         return self._driver
 
     @property
@@ -77,4 +72,4 @@ class AnthropicProvider(LLMProvider):
         return self._tools_adapter.execute_by_name(tool_name, *args, **kwargs)
 
 
-LLMProviderRegistry.register(AnthropicProvider.name, AnthropicProvider)
+LLMProviderRegistry.register(AnthropicProvider.NAME, AnthropicProvider)

janito/providers/azure_openai/provider.py

@@ -16,7 +16,8 @@ maintainer = "João Pinto <lamego.pinto@gmail.com>"
 
 class AzureOpenAIProvider(LLMProvider):
     name = "azure_openai"
-    maintainer = "João Pinto <lamego.pinto@gmail.com>"
+    NAME = "azure_openai"
+    MAINTAINER = "João Pinto <lamego.pinto@gmail.com>"
     MODEL_SPECS = MODEL_SPECS
     DEFAULT_MODEL = "azure_openai_deployment"
 
@@ -30,7 +31,7 @@ class AzureOpenAIProvider(LLMProvider):
             self._driver = None
             return
         self._auth_manager = auth_manager or LLMAuthManager()
-        self._api_key = self._auth_manager.get_credentials(type(self).name)
+        self._api_key = self._auth_manager.get_credentials(type(self).NAME)
         self._tools_adapter = get_local_tools_adapter()
         self._driver_config = config or LLMDriverConfig(model=None)
         if not self._driver_config.model:
@@ -41,6 +42,7 @@ class AzureOpenAIProvider(LLMProvider):
             self._driver_config.extra["api_version"] = "2023-05-15"
         # Inject azure_deployment_name from config if present
         from janito.config import config as global_config
+
         deployment_name = global_config.get("azure_deployment_name")
         if deployment_name:
             self._driver_config.extra["azure_deployment_name"] = deployment_name
@@ -76,7 +78,10 @@ class AzureOpenAIProvider(LLMProvider):
         """
         if model_name is None:
             # Return all known specs, but note: only static ones are listed
-            return {name: model_info.to_dict() for name, model_info in self.MODEL_SPECS.items()}
+            return {
+                name: model_info.to_dict()
+                for name, model_info in self.MODEL_SPECS.items()
+            }
         if model_name in self.MODEL_SPECS:
             return self.MODEL_SPECS[model_name].to_dict()
         # Accept any deployment name as a valid model
@@ -120,4 +125,4 @@ class AzureOpenAIProvider(LLMProvider):
         return self._tools_adapter.execute_by_name(tool_name, *args, **kwargs)
 
 
-LLMProviderRegistry.register(AzureOpenAIProvider.name, AzureOpenAIProvider)
+LLMProviderRegistry.register(AzureOpenAIProvider.NAME, AzureOpenAIProvider)

janito/providers/deepseek/provider.py

@@ -12,9 +12,10 @@ available = OpenAIModelDriver.available
 unavailable_reason = OpenAIModelDriver.unavailable_reason
 
 
-class DeepseekProvider(LLMProvider):
+class DeepSeekProvider(LLMProvider):
     name = "deepseek"
-    maintainer = "Needs maintainer"
+    NAME = "deepseek"
+    MAINTAINER = "João Pinto <lamego.pinto@gmail.com>"
     MODEL_SPECS = MODEL_SPECS
     DEFAULT_MODEL = "deepseek-chat"  # Options: deepseek-chat, deepseek-reasoner
 
@@ -28,7 +29,7 @@ class DeepseekProvider(LLMProvider):
             self._driver = None
         else:
             self.auth_manager = auth_manager or LLMAuthManager()
-            self._api_key = self.auth_manager.get_credentials(type(self).name)
+            self._api_key = self.auth_manager.get_credentials(type(self).NAME)
             self._tools_adapter = get_local_tools_adapter()
             self._driver_config = config or LLMDriverConfig(model=None)
             if not self._driver_config.model:
@@ -91,4 +92,4 @@ class DeepseekProvider(LLMProvider):
         return self._tools_adapter.execute_by_name(tool_name, *args, **kwargs)
 
 
-LLMProviderRegistry.register(DeepseekProvider.name, DeepseekProvider)
+LLMProviderRegistry.register(DeepSeekProvider.NAME, DeepSeekProvider)

janito/providers/google/model_info.py

@@ -10,7 +10,7 @@ MODEL_SPECS = {
         max_cot=24576,
         thinking_supported=True,
     ),
-        "gemini-2.5-pro": LLMModelInfo(
+    "gemini-2.5-pro": LLMModelInfo(
         name="gemini-2.5-pro",
         other={"description": "Google Gemini 2.5 Pro (OpenAI-compatible endpoint)"},
         open="google",
@@ -21,7 +21,9 @@ MODEL_SPECS = {
     ),
     "gemini-2.5-flash-lite-preview-06-17": LLMModelInfo(
         name="gemini-2.5-flash-lite-preview-06-17",
-        other={"description": "Google Gemini 2.5 Flash-Lite Preview (OpenAI-compatible endpoint)"},
+        other={
+            "description": "Google Gemini 2.5 Flash-Lite Preview (OpenAI-compatible endpoint)"
+        },
         open="google",
         driver="OpenAIModelDriver",
         max_response=64000,

janito/providers/google/provider.py

@@ -13,9 +13,11 @@ try:
 except ImportError:
     MODEL_SPECS = {}
 
+
 class GoogleProvider(LLMProvider):
     name = "google"
-    maintainer = "João Pinto <lamego.pinto@gmail.com>"
+    NAME = "google"
+    MAINTAINER = "João Pinto <lamego.pinto@gmail.com>"
     MODEL_SPECS = MODEL_SPECS
     DEFAULT_MODEL = "gemini-2.5-flash"  # Default Gemini model
 
@@ -33,19 +35,23 @@ class GoogleProvider(LLMProvider):
             self._tools_adapter = get_local_tools_adapter()
             self._driver_config = config or LLMDriverConfig(model=None)
             # Only set default if model is not set by CLI/config
-            if not getattr(self._driver_config, 'model', None):
+            if not getattr(self._driver_config, "model", None):
                 self._driver_config.model = self.DEFAULT_MODEL
             if not self._driver_config.api_key:
                 self._driver_config.api_key = self._api_key
             # Set the Gemini API endpoint for OpenAI compatibility
-            self._driver_config.base_url = "https://generativelanguage.googleapis.com/v1beta/openai/"
+            self._driver_config.base_url = (
+                "https://generativelanguage.googleapis.com/v1beta/openai/"
+            )
             self.fill_missing_device_info(self._driver_config)
             self._driver = None  # to be provided by factory/agent
 
     @property
     def driver(self) -> OpenAIModelDriver:
         if not self.available:
-            raise ImportError(f"GoogleOpenAIProvider unavailable: {self.unavailable_reason}")
+            raise ImportError(
+                f"GoogleOpenAIProvider unavailable: {self.unavailable_reason}"
+            )
         return self._driver
 
     @property
@@ -80,4 +86,4 @@ class GoogleProvider(LLMProvider):
         return self._tools_adapter.execute_by_name(tool_name, *args, **kwargs)
 
 
-LLMProviderRegistry.register(GoogleProvider.name, GoogleProvider)
+LLMProviderRegistry.register(GoogleProvider.NAME, GoogleProvider)

janito/providers/groq/__init__.py

@@ -0,0 +1 @@
+from .provider import GroqProvider

janito/providers/groq/model_info.py

@@ -0,0 +1,46 @@
+# Groq provider model specifications
+from janito.llm.model import LLMModelInfo
+
+MODEL_SPECS = {
+    "moonshotai/kimi-k2-instruct": LLMModelInfo(
+        name="moonshotai/kimi-k2-instruct",
+        context=128000,
+        max_input=122880,
+        max_cot="N/A",
+        max_response=4096,
+        thinking_supported=False,
+        default_temp=0.2,
+        open="groq",
+        driver="GroqModelDriver",
+        other={
+            "description": "Kimi K2 Instruct model by Moonshot AI",
+            "supports_tools": True,
+            "supports_streaming": True,
+            "supports_vision": False,
+            "supports_system_prompt": True,
+            "supports_temperature": True,
+            "supports_top_p": True,
+            "supports_frequency_penalty": True,
+            "supports_presence_penalty": True,
+            "supports_stop_sequences": True,
+            "supports_max_tokens": True,
+            "supports_seed": False,
+            "supports_json_mode": True,
+            "supports_logprobs": False,
+            "supports_top_logprobs": False,
+            "supports_response_format": True,
+            "supports_n": False,
+            "supports_best_of": False,
+            "supports_echo": False,
+            "supports_logit_bias": False,
+            "supports_user": False,
+            "supports_assistant": False,
+            "supports_system": False,
+            "supports_functions": True,
+            "supports_tool_calls": True,
+            "supports_parallel_tool_calls": True,
+            "supports_stream_options": False,
+            "supports_include_usage": False,
+        },
+    )
+}

janito/providers/groq/provider.py

@@ -0,0 +1,76 @@
+from janito.llm.provider import LLMProvider
+from janito.llm.model import LLMModelInfo
+from janito.llm.auth import LLMAuthManager
+from janito.llm.driver_config import LLMDriverConfig
+from janito.drivers.openai.driver import OpenAIModelDriver
+from janito.tools import get_local_tools_adapter
+from janito.providers.registry import LLMProviderRegistry
+from .model_info import MODEL_SPECS
+from queue import Queue
+
+available = OpenAIModelDriver.available
+unavailable_reason = OpenAIModelDriver.unavailable_reason
+
+
+class GroqProvider(LLMProvider):
+    name = "groq"
+    NAME = "groq"
+    MAINTAINER = "Groq Inc. <support@groq.com>"
+    MODEL_SPECS = MODEL_SPECS
+    DEFAULT_MODEL = "moonshotai/kimi-k2-instruct"
+
+    def __init__(
+        self, auth_manager: LLMAuthManager = None, config: LLMDriverConfig = None
+    ):
+        if not self.available:
+            self._tools_adapter = get_local_tools_adapter()
+            self._driver = None
+        else:
+            self.auth_manager = auth_manager or LLMAuthManager()
+            self._api_key = self.auth_manager.get_credentials(type(self).NAME)
+            self._tools_adapter = get_local_tools_adapter()
+            self._driver_config = config or LLMDriverConfig(model=self.DEFAULT_MODEL)
+            if not self._driver_config.model:
+                self._driver_config.model = self.DEFAULT_MODEL
+
+            if not self._driver_config.api_key:
+                self._driver_config.api_key = self._api_key
+            self._driver_config.base_url = "https://api.groq.com/openai/v1"
+            self.fill_missing_device_info(self._driver_config)
+            self._driver = None
+
+    @property
+    def driver(self) -> OpenAIModelDriver:
+        if not self.available:
+            raise ImportError(f"GroqProvider unavailable: {self.unavailable_reason}")
+        return self._driver
+
+    @property
+    def available(self):
+        return available
+
+    @property
+    def unavailable_reason(self):
+        return unavailable_reason
+
+    def create_driver(self):
+        driver = OpenAIModelDriver(
+            tools_adapter=self._tools_adapter, provider_name=self.NAME
+        )
+        driver.config = self._driver_config
+        return driver
+
+    @property
+    def model_name(self):
+        return self._driver_config.model
+
+    @property
+    def driver_config(self):
+        return self._driver_config
+
+    def execute_tool(self, tool_name: str, event_bus, *args, **kwargs):
+        self._tools_adapter.event_bus = event_bus
+        return self._tools_adapter.execute_by_name(tool_name, *args, **kwargs)
+
+
+LLMProviderRegistry.register(GroqProvider.NAME, GroqProvider)

janito/providers/moonshotai/provider.py

@@ -6,13 +6,17 @@ from janito.tools import get_local_tools_adapter
 from janito.providers.registry import LLMProviderRegistry
 from .model_info import MOONSHOTAI_MODEL_SPECS
 
+
 class MoonshotAIProvider(LLMProvider):
     name = "moonshotai"
-    maintainer = "João Pinto <lamego.pinto@gmail.com>"
+    NAME = "moonshotai"
+    MAINTAINER = "João Pinto <lamego.pinto@gmail.com>"
     MODEL_SPECS = MOONSHOTAI_MODEL_SPECS
     DEFAULT_MODEL = "kimi-k2-0711-preview"
 
-    def __init__(self, auth_manager: LLMAuthManager = None, config: LLMDriverConfig = None):
+    def __init__(
+        self, auth_manager: LLMAuthManager = None, config: LLMDriverConfig = None
+    ):
         if not self.available:
             self._tools_adapter = get_local_tools_adapter()
             self._driver = None
@@ -49,7 +53,9 @@ class MoonshotAIProvider(LLMProvider):
     @property
     def driver(self) -> OpenAIModelDriver:
         if not self.available:
-            raise ImportError(f"MoonshotAIProvider unavailable: {self.unavailable_reason}")
+            raise ImportError(
+                f"MoonshotAIProvider unavailable: {self.unavailable_reason}"
+            )
         return self._driver
 
     @property
@@ -79,4 +85,5 @@ class MoonshotAIProvider(LLMProvider):
         self._tools_adapter.event_bus = event_bus
         return self._tools_adapter.execute_by_name(tool_name, *args, **kwargs)
 
-LLMProviderRegistry.register(MoonshotAIProvider.name, MoonshotAIProvider)
+
+LLMProviderRegistry.register(MoonshotAIProvider.NAME, MoonshotAIProvider)

janito/providers/openai/model_info.py

@@ -123,5 +123,4 @@ MODEL_SPECS = {
         open="openai",
         driver="OpenAIModelDriver",
     ),
-
 }