janito 2.3.1__py3-none-any.whl → 2.5.0__py3-none-any.whl

janito/llm/agent.py

@@ -94,6 +94,21 @@ class LLMAgent:
                 autoescape=select_autoescape(),
             )
             template = env.get_template(Path(self.system_prompt_template).name)
+            # 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 = ""
+                if perms.read:
+                    perm_str += "r"
+                if perms.write:
+                    perm_str += "w"
+                if perms.execute:
+                    perm_str += "x"
+                self._template_vars["allowed_permissions"] = perm_str or None
+            else:
+                self._template_vars["allowed_permissions"] = perms
             self.system_prompt = template.render(**self._template_vars)
 
     def get_system_prompt(self) -> str:
@@ -165,13 +180,10 @@ class LLMAgent:
         if getattr(self, "verbose_agent", False):
             print("[agent] [DEBUG] Entered _process_next_response")
         elapsed = 0.0
-        try:
-            if getattr(self, "verbose_agent", False):
-                print("[agent] [DEBUG] Waiting for event from output_queue...")
-            return self._poll_for_event(poll_timeout, max_wait_time)
-        except KeyboardInterrupt:
-            self._handle_keyboard_interrupt()
-            return None, False
+        if getattr(self, "verbose_agent", False):
+            print("[agent] [DEBUG] Waiting for event from output_queue...")
+        # Let KeyboardInterrupt propagate to caller
+        return self._poll_for_event(poll_timeout, max_wait_time)
 
     def _poll_for_event(self, poll_timeout, max_wait_time):
         elapsed = 0.0
@@ -201,15 +213,6 @@ class LLMAgent:
             ]:
                 return (event, False)
 
-    def _handle_keyboard_interrupt(self):
-        if hasattr(self, "input_queue") and self.input_queue is not None:
-            from janito.driver_events import RequestFinished
-
-            cancel_event = RequestFinished(
-                status=RequestStatus.CANCELLED,
-                reason="User interrupted (KeyboardInterrupt)",
-            )
-            self.input_queue.put(cancel_event)
 
     def _get_event_from_output_queue(self, poll_timeout):
         try:
@@ -302,6 +305,13 @@ class LLMAgent:
             and hasattr(self.driver, "clear_output_queue")
         ):
             self.driver.clear_output_queue()
+        # Drain input queue before sending new messages
+        if (
+            hasattr(self, "driver")
+            and self.driver
+            and hasattr(self.driver, "clear_input_queue")
+        ):
+            self.driver.clear_input_queue()
         """
         Main agent conversation loop supporting function/tool calls and conversation history extension, now as a blocking event-driven loop with event publishing.
 
@@ -329,6 +339,7 @@ class LLMAgent:
             try:
                 result, added_tool_results = self._process_next_response()
             except KeyboardInterrupt:
+                # Propagate the interrupt to the caller, but signal the driver to cancel first
                 cancel_event.set()
                 raise
             if getattr(self, "verbose_agent", False):
@@ -420,6 +431,59 @@ class LLMAgent:
             return self.llm_provider.model_name
         return "?"
 
+    def reset_driver_config_to_model_defaults(self, model_name: str):
+        """
+        Reset all driver config fields to the model's defaults for the current provider (overwriting any user customizations).
+        """
+        provider = self.llm_provider
+        # Find model spec
+        model_spec = None
+        if hasattr(provider, "MODEL_SPECS"):
+            model_spec = provider.MODEL_SPECS.get(model_name)
+        if not model_spec:
+            raise ValueError(f"Model '{model_name}' not found in provider MODEL_SPECS.")
+        # Overwrite all config fields with model defaults
+        config = getattr(provider, "driver_config", None)
+        if config is None:
+            return
+        config.model = model_name
+        # Standard fields, with safe conversion for int fields
+        def safe_int(val):
+            try:
+                if val is None or val == "N/A":
+                    return None
+                return int(val)
+            except Exception:
+                return None
+        def safe_float(val):
+            try:
+                if val is None or val == "N/A":
+                    return None
+                return float(val)
+            except Exception:
+                return None
+        config.temperature = safe_float(getattr(model_spec, "default_temp", None))
+        config.max_tokens = safe_int(getattr(model_spec, "max_response", None))
+        config.max_completion_tokens = safe_int(getattr(model_spec, "max_cot", None))
+        # Optionally reset other fields to None/defaults
+        config.top_p = None
+        config.presence_penalty = None
+        config.frequency_penalty = None
+        config.stop = None
+        config.reasoning_effort = None
+        # Update driver if present
+        if self.driver is not None:
+            if hasattr(self.driver, "model_name"):
+                self.driver.model_name = model_name
+            if hasattr(self.driver, "config"):
+                self.driver.config = config
+
+    def change_model(self, model_name: str):
+        """
+        Change the model for the agent's provider and driver config, and update the driver if present.
+        """
+        self.reset_driver_config_to_model_defaults(model_name)
+
     def join_driver(self, timeout=None):
         """
         Wait for the driver's background thread to finish. Call this before exiting to avoid daemon thread shutdown errors.

janito/llm/auth.py

@@ -1,63 +1,63 @@
-"""
-LLMAuthManager: Handles authentication credentials for LLM providers, persisted in ~/.janito/auth.json or a custom path.
-"""
-
-import os
-import json
-from typing import Dict, Optional
-
-
-class LLMAuthManager:
-    """
-    Manages authentication tokens, API keys, or credentials for LLM providers.
-    Persists credentials in ~/.janito/auth.json or a custom path.
-    """
-
-    def __init__(self, auth_file: Optional[str] = None):
-        if auth_file is not None:
-            self._auth_file = os.path.expanduser(auth_file)
-        else:
-            self._auth_file = os.path.expanduser("~/.janito/auth.json")
-        self._credentials: Dict[str, str] = {}
-        self._load_credentials()
-
-    def _load_credentials(self):
-        if os.path.exists(self._auth_file):
-            try:
-                with open(self._auth_file, "r") as f:
-                    self._credentials = json.load(f)
-            except Exception:
-                self._credentials = {}
-        else:
-            self._credentials = {}
-
-    def _save_credentials(self):
-        os.makedirs(os.path.dirname(self._auth_file), exist_ok=True)
-        with open(self._auth_file, "w") as f:
-            json.dump(self._credentials, f, indent=2)
-            f.write("\n")
-
-    def set_credentials(self, provider_name: str, credentials: str) -> None:
-        """
-        Store credentials for a given provider and persist to disk. Raises ValueError if provider is unknown.
-        """
-        from janito.providers.registry import LLMProviderRegistry
-
-        if provider_name not in LLMProviderRegistry.list_providers():
-            raise ValueError(f"Unknown provider: {provider_name}")
-        self._credentials[provider_name] = credentials
-        self._save_credentials()
-
-    def get_credentials(self, provider_name: str) -> Optional[str]:
-        """
-        Retrieve credentials for a given provider.
-        """
-        return self._credentials.get(provider_name)
-
-    def remove_credentials(self, provider_name: str) -> None:
-        """
-        Remove credentials for a given provider and update disk.
-        """
-        if provider_name in self._credentials:
-            del self._credentials[provider_name]
-            self._save_credentials()
+"""
+LLMAuthManager: Handles authentication credentials for LLM providers, persisted in ~/.janito/auth.json or a custom path.
+"""
+
+import os
+import json
+from typing import Dict, Optional
+
+
+class LLMAuthManager:
+    """
+    Manages authentication tokens, API keys, or credentials for LLM providers.
+    Persists credentials in ~/.janito/auth.json or a custom path.
+    """
+
+    def __init__(self, auth_file: Optional[str] = None):
+        if auth_file is not None:
+            self._auth_file = os.path.expanduser(auth_file)
+        else:
+            self._auth_file = os.path.expanduser("~/.janito/auth.json")
+        self._credentials: Dict[str, str] = {}
+        self._load_credentials()
+
+    def _load_credentials(self):
+        if os.path.exists(self._auth_file):
+            try:
+                with open(self._auth_file, "r") as f:
+                    self._credentials = json.load(f)
+            except Exception:
+                self._credentials = {}
+        else:
+            self._credentials = {}
+
+    def _save_credentials(self):
+        os.makedirs(os.path.dirname(self._auth_file), exist_ok=True)
+        with open(self._auth_file, "w") as f:
+            json.dump(self._credentials, f, indent=2)
+            f.write("\n")
+
+    def set_credentials(self, provider_name: str, credentials: str) -> None:
+        """
+        Store credentials for a given provider and persist to disk. Raises ValueError if provider is unknown.
+        """
+        from janito.providers.registry import LLMProviderRegistry
+
+        if provider_name not in LLMProviderRegistry.list_providers():
+            raise ValueError(f"Unknown provider: {provider_name}")
+        self._credentials[provider_name] = credentials
+        self._save_credentials()
+
+    def get_credentials(self, provider_name: str) -> Optional[str]:
+        """
+        Retrieve credentials for a given provider.
+        """
+        return self._credentials.get(provider_name)
+
+    def remove_credentials(self, provider_name: str) -> None:
+        """
+        Remove credentials for a given provider and update disk.
+        """
+        if provider_name in self._credentials:
+            del self._credentials[provider_name]
+            self._save_credentials()

janito/llm/driver.py

@@ -19,6 +19,14 @@ class LLMDriver(ABC):
         except Exception:
             pass
 
+    def clear_input_queue(self):
+        """Remove all items from the input queue."""
+        try:
+            while True:
+                self.input_queue.get_nowait()
+        except Exception:
+            pass
+
     """
     Abstract base class for LLM drivers (threaded, queue-based).
     Subclasses must implement:

janito/provider_registry.py

@@ -1,176 +1,178 @@
-"""
-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
-
-
-class ProviderRegistry:
-    def list_providers(self):
-        """List all supported LLM providers as a table using rich, showing if auth is configured and supported model names."""
-        providers = self._get_provider_names()
-        table = self._create_table()
-        rows = self._get_all_provider_rows(providers)
-        self._add_rows_to_table(table, rows)
-        self._print_table(table)
-
-    def _get_provider_names(self):
-        return list(STATIC_PROVIDER_METADATA.keys())
-
-    def _create_table(self):
-        table = Table(title="Supported LLM Providers")
-        table.add_column("Provider", style="cyan")
-        table.add_column("Maintainer", style="yellow", justify="center")
-        table.add_column("Model Names", style="magenta")
-        return table
-
-    def _get_all_provider_rows(self, providers):
-        rows = []
-        for p in providers:
-            info = self._get_provider_info(p)
-            # info is (provider_name, maintainer, model_names, skip)
-            if len(info) == 4 and info[3]:
-                continue  # skip providers flagged as not implemented
-            rows.append(info[:3])
-        rows.sort(key=self._maintainer_sort_key)
-        return rows
-
-    def _add_rows_to_table(self, table, rows):
-        for idx, (p, maintainer, model_names) in enumerate(rows):
-            table.add_row(p, maintainer, model_names)
-            if idx != len(rows) - 1:
-                table.add_section()
-
-    def _print_table(self, table):
-        """Print the table using rich when running in a terminal; otherwise fall back to a plain ASCII listing.
-        This avoids UnicodeDecodeError when the parent process captures the output with a non-UTF8 encoding.
-        """
-        import sys
-
-        if sys.stdout.isatty():
-            # Safe to use rich's unicode output when attached to an interactive terminal.
-            shared_console.print(table)
-            return
-
-        # Fallback: plain ASCII output
-        print("Supported LLM Providers")
-        print("Provider | Maintainer | Model Names")
-        for row in table.rows:
-            # row is a rich.table.Row -> row.cells is a list of Text objects
-            cells_text = [str(cell) for cell in row.cells]
-            ascii_row = " | ".join(cells_text).encode("ascii", "ignore").decode("ascii")
-            print(ascii_row)
-        shared_console.print(table)
-
-    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
-        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):
-        try:
-            available = getattr(provider_instance, "available", True)
-            unavailable_reason = getattr(provider_instance, "unavailable_reason", None)
-        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",
-            "mistralai": "janito.providers.mistralai.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 "-"
-
-    def _maintainer_sort_key(self, row):
-        maint = row[1]
-        is_needs_maint = "Needs maintainer" in maint
-        return (is_needs_maint, row[2] != "✅ Auth")
-
-    def get_provider(self, provider_name):
-        """Return the provider class for the given provider name. Returns None if not found."""
-        from janito.providers.registry import LLMProviderRegistry
-
-        if not provider_name:
-            print("Error: Provider name must be specified.")
-            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}.")
-            return None
-        return provider_class
-
-    def get_instance(self, provider_name, config=None):
-        """Return an instance of the provider for the given provider name, optionally passing a config object. Returns None if not found."""
-        provider_class = self.get_provider(provider_name)
-        if provider_class is None:
-            return None
-        if config is not None:
-            return provider_class(config=config)
-        return provider_class()
-
-
-# For backward compatibility
-def list_providers():
-    """Legacy function for listing providers, now uses ProviderRegistry class."""
-    ProviderRegistry().list_providers()
+"""
+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
+
+
+class ProviderRegistry:
+    def list_providers(self):
+        """List all supported LLM providers as a table using rich, showing if auth is configured and supported model names."""
+        providers = self._get_provider_names()
+        table = self._create_table()
+        rows = self._get_all_provider_rows(providers)
+        self._add_rows_to_table(table, rows)
+        self._print_table(table)
+
+    def _get_provider_names(self):
+        return list(STATIC_PROVIDER_METADATA.keys())
+
+    def _create_table(self):
+        table = Table(title="Supported LLM Providers")
+        table.add_column("Provider", style="cyan")
+        table.add_column("Maintainer", style="yellow", justify="center")
+        table.add_column("Model Names", style="magenta")
+        return table
+
+    def _get_all_provider_rows(self, providers):
+        rows = []
+        for p in providers:
+            info = self._get_provider_info(p)
+            # info is (provider_name, maintainer, model_names, skip)
+            if len(info) == 4 and info[3]:
+                continue  # skip providers flagged as not implemented
+            rows.append(info[:3])
+        rows.sort(key=self._maintainer_sort_key)
+        return rows
+
+    def _add_rows_to_table(self, table, rows):
+        for idx, (p, maintainer, model_names) in enumerate(rows):
+            table.add_row(p, maintainer, model_names)
+            if idx != len(rows) - 1:
+                table.add_section()
+
+    def _print_table(self, table):
+        """Print the table using rich when running in a terminal; otherwise fall back to a plain ASCII listing.
+        This avoids UnicodeDecodeError when the parent process captures the output with a non-UTF8 encoding.
+        """
+        import sys
+
+        if sys.stdout.isatty():
+            # Safe to use rich's unicode output when attached to an interactive terminal.
+            shared_console.print(table)
+            return
+
+        # Fallback: plain ASCII output (render without rich formatting)
+        print("Supported LLM Providers")
+        # Build header from column titles
+        header_titles = [column.header or "" for column in table.columns]
+        print(" | ".join(header_titles))
+        # rich.table.Row objects in recent Rich versions don't expose a public `.cells` attribute.
+        # Instead, cell content is stored in each column's private `_cells` list.
+        for row_index, _ in enumerate(table.rows):
+            cells_text = [str(column._cells[row_index]) for column in table.columns]
+            ascii_row = " | ".join(cells_text).encode("ascii", "ignore").decode("ascii")
+            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
+        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):
+        try:
+            available = getattr(provider_instance, "available", True)
+            unavailable_reason = getattr(provider_instance, "unavailable_reason", None)
+        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",
+            
+            "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 "-"
+
+    def _maintainer_sort_key(self, row):
+        maint = row[1]
+        is_needs_maint = "Needs maintainer" in maint
+        return (is_needs_maint, row[2] != "✅ Auth")
+
+    def get_provider(self, provider_name):
+        """Return the provider class for the given provider name. Returns None if not found."""
+        from janito.providers.registry import LLMProviderRegistry
+
+        if not provider_name:
+            print("Error: Provider name must be specified.")
+            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}.")
+            return None
+        return provider_class
+
+    def get_instance(self, provider_name, config=None):
+        """Return an instance of the provider for the given provider name, optionally passing a config object. Returns None if not found."""
+        provider_class = self.get_provider(provider_name)
+        if provider_class is None:
+            return None
+        if config is not None:
+            return provider_class(config=config)
+        return provider_class()
+
+
+# For backward compatibility
+def list_providers():
+    """Legacy function for listing providers, now uses ProviderRegistry class."""
+    ProviderRegistry().list_providers()

janito/providers/__init__.py

@@ -1,8 +1,6 @@
 # Ensure all providers are registered by importing their modules
 import janito.providers.openai.provider
 import janito.providers.google.provider
-import janito.providers.mistralai.provider
-import janito.providers.google.provider
 import janito.providers.azure_openai.provider
 import janito.providers.anthropic.provider
 import janito.providers.deepseek.provider