janito 3.4.0__py3-none-any.whl → 3.5.1__py3-none-any.whl

janito/cli/main_cli.py

@@ -238,6 +238,13 @@ definition = [
             "help": "List all resources (tools, commands, config) from loaded plugins",
         },
     ),
+    (
+        ["--check-tools"],
+        {
+            "action": "store_true",
+            "help": "Check all registered tools for signature validation and availability",
+        },
+    ),
 ]
 
 MODIFIER_KEYS = [
@@ -269,18 +276,7 @@ GETTER_KEYS = [
     "region_info",
     "list_providers_region",
     "ping",
-]
-GETTER_KEYS = [
-    "show_config",
-    "list_providers",
-    "list_profiles",
-    "list_models",
-    "list_tools",
-    "list_config",
-    "list_drivers",
-    "region_info",
-    "list_providers_region",
-    "ping",
+    "check_tools",
 ]
 
 
@@ -406,6 +402,7 @@ class JanitoCLI:
             or self.args.list_plugins_available
             or self.args.list_resources
             or self.args.ping
+            or self.args.check_tools
         ):
             self._maybe_print_verbose_provider_model()
             handle_getter(self.args)

janito/cli/prompt_core.py

@@ -207,15 +207,53 @@ class PromptHandler:
         """
         try:
             self._print_verbose_debug("Calling agent.chat()...")
-            final_event = self.agent.chat(prompt=user_prompt)
-            if hasattr(self.agent, "set_latest_event"):
-                self.agent.set_latest_event(final_event)
-            self.agent.last_event = final_event
-            self._print_verbose_debug(f"agent.chat() returned: {final_event}")
-            self._print_verbose_final_event(final_event)
-            if on_event and final_event is not None:
-                on_event(final_event)
-                global_event_bus.publish(final_event)
+
+            # Use global cancellation manager
+            from janito.llm.cancellation_manager import get_cancellation_manager
+            import time
+            from threading import Thread, Event
+
+            cancel_manager = get_cancellation_manager()
+            driver_cancel_event = cancel_manager.start_new_request()
+
+            # Timer setup with live status display
+            start_time = time.time()
+            stop_timer = Event()
+            
+            # Create a status display with timer
+            from rich.live import Live
+            from rich.text import Text
+            
+            def get_timer_text():
+                elapsed = time.time() - start_time
+                minutes, seconds = divmod(int(elapsed), 60)
+                return Text(f"⏱️  Waiting for response... {minutes:02d}:{seconds:02d}", style="cyan")
+            
+            # Use Live display for updating timer
+            with Live(get_timer_text(), refresh_per_second=4, console=self.console) as live:
+                def update_timer():
+                    while not stop_timer.wait(0.25):  # Update every 250ms
+                        live.update(get_timer_text())
+                
+                timer_thread = Thread(target=update_timer, daemon=True)
+                timer_thread.start()
+
+                try:
+                    final_event = self.agent.chat(prompt=user_prompt)
+                    stop_timer.set()  # Stop the timer
+                    
+                    if hasattr(self.agent, "set_latest_event"):
+                        self.agent.set_latest_event(final_event)
+                    self.agent.last_event = final_event
+                    self._print_verbose_debug(f"agent.chat() returned: {final_event}")
+                    self._print_verbose_final_event(final_event)
+                    if on_event and final_event is not None:
+                        on_event(final_event)
+                        global_event_bus.publish(final_event)
+                finally:
+                    stop_timer.set()  # Ensure timer stops
+                    cancel_manager.clear_current_request()
+
         except KeyboardInterrupt:
             # Capture user interrupt / cancellation
             self.console.print("[red]Interrupted by the user.[/red]")

janito/cli/rich_terminal_reporter.py

@@ -161,10 +161,10 @@ class RichTerminalReporter(EventHandlerBase):
             self.console.print(msg)
             self.console.file.flush()
         elif subtype == ReportSubtype.STDOUT:
-            self.console.print(msg)
+            self.console.print(msg, style=None)
             self.console.file.flush()
         elif subtype == ReportSubtype.STDERR:
-            self.console.print(Text(msg, style="on red"))
+            self.console.print(msg, style=None)
             self.console.file.flush()
         else:
             self.console.print(msg)

janito/drivers/openai/driver.py

@@ -181,6 +181,7 @@ class OpenAIModelDriver(LLMDriver):
         is_insufficient_quota = (
             "insufficient_quota" in lower_err
             or "exceeded your current quota" in lower_err
+            or "exceeded_current_quota_error" in lower_err
         )
         is_rate_limit = (
             status_code == 429

janito/drivers/zai/driver.py

@@ -174,6 +174,7 @@ class ZAIModelDriver(LLMDriver):
         is_insufficient_quota = (
             "insufficient_quota" in lower_err
             or "exceeded your current quota" in lower_err
+            or "exceeded_current_quota_error" in lower_err
         )
         is_rate_limit = (
             status_code == 429

janito/i18n/it.py

@@ -1,46 +1,46 @@
-# pragma: allowlist secret
-translations = {
-    "36107ed78ab25f6fb12ad8ce13018cd1ce6735d1": "Avvio del server web...",
-    "70a0d194687568a47aa617fd85036ace1e69a982": "Vuoi davvero uscire? (s/n): ",
-    "5c9ebcbbd7632ecb328bd52958b17158afaa32c6": "F12 = Azione Rapida (segue l'azione raccomandata)",
-    "fe21121e2934234b68d19b2757532117d440c1e3": "Chiave API non trovata. Si prega di configurare 'api_key' nel file di configurazione.",
-    "c9e3759b1756eba35b381ce2b72cd659e132b01f": "Ciao, {name}!",
-    "ca1fee2f55baabdc2e4b0e9529c89ee024e62079": "Nessun prompt fornito nei messaggi",
-    "f7449d23d0c500ae2a0b31e04f92b47a4d8ae845": "max_tokens deve essere un intero, ricevuto: {resolved_max_tokens!r}",
-    "70a9ed8edb6da12e208431a31aa16ba54419b26f": "Risposta non valida/malformed da OpenAI (tentativo {attempt}/{max_retries}). Riprovo tra {wait_time} secondi...",
-    "a873085e3b06184fb5d27e842f97b06b6190976d": "Numero massimo di tentativi per risposta non valida raggiunto. Generazione errore.",
-    "66a34568bbe846bb1bde3619eb4d6dfa10211104": "L'API non supporta l'uso degli strumenti.",
-    "09b81476b75586da4116b83f8be70d77b174cec3": "Limite di richieste API OpenAI (429) (tentativo {attempt}/{max_retries}): {e}. Riprovo tra {wait_time} secondi...",
-    "5717a35dd2a1533fb7e15edc8c9329cb69f3410b": "Errore server API OpenAI (tentativo {attempt}/{max_retries}): {e}. Riprovo tra {wait_time} secondi...",
-    "02e760ba15ed863176c1290ac8a9b923963103cd": "Errore client API OpenAI {status_code}: {e}. Nessun nuovo tentativo.",
-    "2e52b0bbc8f16226b70e3e20f95c9245d2bcdb47": "Errore API OpenAI (tentativo {attempt}/{max_retries}): {e}. Riprovo tra {wait_time} secondi...",
-    "012cc970e039fdd79c452fc676202c814ffc76ae": "Numero massimo di tentativi per errore API OpenAI raggiunto. Generazione errore.",
-    "d0438e45667d31e0022b2497b5901cd4300f084b": "QueuedMessageHandler.handle_message si aspetta un dizionario con 'type' e 'message', ricevuto {msg_type}: {msg!r}",
-    "9d3460187ffa19c7c8a4020157072b1087e1bd2f": "[QueuedMessageHandler] {msg_type}: {msg}",
-    "3813833343430e8afa8fce33385c5e39fb24dd60": "[QueuedMessageHandler] {msg_type}: {message}",
-    "0be9a22226e16a40797010d23a0f581542dca40e": "[ToolExecutor] {tool_name} chiamato con argomenti: {args}",
-    "42c68edcb25442f518b1af77c6a2ddc07461aae0": "[ToolExecutor] Motivo chiamata: {tool_call_reason}",
-    "002ff598115d84595ffeee6219cb5c03d3a1d4a6": "Domanda",
-    "35747d13dcd91e8e8790c7f767d5ed764f541b9e": "procedi",
-    "33dde3a1afbc418768a69fa53168d9b0638fe1aa": "avanti",
-    "eee0bbba4ff92adbeb038a77df0466d660f15716": "continua",
-    "edee9402d198b04ac77dcf5dc9cc3dac44573782": "prossimo",
-    "8fdb7e2fa84f4faf0d9b92f466df424ec47a165b": "ok",
-    "5f8f924671cda79b5205a6bf1b776f347c4a7a07": "Opzioni di configurazione disponibili:\n",
-    "cef780a309cd234750764d42697882c24168ddab": "{key:15} {desc} (predefinito: {default})",
-    "68c2cc7f0ceaa3e499ecb4db331feb4debbbcc23": "Modello",
-    "c3f104d1365744b538bfde9f4adb6a6df4b80355": "Funzione",
-    "99a0efc6cfd85d8ff2732a6718140f822cb90472": "Stile",
-    "f1702b4686278becffc88baabe6f4b7a8355532c": "Messaggi",
-    "c38c6c1f3a2743f8626703abb302e403d20ff81c": "Token",
-    "a817d7eb8e0f1dab755ab5203a082e5c3c094fce": "Prompt",
-    "2ff255684a2277f806fcebf3fe338ed27857f350": "Completamento",
-    "b25928c69902557b0ef0a628490a3a1768d7b82f": "Totale",
-    "76e63d65c883ed50df40ac3aeef0c2d6a1c4ad60": "Azione Rapida",
-    "5397e0583f14f6c88de06b1ef28f460a1fb5b0ae": "Sì",
-    "816c52fd2bdd94a63cd0944823a6c0aa9384c103": "No",
-    "c47ae15370cfe1ed2781eedc1dc2547d12d9e972": "Aiuto",
-    "cc3dbd47e1cf9003a55d3366b3adbcd72275e525": "Nuovo Task",
-    "efa5a8b84e1afe65c81ecfce28c398c48f19ddc2": "Benvenuto su Janito{version_str}! Modalità chat attiva. Digita /exit per uscire.",
-    "b314d6e1460f86e0f21abc5aceb7935a2a0667e8": "Benvenuto su Janito{version_str} in modalità [white on magenta]VANILLA[/white on magenta]! Strumenti, prompt di sistema e temperatura sono disattivati, a meno che non siano sovrascritti.",
-}
+# pragma: allowlist secret
+translations = {
+    "36107ed78ab25f6fb12ad8ce13018cd1ce6735d1": "Avvio del server web...",
+    "70a0d194687568a47aa617fd85036ace1e69a982": "Vuoi davvero uscire? (s/n): ",
+    "5c9ebcbbd7632ecb328bd52958b17158afaa32c6": "F12 = Azione Rapida (segue l'azione raccomandata)",
+    "fe21121e2934234b68d19b2757532117d440c1e3": "Chiave API non trovata. Si prega di configurare 'api_key' nel file di configurazione.",
+    "c9e3759b1756eba35b381ce2b72cd659e132b01f": "Ciao, {name}!",
+    "ca1fee2f55baabdc2e4b0e9529c89ee024e62079": "Nessun prompt fornito nei messaggi",
+    "f7449d23d0c500ae2a0b31e04f92b47a4d8ae845": "max_tokens deve essere un intero, ricevuto: {resolved_max_tokens!r}",
+    "70a9ed8edb6da12e208431a31aa16ba54419b26f": "Risposta non valida/malformed da OpenAI (tentativo {attempt}/{max_retries}). Riprovo tra {wait_time} secondi...",
+    "a873085e3b06184fb5d27e842f97b06b6190976d": "Numero massimo di tentativi per risposta non valida raggiunto. Generazione errore.",
+    "66a34568bbe846bb1bde3619eb4d6dfa10211104": "L'API non supporta l'uso degli strumenti.",
+    "09b81476b75586da4116b83f8be70d77b174cec3": "Limit di richieste API OpenAI (429) (tentativo {attempt}/{max_retries}): {e}. Riprovo tra {wait_time} secondi...",
+    "5717a35dd2a1533fb7e15edc8c9329cb69f3410b": "Errore server API OpenAI (tentativo {attempt}/{max_retries}): {e}. Riprovo tra {wait_time} secondi...",
+    "02e760ba15ed863176c1290ac8a9b923963103cd": "Errore client API OpenAI {status_code}: {e}. Nessun nuovo tentativo.",
+    "2e52b0bbc8f16226b70e3e20f95c9245d2bcdb47": "Errore API OpenAI (tentativo {attempt}/{max_retries}): {e}. Riprovo tra {wait_time} secondi...",
+    "012cc970e039fdd79c452fc676202c814ffc76ae": "Numero massimo di tentativi per errore API OpenAI raggiunto. Generazione errore.",
+    "d0438e45667d31e0022b2497b5901cd4300f084b": "QueuedMessageHandler.handle_message si aspetta un dizionario con 'type' e 'message', ricevuto {msg_type}: {msg!r}",
+    "9d3460187ffa19c7c8a4020157072b1087e1bd2f": "[QueuedMessageHandler] {msg_type}: {msg}",
+    "3813833343430e8afa8fce33385c5e39fb24dd60": "[QueuedMessageHandler] {msg_type}: {message}",
+    "0be9a22226e16a40797010d23a0f581542dca40e": "[ToolExecutor] {tool_name} chiamato con argomenti: {args}",
+    "42c68edcb25442f518b1af77c6a2ddc07461aae0": "[ToolExecutor] Motivo chiamata: {tool_call_reason}",
+    "002ff598115d84595ffeee6219cb5c03d3a1d4a6": "Domanda",
+    "35747d13dcd91e8e8790c7f767d5ed764f541b9e": "procedi",
+    "33dde3a1afbc418768a69fa53168d9b0638fe1aa": "avanti",
+    "eee0bbba4ff92adbeb038a77df0466d660f15716": "continua",
+    "edee9402d198b04ac77dcf5dc9cc3dac44573782": "prossimo",
+    "8fdb7e2fa84f4faf0d9b92f466df424ec47a165b": "ok",
+    "5f8f924671cda79b5205a6bf1b776f347c4a7a07": "Opzioni di configurazione disponibili:\n",
+    "cef780a309cd234750764d42697882c24168ddab": "{key:15} {desc} (predefinito: {default})",
+    "68c2cc7f0ceaa3e499ecb4db331feb4debbbcc23": "Modello",
+    "c3f104d1365744b538bfde9f4adb6a6df4b80355": "Funzione",
+    "99a0efc6cfd85d8ff2732a6718140f822cb90472": "Stile",
+    "f1702b4686278becffc88baabe6f4b7a8355532c": "Messaggi",
+    "c38c6c1f3a2743f8626703abb302e403d20ff81c": "Token",
+    "a817d7eb8e0f1dab755ab5203a082e5c3c094fce": "Prompt",
+    "2ff255684a2277f806fcebf3fe338ed27857f350": "Completamento",
+    "b25928c69902557b0ef0a628490a3a1768d7b82f": "Totale",
+    "76e63d65c883ed50df40ac3aeef0c2d6a1c4ad60": "Azione Rapida",
+    "5397e0583f14f6c88de06b1ef28f460a1fb5b0ae": "Sì",
+    "816c52fd2bdd94a63cd0944823a6c0aa9384c103": "No",
+    "c47ae15370cfe1ed2781eedc1dc2547d12d9e972": "Aiuto",
+    "cc3dbd47e1cf9003a55d3366b3adbcd72275e525": "Nuovo Task",
+    "efa5a8b84e1afe65c81ecfce28c398c48f19ddc2": "Benvenuto su Janito{version_str}! Modalità chat attiva. Digita /exit per uscire.",
+    "b314d6e1460f86e0f21abc5aceb7935a2a0667e8": "Benvenuto su Janito{version_str} in modalità [white on magenta]VANILLA[/white on magenta]! Strumenti, prompt di sistema e temperatura sono disattivati, a meno che non siano sovrascritti.",
+}

janito/llm/agent.py

@@ -318,23 +318,39 @@ class LLMAgent:
         loop_count = 1
         import threading
 
-        cancel_event = threading.Event()
-        while True:
-            self._print_verbose_chat_loop(loop_count)
-            driver_input = self._prepare_driver_input(config, cancel_event=cancel_event)
-            self.input_queue.put(driver_input)
-            try:
-                result, added_tool_results = self._process_next_response()
-            except KeyboardInterrupt:
-                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}"
+        # Use global cancellation manager
+        from janito.llm.cancellation_manager import get_cancellation_manager
+
+        cancel_manager = get_cancellation_manager()
+        driver_cancel_event = cancel_manager.start_new_request()
+
+        # Store cancellation event on agent for external access
+        self.cancel_event = driver_cancel_event
+
+        try:
+            while True:
+                self._print_verbose_chat_loop(loop_count)
+                driver_input = self._prepare_driver_input(
+                    config, cancel_event=driver_cancel_event
                 )
-            if self._should_exit_chat_loop(result, added_tool_results):
-                return result
-            loop_count += 1
+                self.input_queue.put(driver_input)
+                try:
+                    result, added_tool_results = self._process_next_response()
+                except KeyboardInterrupt:
+                    cancel_manager.cancel_current_request()
+                    raise
+                if getattr(self, "verbose_agent", False):
+                    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
+        finally:
+            cancel_manager.clear_current_request()
+            # Clean up cancellation event
+            if hasattr(self, "cancel_event"):
+                delattr(self, "cancel_event")
 
     def _clear_driver_queues(self):
         if hasattr(self, "driver") and self.driver:

janito/llm/auth_utils.py

@@ -13,9 +13,18 @@ def handle_missing_api_key(provider_name: str, env_var_name: str) -> None:
         provider_name: Name of the provider (e.g., 'alibaba', 'openai')
         env_var_name: Environment variable name (e.g., 'ALIBABA_API_KEY')
     """
-    print(
-        f"[ERROR] No API key found for provider '{provider_name}'. Please set the API key using:"
-    )
-    print(f"  janito --set-api-key YOUR_API_KEY -p {provider_name}")
-    print(f"Or set the {env_var_name} environment variable.")
+    if provider_name == "moonshot":
+        print(
+            f"[ERROR] You exceeded your current token quota for Moonshot. Please check your account balance at:"
+        )
+        print(f"  https://platform.moonshot.ai/console/pay")
+        print()
+        print(f"To set a new API key, use:")
+        print(f"  janito --set-api-key YOUR_NEW_API_KEY -p moonshot")
+    else:
+        print(
+            f"[ERROR] No API key found for provider '{provider_name}'. Please set the API key using:"
+        )
+        print(f"  janito --set-api-key YOUR_API_KEY -p {provider_name}")
+        print(f"Or set the {env_var_name} environment variable.")
     sys.exit(1)

janito/llm/cancellation_manager.py

@@ -0,0 +1,63 @@
+"""
+Global cancellation manager for LLM requests.
+Provides a centralized way to cancel ongoing requests.
+"""
+
+import threading
+from typing import Optional
+
+
+class CancellationManager:
+    """Manages cancellation of LLM requests across the application."""
+
+    def __init__(self):
+        self._current_cancel_event: Optional[threading.Event] = None
+        self._lock = threading.Lock()
+        self._keyboard_cancellation = None
+
+    def start_new_request(self) -> threading.Event:
+        """Start a new request and return its cancellation event."""
+        with self._lock:
+            # Create new cancellation event for this request
+            self._current_cancel_event = threading.Event()
+
+            # Start keyboard monitoring
+            from janito.llm.enter_cancellation import get_enter_cancellation
+
+            self._keyboard_cancellation = get_enter_cancellation()
+            self._keyboard_cancellation.start_monitoring(self._current_cancel_event)
+
+            return self._current_cancel_event
+
+    def cancel_current_request(self) -> bool:
+        """Cancel the current request if one is active."""
+        with self._lock:
+            if self._current_cancel_event is not None:
+                self._current_cancel_event.set()
+                return True
+            return False
+
+    def get_current_cancel_event(self) -> Optional[threading.Event]:
+        """Get the current cancellation event."""
+        with self._lock:
+            return self._current_cancel_event
+
+    def clear_current_request(self):
+        """Clear the current request cancellation event."""
+        with self._lock:
+            if self._keyboard_cancellation:
+                self._keyboard_cancellation.stop_monitoring()
+                self._keyboard_cancellation = None
+            self._current_cancel_event = None
+
+
+# Global cancellation manager instance
+_global_manager = None
+
+
+def get_cancellation_manager() -> CancellationManager:
+    """Get the global cancellation manager instance."""
+    global _global_manager
+    if _global_manager is None:
+        _global_manager = CancellationManager()
+    return _global_manager

janito/llm/driver.py

@@ -252,3 +252,11 @@ class LLMDriver(ABC):
     def _get_message_from_result(self, result):
         """Extract the message object from the provider result. Subclasses must implement this."""
         raise NotImplementedError("Subclasses must implement _get_message_from_result.")
+
+    def cancel_current_request(self):
+        """Cancel the current request being processed."""
+        # Use global cancellation manager to cancel the current request
+        from janito.llm.cancellation_manager import get_cancellation_manager
+
+        cancel_manager = get_cancellation_manager()
+        cancel_manager.cancel_current_request()

janito/llm/enter_cancellation.py

@@ -0,0 +1,107 @@
+"""
+Enter key cancellation for LLM requests.
+Allows pressing Enter to cancel ongoing requests.
+"""
+
+import threading
+import sys
+import time
+from typing import Optional
+
+
+class EnterCancellation:
+    """Handles Enter key cancellation of LLM requests."""
+
+    def __init__(self):
+        self._cancel_event: Optional[threading.Event] = None
+        self._listener_thread: Optional[threading.Thread] = None
+        self._listening = False
+
+    def start_monitoring(self, cancel_event: threading.Event):
+        """Start monitoring for Enter key to cancel the request."""
+        if self._listening:
+            return
+
+        self._cancel_event = cancel_event
+        self._listening = True
+
+        self._listener_thread = threading.Thread(
+            target=self._monitor_enter_key, daemon=True
+        )
+        self._listener_thread.start()
+
+    def stop_monitoring(self):
+        """Stop monitoring for keyboard input."""
+        self._listening = False
+        if self._listener_thread and self._listener_thread.is_alive():
+            self._listener_thread.join(timeout=0.1)
+
+    def _monitor_enter_key(self):
+        """Monitor for Enter key press."""
+        try:
+            self._handle_key_monitoring()
+        except Exception:
+            # Silently handle any errors
+            pass
+
+    def _handle_key_monitoring(self):
+        """Handle the actual key monitoring logic."""
+        import sys
+        import select
+
+        try:
+            import msvcrt  # Windows-specific keyboard input
+
+            self._monitor_windows_keys()
+        except ImportError:
+            self._monitor_unix_keys()
+
+    def _monitor_windows_keys(self):
+        """Monitor keys on Windows systems."""
+        import msvcrt
+
+        while (
+            self._listening and self._cancel_event and not self._cancel_event.is_set()
+        ):
+            try:
+                if msvcrt.kbhit():
+                    char = msvcrt.getch()
+                    if char in [b"\r", b"\n"]:
+                        if self._cancel_event:
+                            self._cancel_event.set()
+                        break
+                else:
+                    time.sleep(0.05)
+            except (IOError, OSError):
+                break
+
+    def _monitor_unix_keys(self):
+        """Monitor keys on Unix-like systems."""
+        import sys
+        import select
+
+        while (
+            self._listening and self._cancel_event and not self._cancel_event.is_set()
+        ):
+            try:
+                if sys.stdin in select.select([sys.stdin], [], [], 0.05)[0]:
+                    char = sys.stdin.read(1)
+                    if char in ["\r", "\n"]:
+                        if self._cancel_event:
+                            self._cancel_event.set()
+                        break
+                time.sleep(0.05)
+            except:
+                time.sleep(0.05)
+
+
+# Global instance
+_global_enter_cancellation = None
+
+
+def get_enter_cancellation() -> EnterCancellation:
+    """Get the global Enter cancellation instance."""
+    global _global_enter_cancellation
+    if _global_enter_cancellation is None:
+        _global_enter_cancellation = EnterCancellation()
+    return _global_enter_cancellation

janito/plugin_system/__init__.py

@@ -0,0 +1,10 @@
+"""
+Plugin System Core Package
+
+This package provides the foundational plugin system architecture.
+It should not depend on any specific plugin implementations.
+"""
+
+from .base import Plugin, PluginMetadata, PluginResource
+
+__all__ = ["Plugin", "PluginMetadata", "PluginResource"]

janito/{plugins → plugin_system}/base.py

@@ -5,7 +5,10 @@ Base classes for janito plugins.
 from abc import ABC, abstractmethod
 from dataclasses import dataclass
 from typing import Dict, Any, List, Optional, Type, Union
-from janito.tools.tool_base import ToolBase
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from janito.tools.tool_base import ToolBase
 
 
 @dataclass
@@ -50,7 +53,7 @@ class Plugin(ABC):
         """Return metadata describing this plugin."""
         pass
 
-    def get_tools(self) -> List[Type[ToolBase]]:
+    def get_tools(self) -> List[Type["ToolBase"]]:
         """
         Return a list of tool classes provided by this plugin.