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

janito/cli/single_shot_mode/handler.py

@@ -2,48 +2,32 @@
 PromptHandler: Handles prompt submission and response formatting for janito CLI (one-shot prompt execution).
 """
 
-import time
-from janito.version import __version__ as VERSION
-from janito.cli.prompt_core import PromptHandler as GenericPromptHandler
-from janito.cli.verbose_output import (
-    print_verbose_header,
-    print_performance,
-    handle_exception,
-)
+from __future__ import annotations
+
+from janito.cli.prompt_setup import setup_agent_and_prompt_handler
 import janito.tools  # Ensure all tools are registered
 from janito.cli.console import shared_console
 
 
 class PromptHandler:
-    def __init__(self, args, provider_instance, llm_driver_config, role=None, exec_enabled=False):
+    def __init__(self, args, provider_instance, llm_driver_config, role=None, exec_enabled=False, allowed_permissions=None):
         self.args = args
         self.provider_instance = provider_instance
         self.llm_driver_config = llm_driver_config
         self.role = role
         self.exec_enabled = exec_enabled
-        from janito.agent.setup_agent import create_configured_agent
-
-        # DEBUG: Print exec_enabled propagation
-        self.agent = create_configured_agent(
+        # Instantiate agent together with prompt handler using the shared helper
+        self.agent, self.generic_handler = setup_agent_and_prompt_handler(
+            args=args,
             provider_instance=provider_instance,
             llm_driver_config=llm_driver_config,
             role=role,
             verbose_tools=getattr(args, "verbose_tools", False),
             verbose_agent=getattr(args, "verbose_agent", False),
             exec_enabled=exec_enabled,
+            allowed_permissions=allowed_permissions,
+            profile=getattr(args, "profile", None),
         )
-        # Setup conversation/history if needed
-        # Dynamically enable/disable execution tools in the registry
-        try:
-            registry = __import__('janito.tools', fromlist=['get_local_tools_adapter']).get_local_tools_adapter()
-            if hasattr(registry, 'set_execution_tools_enabled'):
-                registry.set_execution_tools_enabled(exec_enabled)
-        except Exception as e:
-            shared_console.print(f"[yellow]Warning: Could not update execution tools dynamically in single-shot mode: {e}[/yellow]")
-        self.generic_handler = GenericPromptHandler(
-            args, [], provider_instance=provider_instance
-        )
-        self.generic_handler.agent = self.agent
 
     def handle(self) -> None:
         import traceback
@@ -75,56 +59,13 @@ class PromptHandler:
         self._post_prompt_actions()
 
     def _post_prompt_actions(self):
-        final_event = getattr(self.agent, "last_event", None)
-        if final_event is not None:
-            self._print_exit_reason_and_parts(final_event)
-            # --- BEGIN: Print token info in rich rule if --verbose is set ---
-            if hasattr(self.args, "verbose") and self.args.verbose:
-                from janito.perf_singleton import performance_collector
-
-                token_info = performance_collector.get_last_request_usage()
-                from rich.rule import Rule
-                from rich import print as rich_print
-                from janito.cli.utils import format_tokens
-
-                if token_info:
-                    if isinstance(token_info, dict):
-                        token_str = " | ".join(
-                            f"{k}: {format_tokens(v) if isinstance(v, int) else v}"
-                            for k, v in token_info.items()
-                        )
-                    else:
-                        token_str = str(token_info)
-                    rich_print(Rule(f"[bold cyan]Token Usage[/bold cyan] {token_str}"))
-                else:
-                    rich_print(Rule("[cyan]No token usage info available.[/cyan]"))
-        else:
-            shared_console.print("[yellow]No output produced by the model.[/yellow]")
+        # Align with chat mode: only print token usage summary
+        from janito.formatting_token import print_token_message_summary
+        from janito.perf_singleton import performance_collector
+        usage = performance_collector.get_last_request_usage()
+        print_token_message_summary(shared_console, msg_count=1, usage=usage)
         self._cleanup_driver_and_console()
 
-    def _print_exit_reason_and_parts(self, final_event):
-        exit_reason = (
-            getattr(final_event, "metadata", {}).get("exit_reason")
-            if hasattr(final_event, "metadata")
-            else None
-        )
-        if exit_reason:
-            print(f"[bold yellow]Exit reason: {exit_reason}[/bold yellow]")
-        parts = getattr(final_event, "parts", None)
-        if not exit_reason:
-            if parts is None or len(parts) == 0:
-                shared_console.print(
-                    "[yellow]No output produced by the model.[/yellow]"
-                )
-            else:
-                if hasattr(self.args, "verbose_agent") and self.args.verbose_agent:
-                    print(
-                        "[yellow]No user-visible output. Model returned the following parts:"
-                    )
-                    for idx, part in enumerate(parts):
-                        print(
-                            f"  [part {idx}] type: {type(part).__name__} | content: {getattr(part, 'content', repr(part))}"
-                        )
 
     def _cleanup_driver_and_console(self):
         if hasattr(self.agent, "join_driver"):

janito/cli/verbose_output.py

@@ -6,7 +6,7 @@ from rich import print as rich_print
 from rich.align import Align
 from rich.panel import Panel
 from rich.text import Text
-from janito.version import __version__ as VERSION
+from janito import __version__ as VERSION
 from janito.cli.utils import format_tokens
 
 

janito/config_manager.py

@@ -1,112 +1,125 @@
-import json
-from pathlib import Path
-from threading import Lock
-
-
-class ConfigManager:
-    """
-    Unified configuration manager supporting:
-      - Defaults
-      - File-based configuration
-      - Runtime overrides (e.g., CLI args)
-    """
-
-    _instance = None
-    _lock = Lock()
-
-    def __new__(cls, *args, **kwargs):
-        with cls._lock:
-            if not cls._instance:
-                cls._instance = super(ConfigManager, cls).__new__(cls)
-        return cls._instance
-
-    def __init__(self, config_path=None, defaults=None, runtime_overrides=None):
-        # Lazy single-init
-        if hasattr(self, "_initialized") and self._initialized:
-            return
-        self._initialized = True
-
-        self.config_path = Path(config_path or Path.home() / ".janito" / "config.json")
-        self.defaults = dict(defaults) if defaults else {}
-        self.file_config = {}
-        self.runtime_overrides = dict(runtime_overrides) if runtime_overrides else {}
-        self._load_file_config()
-
-    def _load_file_config(self):
-        if self.config_path.exists():
-            with open(self.config_path, "r", encoding="utf-8") as f:
-                try:
-                    self.file_config = json.load(f)
-                except Exception:
-                    self.file_config = {}
-        else:
-            self.file_config = {}
-
-    def save(self):
-        self.config_path.parent.mkdir(parents=True, exist_ok=True)
-        with open(self.config_path, "w", encoding="utf-8") as f:
-            json.dump(self.file_config, f, indent=2)
-            f.write("\n")
-
-    def get(self, key, default=None):
-        # Precedence: runtime_overrides > file_config > defaults
-        for layer in (self.runtime_overrides, self.file_config, self.defaults):
-            if key in layer and layer[key] is not None:
-                return layer[key]
-        return default
-
-    def runtime_set(self, key, value):
-        self.runtime_overrides[key] = value
-
-    def file_set(self, key, value):
-        # Always reload, update, and persist
-        self._load_file_config()
-        self.file_config[key] = value
-        with open(self.config_path, "w", encoding="utf-8") as f:
-            json.dump(self.file_config, f, indent=2)
-            f.write("\n")
-
-    def all(self, layered=False):
-        merged = dict(self.defaults)
-        merged.update(self.file_config)
-        merged.update(self.runtime_overrides)
-        if layered:
-            # Only file+runtime, i.e., what is saved to disk
-            d = dict(self.file_config)
-            d.update(self.runtime_overrides)
-            return d
-        return merged
-
-    # Namespaced provider/model config
-    def get_provider_config(self, provider, default=None):
-        providers = self.file_config.get("providers") or {}
-        return providers.get(provider) or (default or {})
-
-    def set_provider_config(self, provider, key, value):
-        if "providers" not in self.file_config:
-            self.file_config["providers"] = {}
-        if provider not in self.file_config["providers"]:
-            self.file_config["providers"][provider] = {}
-        self.file_config["providers"][provider][key] = value
-
-    def get_provider_model_config(self, provider, model, default=None):
-        return (
-            self.file_config.get("providers")
-            or {}.get(provider, {}).get("models", {}).get(model)
-            or (default or {})
-        )
-
-    def set_provider_model_config(self, provider, model, key, value):
-        if "providers" not in self.file_config:
-            self.file_config["providers"] = {}
-        if provider not in self.file_config["providers"]:
-            self.file_config["providers"][provider] = {}
-        if "models" not in self.file_config["providers"][provider]:
-            self.file_config["providers"][provider]["models"] = {}
-        if model not in self.file_config["providers"][provider]["models"]:
-            self.file_config["providers"][provider]["models"][model] = {}
-        self.file_config["providers"][provider]["models"][model][key] = value
-
-    # Support loading runtime overrides after init (e.g. after parsing CLI args)
-    def apply_runtime_overrides(self, overrides_dict):
-        self.runtime_overrides.update(overrides_dict)
+import json
+from pathlib import Path
+from threading import Lock
+
+
+class ConfigManager:
+    """
+    Unified configuration manager supporting:
+      - Defaults
+      - File-based configuration
+      - Runtime overrides (e.g., CLI args)
+    """
+
+    _instance = None
+    _lock = Lock()
+
+    def __new__(cls, *args, **kwargs):
+        with cls._lock:
+            if not cls._instance:
+                cls._instance = super(ConfigManager, cls).__new__(cls)
+        return cls._instance
+
+    def __init__(self, config_path=None, defaults=None, runtime_overrides=None):
+        # Lazy single-init
+        if hasattr(self, "_initialized") and self._initialized:
+            return
+        self._initialized = True
+
+        self.config_path = Path(config_path or Path.home() / ".janito" / "config.json")
+        self.defaults = dict(defaults) if defaults else {}
+        self.file_config = {}
+        self.runtime_overrides = dict(runtime_overrides) if runtime_overrides else {}
+        self._load_file_config()
+        self._apply_tool_permissions_on_startup()
+
+    def _apply_tool_permissions_on_startup(self):
+        # On startup, read tool_permissions from config and set global permissions
+        perm_str = self.file_config.get("tool_permissions")
+        if perm_str:
+            try:
+                from janito.tools.permissions_parse import parse_permissions_string
+                from janito.tools.permissions import set_global_allowed_permissions
+                perms = parse_permissions_string(perm_str)
+                set_global_allowed_permissions(perms)
+            except Exception as e:
+                print(f"Warning: Failed to apply tool_permissions from config: {e}")
+
+    def _load_file_config(self):
+        if self.config_path.exists():
+            with open(self.config_path, "r", encoding="utf-8") as f:
+                try:
+                    self.file_config = json.load(f)
+                except Exception:
+                    self.file_config = {}
+        else:
+            self.file_config = {}
+
+    def save(self):
+        self.config_path.parent.mkdir(parents=True, exist_ok=True)
+        with open(self.config_path, "w", encoding="utf-8") as f:
+            json.dump(self.file_config, f, indent=2)
+            f.write("\n")
+
+    def get(self, key, default=None):
+        # Precedence: runtime_overrides > file_config > defaults
+        for layer in (self.runtime_overrides, self.file_config, self.defaults):
+            if key in layer and layer[key] is not None:
+                return layer[key]
+        return default
+
+    def runtime_set(self, key, value):
+        self.runtime_overrides[key] = value
+
+    def file_set(self, key, value):
+        # Always reload, update, and persist
+        self._load_file_config()
+        self.file_config[key] = value
+        with open(self.config_path, "w", encoding="utf-8") as f:
+            json.dump(self.file_config, f, indent=2)
+            f.write("\n")
+
+    def all(self, layered=False):
+        merged = dict(self.defaults)
+        merged.update(self.file_config)
+        merged.update(self.runtime_overrides)
+        if layered:
+            # Only file+runtime, i.e., what is saved to disk
+            d = dict(self.file_config)
+            d.update(self.runtime_overrides)
+            return d
+        return merged
+
+    # Namespaced provider/model config
+    def get_provider_config(self, provider, default=None):
+        providers = self.file_config.get("providers") or {}
+        return providers.get(provider) or (default or {})
+
+    def set_provider_config(self, provider, key, value):
+        if "providers" not in self.file_config:
+            self.file_config["providers"] = {}
+        if provider not in self.file_config["providers"]:
+            self.file_config["providers"][provider] = {}
+        self.file_config["providers"][provider][key] = value
+
+    def get_provider_model_config(self, provider, model, default=None):
+        return (
+            self.file_config.get("providers")
+            or {}.get(provider, {}).get("models", {}).get(model)
+            or (default or {})
+        )
+
+    def set_provider_model_config(self, provider, model, key, value):
+        if "providers" not in self.file_config:
+            self.file_config["providers"] = {}
+        if provider not in self.file_config["providers"]:
+            self.file_config["providers"][provider] = {}
+        if "models" not in self.file_config["providers"][provider]:
+            self.file_config["providers"][provider]["models"] = {}
+        if model not in self.file_config["providers"][provider]["models"]:
+            self.file_config["providers"][provider]["models"][model] = {}
+        self.file_config["providers"][provider]["models"][model][key] = value
+
+    # Support loading runtime overrides after init (e.g. after parsing CLI args)
+    def apply_runtime_overrides(self, overrides_dict):
+        self.runtime_overrides.update(overrides_dict)

janito/drivers/openai/README.md

@@ -0,0 +1,20 @@
+# OpenAI Driver Debugging
+
+## HTTP Debugging via Environment Variable
+
+To debug HTTP requests and responses for the OpenAI driver, set the environment variable `OPENAI_DEBUG_HTTP=1` before running your application. This will print the full HTTP request and response bodies to the console for troubleshooting purposes.
+
+**Example (PowerShell):**
+
+```
+$env:OPENAI_DEBUG_HTTP=1
+python your_app.py
+```
+
+**Example (bash):**
+
+```
+OPENAI_DEBUG_HTTP=1 python your_app.py
+```
+
+This feature is implemented in `janito/drivers/openai/driver.py` and works by wrapping the OpenAI client HTTP transport with a debug logger when the environment variable is set.

janito/event_bus/event.py

@@ -1,6 +1,6 @@
 import attr
 from typing import ClassVar
-from datetime import datetime
+from datetime import datetime, timezone
 
 
 @attr.s(auto_attribs=True, kw_only=True)
@@ -12,4 +12,4 @@ class Event:
     """
 
     category: ClassVar[str] = "generic"
-    timestamp: datetime = attr.ib(factory=datetime.utcnow)
+    timestamp: datetime = attr.ib(factory=lambda: datetime.now(timezone.utc))

janito/i18n/pt.py

@@ -3,7 +3,6 @@ translations = {
     "36107ed78ab25f6fb12ad8ce13018cd1ce6735d1": "Iniciando servidor web...",
     "70a0d194687568a47aa617fd85036ace1e69a982": "Deseja realmente sair? (s/n): ",
     "5c9ebcbbd7632ecb328bd52958b17158afaa32c6": "F12 = Ação Rápida (segue a ação recomendada)",
-    "e4034394acca752c021b2ab50f60da8273e3c314": "TermWeb iniciado... Disponível em http://localhost:{selected_port}",
     "fe21121e2934234b68d19b2757532117d440c1e3": "Chave de API não encontrada. Por favor, configure 'api_key' no seu arquivo de configuração.",
     "c9e3759b1756eba35b381ce2b72cd659e132b01f": "Olá, {name}!",
     "ca1fee2f55baabdc2e4b0e9529c89ee024e62079": "Nenhum prompt fornecido nas mensagens",

janito/llm/README.md

@@ -0,0 +1,23 @@
+# janito.llm Package
+
+This directory contains generic, provider-agnostic classes and methods for working with Large Language Models (LLMs) in the `janito` framework. Its purpose is to provide base abstractions that can be extended by provider-specific implementations.
+
+## Scope and Contents
+
+- **driver.py**
+  - Contains `LLMDriver`, an abstract base class defining the core methods for LLM drivers. Subclasses should implement provider/model-specific logic, while benefiting from consistent streaming and event interfaces.
+- **provider.py**
+  - Contains `LLMProvider`, an abstract base class for LLM API providers. This outlines the required interface for integrating new providers and retrieving model info or driver classes.
+
+## Usage
+- Extend these base classes when adding new drivers or providers.
+- Do not include provider-specific logic here; only generic mechanisms, patterns, or utilities applicable to any LLM integration belong in this package.
+
+## Example
+```python
+from janito.llm.driver import LLMDriver
+from janito.llm.provider import LLMProvider
+```
+
+---
+This README clarifies the intention of the `llm` package as the generic/static contract for LLM drivers and providers.

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.