janito 2.6.1__py3-none-any.whl → 2.8.0__py3-none-any.whl

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

@@ -1,10 +1,14 @@
 from janito.cli.console import shared_console
 from janito.cli.chat_mode.shell.commands.base import ShellCmdHandler
 
+
 class ReadShellHandler(ShellCmdHandler):
     help_text = "/read on|off: Enable or disable read permissions for tools. Usage: /read on or /read off."
 
     def run(self):
+        if self.shell_state and getattr(self.shell_state, 'no_tools_mode', False):
+            shared_console.print("[yellow]No tools are available in this mode (no tools, no context).[/yellow]")
+            return
         if not self.shell_state:
             shared_console.print("[red]Shell state unavailable.[/red]")
             return
@@ -14,23 +18,36 @@ class ReadShellHandler(ShellCmdHandler):
             return
         enable = arg == "on"
         try:
-            from janito.tools.permissions import set_global_allowed_permissions, get_global_allowed_permissions
+            from janito.tools.permissions import (
+                set_global_allowed_permissions,
+                get_global_allowed_permissions,
+            )
             from janito.tools.tool_base import ToolPermissions
+
             current = get_global_allowed_permissions()
-            new_perms = ToolPermissions(read=enable, write=current.write, execute=current.execute)
+            new_perms = ToolPermissions(
+                read=enable, write=current.write, execute=current.execute
+            )
             set_global_allowed_permissions(new_perms)
             # Also update the singleton tools registry permissions
             import janito.tools
+
             janito.tools.local_tools_adapter.set_allowed_permissions(new_perms)
 
         except Exception as e:
-            shared_console.print(f"[yellow]Warning: Could not update read permissions dynamically: {e}[/yellow]")
+            shared_console.print(
+                f"[yellow]Warning: Could not update read permissions dynamically: {e}[/yellow]"
+            )
         # Refresh system prompt if agent is available
         agent = getattr(self.shell_state, "agent", None)
         if agent:
             agent.refresh_system_prompt_from_template()
             # No need to print the system prompt after permission change
         if enable:
-            shared_console.print("[green]Read permissions ENABLED. Tools can now read files and data.[/green]")
+            shared_console.print(
+                "[green]Read permissions ENABLED. Tools can now read files and data.[/green]"
+            )
         else:
-            shared_console.print("[yellow]Read permissions DISABLED. Tools cannot read files/data.[/yellow]")
+            shared_console.print(
+                "[yellow]Read permissions DISABLED. Tools cannot read files/data.[/yellow]"
+            )

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

@@ -1,6 +1,7 @@
 from janito.cli.console import shared_console
 from janito.cli.chat_mode.shell.commands.base import ShellCmdHandler
 
+
 class ToolsShellHandler(ShellCmdHandler):
     help_text = "List available tools"
 
@@ -27,7 +28,7 @@ class ToolsShellHandler(ShellCmdHandler):
         perm_groups = {}
         for tool in tools:
             inst = tool_instances.get(tool, None)
-            perms = getattr(inst, 'permissions', None)
+            perms = getattr(inst, "permissions", None)
             if not perms:
                 group = "unknown"
             else:
@@ -37,6 +38,7 @@ class ToolsShellHandler(ShellCmdHandler):
 
     def _print_tools_table(self, perm_groups):
         from rich.table import Table
+
         table = Table(title="Tools by Permission Class")
         table.add_column("Permission Type", style="cyan", no_wrap=True)
         table.add_column("Tools", style="magenta")
@@ -47,27 +49,36 @@ class ToolsShellHandler(ShellCmdHandler):
     def _find_exec_tools(self, registry):
         exec_tools = []
         for tool_instance in registry.get_tools():
-            perms = getattr(tool_instance, 'permissions', None)
+            perms = getattr(tool_instance, "permissions", None)
             if perms and perms.execute:
                 exec_tools.append(tool_instance.tool_name)
         return exec_tools
 
     def run(self):
+        # Check for no_tools_mode in shell_state
+        if self.shell_state and getattr(self.shell_state, 'no_tools_mode', False):
+            shared_console.print("[yellow]No tools are available in this mode (no tools, no context).[/yellow]")
+            return
         try:
             import janito.tools  # Ensure all tools are registered
             from janito.tools.permissions import get_global_allowed_permissions
+
             registry = janito.tools.get_local_tools_adapter()
             tools = registry.list_tools()
             shared_console.print("Registered tools:")
             tool_instances = {t.tool_name: t for t in registry.get_tools()}
             if not tools:
-                shared_console.print("No tools are enabled under the current permission settings.")
+                shared_console.print(
+                    "No tools are enabled under the current permission settings."
+                )
                 return
             perm_groups = self._group_tools_by_permission(tools, tool_instances)
             self._print_tools_table(perm_groups)
             exec_tools = self._find_exec_tools(registry)
             perms = get_global_allowed_permissions()
             if not perms.execute and exec_tools:
-                shared_console.print("[yellow]⚠️  Warning: Execution tools (e.g., commands, code execution) are disabled. Use -x to enable them.[/yellow]")
+                shared_console.print(
+                    "[yellow]⚠️  Warning: Execution tools (e.g., commands, code execution) are disabled. Use -x to enable them.[/yellow]"
+                )
         except Exception as e:
             shared_console.print(f"[red]Error loading tools: {e}[/red]")

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

@@ -1,10 +1,14 @@
 from janito.cli.console import shared_console
 from janito.cli.chat_mode.shell.commands.base import ShellCmdHandler
 
+
 class WriteShellHandler(ShellCmdHandler):
     help_text = "/write on|off: Enable or disable write permissions for tools. Usage: /write on or /write off."
 
     def run(self):
+        if self.shell_state and getattr(self.shell_state, 'no_tools_mode', False):
+            shared_console.print("[yellow]No tools are available in this mode (no tools, no context).[/yellow]")
+            return
         if not self.shell_state:
             shared_console.print("[red]Shell state unavailable.[/red]")
             return
@@ -14,23 +18,36 @@ class WriteShellHandler(ShellCmdHandler):
             return
         enable = arg == "on"
         try:
-            from janito.tools.permissions import set_global_allowed_permissions, get_global_allowed_permissions
+            from janito.tools.permissions import (
+                set_global_allowed_permissions,
+                get_global_allowed_permissions,
+            )
             from janito.tools.tool_base import ToolPermissions
+
             current = get_global_allowed_permissions()
-            new_perms = ToolPermissions(read=current.read, write=enable, execute=current.execute)
+            new_perms = ToolPermissions(
+                read=current.read, write=enable, execute=current.execute
+            )
             set_global_allowed_permissions(new_perms)
             # Also update the singleton tools registry permissions
             import janito.tools
+
             janito.tools.local_tools_adapter.set_allowed_permissions(new_perms)
 
         except Exception as e:
-            shared_console.print(f"[yellow]Warning: Could not update write permissions dynamically: {e}[/yellow]")
+            shared_console.print(
+                f"[yellow]Warning: Could not update write permissions dynamically: {e}[/yellow]"
+            )
         # Refresh system prompt if agent is available
         agent = getattr(self.shell_state, "agent", None)
         if agent:
             agent.refresh_system_prompt_from_template()
             # No need to print the system prompt after permission change
         if enable:
-            shared_console.print("[green]Write permissions ENABLED. Tools can now write files and data.[/green]")
+            shared_console.print(
+                "[green]Write permissions ENABLED. Tools can now write files and data.[/green]"
+            )
         else:
-            shared_console.print("[yellow]Write permissions DISABLED. Tools cannot write files/data.[/yellow]")
+            shared_console.print(
+                "[yellow]Write permissions DISABLED. Tools cannot write files/data.[/yellow]"
+            )

janito/cli/chat_mode/shell/input_history.py

@@ -12,7 +12,9 @@ class UserInputHistory:
     """
 
     def __init__(self, history_dir=None):
-        self.history_dir = history_dir or os.path.join(os.path.expanduser("~"), ".janito", "input_history")
+        self.history_dir = history_dir or os.path.join(
+            os.path.expanduser("~"), ".janito", "input_history"
+        )
         os.makedirs(self.history_dir, exist_ok=True)
 
     def _get_today_file(self):

janito/cli/chat_mode/shell/session/manager.py

@@ -38,5 +38,3 @@ def set_role(role):
     rc = RuntimeConfig()
     rc.role = role
     rc.save()
-
-

janito/cli/chat_mode/toolbar.py

@@ -3,6 +3,7 @@ from janito.performance_collector import PerformanceCollector
 from janito.cli.config import config
 from janito import __version__ as VERSION
 
+
 def format_tokens(n, tag=None):
     if n is None:
         return "?"
@@ -14,15 +15,20 @@ def format_tokens(n, tag=None):
         val = f"{n/1000000:.1f}M"
     return f"<{tag}>{val}</{tag}>" if tag else val
 
+
 def assemble_first_line(provider_name, model_name, role, agent=None):
     return f" Janito {VERSION} | Provider: <provider>{provider_name}</provider> | Model: <model>{model_name}</model> | Role: <role>{role}</role>"
 
+
 def assemble_bindings_line(width, permissions=None):
     def color_state(state):
-        return 'on ' if state == "on" else 'off'
+        return "on " if state == "on" else "off"
+
     read_state = color_state("on" if getattr(permissions, "read", False) else "off")
     write_state = color_state("on" if getattr(permissions, "write", False) else "off")
-    execute_state = color_state("on" if getattr(permissions, "execute", False) else "off")
+    execute_state = color_state(
+        "on" if getattr(permissions, "execute", False) else "off"
+    )
     return (
         f" <key-label>CTRL-C</key-label>: Interrupt/Exit | "
         f"<key-label>F2</key-label>: /restart | "
@@ -30,6 +36,7 @@ def assemble_bindings_line(width, permissions=None):
         f"<key-label>F12</key-label>: Do It "
     )
 
+
 def _get_status(shell_state):
     _support = getattr(shell_state, "_support", False)
     _status = getattr(shell_state, "_status", None)
@@ -37,47 +44,46 @@ def _get_status(shell_state):
         return None
     if _status == "starting" or _status is None:
         return _status
-    live_status = getattr(shell_state, "_live_status", None)
-    if live_status is not None:
-        return live_status
+
     return _status
 
+
 def _get_agent_info(agent):
-    provider_name = agent.get_provider_name() if hasattr(agent, "get_provider_name") else "?"
+    provider_name = (
+        agent.get_provider_name() if hasattr(agent, "get_provider_name") else "?"
+    )
     model_name = agent.get_model_name() if hasattr(agent, "get_model_name") else "?"
-    role = agent.template_vars.get("role", "?") if hasattr(agent, "template_vars") else "?"
+    role = (
+        agent.template_vars.get("role", "?") if hasattr(agent, "template_vars") else "?"
+    )
     return provider_name, model_name, role
 
+
 def _get_permissions():
     try:
         from janito.tools.permissions import get_global_allowed_permissions
+
         return get_global_allowed_permissions()
     except Exception:
         return None
 
-def _get_termweb_status_line(this__status, _port):
-    if this__status == "online" and _port:
-        return "\n<> Termweb </>Online"
-    elif this__status == "starting":
-        return "\n<> Termweb </>Starting"
-    elif this__status == "offline":
-        return "\n<> Termweb </>Offline"
-    return ""
 
 def get_toolbar_func(perf: PerformanceCollector, msg_count: int, shell_state):
     from prompt_toolkit.application.current import get_app
+
     def get_toolbar():
         width = get_app().output.get_size().columns
         agent = getattr(shell_state, "agent", None)
         this__status = _get_status(shell_state)
-        provider_name, model_name, role = _get_agent_info(agent) if agent is not None else ("?", "?", "?")
+        provider_name, model_name, role = (
+            _get_agent_info(agent) if agent is not None else ("?", "?", "?")
+        )
         usage = perf.get_last_request_usage()
         first_line = assemble_first_line(provider_name, model_name, role, agent=agent)
         permissions = _get_permissions()
         bindings_line = assemble_bindings_line(width, permissions)
         toolbar_text = first_line + "\n" + bindings_line
-        _port = getattr(shell_state, "_port", None)
-        toolbar_text += _get_termweb_status_line(this__status, _port)
+
         return HTML(toolbar_text)
-    return get_toolbar
 
+    return get_toolbar

janito/cli/cli_commands/list_models.py

@@ -32,4 +32,4 @@ def handle_list_models(args, provider_instance):
                 print(f"- {m}")
     except Exception as e:
         print(f"Error listing models for provider '{provider_name}': {e}")
-    sys.exit(0)
+    return

janito/cli/cli_commands/list_providers.py

@@ -7,3 +7,4 @@ from janito.provider_registry import list_providers
 
 def handle_list_providers(args=None):
     list_providers()
+    return

janito/cli/cli_commands/list_tools.py

@@ -3,21 +3,29 @@ CLI Command: List available tools
 """
 
 
-def _group_tools_by_permission(tools, tool_instances):
+def _group_tools_by_permission(tools, tool_instances, disabled_tools):
     read_only_tools = []
     write_only_tools = []
     read_write_tools = []
     exec_tools = []
     import inspect
+
     for tool in tools:
+        # Skip disabled tools entirely
+        if tool in disabled_tools:
+            continue
+
         inst = tool_instances.get(tool, None)
         param_names = []
         if inst and hasattr(inst, "run"):
             sig = inspect.signature(inst.run)
             param_names = [p for p in sig.parameters if p != "self"]
+
         info = {
             "name": tool,
             "params": ", ".join(param_names),
+            "tool_name": tool,
+            "disabled": False,
         }
         perms = getattr(inst, "permissions", None)
         if perms and perms.execute:
@@ -30,33 +38,54 @@ def _group_tools_by_permission(tools, tool_instances):
             write_only_tools.append(info)
     return read_only_tools, write_only_tools, read_write_tools, exec_tools
 
+
 def _print_tools_table(console, title, tools_info):
     from rich.table import Table
-    table = Table(title=title, show_header=True, header_style="bold", show_lines=False, box=None)
+
+    table = Table(
+        title=title, show_header=True, header_style="bold", show_lines=False, box=None
+    )
     table.add_column("Name", style="cyan", no_wrap=True)
     table.add_column("Parameters", style="yellow")
     for info in tools_info:
         table.add_row(info["name"], info["params"] or "-")
     console.print(table)
 
+
 def handle_list_tools(args=None):
     from janito.tools.adapters.local.adapter import LocalToolsAdapter
     import janito.tools  # Ensure all tools are registered
     from janito.tools.tool_base import ToolPermissions
+
     read = getattr(args, "read", False) if args else False
     write = getattr(args, "write", False) if args else False
     execute = getattr(args, "exec", False) if args else False
     if not (read or write or execute):
         read = write = execute = True
     from janito.tools.permissions import set_global_allowed_permissions
-    set_global_allowed_permissions(ToolPermissions(read=read, write=write, execute=execute))
-    registry = janito.tools.get_local_tools_adapter()
+
+    set_global_allowed_permissions(
+        ToolPermissions(read=read, write=write, execute=execute)
+    )
+    # Load disabled tools from config
+    from janito.tools.disabled_tools import DisabledToolsState
+    from janito.config import config
+
+    disabled_str = config.get("disabled_tools", "")
+    if disabled_str:
+        DisabledToolsState.set_disabled_tools(disabled_str)
+    disabled_tools = DisabledToolsState.get_disabled_tools()
+
+    registry = janito.tools.local_tools_adapter
     tools = registry.list_tools()
     if tools:
         from rich.console import Console
+
         console = Console()
         tool_instances = {t.tool_name: t for t in registry.get_tools()}
-        read_only_tools, write_only_tools, read_write_tools, exec_tools = _group_tools_by_permission(tools, tool_instances)
+        read_only_tools, write_only_tools, read_write_tools, exec_tools = (
+            _group_tools_by_permission(tools, tool_instances, disabled_tools)
+        )
         if read_only_tools:
             _print_tools_table(console, "Read-only tools (-r)", read_only_tools)
         if write_only_tools:
@@ -67,5 +96,4 @@ def handle_list_tools(args=None):
             _print_tools_table(console, "Execution tools (-x)", exec_tools)
     else:
         print("No tools registered.")
-    import sys
-    sys.exit(0)
+    return

janito/cli/cli_commands/model_utils.py

@@ -35,18 +35,20 @@ def _print_models_table(models, provider_name):
         row.extend(_build_model_row(m, headers, num_fields))
         table.add_row(*row)
     import sys
+
     if sys.stdout.isatty():
         from rich.console import Console
+
         Console().print(table)
     else:
         # ASCII-friendly fallback table when output is redirected
         print(f"Supported models for provider '{provider_name}'")
         headers_fallback = [h for h in display_headers]
-        print(' | '.join(headers_fallback))
+        print(" | ".join(headers_fallback))
         for m in models:
-            row = [str(m.get('name', ''))]
+            row = [str(m.get("name", ""))]
             row.extend(_build_model_row(m, headers, num_fields))
-            print(' | '.join(row))
+            print(" | ".join(row))
 
 
 def _add_table_columns(table, display_headers):

janito/cli/cli_commands/show_config.py

@@ -49,3 +49,15 @@ def handle_show_config(args):
             console.print(
                 f"  [bold]{pname}[/bold]{' '+sel if sel else ''}: model = [magenta]{eff_model}[/magenta]{extra}"
             )
+
+    # Show disabled tools
+    from janito.tools.disabled_tools import load_disabled_tools_from_config
+
+    disabled_tools = load_disabled_tools_from_config()
+    if disabled_tools:
+        console.print(
+            f"\n[bold red]Disabled tools:[/bold red] {', '.join(sorted(disabled_tools))}"
+        )
+    else:
+        console.print("\n[bold green]No tools are disabled[/bold green]")
+    return

janito/cli/cli_commands/show_system_prompt.py

@@ -14,6 +14,7 @@ import re
 
 def _compute_permission_string(args):
     from janito.tools.tool_base import ToolPermissions
+
     read = getattr(args, "read", False)
     write = getattr(args, "write", False)
     execute = getattr(args, "exec", False)
@@ -33,7 +34,7 @@ def _prepare_context(args, agent_role, allowed_permissions):
     context["role"] = agent_role or "developer"
     context["profile"] = getattr(args, "profile", None)
     context["allowed_permissions"] = allowed_permissions
-    if allowed_permissions and 'x' in allowed_permissions:
+    if allowed_permissions and "x" in allowed_permissions:
         pd = PlatformDiscovery()
         context["platform"] = pd.get_platform_name()
         context["python_version"] = pd.get_python_version()
@@ -43,7 +44,8 @@ def _prepare_context(args, agent_role, allowed_permissions):
 
 def _load_template(profile, templates_dir):
     if profile:
-        template_filename = f"system_prompt_template_{profile}.txt.j2"
+        sanitized_profile = re.sub(r"\\s+", "_", profile.strip())
+        template_filename = f"system_prompt_template_{sanitized_profile}.txt.j2"
         template_path = templates_dir / template_filename
     else:
         return None, None
@@ -65,8 +67,13 @@ def _load_template(profile, templates_dir):
 def _print_debug_info(debug_flag, template_filename, allowed_permissions, context):
     if debug_flag:
         from rich import print as rich_print
-        rich_print(f"[bold magenta][DEBUG][/bold magenta] Rendering system prompt template '[cyan]{template_filename}[/cyan]' with allowed_permissions: [yellow]{allowed_permissions}[/yellow]")
-        rich_print(f"[bold magenta][DEBUG][/bold magenta] Template context: [green]{context}[/green]")
+
+        rich_print(
+            f"[bold magenta][DEBUG][/bold magenta] Rendering system prompt template '[cyan]{template_filename}[/cyan]' with allowed_permissions: [yellow]{allowed_permissions}[/yellow]"
+        )
+        rich_print(
+            f"[bold magenta][DEBUG][/bold magenta] Template context: [green]{context}[/green]"
+        )
 
 
 def handle_show_system_prompt(args):
@@ -85,9 +92,12 @@ def handle_show_system_prompt(args):
 
     # Debug flag detection
     import sys
+
     debug_flag = False
     try:
-        debug_flag = (hasattr(sys, 'argv') and ('--debug' in sys.argv or '--verbose' in sys.argv or '-v' in sys.argv))
+        debug_flag = hasattr(sys, "argv") and (
+            "--debug" in sys.argv or "--verbose" in sys.argv or "-v" in sys.argv
+        )
     except Exception:
         pass
 
@@ -96,8 +106,10 @@ def handle_show_system_prompt(args):
     )
     profile = getattr(args, "profile", None)
     if not profile:
-        print("[janito] No profile specified. The main agent runs without a system prompt template.\n"
-              "Use --profile PROFILE to view a profile-specific system prompt.")
+        print(
+            "[janito] No profile specified. The main agent runs without a system prompt template.\n"
+            "Use --profile PROFILE to view a profile-specific system prompt."
+        )
         return
 
     template_filename, template_content = _load_template(profile, templates_dir)
@@ -117,9 +129,11 @@ def handle_show_system_prompt(args):
 
     template = Template(template_content)
     system_prompt = template.render(**context)
-    system_prompt = re.sub(r'\n{3,}', '\n\n', system_prompt)
+    system_prompt = re.sub(r"\n{3,}", "\n\n", system_prompt)
 
-    print(f"\n--- System Prompt (resolved, profile: {getattr(args, 'profile', 'main')}) ---\n")
+    print(
+        f"\n--- System Prompt (resolved, profile: {getattr(args, 'profile', 'main')}) ---\n"
+    )
     print(system_prompt)
     print("\n-------------------------------\n")
     if agent_role:

janito/cli/config.py

@@ -12,16 +12,3 @@ CONFIG_OPTIONS = {
     "template": "Template context dictionary for Agent Profile prompt rendering (nested)",
     "profile": "Agent Profile name (only 'base' is supported)",
 }
-
-
-
-def get__port():
-    port = config.get("_port")
-    try:
-        return int(port)
-    except Exception:
-        pass
-
-
-def set__port(port):
-    config.file_set("_port", int(port))

janito/cli/core/getters.py

@@ -1,4 +1,5 @@
 """Handlers for get-type CLI commands (show_config, list_providers, models, tools)."""
+
 import sys
 
 from janito.cli.cli_commands.list_providers import handle_list_providers
@@ -17,6 +18,7 @@ def handle_getter(args, config_mgr=None):
         provider = getattr(args, "provider", None)
         if not provider:
             import sys
+
             print(
                 "Error: No provider selected. Please set a provider using '-p PROVIDER', '--set provider=name', or configure a provider."
             )

janito/cli/core/runner.py

@@ -77,7 +77,7 @@ def prepare_llm_driver_config(args, modifiers):
                     f"Error: Model '{model}' is not available for provider '{provider}'."
                 )
                 # Optionally, print available models if possible
-                if hasattr(provider_instance, 'get_model_info'):
+                if hasattr(provider_instance, "get_model_info"):
                     available_models = [
                         m["name"]
                         for m in provider_instance.get_model_info().values()
@@ -97,7 +97,13 @@ def prepare_llm_driver_config(args, modifiers):
     return provider, llm_driver_config, agent_role
 
 
-def handle_runner(args, provider, llm_driver_config, agent_role, verbose_tools=False, ):
+def handle_runner(
+    args,
+    provider,
+    llm_driver_config,
+    agent_role,
+    verbose_tools=False,
+):
     """
     Main runner for CLI execution. If exec_enabled is False, disables execution/run tools.
     """
@@ -107,18 +113,29 @@ def handle_runner(args, provider, llm_driver_config, agent_role, verbose_tools=F
     # Patch: disable execution/run tools if not enabled
     import janito.tools
     from janito.tools.tool_base import ToolPermissions
+
     read = getattr(args, "read", False)
     write = getattr(args, "write", False)
     execute = getattr(args, "exec", False)
     from janito.tools.permissions import set_global_allowed_permissions
     from janito.tools.tool_base import ToolPermissions
+
     allowed_permissions = ToolPermissions(read=read, write=write, execute=execute)
     set_global_allowed_permissions(allowed_permissions)
     # Store the default permissions for later restoration (e.g., on /restart)
     from janito.tools.permissions import set_default_allowed_permissions
+
     set_default_allowed_permissions(allowed_permissions)
+
+    # Load disabled tools from config
+    from janito.tools.disabled_tools import load_disabled_tools_from_config
+
+    load_disabled_tools_from_config()
+
     unrestricted_paths = getattr(args, "unrestricted_paths", False)
-    adapter = janito.tools.get_local_tools_adapter(workdir=getattr(args, "workdir", None))
+    adapter = janito.tools.get_local_tools_adapter(
+        workdir=getattr(args, "workdir", None)
+    )
     if unrestricted_paths:
         # Patch: disable path security enforcement for this adapter instance
         setattr(adapter, "unrestricted_paths", True)
@@ -128,7 +145,7 @@ def handle_runner(args, provider, llm_driver_config, agent_role, verbose_tools=F
         print_verbose_info(
             "Allowed Tool Permissions",
             f"read={read}, write={write}, execute={execute}",
-            style="yellow"
+            style="yellow",
         )
 
     provider_instance = ProviderRegistry().get_instance(provider, llm_driver_config)
@@ -146,11 +163,12 @@ def handle_runner(args, provider, llm_driver_config, agent_role, verbose_tools=F
         )
 
         # DEBUG: Print exec_enabled propagation at runner
-        
+
         handler = SingleShotPromptHandler(
-            args, provider_instance, llm_driver_config,
+            args,
+            provider_instance,
+            llm_driver_config,
             role=agent_role,
-            
             allowed_permissions=allowed_permissions,
         )
         handler.handle()
@@ -167,7 +185,6 @@ def handle_runner(args, provider, llm_driver_config, agent_role, verbose_tools=F
             args=args,
             verbose_tools=verbose_tools,
             verbose_agent=getattr(args, "verbose_agent", False),
-            
             allowed_permissions=allowed_permissions,
         )
         session.run()