janito 2.10.0__tar.gz → 2.14.0__tar.gz

{janito-2.10.0 → janito-2.14.0}/CHANGELOG.md

@@ -2,7 +2,50 @@
 
 All notable changes to this project will be documented in this file.
 
-## [Unreleased]
+## [2.12.0] - 2025-08-05
+
+### Added
+- **Enhanced Provider Documentation**: Updated supported-providers-models.md with comprehensive provider information including drivers and dependencies
+- **Improved Driver Listing**: Enhanced list_drivers command with better dependency detection and duplicate removal
+- **Z.AI Provider**: Added ZAIModelDriver with OpenAI SDK compatibility for Z.AI API
+- **Google Gemini Provider**: Added support for Gemini Pro and Gemini 1.5 Pro models via OpenAI-compatible API
+- **DeepSeek Provider**: Added support for deepseek-chat and deepseek-coder models via OpenAI-compatible API
+- **Alibaba Provider**: Added support for qwen-turbo, qwen-plus, qwen-max, and qwen3-coder-plus models via OpenAI-compatible API
+- **MoonshotAI Provider**: Enhanced with additional models and OpenAI-compatible API support
+- **Azure OpenAI Provider**: Added support for GPT-4o and GPT-4o-mini models
+
+### Changed
+- **CLI Core**: Updated getter functions to exit after execution for better CLI behavior
+- **Driver Architecture**: Enhanced ZAI driver to use OpenAI SDK instead of Z.AI SDK for better compatibility
+- **Dependency Management**: Improved dependency detection in list_drivers command with duplicate removal
+- **Provider Registry**: Enhanced provider information display with driver names and dependency status
+- **Model Support**: Updated all providers to use OpenAI-compatible API where applicable, expanding model availability
+
+### Fixed
+- **Driver Configuration**: Fixed AttributeError in ZAI provider by initializing _driver_config properly
+- **Import Handling**: Added proper import error handling for optional dependencies in ZAI driver
+- **CLI Integration**: Fixed list_drivers integration into main CLI flow
+
+## [2.11.0] - 2025-08-04
+
+### Added
+
+- **Z.AI Provider**: Added complete support for Z.AI with GLM-4.5, GLM-4, and GLM-4V models
+  - GLM-4.5: 128k context with thinking support for advanced reasoning
+  - GLM-4: General-purpose model with 128k context
+  - GLM-4V: Vision model for image understanding with 128k context
+- **Alibaba Cloud Provider**: Added support for Alibaba Cloud's Qwen models
+  - qwen-turbo, qwen-plus, qwen-max, and qwen3-coder-plus models
+- Updated supported providers documentation to include new Z.AI and Alibaba Cloud providers
+
+### Changed
+
+- Enhanced provider registry with new visual indicators and improved model listing
+- Updated documentation to reflect new provider additions and model availability
+
+### Removed
+
+- Removed deprecated PROVIDERS.md file from janito/docs (content merged into supported-providers-models.md)
 
 ## [2.9.0] - 2025-07-16
 ### Added

{janito-2.10.0/janito.egg-info → janito-2.14.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: janito
-Version: 2.10.0
+Version: 2.14.0
 Summary: A new Python package called janito.
 Author-email: João Pinto <janito@ikignosis.org>
 Project-URL: Homepage, https://github.com/ikignosis/janito

{janito-2.10.0 → janito-2.14.0}/docs/guides/terminal-shell.md

@@ -32,6 +32,7 @@ You can use these commands at any time (prefix with `/` or just type the name):
 | `/lang <code>`         | Change the interface language (e.g., `/lang pt`, `/lang en`)      |
 | `/clear`               | Clear the terminal screen                                        |
 | `/multi`               | Enter multiline input mode (write multi-line text, Esc+Enter)    |
+| `--multi` (CLI arg)    | Start chat mode with multiline input as default (no need for /multi) |
 | `/config`              | Show or set configuration (see: `/config show`, `/config set local|global key=value`) |
 | `/edit <filename>`     | Open a file in the browser-based editor                          |
 | `/view`                | Print the current LLM conversation history                       |

{janito-2.10.0 → janito-2.14.0}/docs/index.md

@@ -21,5 +21,6 @@ Janito is a lightweight language model client focused on software development ac
 - [What Is a Language Model Client?](concepts/language-model-clients.md) — Thin vs. Thick Clients explained
 - [Configuring Janito for DeepSeek](deepseek-setup.md) — How to set up and use DeepSeek models
 - [Configuring Janito for MoonshotAI](moonshotai-setup.md) — How to set up and use MoonshotAI models
+- [Configuring Janito for Z.ai](z-ai-setup.md) — How to set up and use Z.ai models
 - **Concepts & Terminology:** See the [concepts](concepts/index.md) section for more foundational explanations.
 

{janito-2.10.0 → janito-2.14.0}/docs/reference/cli-options.md

@@ -20,6 +20,7 @@ These options are useful for one-off runs, scripting, or experimentation. They t
 | `--verbose-agent` | Print info messages for agent event and message part handling. |
 | `-z`, `--zero` | IDE zero mode: disables system prompt & all tools for raw LLM interaction |
 | `-u`, `--unrestricted-paths` | Disable path security: allow tool arguments to use any file/directory path (DANGEROUS). See [Security](../security.md) for details. |
+| `--multi` | Start chat mode with multiline input as default (no need for /multi command) |
 | `-r`, `--read` | Enable tools that require read permissions (default: off) |
 | `-w`, `--write` | Enable tools that require write permissions (default: off) |
 | `-x`, `--exec` | Enable execution/run tools (allows running code or shell tools from the CLI). (default: off) |
@@ -50,7 +51,7 @@ janito [options] [prompt]
 janito -p openai -m gpt-3.5-turbo "Your prompt here"
 janito -c myproject -p openai "Prompt for my project (uses ~/.janito/configs/myproject.json)"
 janito --list-tools
-janito --web  # Enable clickable file links via web viewer
+janito --multi  # Start chat mode with multiline input as default
 janito -u -x --read --write "Run a tool with unrestricted paths (DANGEROUS)"
 ```
 

janito-2.14.0/docs/supported-providers-models.md

@@ -0,0 +1,95 @@
+# Supported Providers and Models
+
+This page lists the supported providers and their available models.
+
+## OpenAI
+
+- **Driver**: OpenAIModelDriver  
+- **Dependencies**: ✅ openai
+
+**Models:**
+
+- GPT-3.5 Turbo
+- GPT-4
+- GPT-4 Turbo
+- GPT-4o
+- GPT-4o-mini
+
+## Azure OpenAI
+
+- **Driver**: AzureOpenAIModelDriver  
+- **Dependencies**: ✅ openai
+
+**Models:**
+
+- GPT-4o
+- GPT-4o-mini
+- GPT-4 Turbo
+
+## Anthropic
+
+- **Driver**: OpenAIModelDriver (via OpenAI-compatible API)  
+- **Dependencies**: ✅ openai
+
+**Models:**
+
+- Claude 3.7 Sonnet (claude-3-7-sonnet-20250219)
+- Claude 3.5 Sonnet (claude-3-5-sonnet-20241022)
+- Claude 3.5 Haiku (claude-3-5-haiku-20241022)
+- Claude 3 Opus (claude-3-opus-20240229)
+- Claude 3 Haiku (claude-3-haiku-20240307)
+
+## Z.AI
+
+- **Driver**: ZAIModelDriver  
+- **Dependencies**: ❌ zai (install with `pip install zai`)
+
+**Models:**
+
+- glm-4.5
+- glm-4.5-air
+
+## MoonshotAI
+
+- **Driver**: OpenAIModelDriver (via OpenAI-compatible API)  
+- **Dependencies**: ✅ openai
+
+**Models:**
+
+- kimi-k2-turbo-preview
+- kimi-k1-8k
+- kimi-k1-32k
+- kimi-k1-128k
+
+## Alibaba
+
+- **Driver**: OpenAIModelDriver (via OpenAI-compatible API)  
+- **Dependencies**: ✅ openai
+
+**Models:**
+
+- qwen-turbo
+- qwen-plus
+- qwen-max
+- qwen3-coder-plus
+- qwen3-coder-480b-a35b-instruct
+
+## Google Gemini
+
+- **Driver**: OpenAIModelDriver (via OpenAI-compatible API)  
+- **Dependencies**: ✅ openai
+
+**Models:**
+
+- Gemini Pro
+- Gemini 1.5 Pro
+
+## DeepSeek
+
+- **Driver**: OpenAIModelDriver (via OpenAI-compatible API)  
+- **Dependencies**: ✅ openai
+
+**Models:**
+
+- deepseek-chat
+- deepseek-coder

janito-2.14.0/docs/z-ai-setup.md

@@ -0,0 +1,83 @@
+# Z.ai API Setup Guide
+
+This guide explains how to set up and use Z.ai's API with your API key.
+
+## Getting Your API Key
+
+1. Visit [Z.ai API Management](https://z.ai/manage-apikey/apikey-list)
+2. Log in to your Z.ai account
+3. Navigate to the API Keys section
+4. Create a new API key if you don't have one yet
+
+## API Key Format
+
+Z.ai uses a new key format that includes both a user ID and secret:
+```
+{id}.{secret}
+```
+
+**Important Security Notes:**
+
+- Never share your API keys
+- Do not expose keys in browsers or client-side code
+- Leaked keys may be automatically regenerated for security
+- Store keys securely in environment variables or secure vaults
+
+## Setting Up Your Environment
+
+### Environment Variable (Recommended)
+
+Set your API key as an environment variable:
+
+**Linux/macOS:**
+```bash
+export ZAI_API_KEY="your-id.your-secret"
+```
+
+**Windows (Command Prompt):**
+```cmd
+set ZAI_API_KEY=your-id.your-secret
+```
+
+**Windows (PowerShell):**
+```powershell
+$env:ZAI_API_KEY="your-id.your-secret"
+```
+
+### Configuration File
+
+You can also store your API key in a configuration file (ensure proper file permissions):
+
+```json
+{
+  "zai_api_key": "your-id.your-secret"
+}
+```
+
+## Rate Limits and Billing
+
+- Check your [API Management dashboard](https://z.ai/manage-apikey/apikey-list) for current rate limits
+- Monitor your usage and billing information
+- Contact support for API recharge if needed
+
+## Support
+
+For API-related support:
+
+- Visit [Z.ai Contact](https://z.ai/contact) for product support
+- Join the [Discord community](https://z.ai/contact) to chat with developers
+- Check the [API documentation](https://z.ai/model-api) for model-specific details
+
+## Available Models
+
+Z.ai provides several models including:
+
+- **GLM-4.5**: Latest flagship model with reasoning, coding, and agent functionalities
+- **GLM-4.5-Air**: Lightweight flagship model with cost-effectiveness
+- **GLM-4.5-Flash**: Most advanced free model
+- **GLM-4-32B-0414-128K**: General-purpose LLM for business and technical domains
+- **CogVideoX-3**: Text-to-video model for high-fidelity motion
+- **Vidu Q1**: High-fidelity 1080p video generation
+- **Vidu 2**: Fast, low-cost 720p video generation
+
+For complete model specifications and capabilities, visit [Z.ai Models](https://z.ai/model-api).

{janito-2.10.0 → janito-2.14.0}/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-2.10.0 → janito-2.14.0}/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-2.14.0/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-2.10.0 → janito-2.14.0}/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-2.14.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-2.10.0 → janito-2.14.0}/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-2.10.0 → janito-2.14.0}/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-2.10.0 → janito-2.14.0}/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-2.14.0/janito/drivers/zai/__init__.py

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