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

janito/docs/PROVIDERS.md

@@ -0,0 +1,224 @@
+# Provider Configuration Guide
+
+This guide covers how to configure and use different LLM providers with Janito.
+
+## MoonshotAI (Recommended)
+
+**MoonshotAI** is the recommended default provider for Janito, offering excellent performance and competitive pricing.
+
+### Setup
+```bash
+# Set API key
+janito --set-api-key YOUR_API_KEY -p moonshotai
+
+# Set as default provider
+janito --set provider=moonshotai
+janito --set model=kimi-k1-8k
+```
+
+### Available Models
+
+- **kimi-k1-8k**: Fast, general-purpose model (8k context)
+- **kimi-k1-32k**: Extended context model (32k context)
+- **kimi-k1-128k**: Long context model (128k context)
+- **kimi-k2-turbo-preview**: Latest enhanced model
+
+### Environment Variables
+```bash
+export MOONSHOTAI_API_KEY=your_key_here
+```
+
+## OpenAI
+
+### Setup
+```bash
+# Set API key
+janito --set-api-key YOUR_API_KEY -p openai
+
+# Use specific model
+janito -p openai -m gpt-4 "Your prompt"
+```
+
+### Available Models
+
+- **gpt-4**: Most capable model
+- **gpt-4-turbo**: Faster, more efficient
+- **gpt-3.5-turbo**: Cost-effective option
+
+### Environment Variables
+```bash
+export OPENAI_API_KEY=your_key_here
+```
+
+## Anthropic
+
+### Setup
+```bash
+# Set API key
+janito --set-api-key YOUR_API_KEY -p anthropic
+
+# Use Claude models
+janito -p anthropic -m claude-3-5-sonnet-20241022 "Your prompt"
+```
+
+### Available Models
+
+- **claude-3-5-sonnet-20241022**: Most capable
+- **claude-3-opus-20240229**: High performance
+- **claude-3-haiku-20240307**: Fast and cost-effective
+
+### Environment Variables
+```bash
+export ANTHROPIC_API_KEY=your_key_here
+```
+
+## Google
+
+### Setup
+```bash
+# Set API key
+janito --set-api-key YOUR_API_KEY -p google
+
+# Use Gemini models
+janito -p google -m gemini-2.0-flash-exp "Your prompt"
+```
+
+### Available Models
+
+- **gemini-2.0-flash-exp**: Latest experimental model
+- **gemini-1.5-pro**: Production-ready
+- **gemini-1.5-flash**: Fast and efficient
+
+### Environment Variables
+```bash
+export GOOGLE_API_KEY=your_key_here
+```
+
+## Azure OpenAI
+
+### Setup
+```bash
+# Set configuration
+janito --set-api-key YOUR_API_KEY -p azure-openai
+janito --set azure_deployment_name=your_deployment_name -p azure-openai
+```
+
+### Configuration
+
+Requires both API key and deployment name:
+
+- **API Key**: Your Azure OpenAI key
+- **Deployment Name**: Your Azure deployment name
+- **Base URL**: Your Azure endpoint URL
+
+### Environment Variables
+```bash
+export AZURE_OPENAI_API_KEY=your_key_here
+export AZURE_OPENAI_ENDPOINT=https://your-resource.openai.azure.com/
+```
+
+## Other Providers
+
+Janito also supports these providers through OpenAI-compatible APIs:
+
+### Alibaba Cloud
+```bash
+janito --set-api-key YOUR_KEY -p alibaba
+```
+
+### DeepSeek
+```bash
+janito --set-api-key YOUR_KEY -p deepseek
+```
+
+### Groq
+```bash
+janito --set-api-key YOUR_KEY -p groq
+```
+
+### Mistral
+```bash
+janito --set-api-key YOUR_KEY -p mistral
+```
+
+## Configuration Management
+
+### Check Current Configuration
+```bash
+janito --show-config
+```
+
+### List All Providers
+```bash
+janito --list-providers
+```
+
+### List Models for a Provider
+```bash
+janito -p moonshotai --list-models
+janito -p openai --list-models
+```
+
+### Switch Providers
+```bash
+# Temporarily for one command
+janito -p openai -m gpt-4 "Your prompt"
+
+# Permanently as default
+janito --set provider=openai
+janito --set model=gpt-4
+```
+
+## Advanced Configuration
+
+### Custom Base URLs
+For OpenAI-compatible providers, you can set custom base URLs:
+
+```bash
+janito --set base_url=https://your-custom-endpoint.com -p openai
+```
+
+### Provider-Specific Settings
+Each provider can have custom settings:
+
+```bash
+# Set temperature for a specific provider/model
+janito --set temperature=0.7 -p moonshotai -m kimi-k1-8k
+
+# Set max tokens
+janito --set max_tokens=2000 -p openai -m gpt-4
+```
+
+## Troubleshooting
+
+### Provider Not Found
+```bash
+# Check if provider is registered
+janito --list-providers
+
+# Re-register provider
+janito --set-api-key YOUR_KEY -p PROVIDER_NAME
+```
+
+### API Key Issues
+```bash
+# Check current API key
+janito --show-config
+
+# Reset API key
+janito --set-api-key NEW_KEY -p PROVIDER_NAME
+```
+
+### Model Not Available
+```bash
+# List available models for provider
+janito -p PROVIDER_NAME --list-models
+```
+
+## Best Practices
+
+1. **Start with MoonshotAI**: It's the recommended default for good reason
+2. **Use environment variables**: For CI/CD and containerized environments
+3. **Test different models**: Each has different strengths and pricing
+4. **Monitor usage**: Keep track of API costs and rate limits
+5. **Use profiles**: Set up different configurations for different use cases

janito/drivers/azure_openai/driver.py

@@ -63,6 +63,13 @@ class AzureOpenAIModelDriver(OpenAIModelDriver):
 
     def _instantiate_openai_client(self, config):
         try:
+            if not config.api_key:
+                provider_name = getattr(self, 'provider_name', 'Azure OpenAI')
+                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 azure-openai")
+                print(f"Or set the AZURE_OPENAI_API_KEY environment variable.")
+                raise ValueError(f"API key is required for provider '{provider_name}'")
+
             from openai import AzureOpenAI
 
             api_key_display = str(config.api_key)

janito/drivers/openai/driver.py

@@ -74,8 +74,9 @@ class OpenAIModelDriver(LLMDriver):
                 api_kwargs[p] = v
         api_kwargs["messages"] = conversation
         api_kwargs["stream"] = False
-        if self.tools_adapter and self.tools_adapter.get_tool_classes():
-            api_kwargs["parallel_tool_calls"] = True
+        # Always return the prepared kwargs, even if no tools are registered. The
+        # OpenAI Python SDK expects a **mapping** – passing *None* will raise
+        # ``TypeError: argument after ** must be a mapping, not NoneType``.
         return api_kwargs
 
     def _call_api(self, driver_input: DriverInput):
@@ -245,6 +246,13 @@ 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}'")
+
             api_key_display = str(config.api_key)
             if api_key_display and len(api_key_display) > 8:
                 api_key_display = api_key_display[:4] + "..." + api_key_display[-4:]

janito/llm/provider.py

@@ -17,7 +17,7 @@ class LLMProvider(ABC):
     Abstract base class for Large Language Model (LLM) providers.
 
     Provider Usage and Driver Communication Flow:
-      1. Provider class is selected (e.g., OpenAIProvider, MistralProvider).
+      1. Provider class is selected (e.g., OpenAIProvider).
       2. An instance of the provider is created. This instance is bound to a specific configuration (LLMDriverConfig) containing model, credentials, etc.
       3. All drivers created by that provider instance are associated with the bound config.
       4. To communicate with an LLM, call create_driver() on the provider instance, which yields a driver configured for the attached config. Every driver created via this method inherits the provider's configuration.

janito/mkdocs.yml

@@ -0,0 +1,40 @@
+site_name: Janito CLI Documentation
+site_description: A powerful command-line tool for running LLM-powered workflows
+site_url: https://janito.readthedocs.io/
+
+nav:
+  - Home: README.md
+  - Getting Started: docs/GETTING_STARTED.md
+  - Providers: docs/PROVIDERS.md
+  - Tools: docs/TOOLS_REFERENCE.md
+
+markdown_extensions:
+  - admonition
+  - codehilite
+  - toc:
+      permalink: true
+  - pymdownx.superfences
+  - pymdownx.tabbed:
+      alternate_style: true
+
+theme:
+  name: material
+  palette:
+    - scheme: default
+      primary: blue
+      accent: blue
+  features:
+    - navigation.tabs
+    - navigation.sections
+    - navigation.expand
+    - search.highlight
+    - search.share
+
+repo_url: https://github.com/ikignosis/janito
+repo_name: ikignosis/janito
+edit_uri: edit/main/docs/
+
+extra:
+  social:
+    - icon: fontawesome/brands/github
+      link: https://github.com/ikignosis/janito

janito/provider_registry.py

@@ -93,11 +93,21 @@ class ProviderRegistry:
                 model_specs = model_info_mod.MODEL_SPECS
             elif hasattr(model_info_mod, "MOONSHOTAI_MODEL_SPECS"):
                 model_specs = model_info_mod.MOONSHOTAI_MODEL_SPECS
-
-            if provider_name == "groq":
-                return "<any> (must be provided)"
+            
             if model_specs:
-                return ", ".join(model_specs.keys())
+                default_model = getattr(provider_class, "DEFAULT_MODEL", None)
+                model_names = []
+                
+                for model_key in model_specs.keys():
+                    if model_key == default_model:
+                        # Highlight the default model with color and star icon
+                        model_names.append(f"[bold green]⭐ {model_key}[/bold green]")
+                    else:
+                        model_names.append(model_key)
+                
+                if provider_name == "moonshotai":
+                    return ", ".join(model_names)
+                return ", ".join(model_names)
             return "-"
         except Exception as e:
             return "-"

janito/providers/__init__.py

@@ -5,4 +5,4 @@ import janito.providers.azure_openai.provider
 import janito.providers.anthropic.provider
 import janito.providers.deepseek.provider
 import janito.providers.moonshotai.provider
-import janito.providers.groq.provider
+import janito.providers.alibaba.provider

janito/providers/alibaba/model_info.py

@@ -0,0 +1,33 @@
+from janito.llm.model import LLMModelInfo
+
+MODEL_SPECS = {
+    "qwen-turbo": LLMModelInfo(
+        name="qwen-turbo",
+        context=1008192,
+        max_response=8192,
+        category="Alibaba Qwen Turbo Model (OpenAI-compatible)",
+        driver="OpenAIModelDriver",
+    ),
+    "qwen-plus": LLMModelInfo(
+        name="qwen-plus", 
+        context=131072,
+        max_response=8192,
+        category="Alibaba Qwen Plus Model (OpenAI-compatible)",
+        driver="OpenAIModelDriver",
+    ),
+    "qwen-max": LLMModelInfo(
+        name="qwen-max",
+        context=32768, 
+        max_response=8192,
+        category="Alibaba Qwen Max Model (OpenAI-compatible)",
+        driver="OpenAIModelDriver",
+    ),
+
+    "qwen3-coder-plus": LLMModelInfo(
+        name="qwen3-coder-plus",
+        context=1048576,
+        max_response=65536,
+        category="Alibaba Qwen3 Coder Plus Model (OpenAI-compatible)",
+        driver="OpenAIModelDriver",
+    ),
+}

janito/providers/alibaba/provider.py

@@ -0,0 +1,102 @@
+from janito.llm.provider import LLMProvider
+from janito.llm.model import LLMModelInfo
+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
+from queue import Queue
+
+available = OpenAIModelDriver.available
+unavailable_reason = OpenAIModelDriver.unavailable_reason
+
+
+class AlibabaProvider(LLMProvider):
+    name = "alibaba"
+    NAME = "alibaba"
+    MAINTAINER = "João Pinto <janito@ikignosis.org>"
+    MODEL_SPECS = MODEL_SPECS
+    DEFAULT_MODEL = "qwen-turbo"  # Options: qwen-turbo, qwen-plus, qwen-max
+
+    def __init__(
+        self, auth_manager: LLMAuthManager = None, config: LLMDriverConfig = None
+    ):
+        # 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.")
+            
+            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.fill_missing_device_info(self._driver_config)
+            self._driver = None  # to be provided by factory/agent
+
+    @property
+    def driver(self) -> OpenAIModelDriver:
+        if not self.available:
+            raise ImportError(f"AlibabaProvider unavailable: {self.unavailable_reason}")
+        return self._driver
+
+    @property
+    def available(self):
+        return available
+
+    @property
+    def unavailable_reason(self):
+        return unavailable_reason
+
+    def create_driver(self):
+        """
+        Creates and returns a new OpenAIModelDriver instance with input/output queues.
+        """
+        driver = OpenAIModelDriver(
+            tools_adapter=self._tools_adapter, provider_name=self.name
+        )
+        driver.config = self.driver_config
+        # NOTE: The caller is responsible for calling driver.start() if background processing is needed.
+        return driver
+
+    def create_agent(self, tools_adapter=None, agent_name: str = None, **kwargs):
+        from janito.llm.agent import LLMAgent
+
+        # Always create a new driver with the passed-in tools_adapter
+        if tools_adapter is None:
+            tools_adapter = get_local_tools_adapter()
+        # Should use new-style driver construction via queues/factory (handled elsewhere)
+        raise NotImplementedError(
+            "create_agent must be constructed via new factory using input/output queues and config."
+        )
+
+    @property
+    def model_name(self):
+        return self._driver_config.model
+
+    @property
+    def driver_config(self):
+        """Public, read-only access to the provider's LLMDriverConfig object."""
+        return self._driver_config
+
+    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)
+
+
+LLMProviderRegistry.register(AlibabaProvider.NAME, AlibabaProvider)

janito/providers/anthropic/provider.py

@@ -21,6 +21,12 @@ class AnthropicProvider(LLMProvider):
         self._tools_adapter = get_local_tools_adapter()
         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
+        
         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

@@ -11,13 +11,13 @@ from janito.drivers.azure_openai.driver import AzureOpenAIModelDriver
 
 available = AzureOpenAIModelDriver.available
 unavailable_reason = AzureOpenAIModelDriver.unavailable_reason
-maintainer = "João Pinto <lamego.pinto@gmail.com>"
+maintainer = "João Pinto <janito@ikignosis.org>"
 
 
 class AzureOpenAIProvider(LLMProvider):
     name = "azure_openai"
     NAME = "azure_openai"
-    MAINTAINER = "João Pinto <lamego.pinto@gmail.com>"
+    MAINTAINER = "João Pinto <janito@ikignosis.org>"
     MODEL_SPECS = MODEL_SPECS
     DEFAULT_MODEL = "azure_openai_deployment"
 
@@ -32,6 +32,12 @@ class AzureOpenAIProvider(LLMProvider):
             return
         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
+        
         self._tools_adapter = get_local_tools_adapter()
         self._driver_config = config or LLMDriverConfig(model=None)
         if not self._driver_config.model:

janito/providers/deepseek/provider.py

@@ -15,7 +15,7 @@ unavailable_reason = OpenAIModelDriver.unavailable_reason
 class DeepSeekProvider(LLMProvider):
     name = "deepseek"
     NAME = "deepseek"
-    MAINTAINER = "João Pinto <lamego.pinto@gmail.com>"
+    MAINTAINER = "João Pinto <janito@ikignosis.org>"
     MODEL_SPECS = MODEL_SPECS
     DEFAULT_MODEL = "deepseek-chat"  # Options: deepseek-chat, deepseek-reasoner
 
@@ -30,6 +30,12 @@ class DeepSeekProvider(LLMProvider):
         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 DEEPSEEK_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:

janito/providers/google/provider.py

@@ -17,7 +17,7 @@ except ImportError:
 class GoogleProvider(LLMProvider):
     name = "google"
     NAME = "google"
-    MAINTAINER = "João Pinto <lamego.pinto@gmail.com>"
+    MAINTAINER = "João Pinto <janito@ikignosis.org>"
     MODEL_SPECS = MODEL_SPECS
     DEFAULT_MODEL = "gemini-2.5-flash"  # Default Gemini model
 
@@ -32,6 +32,12 @@ class GoogleProvider(LLMProvider):
         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 GOOGLE_API_KEY environment variable.")
+                return
+            
             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/model_info.py

@@ -12,4 +12,15 @@ MOONSHOTAI_MODEL_SPECS = {
         open="moonshotai",
         driver="OpenAIModelDriver",
     ),
+    "kimi-k2-turbo-preview": LLMModelInfo(
+        name="kimi-k2-turbo-preview",
+        context=128000,
+        max_input=100000,
+        max_cot="N/A",
+        max_response=4096,
+        thinking_supported=False,
+        default_temp=0.2,
+        open="moonshotai",
+        driver="OpenAIModelDriver",
+    ),
 }

janito/providers/moonshotai/provider.py

@@ -10,9 +10,9 @@ from .model_info import MOONSHOTAI_MODEL_SPECS
 class MoonshotAIProvider(LLMProvider):
     name = "moonshotai"
     NAME = "moonshotai"
-    MAINTAINER = "João Pinto <lamego.pinto@gmail.com>"
+    MAINTAINER = "João Pinto <janito@ikignosis.org>"
     MODEL_SPECS = MOONSHOTAI_MODEL_SPECS
-    DEFAULT_MODEL = "kimi-k2-0711-preview"
+    DEFAULT_MODEL = "kimi-k2-turbo-preview"
 
     def __init__(
         self, auth_manager: LLMAuthManager = None, config: LLMDriverConfig = None
@@ -23,6 +23,12 @@ class MoonshotAIProvider(LLMProvider):
         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:

janito/providers/openai/provider.py

@@ -15,7 +15,7 @@ unavailable_reason = OpenAIModelDriver.unavailable_reason
 class OpenAIProvider(LLMProvider):
     name = "openai"
     NAME = "openai"
-    MAINTAINER = "João Pinto <lamego.pinto@gmail.com>"
+    MAINTAINER = "João Pinto <janito@ikignosis.org>"
     MODEL_SPECS = MODEL_SPECS
     DEFAULT_MODEL = "gpt-4.1"  # Options: gpt-4.1, gpt-4o, o3-mini, o4-mini,
 
@@ -31,6 +31,12 @@ class OpenAIProvider(LLMProvider):
         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 OPENAI_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: