janito 3.0.0__py3-none-any.whl → 3.2.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,30 @@ 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()
+
         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/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/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,26 @@ 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
+
+            cancel_manager = get_cancellation_manager()
+            driver_cancel_event = cancel_manager.start_new_request()
+
+            try:
+                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)
+            finally:
+                cancel_manager.clear_current_request()
+
         except KeyboardInterrupt:
             # Capture user interrupt / cancellation
             self.console.print("[red]Interrupted by the user.[/red]")

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

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