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

janito/cli/cli_commands/list_tools.py

@@ -3,16 +3,49 @@ CLI Command: List available tools
 """
 
 
+def _group_tools_by_permission(tools, tool_instances):
+    read_only_tools = []
+    write_only_tools = []
+    read_write_tools = []
+    exec_tools = []
+    import inspect
+    for tool in tools:
+        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),
+        }
+        perms = getattr(inst, "permissions", None)
+        if perms and perms.execute:
+            exec_tools.append(info)
+        elif perms and perms.read and perms.write:
+            read_write_tools.append(info)
+        elif perms and perms.read:
+            read_only_tools.append(info)
+        elif perms and perms.write:
+            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.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
-
-    # Determine permissions from args (default: all False)
     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 no permissions are specified, assume user wants to list all tools
     if not (read or write or execute):
         read = write = execute = True
     from janito.tools.permissions import set_global_allowed_permissions
@@ -20,67 +53,19 @@ def handle_list_tools(args=None):
     registry = janito.tools.get_local_tools_adapter()
     tools = registry.list_tools()
     if tools:
-        from rich.table import Table
         from rich.console import Console
         console = Console()
-        # Get tool instances to check provides_execution and get info
         tool_instances = {t.tool_name: t for t in registry.get_tools()}
-        read_only_tools = []
-        write_only_tools = []
-        read_write_tools = []
-        exec_tools = []
-        for tool in tools:
-            inst = tool_instances.get(tool, None)
-            # Extract parameter names from run signature
-            param_names = []
-            if inst and hasattr(inst, "run"):
-                import inspect
-                sig = inspect.signature(inst.run)
-                param_names = [p for p in sig.parameters if p != "self"]
-            info = {
-                "name": tool,
-                "params": ", ".join(param_names),
-            }
-            perms = getattr(inst, "permissions", None)
-            if perms and perms.execute:
-                exec_tools.append(info)
-            elif perms and perms.read and perms.write:
-                read_write_tools.append(info)
-            elif perms and perms.read:
-                read_only_tools.append(info)
-            elif perms and perms.write:
-                write_only_tools.append(info)
-        # Print each group if not empty
+        read_only_tools, write_only_tools, read_write_tools, exec_tools = _group_tools_by_permission(tools, tool_instances)
         if read_only_tools:
-            table = Table(title="Read-only tools (-r)", 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 read_only_tools:
-                table.add_row(info["name"], info["params"] or "-")
-            console.print(table)
+            _print_tools_table(console, "Read-only tools (-r)", read_only_tools)
         if write_only_tools:
-            table = Table(title="Write-only tools (-w)", 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 write_only_tools:
-                table.add_row(info["name"], info["params"] or "-")
-            console.print(table)
+            _print_tools_table(console, "Write-only tools (-w)", write_only_tools)
         if read_write_tools:
-            table = Table(title="Read-Write tools (-rw)", 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 read_write_tools:
-                table.add_row(info["name"], info["params"] or "-")
-            console.print(table)
+            _print_tools_table(console, "Read-Write tools (-rw)", read_write_tools)
         if exec_tools:
-            exec_table = Table(title="Execution tools (-x)", show_header=True, header_style="bold", show_lines=False, box=None)
-            exec_table.add_column("Name", style="cyan", no_wrap=True)
-            exec_table.add_column("Parameters", style="yellow")
-            for info in exec_tools:
-                exec_table.add_row(info["name"], info["params"] or "-")
-            console.print(exec_table)
+            _print_tools_table(console, "Execution tools (-x)", exec_tools)
     else:
         print("No tools registered.")
     import sys
-
     sys.exit(0)

janito/cli/cli_commands/show_system_prompt.py

@@ -9,25 +9,10 @@ from janito.platform_discovery import PlatformDiscovery
 from pathlib import Path
 from jinja2 import Template
 import importlib.resources
+import re
 
 
-def handle_show_system_prompt(args):
-    # Collect modifiers as in JanitoCLI
-    from janito.cli.main_cli import MODIFIER_KEYS
-
-    modifiers = {
-        k: getattr(args, k) for k in MODIFIER_KEYS if getattr(args, k, None) is not None
-    }
-    provider, llm_driver_config, agent_role = prepare_llm_driver_config(args, modifiers)
-    if provider is None or llm_driver_config is None:
-        print("Error: Could not resolve provider or LLM driver config.")
-        return
-
-    # Prepare context for Jinja2 rendering
-    context = {}
-    context["role"] = agent_role or "developer"
-    context["profile"] = getattr(args, "profile", None)
-    # Compute allowed_permissions from CLI args (as in agent setup)
+def _compute_permission_string(args):
     from janito.tools.tool_base import ToolPermissions
     read = getattr(args, "read", False)
     write = getattr(args, "write", False)
@@ -40,63 +25,99 @@ def handle_show_system_prompt(args):
         perm_str += "w"
     if allowed.execute:
         perm_str += "x"
-    allowed_permissions = perm_str or None
+    return perm_str or None
+
+
+def _prepare_context(args, agent_role, allowed_permissions):
+    context = {}
+    context["role"] = agent_role or "developer"
+    context["profile"] = getattr(args, "profile", None)
     context["allowed_permissions"] = allowed_permissions
-    # DEBUG: Show permissions/context before rendering
-    from rich import print as rich_print
-    debug_flag = False
-    import sys
-    try:
-        debug_flag = (hasattr(sys, 'argv') and ('--debug' in sys.argv or '--verbose' in sys.argv or '-v' in sys.argv))
-    except Exception:
-        pass
-    if debug_flag:
-        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]")
     if allowed_permissions and 'x' in allowed_permissions:
         pd = PlatformDiscovery()
         context["platform"] = pd.get_platform_name()
         context["python_version"] = pd.get_python_version()
         context["shell_info"] = pd.detect_shell()
+    return context
 
-    # Locate and load the system prompt template
-    templates_dir = (
-        Path(__file__).parent.parent.parent / "agent" / "templates" / "profiles"
-    )
-    profile = getattr(args, "profile", None)
+
+def _load_template(profile, templates_dir):
     if profile:
         template_filename = f"system_prompt_template_{profile}.txt.j2"
         template_path = templates_dir / template_filename
     else:
-        # No profile specified means the main agent has no dedicated system prompt template.
-        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
+        return None, None
     template_content = None
     if template_path and template_path.exists():
         with open(template_path, "r", encoding="utf-8") as file:
             template_content = file.read()
     else:
-        # Try package import fallback
         try:
             with importlib.resources.files("janito.agent.templates.profiles").joinpath(
                 template_filename
             ).open("r", encoding="utf-8") as file:
                 template_content = file.read()
         except (FileNotFoundError, ModuleNotFoundError, AttributeError):
-            if profile:
-                raise FileNotFoundError(
-                    f"[janito] Could not find profile-specific template '{template_filename}' in {template_path} nor in janito.agent.templates.profiles package."
-                )
-            else:
-                print(
-                    f"[janito] Could not find {template_filename} in {template_path} nor in janito.agent.templates.profiles package."
-                )
-                print("No system prompt is set or resolved for this configuration.")
-                return
+            return template_filename, None
+    return template_filename, template_content
+
+
+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]")
+
+
+def handle_show_system_prompt(args):
+    from janito.cli.main_cli import MODIFIER_KEYS
+
+    modifiers = {
+        k: getattr(args, k) for k in MODIFIER_KEYS if getattr(args, k, None) is not None
+    }
+    provider, llm_driver_config, agent_role = prepare_llm_driver_config(args, modifiers)
+    if provider is None or llm_driver_config is None:
+        print("Error: Could not resolve provider or LLM driver config.")
+        return
+
+    allowed_permissions = _compute_permission_string(args)
+    context = _prepare_context(args, agent_role, allowed_permissions)
+
+    # 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))
+    except Exception:
+        pass
+
+    templates_dir = (
+        Path(__file__).parent.parent.parent / "agent" / "templates" / "profiles"
+    )
+    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.")
+        return
+
+    template_filename, template_content = _load_template(profile, templates_dir)
+    _print_debug_info(debug_flag, template_filename, allowed_permissions, context)
+
+    if not template_content:
+        if profile:
+            raise FileNotFoundError(
+                f"[janito] Could not find profile-specific template '{template_filename}' in {templates_dir / template_filename} nor in janito.agent.templates.profiles package."
+            )
+        else:
+            print(
+                f"[janito] Could not find {template_filename} in {templates_dir / template_filename} nor in janito.agent.templates.profiles package."
+            )
+            print("No system prompt is set or resolved for this configuration.")
+            return
 
     template = Template(template_content)
     system_prompt = template.render(**context)
+    system_prompt = re.sub(r'\n{3,}', '\n\n', system_prompt)
 
     print(f"\n--- System Prompt (resolved, profile: {getattr(args, 'profile', 'main')}) ---\n")
     print(system_prompt)

janito/cli/core/runner.py

@@ -92,7 +92,8 @@ def prepare_llm_driver_config(args, modifiers):
     llm_driver_config = LLMDriverConfig(**driver_config_data)
     if getattr(llm_driver_config, "verbose_api", None):
         pass
-    agent_role = modifiers.get("role", "developer")
+    # If both --role and --profile are provided, --role takes precedence for agent_role
+    agent_role = modifiers.get("role") or modifiers.get("profile") or "developer"
     return provider, llm_driver_config, agent_role
 
 
@@ -116,7 +117,11 @@ def handle_runner(args, provider, llm_driver_config, agent_role, verbose_tools=F
     # 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)
+    unrestricted_paths = getattr(args, "unrestricted_paths", False)
     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)
 
     # Print allowed permissions in verbose mode
     if getattr(args, "verbose", False):

janito/cli/core/setters.py

@@ -18,47 +18,56 @@ def handle_set(args, config_mgr=None):
     if not set_arg:
         return False
     try:
-        if "=" not in set_arg:
-            print(
-                "Error: --set requires KEY=VALUE (e.g., --set provider=provider_name)."
-            )
+        if not _validate_set_arg_format(set_arg):
             return True
-        key, value = set_arg.split("=", 1)
-        key, value = key.strip(), value.strip()
+        key, value = _parse_set_arg(set_arg)
         key = key.replace("-", "_")
+        return _dispatch_set_key(key, value)
+    except Exception as e:
+        print(f"Error parsing --set value: {e}")
+        return True
 
-        if key == "provider":
-            return _handle_set_config_provider(value)
-        if key == "model":
-            return _handle_set_global_model(value)
-        if "." in key and key.endswith(".model"):
-            return _handle_set_provider_model(key, value)
-        if key == "max_tokens":
-            return _handle_set_max_tokens(value)
-        if key == "base_url":
-            return _handle_set_base_url(value)
-        if key in ["azure_deployment_name", "azure-deployment-name"]:
-            global_config.file_set("azure_deployment_name", value)
-            print(f"Azure deployment name set to '{value}'.")
-            return True
-        if ".max_tokens" in key or ".base_url" in key:
-            return _handle_set_provider_level_setting(key, value)
-        # Tool permissions support: janito set tool_permissions=rwx
-        if key == "tool_permissions":
-            from janito.tools.permissions_parse import parse_permissions_string
-            from janito.tools.permissions import set_global_allowed_permissions
-            perms = parse_permissions_string(value)
-            global_config.file_set("tool_permissions", value)
-            set_global_allowed_permissions(perms)
-            print(f"Tool permissions set to '{value}' (parsed: {perms})")
-            return True
+def _validate_set_arg_format(set_arg):
+    if "=" not in set_arg:
         print(
-            f"Error: Unknown config key '{key}'. Supported: provider, model, <provider>.model, max_tokens, base_url, azure_deployment_name, <provider>.max_tokens, <provider>.base_url, <provider>.<model>.max_tokens, <provider>.<model>.base_url, tool_permissions"
+            "Error: --set requires KEY=VALUE (e.g., --set provider=provider_name)."
         )
+        return False
+    return True
+
+def _parse_set_arg(set_arg):
+    key, value = set_arg.split("=", 1)
+    return key.strip(), value.strip()
+
+def _dispatch_set_key(key, value):
+    if key == "provider":
+        return _handle_set_config_provider(value)
+    if key == "model":
+        return _handle_set_global_model(value)
+    if "." in key and key.endswith(".model"):
+        return _handle_set_provider_model(key, value)
+    if key == "max_tokens":
+        return _handle_set_max_tokens(value)
+    if key == "base_url":
+        return _handle_set_base_url(value)
+    if key in ["azure_deployment_name", "azure-deployment-name"]:
+        global_config.file_set("azure_deployment_name", value)
+        print(f"Azure deployment name set to '{value}'.")
         return True
-    except Exception as e:
-        print(f"Error parsing --set value: {e}")
+    if ".max_tokens" in key or ".base_url" in key:
+        return _handle_set_provider_level_setting(key, value)
+    if key == "tool_permissions":
+        from janito.tools.permissions_parse import parse_permissions_string
+        from janito.tools.permissions import set_global_allowed_permissions
+        perms = parse_permissions_string(value)
+        global_config.file_set("tool_permissions", value)
+        set_global_allowed_permissions(perms)
+        print(f"Tool permissions set to '{value}' (parsed: {perms})")
         return True
+    print(
+        f"Error: Unknown config key '{key}'. Supported: provider, model, <provider>.model, max_tokens, base_url, azure_deployment_name, <provider>.max_tokens, <provider>.base_url, <provider>.<model>.max_tokens, <provider>.<model>.base_url, tool_permissions"
+    )
+    return True
 
 
 def _handle_set_max_tokens(value):

janito/cli/main_cli.py

@@ -14,6 +14,14 @@ from janito.cli.core.event_logger import (
 )
 
 definition = [
+    (
+        ["-u", "--unrestricted-paths"],
+        {
+            "action": "store_true",
+            "help": "Disable path security: allow tool arguments to use any file/directory path (DANGEROUS)",
+        },
+    ),
+
     (
         ["--profile"],
         {
@@ -22,6 +30,14 @@ definition = [
             "default": None,
         },
     ),
+    (
+        ["--role"],
+        {
+            "metavar": "ROLE",
+            "help": "Select the developer role name (overrides profile, e.g. 'python-expert').",
+            "default": None,
+        },
+    ),
     (
         ["-W", "--workdir"],
         {
@@ -165,6 +181,7 @@ MODIFIER_KEYS = [
     "provider",
     "model",
     "role",
+    "profile",
     "system",
     "temperature",
 
@@ -240,11 +257,15 @@ class JanitoCLI:
                 setattr(self.args, key, None)
 
     def collect_modifiers(self):
-        return {
+        modifiers = {
             k: getattr(self.args, k)
             for k in MODIFIER_KEYS
             if getattr(self.args, k, None) is not None
         }
+        # If --role is provided, override role in modifiers
+        if getattr(self.args, "role", None):
+            modifiers["role"] = getattr(self.args, "role")
+        return modifiers
 
     def classify(self):
         if any(getattr(self.args, k, None) for k in SETTER_KEYS):
@@ -273,6 +294,9 @@ class JanitoCLI:
             self._maybe_print_verbose_provider_model()
             handle_getter(self.args)
             return
+        # If running in single shot mode and --profile is not provided, default to 'developer' profile
+        if get_prompt_mode(self.args) == "single_shot" and not getattr(self.args, "profile", None):
+            self.args.profile = "developer"
         provider = self._get_provider_or_default()
         if provider is None:
             print(

janito/cli/prompt_core.py

@@ -49,87 +49,94 @@ class PromptHandler:
             on_event(inner_event)
         from janito.tools.tool_events import ToolCallFinished
 
-        # Print tool result if ToolCallFinished event is received
         if isinstance(inner_event, ToolCallFinished):
-            # Print result if verbose_tools is enabled or always for user visibility
-            if hasattr(self.args, "verbose_tools") and self.args.verbose_tools:
-                self.console.print(
-                    f"[cyan][tools-adapter] Tool '{inner_event.tool_name}' result:[/cyan] {inner_event.result}"
-                )
-            else:
-                self.console.print(inner_event.result)
-            return None
+            return self._handle_tool_call_finished(inner_event)
         if isinstance(inner_event, RateLimitRetry):
-            status.update(f"[yellow]Rate limited. Waiting {inner_event.retry_delay:.0f}s before retry (attempt {inner_event.attempt}).[yellow]")
-            return None
+            return self._handle_rate_limit_retry(inner_event, status)
         if isinstance(inner_event, RequestFinished):
+            if getattr(inner_event, "status", None) == "error":
+                return self._handle_request_finished_error(inner_event, status)
+            if getattr(inner_event, "status", None) in (RequestStatus.EMPTY_RESPONSE, RequestStatus.TIMEOUT):
+                return self._handle_empty_or_timeout(inner_event, status)
             status.update("[bold green]Received response![bold green]")
             return "break"
-        elif (
-            isinstance(inner_event, RequestFinished)
-            and getattr(inner_event, "status", None) == "error"
-        ):  # noqa
-            error_msg = (
-                inner_event.error if hasattr(inner_event, "error") else "Unknown error"
+        if isinstance(inner_event, ToolCallError):
+            return self._handle_tool_call_error(inner_event, status)
+        event_type = type(inner_event).__name__
+        self.console.print(
+            f"[yellow]Warning: Unknown event type encountered: {event_type}[yellow]"
+        )
+        return None
+
+    def _handle_tool_call_finished(self, inner_event):
+        if hasattr(self.args, "verbose_tools") and self.args.verbose_tools:
+            self.console.print(
+                f"[cyan][tools-adapter] Tool '{inner_event.tool_name}' result:[/cyan] {inner_event.result}"
+            )
+        else:
+            self.console.print(inner_event.result)
+        return None
+
+    def _handle_rate_limit_retry(self, inner_event, status):
+        status.update(f"[yellow]Rate limited. Waiting {inner_event.retry_delay:.0f}s before retry (attempt {inner_event.attempt}).[yellow]")
+        return None
+
+    def _handle_request_finished_error(self, inner_event, status):
+        error_msg = (
+            inner_event.error if hasattr(inner_event, "error") else "Unknown error"
+        )
+        if (
+            "Status 429" in error_msg
+            and "Service tier capacity exceeded for this model" in error_msg
+        ):
+            status.update(
+                "[yellow]Service tier capacity exceeded, retrying...[yellow]"
             )
-            if (
-                "Status 429" in error_msg
-                and "Service tier capacity exceeded for this model" in error_msg
-            ):
-                status.update(
-                    "[yellow]Service tier capacity exceeded, retrying...[yellow]"
-                )
-                return "break"
-            status.update(f"[bold red]Error: {error_msg}[bold red]")
-            self.console.print(f"[red]Error: {error_msg}[red]")
             return "break"
-        elif isinstance(inner_event, ToolCallError):
-            error_msg = (
-                inner_event.error
-                if hasattr(inner_event, "error")
-                else "Unknown tool error"
+        status.update(f"[bold red]Error: {error_msg}[bold red]")
+        self.console.print(f"[red]Error: {error_msg}[red]")
+        return "break"
+
+    def _handle_tool_call_error(self, inner_event, status):
+        error_msg = (
+            inner_event.error
+            if hasattr(inner_event, "error")
+            else "Unknown tool error"
+        )
+        tool_name = (
+            inner_event.tool_name
+            if hasattr(inner_event, "tool_name")
+            else "unknown"
+        )
+        status.update(
+            f"[bold red]Tool Error in '{tool_name}': {error_msg}[bold red]"
+        )
+        self.console.print(f"[red]Tool Error in '{tool_name}': {error_msg}[red]")
+        return "break"
+
+    def _handle_empty_or_timeout(self, inner_event, status):
+        details = getattr(inner_event, "details", None) or {}
+        block_reason = details.get("block_reason")
+        block_msg = details.get("block_reason_message")
+        msg = details.get(
+            "message", "LLM returned an empty or incomplete response."
+        )
+        driver_name = getattr(inner_event, "driver_name", "unknown driver")
+        if block_reason or block_msg:
+            status.update(
+                f"[bold yellow]Blocked by driver: {driver_name} | {block_reason or ''} {block_msg or ''}[bold yellow]"
             )
-            tool_name = (
-                inner_event.tool_name
-                if hasattr(inner_event, "tool_name")
-                else "unknown"
+            self.console.print(
+                f"[yellow]Blocked by driver: {driver_name} (empty response): {block_reason or ''}\n{block_msg or ''}[/yellow]"
             )
+        else:
             status.update(
-                f"[bold red]Tool Error in '{tool_name}': {error_msg}[bold red]"
+                f"[yellow]LLM produced no output for this request (driver: {driver_name}).[/yellow]"
             )
-            self.console.print(f"[red]Tool Error in '{tool_name}': {error_msg}[red]")
-            return "break"
-        elif isinstance(inner_event, RequestFinished) and getattr(
-            inner_event, "status", None
-        ) in (RequestStatus.EMPTY_RESPONSE, RequestStatus.TIMEOUT):
-            details = getattr(inner_event, "details", None) or {}
-            block_reason = details.get("block_reason")
-            block_msg = details.get("block_reason_message")
-            msg = details.get(
-                "message", "LLM returned an empty or incomplete response."
+            self.console.print(
+                f"[yellow]Warning: {msg} (driver: {driver_name})[/yellow]"
             )
-            driver_name = getattr(inner_event, "driver_name", "unknown driver")
-            if block_reason or block_msg:
-                status.update(
-                    f"[bold yellow]Blocked by driver: {driver_name} | {block_reason or ''} {block_msg or ''}[bold yellow]"
-                )
-                self.console.print(
-                    f"[yellow]Blocked by driver: {driver_name} (empty response): {block_reason or ''}\n{block_msg or ''}[/yellow]"
-                )
-            else:
-                status.update(
-                    f"[yellow]LLM produced no output for this request (driver: {driver_name}).[/yellow]"
-                )
-                self.console.print(
-                    f"[yellow]Warning: {msg} (driver: {driver_name})[/yellow]"
-                )
-            return "break"
-        # Report unknown event types
-        event_type = type(inner_event).__name__
-        self.console.print(
-            f"[yellow]Warning: Unknown event type encountered: {event_type}[yellow]"
-        )
-        return None
+        return "break"
 
     def _process_event_iter(self, event_iter, on_event):
         for event in event_iter:

janito/cli/rich_terminal_reporter.py

@@ -30,7 +30,8 @@ class RichTerminalReporter(EventHandlerBase):
         self.raw_mode = raw_mode
         import janito.report_events as report_events
 
-        super().__init__(driver_events, report_events)
+        import janito.tools.tool_events as tool_events
+        super().__init__(driver_events, report_events, tool_events)
         self._waiting_printed = False
 
     def on_RequestStarted(self, event):
@@ -102,7 +103,27 @@ class RichTerminalReporter(EventHandlerBase):
                 self.console.file.flush()
         # No output if not raw_mode or if response is None
 
+    def on_ToolCallError(self, event):
+        # Optionally handle tool call errors in a user-friendly way
+        error = getattr(event, "error", None)
+        tool = getattr(event, "tool_name", None)
+        if error and tool:
+            self.console.print(f"[bold red]Tool Error ({tool}):[/] {error}")
+            self.console.file.flush()
+
     def on_ReportEvent(self, event):
+        # Special handling for security-related report events
+        subtype = getattr(event, "subtype", None)
+        msg = getattr(event, "message", None)
+        action = getattr(event, "action", None)
+        tool = getattr(event, "tool", None)
+        context = getattr(event, "context", None)
+        if subtype == ReportSubtype.ERROR and msg and "[SECURITY] Path access denied" in msg:
+            # Highlight security errors with a distinct style
+            self.console.print(Panel(f"{msg}", title="[red]SECURITY VIOLATION[/red]", style="bold red"))
+            self.console.file.flush()
+            return
+
         msg = event.message if hasattr(event, "message") else None
         subtype = event.subtype if hasattr(event, "subtype") else None
         if not msg or not subtype: