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

janito/cli/core/runner.py

@@ -1,148 +1,165 @@
-"""Handles LLM driver config preparation and execution modes."""
-
-from janito.llm.driver_config import LLMDriverConfig
-from janito.provider_config import get_config_provider
-from janito.cli.verbose_output import print_verbose_info
-
-
-def _choose_provider(args):
-    provider = getattr(args, "provider", None)
-    if provider is None:
-        provider = get_config_provider()
-        if provider and getattr(args, "verbose", False):
-            print_verbose_info(
-                "Default provider", provider, style="magenta", align_content=True
-            )
-        elif provider is None:
-            print(
-                "Error: No provider selected and no provider found in config. Please set a provider using '-p PROVIDER', '--set provider=name', or configure a provider."
-            )
-            return None
-    return provider
-
-
-def _populate_driver_config_data(args, modifiers, provider, model):
-    from janito.provider_config import get_effective_setting
-
-    CONFIG_LOOKUP_KEYS = ("max_tokens", "base_url")
-    driver_config_data = {"model": model}
-    if getattr(args, "verbose_api", None) is not None:
-        driver_config_data["verbose_api"] = args.verbose_api
-    for field in LLMDriverConfig.__dataclass_fields__:
-        if field in CONFIG_LOOKUP_KEYS:
-            if field in modifiers and modifiers[field] is not None:
-                driver_config_data[field] = modifiers[field]
-            else:
-                value = get_effective_setting(provider, model, field)
-                if value is not None:
-                    driver_config_data[field] = value
-        elif field in modifiers and field != "model":
-            driver_config_data[field] = modifiers[field]
-    return driver_config_data
-
-
-def prepare_llm_driver_config(args, modifiers):
-    """Prepare the LLMDriverConfig instance based on CLI *args* and *modifiers*.
-
-    This helper additionally validates that the chosen ``--model`` (or the
-    resolved model coming from config precedence) is actually available for the
-    selected provider.  If the combination is invalid an error is printed and
-    ``None`` is returned for the config so that the caller can abort execution
-    gracefully.
-    """
-    provider = _choose_provider(args)
-    if provider is None:
-        return None, None, None
-    from janito.provider_config import get_effective_model
-
-    model = getattr(args, "model", None)
-    if not model:
-        model = get_effective_model(provider)
-
-    # Validate that the chosen model is supported by the selected provider
-    if model:
-        from janito.provider_registry import ProviderRegistry
-
-        provider_instance = None
-        provider_instance = ProviderRegistry().get_instance(provider)
-        if provider_instance is None:
-            return provider, None, None
-        try:
-            if not provider_instance.is_model_available(model):
-                print(
-                    f"Error: Model '{model}' is not available for provider '{provider}'."
-                )
-                # Optionally, print available models if possible
-                if hasattr(provider_instance, 'get_model_info'):
-                    available_models = [
-                        m["name"]
-                        for m in provider_instance.get_model_info().values()
-                        if isinstance(m, dict) and "name" in m
-                    ]
-                    print(f"Available models: {', '.join(available_models)}")
-                return provider, None, None
-        except Exception as e:
-            print(f"Error validating model for provider '{provider}': {e}")
-            return provider, None, None
-    driver_config_data = _populate_driver_config_data(args, modifiers, provider, model)
-    llm_driver_config = LLMDriverConfig(**driver_config_data)
-    if getattr(llm_driver_config, "verbose_api", None):
-        pass
-    agent_role = modifiers.get("role", "software developer")
-    return provider, llm_driver_config, agent_role
-
-
-def handle_runner(args, provider, llm_driver_config, agent_role, verbose_tools=False, exec_enabled=False):
-    """
-    Main runner for CLI execution. If exec_enabled is False, disables execution/run tools.
-    """
-    zero_mode = getattr(args, "zero", False)
-    from janito.provider_registry import ProviderRegistry
-
-    # Patch: disable execution/run tools if not enabled
-    if not exec_enabled:
-        import janito.tools
-        adapter = janito.tools.get_local_tools_adapter(workdir=getattr(args, "workdir", None))
-        if hasattr(adapter, "disable_execution_tools"):
-            adapter.disable_execution_tools()
-    else:
-        import janito.tools
-        adapter = janito.tools.get_local_tools_adapter(workdir=getattr(args, "workdir", None))
-
-    provider_instance = ProviderRegistry().get_instance(provider, llm_driver_config)
-    if provider_instance is None:
-        return
-    mode = get_prompt_mode(args)
-    if getattr(args, "verbose", False):
-        print_verbose_info(
-            "Active LLMDriverConfig (after provider)", llm_driver_config, style="green"
-        )
-        print_verbose_info("Agent role", agent_role, style="green")
-    if mode == "single_shot":
-        from janito.cli.single_shot_mode.handler import (
-            PromptHandler as SingleShotPromptHandler,
-        )
-
-        handler = SingleShotPromptHandler(
-            args, provider_instance, llm_driver_config, role=agent_role
-        )
-        handler.handle()
-    else:
-        from janito.cli.chat_mode.session import ChatSession
-        from rich.console import Console
-
-        console = Console()
-        session = ChatSession(
-            console,
-            provider_instance,
-            llm_driver_config,
-            role=agent_role,
-            args=args,
-            verbose_tools=verbose_tools,
-            verbose_agent=getattr(args, "verbose_agent", False),
-        )
-        session.run()
-
-
-def get_prompt_mode(args):
-    return "single_shot" if getattr(args, "user_prompt", None) else "chat_mode"
+"""Handles LLM driver config preparation and execution modes."""
+
+from janito.llm.driver_config import LLMDriverConfig
+from janito.provider_config import get_config_provider
+from janito.cli.verbose_output import print_verbose_info
+
+
+def _choose_provider(args):
+    provider = getattr(args, "provider", None)
+    if provider is None:
+        provider = get_config_provider()
+        if provider and getattr(args, "verbose", False):
+            print_verbose_info(
+                "Default provider", provider, style="magenta", align_content=True
+            )
+        elif provider is None:
+            print(
+                "Error: No provider selected and no provider found in config. Please set a provider using '-p PROVIDER', '--set provider=name', or configure a provider."
+            )
+            return None
+    return provider
+
+
+def _populate_driver_config_data(args, modifiers, provider, model):
+    from janito.provider_config import get_effective_setting
+
+    CONFIG_LOOKUP_KEYS = ("max_tokens", "base_url")
+    driver_config_data = {"model": model}
+    if getattr(args, "verbose_api", None) is not None:
+        driver_config_data["verbose_api"] = args.verbose_api
+
+    # Add reasoning_effort from --effort CLI argument
+    if getattr(args, "effort", None) is not None:
+        driver_config_data["reasoning_effort"] = args.effort
+    for field in LLMDriverConfig.__dataclass_fields__:
+        if field in CONFIG_LOOKUP_KEYS:
+            if field in modifiers and modifiers[field] is not None:
+                driver_config_data[field] = modifiers[field]
+            else:
+                value = get_effective_setting(provider, model, field)
+                if value is not None:
+                    driver_config_data[field] = value
+        elif field in modifiers and field != "model":
+            driver_config_data[field] = modifiers[field]
+    return driver_config_data
+
+
+def prepare_llm_driver_config(args, modifiers):
+    """Prepare the LLMDriverConfig instance based on CLI *args* and *modifiers*.
+
+    This helper additionally validates that the chosen ``--model`` (or the
+    resolved model coming from config precedence) is actually available for the
+    selected provider.  If the combination is invalid an error is printed and
+    ``None`` is returned for the config so that the caller can abort execution
+    gracefully.
+    """
+    provider = _choose_provider(args)
+    if provider is None:
+        return None, None, None
+    from janito.provider_config import get_effective_model
+
+    model = getattr(args, "model", None)
+    if not model:
+        model = get_effective_model(provider)
+
+    # Validate that the chosen model is supported by the selected provider
+    if model:
+        from janito.provider_registry import ProviderRegistry
+
+        provider_instance = None
+        provider_instance = ProviderRegistry().get_instance(provider)
+        if provider_instance is None:
+            return provider, None, None
+        try:
+            if not provider_instance.is_model_available(model):
+                print(
+                    f"Error: Model '{model}' is not available for provider '{provider}'."
+                )
+                # Optionally, print available models if possible
+                if hasattr(provider_instance, 'get_model_info'):
+                    available_models = [
+                        m["name"]
+                        for m in provider_instance.get_model_info().values()
+                        if isinstance(m, dict) and "name" in m
+                    ]
+                    print(f"Available models: {', '.join(available_models)}")
+                return provider, None, None
+        except Exception as e:
+            print(f"Error validating model for provider '{provider}': {e}")
+            return provider, None, None
+    driver_config_data = _populate_driver_config_data(args, modifiers, provider, model)
+    llm_driver_config = LLMDriverConfig(**driver_config_data)
+    if getattr(llm_driver_config, "verbose_api", None):
+        pass
+    agent_role = modifiers.get("role", "software developer")
+    return provider, llm_driver_config, agent_role
+
+
+def handle_runner(args, provider, llm_driver_config, agent_role, verbose_tools=False, exec_enabled=False):
+    """
+    Main runner for CLI execution. If exec_enabled is False, disables execution/run tools.
+    """
+    zero_mode = getattr(args, "zero", False)
+    from janito.provider_registry import ProviderRegistry
+
+    # Patch: disable execution/run tools if not enabled
+    import janito.tools
+    adapter = janito.tools.get_local_tools_adapter(workdir=getattr(args, "workdir", None))
+    if not exec_enabled:
+        if hasattr(adapter, "disable_execution_tools"):
+            adapter.disable_execution_tools()
+    else:
+        # Try to re-register execution tools if possible (print warning if not supported)
+        if hasattr(adapter, "register_tool"):
+            # This is a no-op if already registered, but we can attempt to re-register known execution tools
+            try:
+                from janito.tools.adapters.local import PythonCodeRunTool, PythonCommandRunTool, PythonFileRunTool, RunBashCommandTool, RunPowershellCommandTool
+                for tool_cls in [PythonCodeRunTool, PythonCommandRunTool, PythonFileRunTool, RunBashCommandTool, RunPowershellCommandTool]:
+                    try:
+                        adapter.register_tool(tool_cls)
+                    except Exception:
+                        pass  # Already registered or error
+            except Exception:
+                pass
+
+    provider_instance = ProviderRegistry().get_instance(provider, llm_driver_config)
+    if provider_instance is None:
+        return
+    mode = get_prompt_mode(args)
+    if getattr(args, "verbose", False):
+        print_verbose_info(
+            "Active LLMDriverConfig (after provider)", llm_driver_config, style="green"
+        )
+        print_verbose_info("Agent role", agent_role, style="green")
+    if mode == "single_shot":
+        from janito.cli.single_shot_mode.handler import (
+            PromptHandler as SingleShotPromptHandler,
+        )
+
+        # DEBUG: Print exec_enabled propagation at runner
+        
+        handler = SingleShotPromptHandler(
+            args, provider_instance, llm_driver_config, role=agent_role, exec_enabled=exec_enabled
+        )
+        handler.handle()
+    else:
+        from janito.cli.chat_mode.session import ChatSession
+        from rich.console import Console
+
+        console = Console()
+        session = ChatSession(
+            console,
+            provider_instance,
+            llm_driver_config,
+            role=agent_role,
+            args=args,
+            verbose_tools=verbose_tools,
+            verbose_agent=getattr(args, "verbose_agent", False),
+            exec_enabled=exec_enabled,
+        )
+        session.run()
+
+
+def get_prompt_mode(args):
+    return "single_shot" if getattr(args, "user_prompt", None) else "chat_mode"

janito/cli/core/setters.py

@@ -37,10 +37,14 @@ def handle_set(args, config_mgr=None):
             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)
         print(
-            f"Error: Unknown config key '{key}'. Supported: provider, model, <provider>.model, max_tokens, base_url, <provider>.max_tokens, <provider>.base_url, <provider>.<model>.max_tokens, <provider>.<model>.base_url"
+            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"
         )
         return True
     except Exception as e:

janito/cli/main_cli.py

@@ -1,4 +1,5 @@
 import argparse
+import sys
 import enum
 from janito.cli.core.setters import handle_api_key_set, handle_set
 from janito.cli.core.getters import handle_getter
@@ -118,6 +119,13 @@ definition = [
             "help": "Port for the termweb server (default: 8088)",
         },
     ),
+    (["--effort"],
+        {
+            "choices": ["low", "medium", "high", "none"],
+            "default": None,
+            "help": "Set the reasoning effort for models that support it (low, medium, high, none)",
+        },
+    ),
     (["user_prompt"], {"nargs": argparse.REMAINDER, "help": "Prompt to submit"}),
     (
         ["-e", "--event-log"],
@@ -138,6 +146,7 @@ MODIFIER_KEYS = [
     "role",
     "system",
     "temperature",
+
     "verbose",
     "raw",
     "web",
@@ -238,7 +247,7 @@ class JanitoCLI:
             print(
                 "Error: No provider selected and no provider found in config. Please set a provider using '-p PROVIDER', '--set provider=name', or configure a provider."
             )
-            return
+            sys.exit(1)
         modifiers = self.collect_modifiers()
         self._maybe_print_verbose_modifiers(modifiers)
         setup_event_logger_if_needed(self.args)
@@ -251,6 +260,8 @@ class JanitoCLI:
         self._maybe_print_verbose_llm_config(llm_driver_config, run_mode)
         if run_mode == RunMode.RUN:
             self._maybe_print_verbose_run_mode()
+            # DEBUG: Print exec_enabled propagation at main_cli
+            
             handle_runner(
                 self.args,
                 provider,

janito/cli/prompt_core.py

@@ -8,7 +8,7 @@ from janito.performance_collector import PerformanceCollector
 from rich.status import Status
 from rich.console import Console
 from typing import Any, Optional, Callable
-from janito.driver_events import RequestStarted, RequestFinished, RequestStatus
+from janito.driver_events import RequestStarted, RequestFinished, RequestStatus, RateLimitRetry
 from janito.tools.tool_events import ToolCallError
 import threading
 from janito.cli.verbose_output import print_verbose_header
@@ -59,13 +59,16 @@ class PromptHandler:
             else:
                 self.console.print(inner_event.result)
             return None
+        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
         if isinstance(inner_event, RequestFinished):
             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"
             )

janito/cli/rich_terminal_reporter.py

@@ -32,17 +32,25 @@ class RichTerminalReporter(EventHandlerBase):
         self._waiting_printed = False
 
     def on_RequestStarted(self, event):
-        # Print waiting message with provider name
+        # Print waiting message with provider and model name
         provider = None
+        model = None
         if hasattr(event, "payload") and isinstance(event.payload, dict):
             provider = event.payload.get("provider_name")
+            model = event.payload.get("model") or event.payload.get("model_name")
         if not provider:
             provider = getattr(event, "provider_name", None)
         if not provider:
             provider = getattr(event, "driver_name", None)
         if not provider:
             provider = "LLM"
-        self.console.print(f"[bold cyan]Waiting for {provider}...[/bold cyan]", end="")
+        if not model:
+            model = getattr(event, "model", None)
+        if not model:
+            model = getattr(event, "model_name", None)
+        if not model:
+            model = "?"
+        self.console.print(f"[bold cyan]Waiting for {provider} (model: {model})...[/bold cyan]", end="")
 
     def on_ResponseReceived(self, event):
         parts = event.parts if hasattr(event, "parts") else None
@@ -58,7 +66,18 @@ class RichTerminalReporter(EventHandlerBase):
     def on_RequestFinished(self, event):
         self.console.print("")  # Print end of line after waiting message
         self._waiting_printed = False
-        response = event.response if hasattr(event, "response") else None
+        response = getattr(event, "response", None)
+        error = getattr(event, "error", None)
+        exception = getattr(event, "exception", None)
+
+        # Print error and exception if present
+        if error:
+            self.console.print(f"[bold red]Error:[/] {error}")
+            self.console.file.flush()
+        if exception:
+            self.console.print(f"[red]Exception:[/] {exception}")
+            self.console.file.flush()
+
         if response is not None:
             if self.raw_mode:
                 self.console.print(Pretty(response, expand_all=True))

janito/cli/single_shot_mode/handler.py

@@ -15,21 +15,31 @@ from janito.cli.console import shared_console
 
 
 class PromptHandler:
-    def __init__(self, args, provider_instance, llm_driver_config, role=None):
+    def __init__(self, args, provider_instance, llm_driver_config, role=None, exec_enabled=False):
         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(
             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,
         )
         # 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
         )

janito/cli/verbose_output.py

@@ -19,7 +19,7 @@ def print_verbose_header(agent, args):
         parts = [
             f"Janito {VERSION}",
             f"Provider: {agent.llm_provider.__class__.__name__}",
-            f"Model: {agent.llm_provider.model_name}{role_part}",
+            (f"Model: {agent.llm_provider.driver_config.extra.get('azure_deployment_name', agent.llm_provider.driver_config.model)}{role_part}" if agent.llm_provider.__class__.__name__ == 'AzureOpenAIProvider' else f"Model: {getattr(agent.llm_provider.driver_config, 'model', '-')}{role_part}"),
             f"Driver: {agent.llm_provider.__class__.__module__.split('.')[-2] if len(agent.llm_provider.__class__.__module__.split('.')) > 1 else agent.llm_provider.__class__.__name__}",
         ]
         if hasattr(args, "think") and args.think: