janito 2.10.0__py3-none-any.whl → 2.14.0__py3-none-any.whl

janito/agent/setup_agent.py

@@ -12,7 +12,7 @@ from queue import Queue
 from rich import print as rich_print
 from janito.tools import get_local_tools_adapter
 from janito.llm.agent import LLMAgent
-from janito.drivers.driver_registry import get_driver_class
+
 from janito.platform_discovery import PlatformDiscovery
 from janito.tools.tool_base import ToolPermissions
 from janito.tools.permissions import get_global_allowed_permissions

janito/cli/chat_mode/session.py

@@ -109,6 +109,9 @@ class ChatSession:
         )
         self._support = False
 
+        # Check if multi-line mode should be enabled by default
+        self.multi_line_mode = getattr(args, "multi", False) if args else False
+
     def _select_profile_and_role(self, args, role):
         profile = getattr(args, "profile", None) if args is not None else None
         role_arg = getattr(args, "role", None) if args is not None else None
@@ -213,6 +216,11 @@ class ChatSession:
             f"[green]Working Dir:[/green] {cwd_display}  |  {priv_status}"
         )
 
+        if self.multi_line_mode:
+            self.console.print(
+                "[blue]Multi-line input mode enabled (Esc+Enter or Ctrl+D to submit)[/blue]"
+            )
+
         from janito.cli.chat_mode.shell.commands._priv_check import (
             user_has_any_privileges,
         )
@@ -305,6 +313,7 @@ class ChatSession:
             bottom_toolbar=lambda: get_toolbar_func(
                 self.performance_collector, 0, self.shell_state
             )(),
+            multiline=self.multi_line_mode,
         )
 
     def _handle_input(self, session):

janito/cli/cli_commands/list_drivers.py

@@ -0,0 +1,137 @@
+"""
+CLI Command: List available LLM drivers and their dependencies
+"""
+
+import importlib
+import sys
+from pathlib import Path
+from rich.console import Console
+from rich.table import Table
+from rich.panel import Panel
+from rich.text import Text
+
+console = Console()
+
+
+def get_driver_info():
+    """Get information about all available drivers."""
+    drivers = []
+    
+    # Define known driver modules
+    driver_modules = [
+        ("janito.drivers.openai.driver", "OpenAIModelDriver"),
+        ("janito.drivers.azure_openai.driver", "AzureOpenAIModelDriver"),
+        ("janito.drivers.zai.driver", "ZAIModelDriver"),
+    ]
+    
+    for module_path, class_name in driver_modules:
+        try:
+            # Import the module
+            module = importlib.import_module(module_path)
+            driver_class = getattr(module, class_name)
+            
+            # Get availability info
+            available = getattr(driver_class, 'available', True)
+            unavailable_reason = getattr(driver_class, 'unavailable_reason', None)
+            
+            # Get dependencies from module imports
+            dependencies = []
+            module_file = Path(module.__file__)
+            
+            # Read module file to detect imports
+            with open(module_file, 'r', encoding='utf-8') as f:
+                content = f.read()
+                
+            # Simple dependency detection
+            if 'import openai' in content or 'from openai' in content:
+                dependencies.append('openai')
+            if 'import zai' in content or 'from zai' in content:
+                dependencies.append('zai')
+            if 'import anthropic' in content or 'from anthropic' in content:
+                dependencies.append('anthropic')
+            if 'import google' in content or 'from google' in content:
+                dependencies.append('google-generativeai')
+            
+
+            
+            # Remove duplicates while preserving order
+            seen = set()
+            dependencies = [dep for dep in dependencies if not (dep in seen or seen.add(dep))]
+            
+            # Check if dependencies are available
+            dep_status = []
+            for dep in dependencies:
+                try:
+                    importlib.import_module(dep)
+                    dep_status.append(f"✅ {dep}")
+                except ImportError:
+                    dep_status.append(f"❌ {dep}")
+            
+            if not dependencies:
+                dep_status = ["No external dependencies"]
+            
+            drivers.append({
+                'name': class_name,
+                'available': available,
+                'reason': unavailable_reason,
+                'dependencies': dep_status
+            })
+            
+        except (ImportError, AttributeError) as e:
+            drivers.append({
+                'name': class_name,
+                'module': module_path,
+                'available': False,
+                'reason': str(e),
+                'dependencies': ["❌ Module not found"]
+            })
+    
+    return drivers
+
+
+def handle_list_drivers(args=None):
+    """List all available LLM drivers with their status and dependencies."""
+    drivers = get_driver_info()
+    
+    if not drivers:
+        console.print("[red]No drivers found[/red]")
+        return
+    
+    # Create table
+    table = Table(title="Available LLM Drivers")
+    table.add_column("Driver", style="cyan", no_wrap=True)
+    table.add_column("Status", style="bold")
+    table.add_column("Dependencies", style="yellow")
+    
+    for driver in drivers:
+        name = driver['name']
+        
+        if driver['available']:
+            status = "[green]✅ Available[/green]"
+            if driver['reason']:
+                status = f"[yellow]⚠️ Available ({driver['reason']})[/yellow]"
+        else:
+            status = f"[red]❌ Unavailable[/red]"
+            if driver['reason']:
+                status = f"[red]❌ {driver['reason']}[/red]"
+        
+        deps = "\n".join(driver['dependencies'])
+        
+        table.add_row(name, status, deps)
+    
+    console.print(table)
+    
+    # Installation help
+    # Get unique missing dependencies
+    missing_deps = set()
+    for driver in drivers:
+        for dep_status in driver['dependencies']:
+            if dep_status.startswith('❌'):
+                missing_deps.add(dep_status[2:].strip())
+    
+    if missing_deps:
+        console.print(f"\n[dim]💡 Install missing deps: pip install {' '.join(sorted(missing_deps))}[/dim]")
+
+
+if __name__ == "__main__":
+    handle_list_drivers()

janito/cli/core/getters.py

@@ -7,6 +7,7 @@ from janito.cli.cli_commands.list_models import handle_list_models
 from janito.cli.cli_commands.list_tools import handle_list_tools
 from janito.cli.cli_commands.show_config import handle_show_config
 from janito.cli.cli_commands.list_config import handle_list_config
+from janito.cli.cli_commands.list_drivers import handle_list_drivers
 from functools import partial
 from janito.provider_registry import ProviderRegistry
 
@@ -17,6 +18,7 @@ GETTER_KEYS = [
     "list_models",
     "list_tools",
     "list_config",
+    "list_drivers",
 ]
 
 
@@ -42,7 +44,10 @@ def handle_getter(args, config_mgr=None):
         "list_profiles": partial(handle_list_profiles, args),
         "show_config": partial(handle_show_config, args),
         "list_config": partial(handle_list_config, args),
+        "list_drivers": partial(handle_list_drivers, args),
     }
     for arg in GETTER_KEYS:
         if getattr(args, arg, False) and arg in GETTER_DISPATCH:
-            return GETTER_DISPATCH[arg]()
+            GETTER_DISPATCH[arg]()
+            import sys
+            sys.exit(0)

janito/cli/core/model_guesser.py

@@ -0,0 +1,51 @@
+"""
+Module for guessing the provider based on model names.
+"""
+
+from janito.providers.registry import LLMProviderRegistry
+
+
+def guess_provider_from_model(model_name: str) -> str:
+    """
+    Guess the provider based on the model name.
+    
+    Args:
+        model_name: The name of the model to guess the provider for
+        
+    Returns:
+        The provider name if a match is found, None otherwise
+    """
+    if not model_name:
+        return None
+    
+    model_name = model_name.lower()
+    
+    # Check each provider's models
+    for provider_name in LLMProviderRegistry.list_providers():
+        provider_class = LLMProviderRegistry.get(provider_name)
+        if not provider_class:
+            continue
+            
+        # Get model specs for this provider
+        try:
+            if hasattr(provider_class, 'MODEL_SPECS'):
+                model_specs = provider_class.MODEL_SPECS
+                for spec_model_name in model_specs.keys():
+                    if spec_model_name.lower() == model_name:
+                        return provider_name
+            
+            # Handle special cases like moonshotai
+            if provider_name == "moonshotai":
+                try:
+                    from janito.providers.moonshotai.model_info import MOONSHOTAI_MODEL_SPECS
+                    for spec_model_name in MOONSHOTAI_MODEL_SPECS.keys():
+                        if spec_model_name.lower() == model_name:
+                            return "moonshotai"
+                except ImportError:
+                    pass
+                    
+        except Exception:
+            # Skip providers that have issues accessing model specs
+            continue
+    
+    return None

janito/cli/core/runner.py

@@ -2,6 +2,7 @@
 
 from janito.llm.driver_config import LLMDriverConfig
 from janito.provider_config import get_config_provider
+from janito.cli.core.model_guesser import guess_provider_from_model as _guess_provider_from_model
 from janito.cli.verbose_output import print_verbose_info
 
 
@@ -14,6 +15,17 @@ def _choose_provider(args):
                 "Default provider", provider, style="magenta", align_content=True
             )
         elif provider is None:
+            # Try to guess provider based on model name if -m is provided
+            model = getattr(args, "model", None)
+            if model:
+                guessed_provider = _guess_provider_from_model(model)
+                if guessed_provider:
+                    if getattr(args, "verbose", False):
+                        print_verbose_info(
+                            "Guessed provider", guessed_provider, style="magenta", align_content=True
+                        )
+                    return guessed_provider
+            
             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."
             )
@@ -191,4 +203,4 @@ def handle_runner(
 
 
 def get_prompt_mode(args):
-    return "single_shot" if getattr(args, "user_prompt", None) else "chat_mode"
+    return "single_shot" if getattr(args, "user_prompt", None) else "chat_mode"

janito/cli/main_cli.py

@@ -21,6 +21,13 @@ definition = [
             "help": "Disable path security: allow tool arguments to use any file/directory path (DANGEROUS)",
         },
     ),
+    (
+        ["--multi"],
+        {
+            "action": "store_true",
+            "help": "Start chat mode with multi-line input as default (no need for /multi command)",
+        },
+    ),
     (
         ["--profile"],
         {
@@ -110,6 +117,10 @@ definition = [
         ["--list-providers"],
         {"action": "store_true", "help": "List supported LLM providers"},
     ),
+    (
+        ["--list-drivers"],
+        {"action": "store_true", "help": "List available LLM drivers and their dependencies"},
+    ),
     (
         ["-l", "--list-models"],
         {"action": "store_true", "help": "List all supported models"},
@@ -199,6 +210,7 @@ GETTER_KEYS = [
     "list_models",
     "list_tools",
     "list_config",
+    "list_drivers",
 ]
 
 
@@ -314,14 +326,8 @@ class JanitoCLI:
         if run_mode == RunMode.SET:
             if self._run_set_mode():
                 return
-        # Special handling: provider is not required for list_providers, list_tools, show_config
-        if run_mode == RunMode.GET and (
-            self.args.list_providers
-            or self.args.list_tools
-            or self.args.list_profiles
-            or self.args.show_config
-            or self.args.list_config
-        ):
+        # Special handling: provider is not required for list_providers, list_tools, show_config, list_drivers
+        if run_mode == RunMode.GET:
             self._maybe_print_verbose_provider_model()
             handle_getter(self.args)
             return
@@ -357,8 +363,7 @@ class JanitoCLI:
                 agent_role,
                 verbose_tools=self.args.verbose_tools,
             )
-        elif run_mode == RunMode.GET:
-            handle_getter(self.args)
+
 
     def _run_set_mode(self):
         if handle_api_key_set(self.args):

janito/drivers/openai/driver.py

@@ -44,9 +44,10 @@ class OpenAIModelDriver(LLMDriver):
 
                 tool_classes = self.tools_adapter.get_tool_classes()
                 tool_schemas = generate_tool_schemas(tool_classes)
-                api_kwargs["tools"] = tool_schemas
+                if tool_schemas:  # Only add tools if we have actual schemas
+                    api_kwargs["tools"] = tool_schemas
             except Exception as e:
-                api_kwargs["tools"] = []
+                # Don't add empty tools array - some providers reject it
                 if hasattr(config, "verbose_api") and config.verbose_api:
                     print(f"[OpenAIModelDriver] Tool schema generation failed: {e}")
         # OpenAI-specific parameters

janito/drivers/zai/__init__.py

@@ -0,0 +1 @@
+# Z.AI driver package