janito 3.3.0__py3-none-any.whl → 3.5.0__py3-none-any.whl

janito/README.md

@@ -106,6 +106,9 @@ janito --set model=kimi-k1-8k
 
 ## Advanced Features
 
+### 🚀 New in v3.1.0: Enter Key Cancellation
+**Chat Mode Enhancement**: Press **Enter** at any time to instantly cancel long-running requests in interactive chat mode. No more waiting for stuck requests!
+
 ### Tool Usage
 
 Janito includes powerful built-in tools for:

janito/cli/chat_mode/bindings.py

@@ -35,4 +35,54 @@ class KeyBindingsFactory:
             buf.text = "Do It"
             buf.validate_and_handle()
 
+        @bindings.add("c-c")
+        def _(event):
+            """Handle Ctrl+C to interrupt current request or exit chat."""
+            # Use global cancellation manager for robust cancellation
+            from janito.llm.cancellation_manager import get_cancellation_manager
+
+            cancel_manager = get_cancellation_manager()
+
+            cancelled = cancel_manager.cancel_current_request()
+            if cancelled:
+                # Provide user feedback
+                from rich.console import Console
+
+                console = Console()
+                console.print("[red]Request cancelled by Ctrl+C[/red]")
+
+                # Prevent the Ctrl+C from being processed as input
+                event.app.output.flush()
+                return
+            else:
+                # No active request to cancel, exit the chat
+                from rich.console import Console
+                console = Console()
+                console.print("[yellow]Goodbye![/yellow]")
+                event.app.exit()
+
+        @bindings.add("escape", eager=True)
+        def _(event):
+            """Handle ESC key to interrupt current request (like Ctrl+C)."""
+            import threading
+
+            # Use global cancellation manager for robust cancellation
+            from janito.llm.cancellation_manager import get_cancellation_manager
+
+            cancel_manager = get_cancellation_manager()
+
+            cancelled = cancel_manager.cancel_current_request()
+            if cancelled:
+                # Provide user feedback
+                from rich.console import Console
+
+                console = Console()
+                console.print("[red]Request cancelled by ESC key[/red]")
+
+                # Prevent the ESC key from being processed as input
+                event.app.output.flush()
+                return
+
+            # If no active request to cancel, ESC does nothing
+
         return bindings

janito/cli/chat_mode/session.py

@@ -22,6 +22,7 @@ import time
 
 # Shared prompt/agent factory
 from janito.cli.prompt_setup import setup_agent_and_prompt_handler
+from janito.llm.cancellation_manager import get_cancellation_manager
 
 import time
 
@@ -113,6 +114,10 @@ class ChatSession:
 
         # Check if multi-line mode should be enabled by default
         self.multi_line_mode = getattr(args, "multi", False) if args else False
+        
+        # Default to single-line mode (Enter submits) unless explicitly enabled
+        if not self.multi_line_mode:
+            self.multi_line_mode = False
 
     def _select_profile_and_role(self, args, role):
         profile, role_arg, python_profile, market_profile = self._extract_args(args)
@@ -283,7 +288,13 @@ class ChatSession:
                 )
             )
 
-            self._prompt_handler.run_prompt(cmd_input)
+            try:
+                self._prompt_handler.run_prompt(cmd_input)
+            finally:
+                # Ensure cancellation manager is cleared
+                cancel_manager = get_cancellation_manager()
+                cancel_manager.clear_current_request()
+
             end_time = time.time()
             elapsed = end_time - start_time
             self.msg_count += 1

janito/cli/chat_mode/shell/commands/multi.py

@@ -23,6 +23,11 @@ class MultiShellHandler(ShellCmdHandler):
             submitted["value"] = buffer.text
             event.app.exit(result=buffer.text)
 
+        # Support single ESC to cancel/interrupt (like Ctrl+C)
+        @bindings.add("escape")
+        def _(event):
+            raise KeyboardInterrupt
+
         # Support Ctrl+D
         @bindings.add("c-d")
         def _(event):

janito/cli/chat_mode/shell/commands/security/allowed_sites.py

@@ -59,39 +59,53 @@ Examples:
         command = args[0].lower()
         whitelist_manager = get_url_whitelist_manager()
 
-        if command == "list":
-            sites = whitelist_manager.get_allowed_sites()
-            if sites:
-                print("Allowed sites:")
-                for site in sites:
-                    print(f"  • {site}")
-            else:
-                print("No sites are whitelisted (all sites are allowed)")
-
-        elif command == "add":
-            if len(args) < 2:
-                print("Error: Please specify a site to add")
-                return
-            site = args[1]
-            if whitelist_manager.add_allowed_site(site):
-                print(f"✅ Added '{site}' to allowed sites")
-            else:
-                print(f"ℹ️ '{site}' is already in allowed sites")
-
-        elif command == "remove":
-            if len(args) < 2:
-                print("Error: Please specify a site to remove")
-                return
-            site = args[1]
-            if whitelist_manager.remove_allowed_site(site):
-                print(f"✅ Removed '{site}' from allowed sites")
-            else:
-                print(f"ℹ️ '{site}' was not in allowed sites")
-
-        elif command == "clear":
-            whitelist_manager.clear_whitelist()
-            print("✅ Cleared all allowed sites (all sites are now allowed)")
-
+        handlers = {
+            "list": self._handle_list,
+            "add": self._handle_add,
+            "remove": self._handle_remove,
+            "clear": self._handle_clear,
+        }
+
+        handler = handlers.get(command)
+        if handler:
+            handler(args, whitelist_manager)
         else:
             print(f"Error: Unknown command '{command}'")
             print(self.get_usage())
+
+    def _handle_list(self, args, whitelist_manager):
+        """Handle list command."""
+        sites = whitelist_manager.get_allowed_sites()
+        if sites:
+            print("Allowed sites:")
+            for site in sites:
+                print(f"  • {site}")
+        else:
+            print("No sites are whitelisted (all sites are allowed)")
+
+    def _handle_add(self, args, whitelist_manager):
+        """Handle add command."""
+        if len(args) < 2:
+            print("Error: Please specify a site to add")
+            return
+        site = args[1]
+        if whitelist_manager.add_allowed_site(site):
+            print(f"✅ Added '{site}' to allowed sites")
+        else:
+            print(f"ℹ️ '{site}' is already in allowed sites")
+
+    def _handle_remove(self, args, whitelist_manager):
+        """Handle remove command."""
+        if len(args) < 2:
+            print("Error: Please specify a site to remove")
+            return
+        site = args[1]
+        if whitelist_manager.remove_allowed_site(site):
+            print(f"✅ Removed '{site}' from allowed sites")
+        else:
+            print(f"ℹ️ '{site}' was not in allowed sites")
+
+    def _handle_clear(self, args, whitelist_manager):
+        """Handle clear command."""
+        whitelist_manager.clear_whitelist()
+        print("✅ Cleared all allowed sites (all sites are now allowed)")

janito/cli/cli_commands/list_plugins.py

@@ -8,8 +8,11 @@ from janito.plugins.discovery import list_available_plugins
 import os
 from janito.plugins.manager import PluginManager
 from janito.plugins.builtin import BuiltinPluginRegistry
-from janito.plugins.manager import PluginManager
-from janito.plugins.core_loader import get_core_plugins
+from janito.plugins.auto_loader_fixed import (
+    load_core_plugins,
+    get_loaded_core_plugins,
+    is_core_plugin,
+)
 from rich.console import Console
 from rich.table import Table
 from rich.panel import Panel
@@ -52,7 +55,7 @@ def _list_available_plugins():
         console.print(table)
 
         # Show core plugins
-        from janito.plugins.core_loader import get_core_plugins
+        from janito.plugin_system.core_loader_fixed import get_core_plugins
 
         core_plugins = get_core_plugins()
         core_table = Table(title="Core Plugins (Enabled by Default)")
@@ -95,8 +98,10 @@ def _print_external_plugins(available, builtin_plugins):
 
 def _list_plugin_resources():
     """List all resources from loaded plugins using rich formatting."""
+    from janito.plugins.auto_loader_fixed import get_plugin_manager
+
     console = Console()
-    manager = PluginManager()
+    manager = get_plugin_manager()
     all_resources = manager.list_all_resources()
 
     if all_resources:
@@ -169,8 +174,10 @@ def _print_resources_by_type(resources):
 
 def _list_loaded_plugins():
     """List loaded plugins using rich formatting."""
+    from janito.plugins.auto_loader_fixed import get_plugin_manager
+
     console = Console()
-    manager = PluginManager()
+    manager = get_plugin_manager()
     loaded = manager.list_plugins()
 
     if loaded:
@@ -185,9 +192,7 @@ def _list_loaded_plugins():
         other_plugins = []
 
         for plugin_name in loaded:
-            from janito.plugins.core_loader import get_core_plugins
-            core_plugin_list = get_core_plugins()
-            if plugin_name in core_plugin_list:
+            if is_core_plugin(plugin_name):
                 core_plugins.append(plugin_name)
             else:
                 other_plugins.append(plugin_name)

janito/cli/core/model_guesser.py

@@ -21,34 +21,50 @@ def guess_provider_from_model(model_name: str) -> str:
     model_name = model_name.lower()
 
     # Check each provider's models
+    return _find_provider_for_model(model_name)
+
+
+def _find_provider_for_model(model_name: str) -> str:
+    """Find provider for given model name."""
     for provider_name in LLMProviderRegistry.list_providers():
         provider_class = LLMProviderRegistry.get(provider_name)
         if not provider_class:
             continue
 
-        # Get model specs for this provider
-        try:
-            if hasattr(provider_class, "MODEL_SPECS"):
-                model_specs = provider_class.MODEL_SPECS
-                for spec_model_name in model_specs.keys():
-                    if spec_model_name.lower() == model_name:
-                        return provider_name
-
-            # Handle special cases like moonshot
-            if provider_name == "moonshot":
-                try:
-                    from janito.providers.moonshot.model_info import (
-                        MOONSHOT_MODEL_SPECS,
-                    )
-
-                    for spec_model_name in MOONSHOT_MODEL_SPECS.keys():
-                        if spec_model_name.lower() == model_name:
-                            return "moonshot"
-                except ImportError:
-                    pass
-
-        except Exception:
-            # Skip providers that have issues accessing model specs
-            continue
+        if _check_provider_models(provider_name, provider_class, model_name):
+            return provider_name
 
     return None
+
+
+def _check_provider_models(provider_name: str, provider_class, model_name: str) -> bool:
+    """Check if provider has matching model."""
+    try:
+        if hasattr(provider_class, "MODEL_SPECS"):
+            model_specs = provider_class.MODEL_SPECS
+            for spec_model_name in model_specs.keys():
+                if spec_model_name.lower() == model_name:
+                    return True
+
+        # Handle special cases like moonshot
+        if provider_name == "moonshot":
+            return _check_moonshot_models(model_name)
+
+    except Exception:
+        # Skip providers that have issues accessing model specs
+        pass
+
+    return False
+
+
+def _check_moonshot_models(model_name: str) -> bool:
+    """Check moonshot models specifically."""
+    try:
+        from janito.providers.moonshot.model_info import MOONSHOT_MODEL_SPECS
+
+        for spec_model_name in MOONSHOT_MODEL_SPECS.keys():
+            if spec_model_name.lower() == model_name:
+                return True
+    except ImportError:
+        pass
+    return False

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/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/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()