janito 2.16.0__tar.gz → 2.17.0__tar.gz

{janito-2.16.0 → janito-2.17.0}/CHANGELOG.md

@@ -4,6 +4,34 @@ All notable changes to this project will be documented in this file.
 
 ## [Unreleased]
 
+## [2.17.0] - 2025-08-05
+
+### Added
+
+- **New Provider Support**
+  - **Cerebras Provider**: Added complete support for Cerebras with qwen-3-coder-480b model
+    - qwen-3-coder-480b: 32k context, reasoning-focused model with function calling support
+
+- **Enhanced UX**
+  - Improved error handling for invalid provider names in set-api-key command
+  - Better error messages when provider is not found
+
+### Changed
+
+- **Provider Improvements**
+  - Updated Alibaba endpoint to international URL for better global access
+  - Simplified region display to 2-letter codes for cleaner output
+  - Improved driver listing and region display functionality
+
+- **Zero Mode Enhancement**
+  - Zero mode now properly disables system prompt and tools for minimal interaction
+
+### Fixed
+
+- **Bug Fixes**
+  - Added missing tools adapter to Cerebras provider
+  - Improved error handling for invalid provider names in set-api-key command
+
 ## [2.16.0] - 2025-01-08
 
 ### Added

{janito-2.16.0 → janito-2.17.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: janito
-Version: 2.16.0
+Version: 2.17.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.17.0/docs/cerebras-setup.md

@@ -0,0 +1,56 @@
+# Cerebras Setup Guide
+
+This guide will help you set up Janito to use Cerebras as an LLM provider.
+
+## Prerequisites
+
+1. A Cerebras account
+2. An API key from Cerebras
+
+## Getting an API Key
+
+1. Visit the [Cerebras API Keys page](https://api.cerebras.ai/)
+2. Log in to your account
+3. Generate a new API key
+4. Copy the API key for use in Janito
+
+## Configuration
+
+To configure Janito to use Cerebras, you need to set your API key:
+
+```bash
+janito --set-api-key YOUR_CEREBRAS_API_KEY -p cerebras
+```
+
+Replace `YOUR_CEREBRAS_API_KEY` with the API key you obtained from Cerebras.
+
+## Usage
+
+After setting up your API key, you can use Cerebras models with Janito:
+
+```bash
+janito -p cerebras "Hello, how are you?"
+```
+
+By default, Janito will use the `qwen-3-coder-480b` model. You can specify a different model if needed:
+
+```bash
+janito -p cerebras -m qwen-3-coder-480b "Explain quantum computing"
+```
+
+## Available Models
+
+Cerebras offers several models through their API:
+
+- `qwen-3-coder-480b`: 32k context, reasoning-focused model with function calling support
+
+## Troubleshooting
+
+If you encounter issues:
+
+1. Verify your API key is correct and active
+2. Check that you have internet connectivity
+3. Ensure you're using a supported model name
+4. Check the Cerebras status page for any service outages
+
+For further assistance, consult the [Cerebras documentation](https://api.cerebras.ai/docs) or [Janito documentation](https://docs.janito.dev).

{janito-2.16.0 → janito-2.17.0}/docs/supported-providers-models.md

@@ -36,7 +36,7 @@ This page lists the supported providers and their available models.
 - qwen-turbo
 - qwen-plus
 - qwen-max
-- qwen3-coder-plus
+- qwen3-coder-plus (default)
 - qwen3-coder-480b-a35b-instruct
 
 ## Z.AI
@@ -44,4 +44,22 @@ This page lists the supported providers and their available models.
 - glm-4.5
 - glm-4.5-air
 
+## Cerebras
+
+**Production Models:**
+- llama-4-scout-17b-16e-instruct
+- llama-3.3-70b
+- llama3.1-8b
+- qwen-3-32b
+
+**Preview Models:**
+- llama-4-maverick-17b-128e-instruct
+- qwen-3-235b-a22b-instruct-2507
+- qwen-3-235b-a22b-thinking-2507
+- qwen-3-coder-480b
+- gpt-oss-120b
+
+**Notes:**
+- qwen-3-coder-480b: 32k context, reasoning-focused model with function calling support
+
 <!-- Removed links to model_info.py files for all providers to avoid broken references. -->

{janito-2.16.0 → janito-2.17.0}/janito/agent/setup_agent.py

@@ -167,7 +167,7 @@ def setup_agent(
     """
     Creates an agent. A system prompt is rendered from a template only when a profile is specified.
     """
-    if no_tools_mode:
+    if no_tools_mode or zero_mode:
         tools_provider = None
     else:
         tools_provider = get_local_tools_adapter()

{janito-2.16.0 → janito-2.17.0}/janito/cli/cli_commands/list_drivers.py

@@ -92,6 +92,7 @@ def get_driver_info():
         ("janito.drivers.openai.driver", "OpenAIModelDriver"),
         ("janito.drivers.azure_openai.driver", "AzureOpenAIModelDriver"),
         ("janito.drivers.zai.driver", "ZAIModelDriver"),
+        ("janito.drivers.cerebras.driver", "CerebrasModelDriver"),
     ]
 
     for module_path, class_name in driver_modules:

janito-2.17.0/janito/cli/cli_commands/set_api_key.py

@@ -0,0 +1,30 @@
+"""
+CLI Command: Set API key for the current or selected provider
+"""
+
+from janito.provider_config import set_api_key
+from janito.llm.auth import LLMAuthManager
+from janito.providers.registry import LLMProviderRegistry
+
+
+def handle_set_api_key(args):
+    api_key = getattr(args, "set_api_key", None)
+    provider = getattr(args, "provider", None)
+    if not provider:
+        print("Error: --set-api-key requires -p/--provider to be specified.")
+        return
+    
+    # Validate provider name
+    if provider not in LLMProviderRegistry.list_providers():
+        valid_providers = LLMProviderRegistry.list_providers()
+        print(f"Error: Unknown provider '{provider}'. Valid providers are: {', '.join(valid_providers)}")
+        return
+        
+    try:
+        set_api_key(provider, api_key)
+        auth_manager = LLMAuthManager()
+        print(
+            f"API key set for provider '{provider}'. Auth file updated: {auth_manager._auth_file}"
+        )
+    except ValueError as e:
+        print(f"Error: {e}")

{janito-2.16.0 → janito-2.17.0}/janito/cli/prompt_setup.py

@@ -37,6 +37,8 @@ def setup_agent_and_prompt_handler(
     no_tools_mode = False
     if hasattr(args, 'no_tools_mode'):
         no_tools_mode = getattr(args, 'no_tools_mode', False)
+    
+    zero_mode = getattr(args, 'zero', False)
     agent = create_configured_agent(
         provider_instance=provider_instance,
         llm_driver_config=llm_driver_config,
@@ -46,6 +48,7 @@ def setup_agent_and_prompt_handler(
         allowed_permissions=allowed_permissions,
         profile=profile,
         profile_system_prompt=profile_system_prompt,
+        zero_mode=zero_mode,
         no_tools_mode=no_tools_mode,
     )
 

janito-2.17.0/janito/drivers/cerebras/__init__.py

@@ -0,0 +1 @@
+# Cerebras driver package

{janito-2.16.0 → janito-2.17.0}/janito/providers/__init__.py

@@ -7,3 +7,4 @@ import janito.providers.deepseek.provider
 import janito.providers.moonshotai.provider
 import janito.providers.alibaba.provider
 import janito.providers.zai.provider
+import janito.providers.cerebras.provider

{janito-2.16.0 → janito-2.17.0}/janito/providers/alibaba/provider.py

@@ -17,9 +17,7 @@ class AlibabaProvider(LLMProvider):
     NAME = "alibaba"
     MAINTAINER = "João Pinto <janito@ikignosis.org>"
     MODEL_SPECS = MODEL_SPECS
-    DEFAULT_MODEL = (
-        "qwen3-coder-plus"  # Options: qwen-turbo, qwen-plus, qwen-max, qwen3-coder-plus
-    )
+    DEFAULT_MODEL = "qwen3-coder-plus"  # 128k context, coding-focused model
 
     def __init__(
         self, auth_manager: LLMAuthManager = None, config: LLMDriverConfig = None

janito-2.17.0/janito/providers/cerebras/__init__.py

@@ -0,0 +1 @@
+# Cerebras provider package

janito-2.17.0/janito/providers/cerebras/model_info.py

@@ -0,0 +1,76 @@
+"""Model specifications for Cerebras Inference API."""
+
+from janito.llm.model import LLMModelInfo
+
+MODEL_SPECS = {
+    "qwen-3-32b": LLMModelInfo(
+        name="qwen-3-32b",
+        max_input=128000,
+        max_response=16384,
+        default_temp=0.7,
+        driver="CerebrasModelDriver",
+        other={
+            "description": "Qwen 3 32B model for general instruction following",
+            "pricing": {
+                "input_per_1k_tokens": 0.0002,
+                "output_per_1k_tokens": 0.0006
+            }
+        }
+    ),
+    "qwen-3-235b-a22b-instruct-2507": LLMModelInfo(
+        name="qwen-3-235b-a22b-instruct-2507",
+        max_input=128000,
+        max_response=16384,
+        default_temp=0.7,
+        driver="CerebrasModelDriver",
+        other={
+            "description": "Qwen 3 235B A22B instruction-tuned model (preview)",
+            "pricing": {
+                "input_per_1k_tokens": 0.001,
+                "output_per_1k_tokens": 0.003
+            }
+        }
+    ),
+    "qwen-3-235b-a22b-thinking-2507": LLMModelInfo(
+        name="qwen-3-235b-a22b-thinking-2507",
+        max_input=128000,
+        max_response=16384,
+        default_temp=0.7,
+        driver="CerebrasModelDriver",
+        other={
+            "description": "Qwen 3 235B A22B thinking model for reasoning tasks (preview)",
+            "pricing": {
+                "input_per_1k_tokens": 0.001,
+                "output_per_1k_tokens": 0.003
+            }
+        }
+    ),
+    "qwen-3-coder-480b": LLMModelInfo(
+        name="qwen-3-coder-480b",
+        max_input=128000,
+        max_response=16384,
+        default_temp=0.7,
+        driver="CerebrasModelDriver",
+        other={
+            "description": "Qwen 3 Coder 480B model for programming tasks (preview)",
+            "pricing": {
+                "input_per_1k_tokens": 0.002,
+                "output_per_1k_tokens": 0.006
+            }
+        }
+    ),
+    "gpt-oss-120b": LLMModelInfo(
+        name="gpt-oss-120b",
+        max_input=128000,
+        max_response=16384,
+        default_temp=0.7,
+        driver="CerebrasModelDriver",
+        other={
+            "description": "GPT-OSS 120B open-source model (preview)",
+            "pricing": {
+                "input_per_1k_tokens": 0.0008,
+                "output_per_1k_tokens": 0.0024
+            }
+        }
+    )
+}

janito-2.17.0/janito/providers/cerebras/provider.py

@@ -0,0 +1,145 @@
+"""Cerebras Inference provider implementation."""
+
+from typing import Dict, Any
+from janito.llm.provider import LLMProvider
+from janito.llm.auth import LLMAuthManager
+from janito.llm.driver_config import LLMDriverConfig
+from janito.drivers.openai.driver import OpenAIModelDriver
+from janito.tools import get_local_tools_adapter
+from janito.providers.registry import LLMProviderRegistry
+from .model_info import MODEL_SPECS
+
+
+class CerebrasProvider(LLMProvider):
+    """Cerebras Inference API provider."""
+    
+    name = "cerebras"
+    NAME = "cerebras"
+    DEFAULT_MODEL = "qwen-3-coder-480b"
+    MAINTAINER = "João Pinto <janito@ikignosis.org>"
+    MODEL_SPECS = MODEL_SPECS
+
+    def __init__(self, auth_manager: LLMAuthManager = None, config: LLMDriverConfig = None):
+        """Initialize Cerebras provider with optional configuration."""
+        super().__init__()
+        self._tools_adapter = get_local_tools_adapter()
+        self._driver = None
+        self._tools_adapter = get_local_tools_adapter()
+        self._driver = None
+        if not self.available:
+            return
+
+        self._initialize_config(auth_manager, config)
+        self._setup_model_config()
+        self.fill_missing_device_info(self._driver_config)
+        
+        if not self.available:
+            return
+            
+        self._initialize_config(None, None)
+        self._driver_config.base_url = "https://api.cerebras.ai/v1"
+
+    def _initialize_config(self, auth_manager, config):
+        """Initialize configuration and API key."""
+        self.auth_manager = auth_manager or LLMAuthManager()
+        self._api_key = self.auth_manager.get_credentials(type(self).NAME)
+        if not self._api_key:
+            from janito.llm.auth_utils import handle_missing_api_key
+
+            handle_missing_api_key(self.name, "CEREBRAS_API_KEY")
+
+        self._driver_config = config or LLMDriverConfig(model=None)
+        if not self._driver_config.model:
+            self._driver_config.model = self.DEFAULT_MODEL
+        if not self._driver_config.api_key:
+            self._driver_config.api_key = self._api_key
+
+        self._setup_model_config()
+        self.fill_missing_device_info(self._driver_config)
+
+    def _setup_model_config(self):
+        """Configure token limits based on model specifications."""
+        model_name = self._driver_config.model
+        model_spec = self.MODEL_SPECS.get(model_name)
+
+        # Reset token parameters
+        if hasattr(self._driver_config, "max_tokens"):
+            self._driver_config.max_tokens = None
+        if hasattr(self._driver_config, "max_completion_tokens"):
+            self._driver_config.max_completion_tokens = None
+
+        if model_spec:
+            # Set context length
+            if hasattr(model_spec, "context") and model_spec.context:
+                self._driver_config.context_length = model_spec.context
+            
+            # Set max tokens based on model spec
+            if hasattr(model_spec, "max_response") and model_spec.max_response:
+                self._driver_config.max_tokens = model_spec.max_response
+            
+            # Set max completion tokens if thinking is supported
+            if getattr(model_spec, "thinking_supported", False):
+                max_cot = getattr(model_spec, "max_cot", None)
+                if max_cot and max_cot != "N/A":
+                    self._driver_config.max_completion_tokens = int(max_cot)
+            else:
+                max_response = getattr(model_spec, "max_response", None)
+                if max_response and max_response != "N/A":
+                    self._driver_config.max_tokens = int(max_response)
+
+    @property
+    @property
+    def driver(self) -> OpenAIModelDriver:
+        if not self.available:
+            raise ImportError(
+                f"CerebrasProvider unavailable: {self.unavailable_reason}"
+            )
+        if self._driver is None:
+            self._driver = self.create_driver()
+        return self._driver
+
+    @property
+    def available(self):
+        return OpenAIModelDriver.available
+
+    @property
+    def unavailable_reason(self):
+        return OpenAIModelDriver.unavailable_reason
+
+    def create_driver(self) -> OpenAIModelDriver:
+        """Create and return an OpenAI-compatible Cerebras driver instance."""
+        driver = OpenAIModelDriver(
+            tools_adapter=self._tools_adapter, provider_name=self.name
+        )
+        driver.config = self._driver_config
+        return driver
+
+    @property
+    def driver_config(self):
+        """Return the driver configuration."""
+        return self._driver_config
+
+    def is_model_available(self, model_name: str) -> bool:
+        """Check if a model is available for this provider."""
+        return model_name in self.MODEL_SPECS
+
+    def get_model_info(self, model_name: str = None) -> Dict[str, Any]:
+        """Get model information for the specified model or all models."""
+        if model_name is None:
+            return {
+                name: model_info.to_dict()
+                for name, model_info in self.MODEL_SPECS.items()
+            }
+        
+        if model_name in self.MODEL_SPECS:
+            return self.MODEL_SPECS[model_name].to_dict()
+        
+        return None
+
+    def execute_tool(self, tool_name: str, event_bus, *args, **kwargs):
+        self._tools_adapter.event_bus = event_bus
+        return self._tools_adapter.execute_by_name(tool_name, *args, **kwargs)
+
+
+# Register the provider
+LLMProviderRegistry.register(CerebrasProvider.name, CerebrasProvider)

{janito-2.16.0 → janito-2.17.0}/janito.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: janito
-Version: 2.16.0
+Version: 2.17.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.16.0 → janito-2.17.0}/janito.egg-info/SOURCES.txt

@@ -24,6 +24,7 @@ docs/DIV.md
 docs/Interfaces.txt
 docs/TOOLBAR-STYLING.md
 docs/alternatives.md
+docs/cerebras-setup.md
 docs/deepseek-setup.md
 docs/driver-flow.md
 docs/driver-request-cancellation.md
@@ -185,6 +186,7 @@ janito/docs/GETTING_STARTED.md
 janito/drivers/dashscope.bak.zip
 janito/drivers/openai_responses.bak.zip
 janito/drivers/azure_openai/driver.py
+janito/drivers/cerebras/__init__.py
 janito/drivers/openai/README.md
 janito/drivers/openai/driver.py
 janito/drivers/zai/__init__.py
@@ -219,6 +221,9 @@ janito/providers/anthropic/model_info.py
 janito/providers/anthropic/provider.py
 janito/providers/azure_openai/model_info.py
 janito/providers/azure_openai/provider.py
+janito/providers/cerebras/__init__.py
+janito/providers/cerebras/model_info.py
+janito/providers/cerebras/provider.py
 janito/providers/deepseek/__init__.py
 janito/providers/deepseek/model_info.py
 janito/providers/deepseek/provider.py
@@ -308,6 +313,7 @@ tests/test_cli_list_providers_moonshotai.py
 tests/test_cli_version.py
 tests/test_disabled_tools.py
 tests/test_provider_alibaba.py
+tests/test_provider_cerebras.py
 tests/test_provider_moonshotai.py
 tests/adapters/local/test_read_files.py
 tests/adapters/local/get_file_outline/test_core_outline.py

{janito-2.16.0 → janito-2.17.0}/mkdocs.yml

@@ -1,6 +1,6 @@
 site_name: Janito
 site_name: Janito
-site_url: https://ikignosis.github.io/janito/
+site_url: https://ikignosis.org/janito/
 docs_dir: docs
 repo_url: https://github.com/ikignosis/janito
 repo_name: GitHub

janito-2.17.0/tests/test_provider_cerebras.py

@@ -0,0 +1,93 @@
+"""Tests for Cerebras provider."""
+
+import os
+import pytest
+from unittest.mock import patch, MagicMock
+
+from janito.providers.cerebras.provider import CerebrasProvider
+from janito.providers.cerebras.model_info import MODEL_SPECS
+
+
+class TestCerebrasProvider:
+    """Test cases for Cerebras provider."""
+
+    def test_provider_initialization(self):
+        """Test provider initialization with default config."""
+        provider = CerebrasProvider()
+        assert provider.name == "cerebras"
+        assert provider.DEFAULT_MODEL == "llama-4-scout-17b-16e-instruct"
+        assert provider.MAINTAINER == "Cerebras Systems"
+
+    def test_provider_initialization_with_config(self):
+        """Test provider initialization with custom config."""
+        config = {"model": "llama-4-maverick-17b-128e-instruct", "temperature": 0.5}
+        provider = CerebrasProvider(config=config)
+        assert provider.config["model"] == "llama-4-maverick-17b-128e-instruct"
+        assert provider.config["temperature"] == 0.5
+
+    def test_get_model_info_all_models(self):
+        """Test getting info for all models."""
+        provider = CerebrasProvider()
+        model_info = provider.get_model_info()
+        assert isinstance(model_info, dict)
+        assert len(model_info) == len(MODEL_SPECS)
+        assert "llama-4-scout-17b-16e-instruct" in model_info
+        assert "llama-4-maverick-17b-128e-instruct" in model_info
+
+    def test_get_model_info_single_model(self):
+        """Test getting info for a specific model."""
+        provider = CerebrasProvider()
+        model_info = provider.get_model_info("llama-4-scout-17b-16e-instruct")
+        assert isinstance(model_info, dict)
+        assert model_info["name"] == "llama-4-scout-17b-16e-instruct"
+        assert model_info["driver"] == "CerebrasModelDriver"
+
+    def test_get_model_info_invalid_model(self):
+        """Test getting info for invalid model."""
+        provider = CerebrasProvider()
+        model_info = provider.get_model_info("invalid-model")
+        assert model_info is None
+
+    def test_is_model_available(self):
+        """Test model availability check."""
+        provider = CerebrasProvider()
+        assert provider.is_model_available("llama-4-scout-17b-16e-instruct")
+        assert provider.is_model_available("llama-4-maverick-17b-128e-instruct")
+        assert not provider.is_model_available("invalid-model")
+
+    @patch.dict(os.environ, {"CEREBRAS_API_KEY": "test-key"})
+    def test_create_driver_with_env_key(self):
+        """Test creating driver with API key from environment."""
+        provider = CerebrasProvider()
+        driver = provider.create_driver()
+        assert driver.api_key == "test-key"
+        assert driver.model == "llama-4-scout-17b-16e-instruct"
+
+    def test_create_driver_with_config_key(self):
+        """Test creating driver with API key from config."""
+        config = {"api_key": "config-key", "model": "llama-3.3-70b-instruct"}
+        provider = CerebrasProvider(config=config)
+        driver = provider.create_driver()
+        assert driver.api_key == "config-key"
+        assert driver.model == "llama-3.3-70b-instruct"
+
+    def test_create_driver_missing_api_key(self):
+        """Test creating driver without API key raises error."""
+        provider = CerebrasProvider()
+        with pytest.raises(ValueError, match="Cerebras API key is required"):
+            provider.create_driver()
+
+    def test_create_driver_invalid_model(self):
+        """Test creating driver with invalid model raises error."""
+        config = {"api_key": "test-key", "model": "invalid-model"}
+        provider = CerebrasProvider(config=config)
+        with pytest.raises(ValueError, match="Model 'invalid-model' is not supported"):
+            provider.create_driver()
+
+    def test_driver_property(self):
+        """Test driver property returns driver instance."""
+        with patch.dict(os.environ, {"CEREBRAS_API_KEY": "test-key"}):
+            provider = CerebrasProvider()
+            driver = provider.driver
+            assert driver is not None
+            assert hasattr(driver, 'chat_complete')

janito-2.16.0/janito/cli/cli_commands/set_api_key.py

@@ -1,19 +0,0 @@
-"""
-CLI Command: Set API key for the current or selected provider
-"""
-
-from janito.provider_config import set_api_key
-from janito.llm.auth import LLMAuthManager
-
-
-def handle_set_api_key(args):
-    api_key = getattr(args, "set_api_key", None)
-    provider = getattr(args, "provider", None)
-    if not provider:
-        print("Error: --set-api-key requires -p/--provider to be specified.")
-        return
-    set_api_key(provider, api_key)
-    auth_manager = LLMAuthManager()
-    print(
-        f"API key set for provider '{provider}'. Auth file updated: {auth_manager._auth_file}"
-    )