janito 2.20.1__tar.gz → 2.21.0__tar.gz

{janito-2.20.1/janito.egg-info → janito-2.21.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: janito
-Version: 2.20.1
+Version: 2.21.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.20.1 → janito-2.21.0}/janito/README.md

@@ -43,7 +43,12 @@ janito -p google -m gemini-2.0-flash-exp "Generate unit tests"
 
 ### Interactive Chat Mode
 
-Start an interactive session:
+Start an interactive session (default mode):
+```bash
+janito
+```
+
+Or explicitly:
 ```bash
 janito --chat
 ```
@@ -80,17 +85,23 @@ janito --set model=kimi-k1-8k
 
 ### OpenAI
 
-- **Models**: gpt-4, gpt-4-turbo, gpt-3.5-turbo
+- **Models**: gpt-5, gpt-4.1, gpt-4o, gpt-4-turbo, gpt-3.5-turbo
 - **Setup**: Get API key from [OpenAI Platform](https://platform.openai.com/)
 
 ### Anthropic
 
-- **Models**: claude-3-5-sonnet-20241022, claude-3-opus-20240229
+- **Models**: claude-3-7-sonnet-20250219, claude-3-5-sonnet-20241022, claude-3-opus-20250514
 - **Setup**: Get API key from [Anthropic Console](https://console.anthropic.com/)
 
+### IBM WatsonX
+
+- **Models**: ibm/granite-3-8b-instruct, ibm/granite-3-2b-instruct, meta-llama/llama-3-1-8b-instruct, meta-llama/llama-3-1-70b-instruct, mistralai/mistral-large
+- **Strengths**: Enterprise-grade AI, IBM Granite models, hosted Llama and Mistral models
+- **Setup**: Get API key and project ID from [IBM Cloud](https://cloud.ibm.com/)
+
 ### Google
 
-- **Models**: gemini-2.0-flash-exp, gemini-1.5-pro
+- **Models**: gemini-2.5-flash, gemini-2.5-pro, gemini-2.5-flash-lite-preview-06-17
 - **Setup**: Get API key from [Google AI Studio](https://makersuite.google.com/)
 
 ## Advanced Features
@@ -114,12 +125,44 @@ janito --role python-expert "Optimize this algorithm"
 
 ### Environment Variables
 You can also configure via environment variables:
+
+**MoonshotAI:**
 ```bash
 export MOONSHOTAI_API_KEY=your_key_here
 export JANITO_PROVIDER=moonshotai
 export JANITO_MODEL=kimi-k1-8k
 ```
 
+**OpenAI:**
+```bash
+export OPENAI_API_KEY=your_key_here
+export JANITO_PROVIDER=openai
+export JANITO_MODEL=gpt-5
+```
+
+**IBM WatsonX:**
+```bash
+export WATSONX_API_KEY=your_key_here
+export WATSONX_PROJECT_ID=your_project_id
+export WATSONX_SPACE_ID=your_space_id  # optional
+export JANITO_PROVIDER=ibm
+export JANITO_MODEL=ibm/granite-3-8b-instruct
+```
+
+**Anthropic:**
+```bash
+export ANTHROPIC_API_KEY=your_key_here
+export JANITO_PROVIDER=anthropic
+export JANITO_MODEL=claude-3-7-sonnet-20250219
+```
+
+**Google:**
+```bash
+export GOOGLE_API_KEY=your_key_here
+export JANITO_PROVIDER=google
+export JANITO_MODEL=gemini-2.5-flash
+```
+
 ## Examples
 
 ### Code Generation

janito-2.21.0/janito/docs/GETTING_STARTED.md

@@ -0,0 +1,190 @@
+# Getting Started with Janito
+
+This guide will help you set up Janito CLI quickly and start using it with your preferred AI provider.
+
+## Quick Setup (2 minutes)
+
+### 1. Install Janito
+```bash
+pip install janito
+```
+
+### 2. Choose Your Provider
+
+Janito supports multiple AI providers. Choose one to get started:
+
+**MoonshotAI (Recommended for Chinese users)**
+1. Go to [Moonshot AI Platform](https://platform.moonshot.cn/)
+2. Sign up for an account
+3. Navigate to API Keys section
+4. Create a new API key
+
+**OpenAI**
+1. Go to [OpenAI Platform](https://platform.openai.com/)
+2. Sign up and add payment method
+3. Create an API key
+
+**IBM WatsonX**
+1. Go to [IBM Cloud](https://cloud.ibm.com/)
+2. Create a WatsonX AI service
+3. Get your API key and project ID
+
+### 3. Configure Janito
+
+**MoonshotAI Setup:**
+```bash
+# Set MoonshotAI as your default provider
+janito --set-api-key YOUR_API_KEY -p moonshotai
+
+# Verify it's working
+janito "Hello, can you introduce yourself?"
+```
+
+**OpenAI Setup:**
+```bash
+# Set OpenAI as your default provider
+janito --set-api-key YOUR_OPENAI_API_KEY -p openai
+
+# Verify it's working
+janito "Hello, can you introduce yourself?"
+```
+
+**IBM WatsonX Setup:**
+```bash
+# Set IBM WatsonX as your default provider
+janito --set-api-key YOUR_WATSONX_API_KEY -p ibm
+janito --set-config ibm project_id YOUR_PROJECT_ID
+
+# Verify it's working
+janito "Hello, can you introduce yourself?"
+```
+
+## Your First Commands
+
+### Basic Usage
+```bash
+# Simple prompt
+janito "Create a Python script to calculate fibonacci numbers"
+
+# With specific model
+janito -m kimi-k1-8k "Explain machine learning in simple terms"
+
+# Interactive chat mode
+janito --chat
+```
+
+### Working with Files
+```bash
+# Analyze a file
+janito "Analyze the performance of my_app.py" < my_app.py
+
+# Generate code in a specific directory
+janito -W ./my_project "Create a REST API with FastAPI"
+```
+
+## Configuration Options
+
+### Set as Default Provider
+```bash
+# Make your chosen provider the permanent default
+janito --set provider=moonshotai  # or openai, ibm, etc.
+janito --set model=kimi-k1-8k     # or gpt-5, ibm/granite-3-8b-instruct, etc.
+```
+
+### Environment Variables
+You can also use environment variables:
+
+**MoonshotAI:**
+```bash
+export MOONSHOTAI_API_KEY=your_key_here
+export JANITO_PROVIDER=moonshotai
+export JANITO_MODEL=kimi-k1-8k
+```
+
+**OpenAI:**
+```bash
+export OPENAI_API_KEY=your_key_here
+export JANITO_PROVIDER=openai
+export JANITO_MODEL=gpt-5
+```
+
+**IBM WatsonX:**
+```bash
+export WATSONX_API_KEY=your_key_here
+export WATSONX_PROJECT_ID=your_project_id
+export WATSONX_SPACE_ID=your_space_id  # optional
+export JANITO_PROVIDER=ibm
+export JANITO_MODEL=ibm/granite-3-3-8b-instruct
+```
+
+## Available Models by Provider
+
+### MoonshotAI Models
+- **kimi-k1-8k**: Fast responses, good for general tasks
+- **kimi-k1-32k**: Better for longer contexts
+- **kimi-k1-128k**: Best for very long documents
+- **kimi-k2-turbo-preview**: Latest model with enhanced capabilities
+- **kimi-k2-turbo-preview**: Turbo version of the advanced reasoning model
+
+### OpenAI Models
+- **gpt-5**: Latest GPT model with advanced capabilities
+- **gpt-4.1**: High-performance model for complex tasks
+- **gpt-4o**: Optimized for speed and cost
+- **o3-mini**: Reasoning-focused model
+
+### IBM WatsonX Models
+- **ibm/granite-3-3-8b-instruct**: IBM's latest Granite 3.3 8B Instruct model (default)
+- **ibm/granite-3-8b-instruct**: IBM's Granite 3 8B Instruct model
+- **meta-llama/llama-3-3-70b-instruct**: Meta Llama 3.3 70B hosted on WatsonX
+- **meta-llama/llama-3-1-70b-instruct**: Meta Llama 3.1 70B hosted on WatsonX
+- **mistralai/mistral-large-2407**: Latest Mistral Large model hosted on WatsonX
+
+## Next Steps
+
+1. **Explore tools**: Run `janito --list-tools` to see available tools
+2. **Try chat mode**: Run `janito --chat` for interactive sessions
+3. **Check examples**: Look at the main README.md for more usage examples
+4. **Join community**: Get help and share tips with other users
+
+## Troubleshooting
+
+### Common Issues
+
+**"Provider not found" error**
+```bash
+# Check available providers
+janito --list-providers
+
+# Re-register your provider
+janito --set-api-key YOUR_KEY -p YOUR_PROVIDER
+```
+
+**"Model not available" error**
+```bash
+# List available models for your provider
+janito -p YOUR_PROVIDER --list-models
+```
+
+**API key issues**
+```bash
+# Check current configuration
+janito --show-config
+
+# Reset API key
+janito --set-api-key NEW_KEY -p YOUR_PROVIDER
+```
+
+**IBM WatsonX specific issues**
+```bash
+# Check if project ID is set
+janito --show-config
+
+# Set project ID if missing
+janito --set-config ibm project_id YOUR_PROJECT_ID
+```
+
+### Getting Help
+
+- Check the main README.md for comprehensive documentation
+- Use `janito --help` for command-line options
+- Visit our GitHub repository for issues and discussions

{janito-2.20.1 → janito-2.21.0}/janito/providers/__init__.py

@@ -9,3 +9,4 @@ import janito.providers.alibaba.provider
 import janito.providers.zai.provider
 import janito.providers.cerebras.provider
 import janito.providers.mistral.provider
+import janito.providers.ibm.provider

{janito-2.20.1 → janito-2.21.0}/janito/providers/azure_openai/provider.py

@@ -82,7 +82,7 @@ class AzureOpenAIProvider(LLMProvider):
         If the model_name is not in MODEL_SPECS, return a generic info dict.
         """
         if model_name is None:
-            # Return all known specs, but note: only static ones are listed
+            # Return all known specs
             return {
                 name: model_info.to_dict()
                 for name, model_info in self.MODEL_SPECS.items()

janito-2.21.0/janito/providers/ibm/README.md

@@ -0,0 +1,99 @@
+# IBM WatsonX AI Provider
+
+This provider enables access to IBM WatsonX AI services, including IBM's Granite models and other hosted models.
+
+## Setup
+
+### Prerequisites
+
+1. **IBM Cloud Account**: You need an IBM Cloud account with WatsonX AI service enabled.
+2. **API Key**: Generate an API key from your IBM Cloud dashboard.
+3. **Project ID**: Create a WatsonX project and get the project ID.
+
+### Authentication
+
+Set up your credentials using the CLI:
+
+```bash
+# Set the API key
+janito --set-api-key YOUR_IBM_API_KEY -p ibm
+
+# Set the project ID
+janito --set-config ibm project_id YOUR_PROJECT_ID
+
+# Optional: Set space ID if using WatsonX spaces
+janito --set-config ibm space_id YOUR_SPACE_ID
+```
+
+### Environment Variables
+
+Alternatively, you can set environment variables:
+
+```bash
+export WATSONX_API_KEY="your-api-key"
+export WATSONX_PROJECT_ID="your-project-id"
+export WATSONX_SPACE_ID="your-space-id"  # optional
+```
+
+## Available Models
+
+The IBM provider supports the following models:
+
+- **ibm/granite-3-8b-instruct**: IBM's Granite 3 8B Instruct model (default)
+- **ibm/granite-3-2b-instruct**: IBM's Granite 3 2B Instruct model
+- **meta-llama/llama-3-1-8b-instruct**: Meta Llama 3.1 8B hosted on WatsonX
+- **meta-llama/llama-3-1-70b-instruct**: Meta Llama 3.1 70B hosted on WatsonX
+- **mistralai/mistral-large**: Mistral Large model hosted on WatsonX
+
+## Usage
+
+### Command Line
+
+```bash
+# Use IBM provider with default model
+janito -p ibm "Explain quantum computing"
+
+# Use specific IBM model
+janito -p ibm -m ibm/granite-3-2b-instruct "Generate a Python function"
+
+# Interactive chat mode
+janito -p ibm --chat
+```
+
+### Configuration
+
+You can set IBM as your default provider:
+
+```bash
+janito --set-config provider ibm
+```
+
+## API Reference
+
+The IBM provider uses IBM WatsonX's REST API with OpenAI-compatible format. The base URL is:
+
+```
+https://us-south.ml.cloud.ibm.com
+```
+
+## Limitations
+
+- **Rate Limits**: IBM WatsonX has rate limits based on your subscription tier
+- **Context Window**: Models have different context window limits (typically 128K tokens)
+- **Region Support**: Currently configured for US-South region
+
+## Troubleshooting
+
+### Common Issues
+
+1. **Authentication Error**: Ensure your API key and project ID are correct
+2. **Model Not Found**: Check if the model is available in your WatsonX project
+3. **Rate Limit Exceeded**: Wait and retry, or upgrade your subscription
+
+### Debug Mode
+
+Enable debug logging to see API requests:
+
+```bash
+janito -p ibm --verbose "Your prompt here"
+```

janito-2.21.0/janito/providers/ibm/__init__.py

@@ -0,0 +1 @@
+# IBM WatsonX AI Provider

janito-2.21.0/janito/providers/ibm/model_info.py

@@ -0,0 +1,78 @@
+"""IBM WatsonX AI model specifications."""
+
+from janito.llm.model import LLMModelInfo
+
+MODEL_SPECS = {
+    "ibm/granite-3-8b-instruct": LLMModelInfo(
+        name="ibm/granite-3-8b-instruct",
+        context=128000,
+        max_input=128000,
+        max_response=4096,
+        max_cot=4096,
+        thinking_supported=False,
+        category="IBM WatsonX",
+    ),
+    "ibm/granite-3-3-8b-instruct": LLMModelInfo(
+        name="ibm/granite-3-3-8b-instruct",
+        context=128000,
+        max_input=128000,
+        max_response=4096,
+        max_cot=4096,
+        thinking_supported=False,
+        category="IBM WatsonX",
+    ),
+    "meta-llama/llama-3-1-70b-instruct": LLMModelInfo(
+        name="meta-llama/llama-3-1-70b-instruct",
+        context=128000,
+        max_input=128000,
+        max_response=4096,
+        max_cot=4096,
+        thinking_supported=False,
+        category="IBM WatsonX",
+    ),
+    "meta-llama/llama-3-3-70b-instruct": LLMModelInfo(
+        name="meta-llama/llama-3-3-70b-instruct",
+        context=128000,
+        max_input=128000,
+        max_response=4096,
+        max_cot=4096,
+        thinking_supported=False,
+        category="IBM WatsonX",
+    ),
+    "mistralai/mistral-large": LLMModelInfo(
+        name="mistralai/mistral-large",
+        context=128000,
+        max_input=128000,
+        max_response=4096,
+        max_cot=4096,
+        thinking_supported=False,
+        category="IBM WatsonX",
+    ),
+    "mistralai/mistral-large-2407": LLMModelInfo(
+        name="mistralai/mistral-large-2407",
+        context=128000,
+        max_input=128000,
+        max_response=4096,
+        max_cot=4096,
+        thinking_supported=False,
+        category="IBM WatsonX",
+    ),
+    "openai/gpt-oss-120b": LLMModelInfo(
+        name="openai/gpt-oss-120b",
+        context=128000,
+        max_input=128000,
+        max_response=4096,
+        max_cot=4096,
+        thinking_supported=True,
+        category="IBM WatsonX",
+    ),
+    "openai/gpt-oss-20b": LLMModelInfo(
+        name="openai/gpt-oss-20b",
+        context=128000,
+        max_input=128000,
+        max_response=4096,
+        max_cot=4096,
+        thinking_supported=True,
+        category="IBM WatsonX",
+    ),
+}

janito-2.21.0/janito/providers/ibm/provider.py

@@ -0,0 +1,149 @@
+"""IBM WatsonX AI Provider implementation."""
+
+from janito.llm.provider import LLMProvider
+from janito.llm.auth import LLMAuthManager
+from janito.llm.driver_config import LLMDriverConfig
+from janito.tools import get_local_tools_adapter
+from janito.providers.registry import LLMProviderRegistry
+from .model_info import MODEL_SPECS
+
+try:
+    from janito.drivers.openai.driver import OpenAIModelDriver
+
+    available = True
+    unavailable_reason = None
+except ImportError as e:
+    available = False
+    unavailable_reason = str(e)
+
+
+class IBMProvider(LLMProvider):
+    """IBM WatsonX AI Provider for accessing IBM's AI services."""
+
+    name = "ibm"
+    NAME = "ibm"
+    MAINTAINER = "João Pinto <janito@ikignosis.org>"
+    MODEL_SPECS = MODEL_SPECS
+    DEFAULT_MODEL = "ibm/granite-3-3-8b-instruct"
+
+    def __init__(
+        self, auth_manager: LLMAuthManager = None, config: LLMDriverConfig = 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()
+
+    def _initialize_config(self, auth_manager, config):
+        """Initialize configuration and API credentials."""
+        self.auth_manager = auth_manager or LLMAuthManager()
+
+        # IBM WatsonX uses multiple credentials
+        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, "WATSONX_API_KEY")
+
+        # Get project ID for WatsonX
+        self._project_id = self.auth_manager.get_credentials(
+            f"{type(self).NAME}_project_id"
+        )
+        if not self._project_id:
+            from janito.llm.auth_utils import handle_missing_api_key
+
+            handle_missing_api_key(self.name, "WATSONX_PROJECT_ID")
+
+        # Get region/space ID
+        self._space_id = self.auth_manager.get_credentials(
+            f"{type(self).NAME}_space_id"
+        )
+
+        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)
+
+        # Set IBM WatsonX specific parameters
+        self._driver_config.base_url = "https://us-south.ml.cloud.ibm.com"
+        self._driver_config.project_id = self._project_id
+        if self._space_id:
+            self._driver_config.space_id = self._space_id
+
+        self.fill_missing_device_info(self._driver_config)
+
+    @property
+    def driver(self):
+        if not self.available:
+            raise ImportError(f"IBMProvider 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 configured for IBM WatsonX.
+        IBM WatsonX uses OpenAI-compatible API format.
+        """
+        driver = OpenAIModelDriver(
+            tools_adapter=self._tools_adapter, provider_name=self.NAME
+        )
+        driver.config = self._driver_config
+        return driver
+
+    def create_agent(self, tools_adapter=None, agent_name: str = None, **kwargs):
+        from janito.llm.agent import LLMAgent
+
+        if tools_adapter is None:
+            tools_adapter = get_local_tools_adapter()
+        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(IBMProvider.NAME, IBMProvider)