janito 2.18.0__tar.gz → 2.19.1__tar.gz

{janito-2.18.0 → janito-2.19.1}/CHANGELOG.md

@@ -2,7 +2,25 @@
 
 All notable changes to this project will be documented in this file.
 
-## [Unreleased]
+## [2.19.0] - 2025-08-08
+
+### Added
+
+- **Alibaba Cloud Provider**: Added support for new Qwen3 1M context models
+  - `qwen3-235b-a22b-thinking-2507`: 1M context thinking model
+  - `qwen3-235b-a22b-instruct-2507`: 1M context instruct model
+  - `qwen3-30b-a3b-thinking-2507`: 1M context thinking model
+  - `qwen3-30b-a3b-instruct-2507`: 1M context instruct model
+- **Thinking Mode Support**: Added thinking mode indicators (📖) for models that support chain-of-thought reasoning
+- **Default Model Highlighting**: Added star (⭐) indicators to highlight default models in provider listings
+- **Provider Connectivity Testing**: Added `--ping` flag to test connectivity with all providers when used with `--list-providers`
+- **Enhanced Model Display**: Improved model listing with better formatting of context sizes and response limits
+
+### Changed
+
+- **Alibaba Cloud Provider**: Updated default model from `qwen3-coder-plus` to `qwen3-235b-a22b-instruct-2507` (129k context)
+- **Model Information**: Added thinking mode support tracking in LLMModelInfo class
+- **Documentation**: Updated Alibaba setup guide with comprehensive configuration instructions
 
 ## [2.18.0] - 2025-08-07
 

{janito-2.18.0 → janito-2.19.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: janito
-Version: 2.18.0
+Version: 2.19.1
 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.19.1/docs/alibaba-setup.md

@@ -0,0 +1,70 @@
+# Alibaba Cloud Qwen Setup Guide
+
+This guide explains how to set up the Alibaba Cloud Qwen provider for Janito.
+
+## Prerequisites
+
+- An Alibaba Cloud account
+- Access to the Alibaba Cloud Qwen model service
+- API key for authentication
+
+## Getting Your API Key
+
+1. Log in to your [Alibaba Cloud account](https://account.alibabacloud.com)
+2. Navigate to the **Qwen Model Service** in the console
+3. Go to **API Keys** or **Security Settings**
+4. Create a new API key or use an existing one
+5. Copy the API key value
+
+## Setting Up the API Key
+
+You can set your API key using the Janito CLI:
+
+```bash
+janito --set-api-key alibaba:your-api-key-here
+```
+
+Alternatively, you can set the environment variable:
+
+```bash
+export ALIBABA_API_KEY=your-api-key-here
+```
+
+## Configuration
+
+The Alibaba provider uses the following environment variable:
+
+- `ALIBABA_API_KEY`: Your Alibaba Cloud API key
+
+## Available Models
+
+The Alibaba provider supports the following models:
+
+- `qwen-turbo`: Fast, lightweight model for simple tasks
+- `qwen-plus`: Balanced performance and capability
+- `qwen-max`: Most capable model for complex tasks
+- `qwen3-coder-plus`: Coding-focused model with 128k context
+- `qwen3-coder-480b-a35b-instruct`: Advanced coding model
+- `qwen3-235b-a22b-thinking-2507`: 1M context thinking model
+- `qwen3-235b-a22b-instruct-2507`: 1M context instruct model
+- `qwen3-30b-a3b-thinking-2507`: 1M context thinking model
+- `qwen3-30b-a3b-instruct-2507`: 1M context instruct model
+
+## Default Model
+
+The default model is `qwen3-235b-a22b-instruct-2507`, which provides 129k context and is suitable for general-purpose tasks.
+
+## Troubleshooting
+
+**Q: I'm getting authentication errors**
+A: Verify your API key is correct and has the necessary permissions in the Alibaba Cloud console.
+
+**Q: The model is not responding**
+A: Check your internet connection and verify the Alibaba Cloud Qwen service is available in your region.
+
+**Q: I want to use a different model**
+A: Use the `--model` flag when running Janito:
+
+```bash
+janito --provider alibaba --model qwen-max
+```

janito-2.19.1/docs/index.md

@@ -0,0 +1,53 @@
+# Janito Documentation
+
+Welcome to the Janito documentation! This site contains comprehensive guides, tutorials, and reference materials for using and extending Janito.
+
+## What is Janito?
+
+Janito is a powerful AI assistant designed for developers, providing intelligent code assistance, terminal integration, and extensible tooling capabilities.
+
+## Quick Start
+
+- [**Installation Guide**](guides/installation.md) - Get Janito up and running
+- [**Quickstart & Basic Usage**](guides/using.md) - Learn the basics
+- [**Configuration**](guides/configuration.md) - Set up Janito for your needs
+
+## Key Features
+
+- **Terminal Integration**: Seamless shell integration with intelligent command assistance
+- **Code Intelligence**: Advanced code analysis and generation capabilities
+- **Extensible Tools**: Custom tool development and integration
+- **Multi-Provider Support**: Works with OpenAI, DeepSeek, MoonshotAI, and more
+- **Human-Guided AI**: Collaborative AI that works with you, not instead of you
+
+## Documentation Sections
+
+### Using Janito
+Learn how to use Janito effectively:
+- [Terminal Shell](guides/terminal-shell.md) - Interactive terminal sessions
+- [Single-Shot Commands](guides/single-shot-terminal.md) - One-off command execution
+- [Profiles](guides/profiles.md) - Custom configurations for different workflows
+
+### Development & Extension
+For developers looking to extend Janito:
+- [Developer Guide](guides/developing.md) - Core development concepts
+- [Tools Developer Guide](guides/tools-developer-guide.md) - Creating custom tools
+- [Developer Toolchain](meta/developer-toolchain.md) - Development setup and workflows
+
+### Supported Providers
+Janito supports multiple AI providers:
+- [OpenAI](openai-setup.md)
+- [DeepSeek](deepseek-setup.md)
+- [MoonshotAI](moonshotai-setup.md)
+- [Z.ai](z-ai-setup.md)
+- [Cerebras](cerebras-setup.md)
+
+## Getting Help
+
+- Check our [troubleshooting guides](guides/configuration.md)
+- Review [common issues](guides/using.md)
+- Explore [alternative solutions](alternatives.md)
+
+---
+
+*This documentation is automatically deployed from the latest commit and will always reflect the most current version of Janito.*

janito-2.19.1/docs/overrides/partials/copyright.html

@@ -0,0 +1,6 @@
+<div class="md-copyright" style="text-align: center; width: 100%;">
+  <div class="md-copyright__highlight" style="display: inline-block;">
+    Generated by Janito • 
+    <span style="color: var(--md-accent-fg-color);">{{ config.extra.commit_hash or 'unknown' }}</span>
+  </div>
+</div>

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

@@ -0,0 +1,94 @@
+# Supported Providers and Models
+
+This page lists the supported providers and their available models, organized by openness and sorted alphabetically within each category.
+
+## Open-Source / Open-Weight Models
+
+### Alibaba
+
+- **Qwen3 235B A22B Instruct** (default) - Latest 1M context model
+- **Qwen3 235B A22B Thinking** - Reasoning-focused version
+- **Qwen3 30B A3B Instruct** - Compact 1M context model
+- **Qwen3 30B A3B Thinking** - Compact reasoning version
+- **Qwen3 Coder Plus** - Specialized for programming tasks
+- **Qwen3 Coder 480B** - Large-scale coding model
+- **Qwen Turbo** - High-speed general purpose
+- **Qwen Plus** - Balanced performance
+- **Qwen Max** - Maximum capability
+
+### Cerebras
+
+**Production Models:**
+
+- **Qwen-3 32B** - General instruction following
+
+**Preview Models:**
+
+- **Qwen-3 Coder 480B** - Programming-focused with 32k context
+- **Qwen-3 235B A22B Instruct** - Large-scale instruction model
+- **Qwen-3 235B A22B Thinking** - Reasoning-focused version
+- **GPT-OSS 120B** - Open-source model
+
+**Notes:**
+
+- All Cerebras models support 128k context window
+- Models are optimized for low-latency inference
+- Pricing varies by model size and capability
+
+### DeepSeek
+
+- **DeepSeek Chat** (default) - General purpose chat model
+- **DeepSeek Reasoner** - Specialized for complex reasoning tasks
+
+### MoonshotAI
+
+- **Kimi K2 Turbo Preview** (default) - Latest generation with enhanced performance
+- **Kimi K2 0711 Preview** - Previous preview version
+
+MoonshotAI provides open-source Kimi models with competitive performance.
+
+### Z.AI
+
+- **GLM-4.5** (default) - Advanced reasoning and conversation
+- **GLM-4.5 Air** - Compact and efficient version
+
+## Proprietary Models
+
+### Anthropic
+
+- **Claude 3.7 Sonnet** (default) - Latest Claude model with enhanced reasoning
+- **Claude 4 Opus** - Most capable Claude model (preview)
+- **Claude 4 Sonnet** - Balanced performance and capability (preview)
+- **Claude 3.5 Sonnet** - Previous generation, still highly capable
+- **Claude 3.5 Haiku** - Fast and efficient
+- **Claude 3 Haiku** - Compact and cost-effective
+
+### Google
+
+- **Gemini 2.5 Flash** (default) - Fast and efficient
+- **Gemini 2.5 Pro** - Advanced capabilities with extended context
+- **Gemini 2.5 Flash-Lite Preview** - Lightweight preview version
+
+### OpenAI
+
+- **GPT-5** (default) - Latest generation with advanced reasoning
+- **GPT-5 Mini** - Compact version of GPT-5
+- **GPT-5 Nano** - Ultra-compact version
+- **GPT-4.1** - Enhanced GPT-4 with improved capabilities
+- **GPT-4.1-mini** - Balanced performance and efficiency
+- **GPT-4.1-nano** - Lightweight version
+- **GPT-4 Turbo** - High-performance GPT-4 variant
+- **GPT-4o** - Multimodal GPT-4 optimized for chat
+- **GPT-4o-mini** - Compact multimodal version
+- **o3** - Advanced reasoning model
+- **o3-mini** - Compact reasoning model
+- **o4-mini** - Latest mini reasoning model
+- **GPT-3.5 Turbo** - Cost-effective general purpose
+
+For setup instructions, see the [OpenAI Setup Guide](openai-setup.md).
+
+### Azure OpenAI
+
+- **Azure OpenAI Deployment** - Custom Azure OpenAI deployments
+
+For setup instructions, see [Using Azure OpenAI with Janito](reference/azure-openai.md).

{janito-2.18.0 → janito-2.19.1}/janito/cli/cli_commands/list_models.py

@@ -27,9 +27,23 @@ def handle_list_models(args, provider_instance):
         if models and isinstance(models[0], dict):
             _print_models_table(models, provider_name)
         else:
-            print(f"Supported models for provider '{provider_name}':")
+            # Fallback for simple string model lists
+            from rich.table import Table
+            from janito.cli.console import shared_console
+            
+            table = Table(title=f"Supported models for provider '{provider_name}'")
+            table.add_column("Model Name", style="cyan")
+            
             for m in models:
-                print(f"- {m}")
+                table.add_row(str(m))
+                
+            import sys
+            if sys.stdout.isatty():
+                shared_console.print(table)
+            else:
+                print(f"Supported models for provider '{provider_name}':")
+                for m in models:
+                    print(f"- {m}")
     except Exception as e:
         print(f"Error listing models for provider '{provider_name}': {e}")
     return

janito-2.19.1/janito/cli/cli_commands/list_providers.py

@@ -0,0 +1,15 @@
+"""
+CLI Command: List supported LLM providers
+"""
+
+from janito.provider_registry import list_providers
+from janito.cli.cli_commands.ping_providers import handle_ping_providers
+
+
+def handle_list_providers(args=None):
+    # Check if ping flag is set
+    if args and getattr(args, 'ping', False):
+        handle_ping_providers(args)
+    else:
+        list_providers()
+    return

janito-2.19.1/janito/cli/cli_commands/model_utils.py

@@ -0,0 +1,117 @@
+"""
+Utilities for model-related CLI output
+"""
+
+
+def _print_models_table(models, provider_name):
+    from rich.table import Table
+    from janito.cli.console import shared_console
+
+    table = Table(title=f"Supported models for provider '{provider_name}'")
+    table.add_column("Model Name", style="cyan")
+    table.add_column("Vendor", style="yellow", justify="center")
+    table.add_column("Context", style="magenta", justify="center")
+    table.add_column("Max Input", style="green", justify="center")
+    table.add_column("CoT", style="blue", justify="center")
+    table.add_column("Max Response", style="red", justify="center")
+    table.add_column("Thinking", style="bright_black", justify="center")
+    table.add_column("Driver", style="white")
+
+    # Get default model for this provider
+    from janito.providers.registry import LLMProviderRegistry
+    try:
+        provider_class = LLMProviderRegistry.get(provider_name)
+        default_model = getattr(provider_class, "DEFAULT_MODEL", None)
+    except:
+        default_model = None
+    
+    for m in models:
+        name = str(m.get("name", ""))
+        
+        # Highlight default model with different color
+        if name == default_model:
+            name = f"[bold green]⭐ {name}[/bold green]"
+        
+        vendor = "Open" if m.get("open") is True or m.get("open") == "Open" else "Locked"
+        
+        context = _format_context(m.get("context", ""))
+        max_input = _format_k(m.get("max_input", ""))
+        max_cot = _format_k(m.get("max_cot", ""))
+        max_response = _format_k(m.get("max_response", ""))
+        
+        # Determine thinking indicators
+        thinking_supported = m.get("thinking_supported") is True or m.get("thinking_supported") == "True"
+        cot_value = m.get("max_cot", "")
+        
+        thinking_icon = "📖" if thinking_supported and m.get("thinking", False) else ""
+        # Only show CoT value if it's a valid number and thinking is supported
+        cot_display = ""
+        if thinking_supported and cot_value and str(cot_value).lower() != "n/a":
+            cot_display = _format_k(cot_value)
+        
+        driver = _format_driver(m.get("driver", ""))
+        
+        table.add_row(name, vendor, context, max_input, cot_display, max_response, thinking_icon, driver)
+
+    import sys
+    if sys.stdout.isatty():
+        shared_console.print(table)
+    else:
+        # ASCII-friendly fallback table when output is redirected
+        print(f"Supported models for provider '{provider_name}'")
+        print("Model Name | Vendor | Context | Max Input | CoT | Max Response | Thinking | Driver")
+        
+        # Get default model for fallback
+        from janito.providers.registry import LLMProviderRegistry
+        try:
+            provider_class = LLMProviderRegistry.get(provider_name)
+            default_model = getattr(provider_class, "DEFAULT_MODEL", None)
+        except:
+            default_model = None
+            
+        for m in models:
+            name = str(m.get("name", ""))
+            if name == default_model:
+                name = f"⭐ {name} (default)"
+            
+            vendor = "Open" if m.get("open") is True or m.get("open") == "Open" else "Locked"
+            context = _format_context(m.get("context", ""))
+            max_input = _format_k(m.get("max_input", ""))
+            max_cot = _format_k(m.get("max_cot", ""))
+            max_response = _format_k(m.get("max_response", ""))
+            thinking_supported = m.get("thinking_supported") is True or m.get("thinking_supported") == "True"
+            cot_value = m.get("max_cot", "")
+            
+            thinking = "Y" if thinking_supported and m.get("thinking", False) else ""
+            cot_display = ""
+            if thinking_supported and cot_value and str(cot_value).lower() != "n/a":
+                cot_display = _format_k(cot_value)
+            
+            driver = _format_driver(m.get("driver", ""))
+            print(f"{name} | {vendor} | {context} | {max_input} | {cot_display} | {max_response} | {thinking} | {driver}")
+
+
+def _format_k(val):
+    """Format numeric values with k suffix for thousands."""
+    try:
+        n = int(val)
+        if n >= 1000:
+            return f"{n // 1000}k"
+        return str(n)
+    except Exception:
+        return str(val)
+
+
+def _format_context(val):
+    """Format context field which might be a single value or range."""
+    if isinstance(val, (list, tuple)) and len(val) == 2:
+        return f"{_format_k(val[0])} / {_format_k(val[1])}"
+    return _format_k(val)
+
+
+def _format_driver(val):
+    """Format driver name by removing ModelDriver suffix."""
+    if isinstance(val, (list, tuple)):
+        return ", ".join(val)
+    val_str = str(val)
+    return val_str.removesuffix("ModelDriver").strip()

janito-2.19.1/janito/cli/cli_commands/ping_providers.py

@@ -0,0 +1,55 @@
+from janito.provider_registry import list_providers
+from janito.providers.registry import LLMProviderRegistry
+from janito.cli.console import shared_console
+from rich.table import Table
+from rich.progress import Progress, SpinnerColumn, TextColumn
+import asyncio
+import time
+
+
+def handle_ping_providers(args):
+    """Ping/test connectivity for all providers."""
+    try:
+        # Get all providers
+        providers = list_providers()
+        
+        # Create table for results
+        table = Table(title="Provider Connectivity Test")
+        table.add_column("Provider", style="cyan")
+        table.add_column("Status", style="magenta")
+        table.add_column("Time", style="green")
+        table.add_column("Details", style="yellow")
+        
+        # Test each provider
+        for provider_name in providers:
+            start_time = time.time()
+            try:
+                # Get provider class
+                provider_class = LLMProviderRegistry.get(provider_name)
+                provider = provider_class()
+                
+                # Test the provider (simplified - just check if we can instantiate and get models)
+                models = provider.get_models()
+                if models:
+                    status = "✓ Connected"
+                    details = f"{len(models)} models available"
+                else:
+                    status = "⚠ No models"
+                    details = "Provider reachable but no models returned"
+                
+            except Exception as e:
+                status = "✗ Failed"
+                details = str(e)
+                
+            end_time = time.time()
+            elapsed = f"{(end_time - start_time)*1000:.0f}ms"
+            
+            table.add_row(provider_name, status, elapsed, details)
+        
+        # Print results
+        shared_console.print(table)
+        
+    except Exception as e:
+        print(f"Error testing provider connectivity: {e}")
+    
+    return

{janito-2.18.0 → janito-2.19.1}/janito/cli/main_cli.py

@@ -124,6 +124,10 @@ definition = [
         ["--list-providers"],
         {"action": "store_true", "help": "List supported LLM providers"},
     ),
+    (
+        ["--ping"],
+        {"action": "store_true", "help": "Ping/test connectivity for all providers (use with --list-providers)"},
+    ),
     (
         ["--list-drivers"],
         {
@@ -238,6 +242,19 @@ GETTER_KEYS = [
     "list_drivers",
     "region_info",
     "list_providers_region",
+    "ping",
+]
+GETTER_KEYS = [
+    "show_config",
+    "list_providers",
+    "list_profiles",
+    "list_models",
+    "list_tools",
+    "list_config",
+    "list_drivers",
+    "region_info",
+    "list_providers_region",
+    "ping",
 ]
 
 
@@ -361,6 +378,7 @@ class JanitoCLI:
             or self.args.show_config
             or self.args.list_config
             or self.args.list_drivers
+            or self.args.ping
         ):
             self._maybe_print_verbose_provider_model()
             handle_getter(self.args)

janito-2.19.1/janito/i18n/it.py

@@ -0,0 +1,46 @@
+# pragma: allowlist secret
+translations = {
+    "36107ed78ab25f6fb12ad8ce13018cd1ce6735d1": "Avvio del server web...",
+    "70a0d194687568a47aa617fd85036ace1e69a982": "Vuoi davvero uscire? (s/n): ",
+    "5c9ebcbbd7632ecb328bd52958b17158afaa32c6": "F12 = Azione Rapida (segue l'azione raccomandata)",
+    "fe21121e2934234b68d19b2757532117d440c1e3": "Chiave API non trovata. Si prega di configurare 'api_key' nel file di configurazione.",
+    "c9e3759b1756eba35b381ce2b72cd659e132b01f": "Ciao, {name}!",
+    "ca1fee2f55baabdc2e4b0e9529c89ee024e62079": "Nessun prompt fornito nei messaggi",
+    "f7449d23d0c500ae2a0b31e04f92b47a4d8ae845": "max_tokens deve essere un intero, ricevuto: {resolved_max_tokens!r}",
+    "70a9ed8edb6da12e208431a31aa16ba54419b26f": "Risposta non valida/malformed da OpenAI (tentativo {attempt}/{max_retries}). Riprovo tra {wait_time} secondi...",
+    "a873085e3b06184fb5d27e842f97b06b6190976d": "Numero massimo di tentativi per risposta non valida raggiunto. Generazione errore.",
+    "66a34568bbe846bb1bde3619eb4d6dfa10211104": "L'API non supporta l'uso degli strumenti.",
+    "09b81476b75586da4116b83f8be70d77b174cec3": "Limite di richieste API OpenAI (429) (tentativo {attempt}/{max_retries}): {e}. Riprovo tra {wait_time} secondi...",
+    "5717a35dd2a1533fb7e15edc8c9329cb69f3410b": "Errore server API OpenAI (tentativo {attempt}/{max_retries}): {e}. Riprovo tra {wait_time} secondi...",
+    "02e760ba15ed863176c1290ac8a9b923963103cd": "Errore client API OpenAI {status_code}: {e}. Nessun nuovo tentativo.",
+    "2e52b0bbc8f16226b70e3e20f95c9245d2bcdb47": "Errore API OpenAI (tentativo {attempt}/{max_retries}): {e}. Riprovo tra {wait_time} secondi...",
+    "012cc970e039fdd79c452fc676202c814ffc76ae": "Numero massimo di tentativi per errore API OpenAI raggiunto. Generazione errore.",
+    "d0438e45667d31e0022b2497b5901cd4300f084b": "QueuedMessageHandler.handle_message si aspetta un dizionario con 'type' e 'message', ricevuto {msg_type}: {msg!r}",
+    "9d3460187ffa19c7c8a4020157072b1087e1bd2f": "[QueuedMessageHandler] {msg_type}: {msg}",
+    "3813833343430e8afa8fce33385c5e39fb24dd60": "[QueuedMessageHandler] {msg_type}: {message}",
+    "0be9a22226e16a40797010d23a0f581542dca40e": "[ToolExecutor] {tool_name} chiamato con argomenti: {args}",
+    "42c68edcb25442f518b1af77c6a2ddc07461aae0": "[ToolExecutor] Motivo chiamata: {tool_call_reason}",
+    "002ff598115d84595ffeee6219cb5c03d3a1d4a6": "Domanda",
+    "35747d13dcd91e8e8790c7f767d5ed764f541b9e": "procedi",
+    "33dde3a1afbc418768a69fa53168d9b0638fe1aa": "avanti",
+    "eee0bbba4ff92adbeb038a77df0466d660f15716": "continua",
+    "edee9402d198b04ac77dcf5dc9cc3dac44573782": "prossimo",
+    "8fdb7e2fa84f4faf0d9b92f466df424ec47a165b": "ok",
+    "5f8f924671cda79b5205a6bf1b776f347c4a7a07": "Opzioni di configurazione disponibili:\n",
+    "cef780a309cd234750764d42697882c24168ddab": "{key:15} {desc} (predefinito: {default})",
+    "68c2cc7f0ceaa3e499ecb4db331feb4debbbcc23": "Modello",
+    "c3f104d1365744b538bfde9f4adb6a6df4b80355": "Funzione",
+    "99a0efc6cfd85d8ff2732a6718140f822cb90472": "Stile",
+    "f1702b4686278becffc88baabe6f4b7a8355532c": "Messaggi",
+    "c38c6c1f3a2743f8626703abb302e403d20ff81c": "Token",
+    "a817d7eb8e0f1dab755ab5203a082e5c3c094fce": "Prompt",
+    "2ff255684a2277f806fcebf3fe338ed27857f350": "Completamento",
+    "b25928c69902557b0ef0a628490a3a1768d7b82f": "Totale",
+    "76e63d65c883ed50df40ac3aeef0c2d6a1c4ad60": "Azione Rapida",
+    "5397e0583f14f6c88de06b1ef28f460a1fb5b0ae": "Sì",
+    "816c52fd2bdd94a63cd0944823a6c0aa9384c103": "No",
+    "c47ae15370cfe1ed2781eedc1dc2547d12d9e972": "Aiuto",
+    "cc3dbd47e1cf9003a55d3366b3adbcd72275e525": "Nuovo Task",
+    "efa5a8b84e1afe65c81ecfce28c398c48f19ddc2": "Benvenuto su Janito{version_str}! Modalità chat attiva. Digita /exit per uscire.",
+    "b314d6e1460f86e0f21abc5aceb7935a2a0667e8": "Benvenuto su Janito{version_str} in modalità [white on magenta]VANILLA[/white on magenta]! Strumenti, prompt di sistema e temperatura sono disattivati, a meno che non siano sovrascritti.",
+}

{janito-2.18.0 → janito-2.19.1}/janito/llm/model.py

@@ -10,6 +10,7 @@ class LLMModelInfo:
     max_cot: Any = "N/A"
     max_response: Any = "N/A"
     thinking_supported: Any = "N/A"
+    thinking: bool = False
     default_temp: float = 0.2
     open: Optional[Any] = None
     category: Optional[str] = None

{janito-2.18.0 → janito-2.19.1}/janito/provider_registry.py

@@ -39,7 +39,17 @@ class ProviderRegistry:
             if len(info) == 4 and info[3]:
                 continue  # skip providers flagged as not implemented
             rows.append(info[:3])
-        rows.sort(key=self._maintainer_sort_key)
+        
+        # Group providers by openness (open-source first, then proprietary)
+        open_providers = {'cerebras', 'deepseek', 'alibaba', 'moonshotai', 'zai'}
+        
+        def sort_key(row):
+            provider_name = row[0]
+            is_open = provider_name in open_providers
+            # Sort open providers alphabetically first, then proprietary alphabetically
+            return (not is_open, provider_name)
+        
+        rows.sort(key=sort_key)
         return rows
 
     def _add_rows_to_table(self, table, rows):