janito 2.15.0__py3-none-any.whl → 2.17.0__py3-none-any.whl

janito/drivers/openai/driver.py

@@ -16,6 +16,16 @@ import openai
 
 
 class OpenAIModelDriver(LLMDriver):
+    # Check if required dependencies are available
+    try:
+        import openai
+
+        available = True
+        unavailable_reason = None
+    except ImportError as e:
+        available = False
+        unavailable_reason = f"Missing dependency: {str(e)}"
+
     def _get_message_from_result(self, result):
         """Extract the message object from the provider result (OpenAI-specific)."""
         if hasattr(result, "choices") and result.choices:
@@ -248,11 +258,12 @@ class OpenAIModelDriver(LLMDriver):
     def _instantiate_openai_client(self, config):
         try:
             if not config.api_key:
-                provider_name = getattr(self, 'provider_name', 'OpenAI-compatible')
-                print(f"[ERROR] No API key found for provider '{provider_name}'. Please set the API key using:")
-                print(f"  janito --set-api-key YOUR_API_KEY -p {provider_name.lower()}")
-                print(f"Or set the {provider_name.upper()}_API_KEY environment variable.")
-                raise ValueError(f"API key is required for provider '{provider_name}'")
+                provider_name = getattr(self, "provider_name", "OpenAI-compatible")
+                from janito.llm.auth_utils import handle_missing_api_key
+
+                handle_missing_api_key(
+                    provider_name, f"{provider_name.upper()}_API_KEY"
+                )
 
             api_key_display = str(config.api_key)
             if api_key_display and len(api_key_display) > 8:

janito/drivers/zai/driver.py

@@ -12,18 +12,20 @@ from janito.llm.driver_input import DriverInput
 from janito.driver_events import RequestFinished, RequestStatus, RateLimitRetry
 from janito.llm.message_parts import TextMessagePart, FunctionCallMessagePart
 
-try:
-    import openai
-    available = True
-    unavailable_reason = None
-except ImportError:
-    available = False
-    unavailable_reason = "openai module not installed"
+import openai
 
 
 class ZAIModelDriver(LLMDriver):
-    available = available
-    unavailable_reason = unavailable_reason
+    # Check if required dependencies are available
+    try:
+        from zai import ZaiClient
+
+        available = True
+        unavailable_reason = None
+    except ImportError as e:
+        available = False
+        unavailable_reason = f"Missing dependency: {str(e)}"
+
     def _get_message_from_result(self, result):
         """Extract the message object from the provider result (Z.AI-specific)."""
         if hasattr(result, "choices") and result.choices:
@@ -256,14 +258,11 @@ class ZAIModelDriver(LLMDriver):
         try:
             if not config.api_key:
                 provider_name = getattr(self, "provider_name", "ZAI")
-                print(
-                    f"[ERROR] No API key found for provider '{provider_name}'. Please set the API key using:"
-                )
-                print(f"  janito --set-api-key YOUR_API_KEY -p {provider_name.lower()}")
-                print(
-                    f"Or set the {provider_name.upper()}_API_KEY environment variable."
+                from janito.llm.auth_utils import handle_missing_api_key
+
+                handle_missing_api_key(
+                    provider_name, f"{provider_name.upper()}_API_KEY"
                 )
-                raise ValueError(f"API key is required for provider '{provider_name}'")
 
             api_key_display = str(config.api_key)
             if api_key_display and len(api_key_display) > 8:
@@ -284,12 +283,10 @@ class ZAIModelDriver(LLMDriver):
                     flush=True,
                 )
 
-            # Use OpenAI SDK for Z.AI API compatibility
-            try:
-                import openai
-            except ImportError:
-                raise ImportError("openai module is not available. Please install it with: pip install openai")
-            client = openai.OpenAI(
+            # Use the official Z.ai SDK
+            from zai import ZaiClient
+
+            client = ZaiClient(
                 api_key=config.api_key, base_url="https://api.z.ai/api/paas/v4/"
             )
             return client

janito/formatting_token.py

@@ -29,7 +29,7 @@ def format_token_message_summary(
     msg_count, usage, width=96, use_rich=False, elapsed=None
 ):
     """
-    Returns a string (rich or pt markup) summarizing message count, last token usage, and elapsed time.
+    Returns a string (rich or pt markup) summarizing message count, last token usage, elapsed time, and tokens per second.
     """
     left = f" Messages: {'[' if use_rich else '<'}msg_count{']' if use_rich else '>'}{msg_count}{'[/msg_count]' if use_rich else '</msg_count>'}"
     tokens_part = ""
@@ -42,10 +42,14 @@ def format_token_message_summary(
             f"Completion: {format_tokens(completion_tokens, 'tokens_out', use_rich)}, "
             f"Total: {format_tokens(total_tokens, 'tokens_total', use_rich)}"
         )
-    elapsed_part = (
-        f" | Elapsed: [cyan]{elapsed:.2f}s[/cyan]" if elapsed is not None else ""
-    )
-    return f"{left}{tokens_part}{elapsed_part}"
+    elapsed_part = ""
+    tps_part = ""
+    if elapsed is not None and elapsed > 0:
+        elapsed_part = f" | Elapsed: [cyan]{elapsed:.2f}s[/cyan]"
+        if usage and total_tokens:
+            tokens_per_second = total_tokens / elapsed
+            tps_part = f" | TPS: {int(tokens_per_second)}"
+    return f"{left}{tokens_part}{elapsed_part}{tps_part}"
 
 
 def print_token_message_summary(

janito/llm/auth_utils.py

@@ -0,0 +1,21 @@
+"""
+Authentication utilities for LLM providers.
+"""
+
+import sys
+
+
+def handle_missing_api_key(provider_name: str, env_var_name: str) -> None:
+    """
+    Handle missing API key by printing error message and exiting.
+
+    Args:
+        provider_name: Name of the provider (e.g., 'alibaba', 'openai')
+        env_var_name: Environment variable name (e.g., 'ALIBABA_API_KEY')
+    """
+    print(
+        f"[ERROR] No API key found for provider '{provider_name}'. Please set the API key using:"
+    )
+    print(f"  janito --set-api-key YOUR_API_KEY -p {provider_name}")
+    print(f"Or set the {env_var_name} environment variable.")
+    sys.exit(1)

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/providers/alibaba/provider.py

@@ -17,7 +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
@@ -25,27 +25,29 @@ class AlibabaProvider(LLMProvider):
         # Always set a tools adapter so that even if the driver is unavailable,
         # generic code paths that expect provider.execute_tool() continue to work.
         self._tools_adapter = get_local_tools_adapter()
-        
+
         # Always initialize _driver_config to avoid AttributeError
         self._driver_config = config or LLMDriverConfig(model=None)
-        
+
         if not self.available:
             self._driver = None
         else:
             self.auth_manager = auth_manager or LLMAuthManager()
             self._api_key = self.auth_manager.get_credentials(type(self).NAME)
             if not self._api_key:
-                print(f"[ERROR] No API key found for provider '{self.name}'. Please set the API key using:")
-                print(f"  janito --set-api-key YOUR_API_KEY -p {self.name}")
-                print(f"Or set the ALIBABA_API_KEY environment variable.")
-            
+                from janito.llm.auth_utils import handle_missing_api_key
+
+                handle_missing_api_key(self.name, "ALIBABA_API_KEY")
+
             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
             # Set Alibaba international endpoint as default base_url if not provided
             if not getattr(self._driver_config, "base_url", None):
-                self._driver_config.base_url = "https://dashscope-intl.aliyuncs.com/compatible-mode/v1"
+                self._driver_config.base_url = (
+                    "https://dashscope-intl.aliyuncs.com/compatible-mode/v1"
+                )
             self.fill_missing_device_info(self._driver_config)
             self._driver = None  # to be provided by factory/agent
 
@@ -99,4 +101,4 @@ class AlibabaProvider(LLMProvider):
         return self._tools_adapter.execute_by_name(tool_name, *args, **kwargs)
 
 
-LLMProviderRegistry.register(AlibabaProvider.NAME, AlibabaProvider)
+LLMProviderRegistry.register(AlibabaProvider.NAME, AlibabaProvider)

janito/providers/anthropic/provider.py

@@ -22,11 +22,10 @@ class AnthropicProvider(LLMProvider):
         self.auth_manager = auth_manager or LLMAuthManager()
         self._api_key = self.auth_manager.get_credentials(type(self).NAME)
         if not self._api_key:
-            print(f"[ERROR] No API key found for provider '{self.name}'. Please set the API key using:")
-            print(f"  janito --set-api-key YOUR_API_KEY -p {self.name}")
-            print(f"Or set the ANTHROPIC_API_KEY environment variable.")
-            return
-        
+            from janito.llm.auth_utils import handle_missing_api_key
+
+            handle_missing_api_key(self.name, "ANTHROPIC_API_KEY")
+
         self._tools_adapter = get_local_tools_adapter()
         self._driver_config = config or LLMDriverConfig(model=None)
         if not getattr(self._driver_config, "model", None):

janito/providers/azure_openai/provider.py

@@ -33,11 +33,10 @@ class AzureOpenAIProvider(LLMProvider):
         self._auth_manager = auth_manager or LLMAuthManager()
         self._api_key = self._auth_manager.get_credentials(type(self).NAME)
         if not self._api_key:
-            print(f"[ERROR] No API key found for provider '{self.name}'. Please set the API key using:")
-            print(f"  janito --set-api-key YOUR_API_KEY -p {self.name}")
-            print(f"Or set the AZURE_OPENAI_API_KEY environment variable.")
-            return
-        
+            from janito.llm.auth_utils import handle_missing_api_key
+
+            handle_missing_api_key(self.name, "AZURE_OPENAI_API_KEY")
+
         self._tools_adapter = get_local_tools_adapter()
         self._driver_config = config or LLMDriverConfig(model=None)
         if not self._driver_config.model:

janito/providers/cerebras/__init__.py

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

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/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/providers/deepseek/provider.py

@@ -31,11 +31,10 @@ class DeepSeekProvider(LLMProvider):
             self.auth_manager = auth_manager or LLMAuthManager()
             self._api_key = self.auth_manager.get_credentials(type(self).NAME)
             if not self._api_key:
-                print(f"[ERROR] No API key found for provider '{self.name}'. Please set the API key using:")
-                print(f"  janito --set-api-key YOUR_API_KEY -p {self.name}")
-                print(f"Or set the DEEPSEEK_API_KEY environment variable.")
-                return
-            
+                from janito.llm.auth_utils import handle_missing_api_key
+
+                handle_missing_api_key(self.name, "DEEPSEEK_API_KEY")
+
             self._tools_adapter = get_local_tools_adapter()
             self._driver_config = config or LLMDriverConfig(model=None)
             if not self._driver_config.model:

janito/providers/google/provider.py

@@ -33,11 +33,10 @@ class GoogleProvider(LLMProvider):
             self.auth_manager = auth_manager or LLMAuthManager()
             self._api_key = self.auth_manager.get_credentials(type(self).name)
             if not self._api_key:
-                print(f"[ERROR] No API key found for provider '{self.name}'. Please set the API key using:")
-                print(f"  janito --set-api-key YOUR_API_KEY -p {self.name}")
-                print(f"Or set the GOOGLE_API_KEY environment variable.")
-                return
-            
+                from janito.llm.auth_utils import handle_missing_api_key
+
+                handle_missing_api_key(self.name, "GOOGLE_API_KEY")
+
             self._tools_adapter = get_local_tools_adapter()
             self._driver_config = config or LLMDriverConfig(model=None)
             # Only set default if model is not set by CLI/config

janito/providers/moonshotai/provider.py

@@ -17,44 +17,53 @@ class MoonshotAIProvider(LLMProvider):
     def __init__(
         self, auth_manager: LLMAuthManager = None, config: LLMDriverConfig = None
     ):
+        self._tools_adapter = get_local_tools_adapter()
+        self._driver = None
+
         if not self.available:
-            self._tools_adapter = get_local_tools_adapter()
-            self._driver = None
-        else:
-            self.auth_manager = auth_manager or LLMAuthManager()
-            self._api_key = self.auth_manager.get_credentials(type(self).name)
-            if not self._api_key:
-                print(f"[ERROR] No API key found for provider '{self.name}'. Please set the API key using:")
-                print(f"  janito --set-api-key YOUR_API_KEY -p {self.name}")
-                print(f"Or set the MOONSHOTAI_API_KEY environment variable.")
-                return
-            
-            self._tools_adapter = get_local_tools_adapter()
-            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
-            # Set only the correct token parameter for the model
-            model_name = self._driver_config.model
-            model_spec = self.MODEL_SPECS.get(model_name)
-            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:
-                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)
-            self.fill_missing_device_info(self._driver_config)
-            self._driver = None
-            # Set MoonshotAI base_url
-            self._driver_config.base_url = "https://api.moonshot.ai/v1"
+            return
+
+        self._initialize_config(auth_manager, config)
+        self._setup_model_config()
+        self._driver_config.base_url = "https://api.moonshot.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, "MOONSHOTAI_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
+
+    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:
+            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)
+
+        self.fill_missing_device_info(self._driver_config)
 
     @property
     def driver(self) -> OpenAIModelDriver: