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

janito/drivers/azure_openai/driver.py

@@ -1,14 +1,6 @@
 from janito.drivers.openai.driver import OpenAIModelDriver
 
-# Safe import of AzureOpenAI SDK
-try:
-    from openai import AzureOpenAI
-
-    DRIVER_AVAILABLE = True
-    DRIVER_UNAVAILABLE_REASON = None
-except ImportError:
-    DRIVER_AVAILABLE = False
-    DRIVER_UNAVAILABLE_REASON = "Missing dependency: openai (pip install openai)"
+from openai import AzureOpenAI
 
 from janito.llm.driver_config import LLMDriverConfig
 
@@ -16,30 +8,22 @@ from janito.llm.driver_config import LLMDriverConfig
 class AzureOpenAIModelDriver(OpenAIModelDriver):
     def start(self, *args, **kwargs):
         # Ensure azure_deployment_name is set before starting
-        config = getattr(self, 'config', None)
+        config = getattr(self, "config", None)
         deployment_name = None
-        if config and hasattr(config, 'extra'):
-            deployment_name = config.extra.get('azure_deployment_name')
+        if config and hasattr(config, "extra"):
+            deployment_name = config.extra.get("azure_deployment_name")
         if not deployment_name:
-            raise RuntimeError("AzureOpenAIModelDriver requires 'azure_deployment_name' to be set in config.extra['azure_deployment_name'] before starting.")
+            raise RuntimeError(
+                "AzureOpenAIModelDriver requires 'azure_deployment_name' to be set in config.extra['azure_deployment_name'] before starting."
+            )
         # Call parent start if exists
-        if hasattr(super(), 'start'):
+        if hasattr(super(), "start"):
             return super().start(*args, **kwargs)
 
-    available = DRIVER_AVAILABLE
-    unavailable_reason = DRIVER_UNAVAILABLE_REASON
-
-    @classmethod
-    def is_available(cls):
-        return cls.available
-
     required_config = {"base_url"}  # Update key as used in your config logic
 
     def __init__(self, tools_adapter=None, provider_name=None):
-        if not self.available:
-            raise ImportError(
-                f"AzureOpenAIModelDriver unavailable: {self.unavailable_reason}"
-            )
+
         # Ensure proper parent initialization
         super().__init__(tools_adapter=tools_adapter, provider_name=provider_name)
         self.azure_endpoint = None
@@ -52,25 +36,35 @@ class AzureOpenAIModelDriver(OpenAIModelDriver):
         Also ensures tool schemas are included if tools_adapter is present.
         """
         api_kwargs = super()._prepare_api_kwargs(config, conversation)
-        deployment_name = config.extra.get("azure_deployment_name") if hasattr(config, "extra") else None
+        deployment_name = (
+            config.extra.get("azure_deployment_name")
+            if hasattr(config, "extra")
+            else None
+        )
         if deployment_name:
             api_kwargs["model"] = deployment_name
         # Patch: Ensure tools are included for Azure as for OpenAI
         if self.tools_adapter:
             try:
-                from janito.providers.openai.schema_generator import generate_tool_schemas
+                from janito.providers.openai.schema_generator import (
+                    generate_tool_schemas,
+                )
+
                 tool_classes = self.tools_adapter.get_tool_classes()
                 tool_schemas = generate_tool_schemas(tool_classes)
                 api_kwargs["tools"] = tool_schemas
             except Exception as e:
                 api_kwargs["tools"] = []
                 if hasattr(config, "verbose_api") and config.verbose_api:
-                    print(f"[AzureOpenAIModelDriver] Tool schema generation failed: {e}")
+                    print(
+                        f"[AzureOpenAIModelDriver] Tool schema generation failed: {e}"
+                    )
         return api_kwargs
 
     def _instantiate_openai_client(self, config):
         try:
             from openai import AzureOpenAI
+
             api_key_display = str(config.api_key)
             if api_key_display and len(api_key_display) > 8:
                 api_key_display = api_key_display[:4] + "..." + api_key_display[-4:]
@@ -83,8 +77,11 @@ class AzureOpenAIModelDriver(OpenAIModelDriver):
             client = AzureOpenAI(**client_kwargs)
             return client
         except Exception as e:
-            print(f"[ERROR] Exception during AzureOpenAI client instantiation: {e}", flush=True)
+            print(
+                f"[ERROR] Exception during AzureOpenAI client instantiation: {e}",
+                flush=True,
+            )
             import traceback
+
             print(traceback.format_exc(), flush=True)
             raise
-

janito/drivers/openai/driver.py

@@ -12,15 +12,7 @@ from janito.llm.driver_input import DriverInput
 from janito.driver_events import RequestFinished, RequestStatus, RateLimitRetry
 from janito.llm.message_parts import TextMessagePart, FunctionCallMessagePart
 
-# Safe import of openai SDK
-try:
-    import openai
-
-    DRIVER_AVAILABLE = True
-    DRIVER_UNAVAILABLE_REASON = None
-except ImportError:
-    DRIVER_AVAILABLE = False
-    DRIVER_UNAVAILABLE_REASON = "Missing dependency: openai (pip install openai)"
+import openai
 
 
 class OpenAIModelDriver(LLMDriver):
@@ -33,8 +25,6 @@ class OpenAIModelDriver(LLMDriver):
     """
     OpenAI LLM driver (threaded, queue-based, stateless). Uses input/output queues accessible via instance attributes.
     """
-    available = DRIVER_AVAILABLE
-    unavailable_reason = DRIVER_UNAVAILABLE_REASON
 
     def __init__(self, tools_adapter=None, provider_name=None):
         super().__init__(tools_adapter=tools_adapter, provider_name=provider_name)
@@ -84,13 +74,18 @@ class OpenAIModelDriver(LLMDriver):
                 api_kwargs[p] = v
         api_kwargs["messages"] = conversation
         api_kwargs["stream"] = False
+        # Always return the prepared kwargs, even if no tools are registered. The
+        # OpenAI Python SDK expects a **mapping** – passing *None* will raise
+        # ``TypeError: argument after ** must be a mapping, not NoneType``.
         return api_kwargs
 
     def _call_api(self, driver_input: DriverInput):
         """Call the OpenAI-compatible chat completion endpoint with retry and error handling."""
         cancel_event = getattr(driver_input, "cancel_event", None)
         config = driver_input.config
-        conversation = self.convert_history_to_api_messages(driver_input.conversation_history)
+        conversation = self.convert_history_to_api_messages(
+            driver_input.conversation_history
+        )
         request_id = getattr(config, "request_id", None)
         self._print_api_call_start(config)
         client = self._instantiate_openai_client(config)
@@ -108,14 +103,18 @@ class OpenAIModelDriver(LLMDriver):
                 self._handle_api_success(config, result, request_id)
                 return result
             except Exception as e:
-                if self._handle_api_exception(e, config, api_kwargs, attempt, max_retries, request_id):
+                if self._handle_api_exception(
+                    e, config, api_kwargs, attempt, max_retries, request_id
+                ):
                     attempt += 1
                     continue
                 raise
 
     def _print_api_call_start(self, config):
         if getattr(config, "verbose_api", False):
-            tool_adapter_name = type(self.tools_adapter).__name__ if self.tools_adapter else None
+            tool_adapter_name = (
+                type(self.tools_adapter).__name__ if self.tools_adapter else None
+            )
             tool_names = []
             if self.tools_adapter and hasattr(self.tools_adapter, "list_tools"):
                 try:
@@ -156,17 +155,21 @@ class OpenAIModelDriver(LLMDriver):
             print("[OpenAI] API RESPONSE:", flush=True)
             pretty.pprint(result)
 
-    def _handle_api_exception(self, e, config, api_kwargs, attempt, max_retries, request_id):
+    def _handle_api_exception(
+        self, e, config, api_kwargs, attempt, max_retries, request_id
+    ):
         status_code = getattr(e, "status_code", None)
         err_str = str(e)
         lower_err = err_str.lower()
         is_insufficient_quota = (
-            "insufficient_quota" in lower_err or "exceeded your current quota" in lower_err
+            "insufficient_quota" in lower_err
+            or "exceeded your current quota" in lower_err
         )
         is_rate_limit = (
-            (status_code == 429 or "error code: 429" in lower_err or "resource_exhausted" in lower_err)
-            and not is_insufficient_quota
-        )
+            status_code == 429
+            or "error code: 429" in lower_err
+            or "resource_exhausted" in lower_err
+        ) and not is_insufficient_quota
         if not is_rate_limit or attempt > max_retries:
             self._handle_fatal_exception(e, config, api_kwargs)
         retry_delay = self._extract_retry_delay_seconds(e)
@@ -189,7 +192,9 @@ class OpenAIModelDriver(LLMDriver):
             )
         start_wait = time.time()
         while time.time() - start_wait < retry_delay:
-            if self._check_cancel(getattr(config, "cancel_event", None), request_id, before_call=False):
+            if self._check_cancel(
+                getattr(config, "cancel_event", None), request_id, before_call=False
+            ):
                 return False
             time.sleep(0.1)
         return True
@@ -208,7 +213,9 @@ class OpenAIModelDriver(LLMDriver):
             else:
                 payload = str(exception)
             # Look for 'retryDelay': '41s' or similar
-            m = re.search(r"retryDelay['\"]?\s*[:=]\s*['\"]?(\d+(?:\.\d+)?)(s)?", payload)
+            m = re.search(
+                r"retryDelay['\"]?\s*[:=]\s*['\"]?(\d+(?:\.\d+)?)(s)?", payload
+            )
             if m:
                 return float(m.group(1))
             # Fallback: generic number of seconds in the message
@@ -249,13 +256,17 @@ class OpenAIModelDriver(LLMDriver):
             # HTTP debug wrapper
             if os.environ.get("OPENAI_DEBUG_HTTP", "0") == "1":
                 from http.client import HTTPConnection
+
                 HTTPConnection.debuglevel = 1
                 logging.basicConfig()
                 logging.getLogger().setLevel(logging.DEBUG)
                 requests_log = logging.getLogger("http.client")
                 requests_log.setLevel(logging.DEBUG)
                 requests_log.propagate = True
-                print("[OpenAIModelDriver] HTTP debug enabled via OPENAI_DEBUG_HTTP=1", flush=True)
+                print(
+                    "[OpenAIModelDriver] HTTP debug enabled via OPENAI_DEBUG_HTTP=1",
+                    flush=True,
+                )
 
             client = openai.OpenAI(**client_kwargs)
             return client
@@ -377,26 +388,32 @@ class OpenAIModelDriver(LLMDriver):
             results = [content]
         for result in results:
             if isinstance(result, dict):
-                api_messages.append({
-                    "role": "tool",
-                    "content": result.get("content", ""),
-                    "name": result.get("name", ""),
-                    "tool_call_id": result.get("tool_call_id", ""),
-                })
+                api_messages.append(
+                    {
+                        "role": "tool",
+                        "content": result.get("content", ""),
+                        "name": result.get("name", ""),
+                        "tool_call_id": result.get("tool_call_id", ""),
+                    }
+                )
             else:
-                api_messages.append({
-                    "role": "tool",
-                    "content": str(result),
-                    "name": "",
-                    "tool_call_id": "",
-                })
+                api_messages.append(
+                    {
+                        "role": "tool",
+                        "content": str(result),
+                        "name": "",
+                        "tool_call_id": "",
+                    }
+                )
 
     def _handle_tool_calls(self, api_messages, content):
         try:
             tool_calls = json.loads(content) if isinstance(content, str) else content
         except Exception:
             tool_calls = []
-        api_messages.append({"role": "assistant", "content": "", "tool_calls": tool_calls})
+        api_messages.append(
+            {"role": "assistant", "content": "", "tool_calls": tool_calls}
+        )
 
     def _handle_other_roles(self, api_messages, msg, role, content):
         if role == "function":
@@ -433,4 +450,4 @@ class OpenAIModelDriver(LLMDriver):
                 )
             )
         # Extend here for other message part types if needed
-        return parts
+        return parts

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/llm/provider.py

@@ -17,7 +17,7 @@ class LLMProvider(ABC):
     Abstract base class for Large Language Model (LLM) providers.
 
     Provider Usage and Driver Communication Flow:
-      1. Provider class is selected (e.g., OpenAIProvider, MistralProvider).
+      1. Provider class is selected (e.g., OpenAIProvider).
       2. An instance of the provider is created. This instance is bound to a specific configuration (LLMDriverConfig) containing model, credentials, etc.
       3. All drivers created by that provider instance are associated with the bound config.
       4. To communicate with an LLM, call create_driver() on the provider instance, which yields a driver configured for the attached config. Every driver created via this method inherits the provider's configuration.

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)