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

janito/cli/chat_mode/session.py

@@ -109,6 +109,9 @@ class ChatSession:
         )
         self._support = False
 
+        # Check if multi-line mode should be enabled by default
+        self.multi_line_mode = getattr(args, "multi", False) if args else False
+
     def _select_profile_and_role(self, args, role):
         profile = getattr(args, "profile", None) if args is not None else None
         role_arg = getattr(args, "role", None) if args is not None else None
@@ -213,6 +216,11 @@ class ChatSession:
             f"[green]Working Dir:[/green] {cwd_display}  |  {priv_status}"
         )
 
+        if self.multi_line_mode:
+            self.console.print(
+                "[blue]Multi-line input mode enabled (Esc+Enter or Ctrl+D to submit)[/blue]"
+            )
+
         from janito.cli.chat_mode.shell.commands._priv_check import (
             user_has_any_privileges,
         )
@@ -305,6 +313,7 @@ class ChatSession:
             bottom_toolbar=lambda: get_toolbar_func(
                 self.performance_collector, 0, self.shell_state
             )(),
+            multiline=self.multi_line_mode,
         )
 
     def _handle_input(self, session):

janito/cli/core/model_guesser.py

@@ -0,0 +1,51 @@
+"""
+Module for guessing the provider based on model names.
+"""
+
+from janito.providers.registry import LLMProviderRegistry
+
+
+def guess_provider_from_model(model_name: str) -> str:
+    """
+    Guess the provider based on the model name.
+    
+    Args:
+        model_name: The name of the model to guess the provider for
+        
+    Returns:
+        The provider name if a match is found, None otherwise
+    """
+    if not model_name:
+        return None
+    
+    model_name = model_name.lower()
+    
+    # Check each provider's models
+    for provider_name in LLMProviderRegistry.list_providers():
+        provider_class = LLMProviderRegistry.get(provider_name)
+        if not provider_class:
+            continue
+            
+        # Get model specs for this provider
+        try:
+            if hasattr(provider_class, 'MODEL_SPECS'):
+                model_specs = provider_class.MODEL_SPECS
+                for spec_model_name in model_specs.keys():
+                    if spec_model_name.lower() == model_name:
+                        return provider_name
+            
+            # Handle special cases like moonshotai
+            if provider_name == "moonshotai":
+                try:
+                    from janito.providers.moonshotai.model_info import MOONSHOTAI_MODEL_SPECS
+                    for spec_model_name in MOONSHOTAI_MODEL_SPECS.keys():
+                        if spec_model_name.lower() == model_name:
+                            return "moonshotai"
+                except ImportError:
+                    pass
+                    
+        except Exception:
+            # Skip providers that have issues accessing model specs
+            continue
+    
+    return None

janito/cli/core/runner.py

@@ -2,6 +2,7 @@
 
 from janito.llm.driver_config import LLMDriverConfig
 from janito.provider_config import get_config_provider
+from janito.cli.core.model_guesser import guess_provider_from_model as _guess_provider_from_model
 from janito.cli.verbose_output import print_verbose_info
 
 
@@ -14,6 +15,17 @@ def _choose_provider(args):
                 "Default provider", provider, style="magenta", align_content=True
             )
         elif provider is None:
+            # Try to guess provider based on model name if -m is provided
+            model = getattr(args, "model", None)
+            if model:
+                guessed_provider = _guess_provider_from_model(model)
+                if guessed_provider:
+                    if getattr(args, "verbose", False):
+                        print_verbose_info(
+                            "Guessed provider", guessed_provider, style="magenta", align_content=True
+                        )
+                    return guessed_provider
+            
             print(
                 "Error: No provider selected and no provider found in config. Please set a provider using '-p PROVIDER', '--set provider=name', or configure a provider."
             )
@@ -191,4 +203,4 @@ def handle_runner(
 
 
 def get_prompt_mode(args):
-    return "single_shot" if getattr(args, "user_prompt", None) else "chat_mode"
+    return "single_shot" if getattr(args, "user_prompt", None) else "chat_mode"

janito/cli/main_cli.py

@@ -21,6 +21,13 @@ definition = [
             "help": "Disable path security: allow tool arguments to use any file/directory path (DANGEROUS)",
         },
     ),
+    (
+        ["--multi"],
+        {
+            "action": "store_true",
+            "help": "Start chat mode with multi-line input as default (no need for /multi command)",
+        },
+    ),
     (
         ["--profile"],
         {

janito/drivers/openai/driver.py

@@ -44,9 +44,10 @@ class OpenAIModelDriver(LLMDriver):
 
                 tool_classes = self.tools_adapter.get_tool_classes()
                 tool_schemas = generate_tool_schemas(tool_classes)
-                api_kwargs["tools"] = tool_schemas
+                if tool_schemas:  # Only add tools if we have actual schemas
+                    api_kwargs["tools"] = tool_schemas
             except Exception as e:
-                api_kwargs["tools"] = []
+                # Don't add empty tools array - some providers reject it
                 if hasattr(config, "verbose_api") and config.verbose_api:
                     print(f"[OpenAIModelDriver] Tool schema generation failed: {e}")
         # OpenAI-specific parameters

janito/drivers/zai/__init__.py

@@ -0,0 +1 @@
+# Z.AI driver package

janito/drivers/zai/driver.py

@@ -0,0 +1,465 @@
+import uuid
+import traceback
+import re
+import json
+import math
+import time
+import os
+import logging
+from rich import pretty
+from janito.llm.driver import LLMDriver
+from janito.llm.driver_input import DriverInput
+from janito.driver_events import RequestFinished, RequestStatus, RateLimitRetry
+from janito.llm.message_parts import TextMessagePart, FunctionCallMessagePart
+
+import openai
+
+
+class ZAIModelDriver(LLMDriver):
+    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:
+            return result.choices[0].message
+        return None
+
+    """
+    Z.AI LLM driver (threaded, queue-based, stateless). Uses input/output queues accessible via instance attributes.
+    """
+
+    def __init__(self, tools_adapter=None, provider_name=None):
+        super().__init__(tools_adapter=tools_adapter, provider_name=provider_name)
+
+    def _prepare_api_kwargs(self, config, conversation):
+        """
+        Prepares API kwargs for Z.AI, including tool schemas if tools_adapter is present,
+        and Z.AI-specific arguments (model, max_tokens, temperature, etc.).
+        """
+        api_kwargs = {}
+        # Tool schemas (moved from base)
+        if self.tools_adapter:
+            try:
+                from janito.providers.zai.schema_generator import (
+                    generate_tool_schemas,
+                )
+
+                tool_classes = self.tools_adapter.get_tool_classes()
+                tool_schemas = generate_tool_schemas(tool_classes)
+                api_kwargs["tools"] = tool_schemas
+            except Exception as e:
+                api_kwargs["tools"] = []
+                if hasattr(config, "verbose_api") and config.verbose_api:
+                    print(f"[ZAIModelDriver] Tool schema generation failed: {e}")
+        # Z.AI-specific parameters
+        if config.model:
+            api_kwargs["model"] = config.model
+        # Prefer max_completion_tokens if present, else fallback to max_tokens (for backward compatibility)
+        if (
+            hasattr(config, "max_completion_tokens")
+            and config.max_completion_tokens is not None
+        ):
+            api_kwargs["max_completion_tokens"] = int(config.max_completion_tokens)
+        elif hasattr(config, "max_tokens") and config.max_tokens is not None:
+            # For models that do not support 'max_tokens', map to 'max_completion_tokens'
+            api_kwargs["max_completion_tokens"] = int(config.max_tokens)
+        for p in (
+            "temperature",
+            "top_p",
+            "presence_penalty",
+            "frequency_penalty",
+            "stop",
+            "reasoning_effort",
+        ):
+            v = getattr(config, p, None)
+            if v is not None:
+                api_kwargs[p] = v
+        api_kwargs["messages"] = conversation
+        api_kwargs["stream"] = False
+        # 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):
+        """Call the Z.AI-compatible chat completion endpoint with retry and error handling."""
+        cancel_event = getattr(driver_input, "cancel_event", None)
+        config = driver_input.config
+        conversation = self.convert_history_to_api_messages(
+            driver_input.conversation_history
+        )
+        request_id = getattr(config, "request_id", None)
+        self._print_api_call_start(config)
+        client = self._instantiate_zai_client(config)
+        api_kwargs = self._prepare_api_kwargs(config, conversation)
+        max_retries = getattr(config, "max_retries", 3)
+        attempt = 1
+        while True:
+            try:
+                self._print_api_attempt(config, attempt, max_retries, api_kwargs)
+                if self._check_cancel(cancel_event, request_id, before_call=True):
+                    return None
+                result = client.chat.completions.create(**api_kwargs)
+                if self._check_cancel(cancel_event, request_id, before_call=False):
+                    return None
+                self._handle_api_success(config, result, request_id)
+                return result
+            except Exception as e:
+                if self._handle_api_exception(
+                    e, config, api_kwargs, attempt, max_retries, request_id
+                ):
+                    attempt += 1
+                    continue
+                raise
+
+    def _print_api_call_start(self, config):
+        if getattr(config, "verbose_api", False):
+            tool_adapter_name = (
+                type(self.tools_adapter).__name__ if self.tools_adapter else None
+            )
+            tool_names = []
+            if self.tools_adapter and hasattr(self.tools_adapter, "list_tools"):
+                try:
+                    tool_names = self.tools_adapter.list_tools()
+                except Exception:
+                    tool_names = ["<error retrieving tools>"]
+            print(
+                f"[verbose-api] Z.AI API call about to be sent. Model: {config.model}, max_tokens: {config.max_tokens}, tools_adapter: {tool_adapter_name}, tool_names: {tool_names}",
+                flush=True,
+            )
+
+    def _print_api_attempt(self, config, attempt, max_retries, api_kwargs):
+        if getattr(config, "verbose_api", False):
+            print(
+                f"[Z.AI] API CALL (attempt {attempt}/{max_retries}): chat.completions.create(**{api_kwargs})",
+                flush=True,
+            )
+
+    def _handle_api_success(self, config, result, request_id):
+        self._print_verbose_result(config, result)
+        usage_dict = self._extract_usage(result)
+        if getattr(config, "verbose_api", False):
+            print(
+                f"[Z.AI][DEBUG] Attaching usage info to RequestFinished: {usage_dict}",
+                flush=True,
+            )
+        self.output_queue.put(
+            RequestFinished(
+                driver_name=self.__class__.__name__,
+                request_id=request_id,
+                response=result,
+                status=RequestStatus.SUCCESS,
+                usage=usage_dict,
+            )
+        )
+        if getattr(config, "verbose_api", False):
+            pretty.install()
+            print("[Z.AI] API RESPONSE:", flush=True)
+            pretty.pprint(result)
+
+    def _handle_api_exception(
+        self, e, config, api_kwargs, attempt, max_retries, request_id
+    ):
+        status_code = getattr(e, "status_code", None)
+        err_str = str(e)
+        lower_err = err_str.lower()
+        is_insufficient_quota = (
+            "insufficient_quota" in lower_err
+            or "exceeded your current quota" in lower_err
+        )
+        is_rate_limit = (
+            status_code == 429
+            or "error code: 429" in lower_err
+            or "resource_exhausted" in lower_err
+        ) and not is_insufficient_quota
+        if not is_rate_limit or attempt > max_retries:
+            self._handle_fatal_exception(e, config, api_kwargs)
+        retry_delay = self._extract_retry_delay_seconds(e)
+        if retry_delay is None:
+            retry_delay = min(2 ** (attempt - 1), 30)
+        self.output_queue.put(
+            RateLimitRetry(
+                driver_name=self.__class__.__name__,
+                request_id=request_id,
+                attempt=attempt,
+                retry_delay=retry_delay,
+                error=err_str,
+                details={},
+            )
+        )
+        if getattr(config, "verbose_api", False):
+            print(
+                f"[Z.AI][RateLimit] Attempt {attempt}/{max_retries} failed with rate-limit. Waiting {retry_delay}s before retry.",
+                flush=True,
+            )
+        start_wait = time.time()
+        while time.time() - start_wait < retry_delay:
+            if self._check_cancel(
+                getattr(config, "cancel_event", None), request_id, before_call=False
+            ):
+                return False
+            time.sleep(0.1)
+        return True
+
+    def _extract_retry_delay_seconds(self, exception) -> float | None:
+        """Extract the retry delay in seconds from the provider error response.
+
+        Handles both the Google Gemini style ``RetryInfo`` protobuf (where it's a
+        ``retryDelay: '41s'`` string in JSON) and any number found after the word
+        ``retryDelay``. Returns ``None`` if no delay could be parsed.
+        """
+        try:
+            # Some SDKs expose the raw response JSON on e.args[0]
+            if hasattr(exception, "response") and hasattr(exception.response, "text"):
+                payload = exception.response.text
+            else:
+                payload = str(exception)
+            # Look for 'retryDelay': '41s' or similar
+            m = re.search(
+                r"retryDelay['\"]?\s*[:=]\s*['\"]?(\d+(?:\.\d+)?)(s)?", payload
+            )
+            if m:
+                return float(m.group(1))
+            # Fallback: generic number of seconds in the message
+            m2 = re.search(r"(\d+(?:\.\d+)?)\s*s(?:econds)?", payload)
+            if m2:
+                return float(m2.group(1))
+        except Exception:
+            pass
+        return None
+
+    def _handle_fatal_exception(self, e, config, api_kwargs):
+        """Common path for unrecoverable exceptions.
+
+        Prints diagnostics (respecting ``verbose_api``) then re-raises the
+        exception so standard error handling in ``LLMDriver`` continues.
+        """
+        is_verbose = getattr(config, "verbose_api", False)
+        if is_verbose:
+            print(f"[ERROR] Exception during Z.AI API call: {e}", flush=True)
+            print(f"[ERROR] config: {config}", flush=True)
+            print(
+                f"[ERROR] api_kwargs: {api_kwargs if 'api_kwargs' in locals() else 'N/A'}",
+                flush=True,
+            )
+            print("[ERROR] Full stack trace:", flush=True)
+            print(traceback.format_exc(), flush=True)
+        raise
+
+    def _instantiate_zai_client(self, config):
+        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."
+                )
+                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:]
+            client_kwargs = {
+                "api_key": config.api_key,
+                "base_url": "https://api.z.ai/api/paas/v4",
+            }
+
+            # HTTP debug wrapper
+            if os.environ.get("ZAI_DEBUG_HTTP", "0") == "1":
+                from http.client import HTTPConnection
+
+                HTTPConnection.debuglevel = 1
+                logging.basicConfig()
+                logging.getLogger().setLevel(logging.DEBUG)
+                requests_log = logging.getLogger("http.client")
+                requests_log.setLevel(logging.DEBUG)
+                requests_log.propagate = True
+                print(
+                    "[ZAIModelDriver] HTTP debug enabled via ZAI_DEBUG_HTTP=1",
+                    flush=True,
+                )
+
+            client = openai.OpenAI(**client_kwargs)
+            return client
+        except Exception as e:
+            print(
+                f"[ERROR] Exception during Z.AI client instantiation: {e}", flush=True
+            )
+            print(traceback.format_exc(), flush=True)
+            raise
+
+    def _check_cancel(self, cancel_event, request_id, before_call=True):
+        if cancel_event is not None and cancel_event.is_set():
+            status = RequestStatus.CANCELLED
+            reason = (
+                "Cancelled before API call"
+                if before_call
+                else "Cancelled during API call"
+            )
+            self.output_queue.put(
+                RequestFinished(
+                    driver_name=self.__class__.__name__,
+                    request_id=request_id,
+                    status=status,
+                    reason=reason,
+                )
+            )
+            return True
+        return False
+
+    def _print_verbose_result(self, config, result):
+        if config.verbose_api:
+            print("[Z.AI] API RAW RESULT:", flush=True)
+            pretty.pprint(result)
+            if hasattr(result, "__dict__"):
+                print("[Z.AI] API RESULT __dict__:", flush=True)
+                pretty.pprint(result.__dict__)
+            try:
+                print("[Z.AI] API RESULT as dict:", dict(result), flush=True)
+            except Exception:
+                pass
+            print(
+                f"[Z.AI] API RESULT .usage: {getattr(result, 'usage', None)}",
+                flush=True,
+            )
+            try:
+                print(f"[Z.AI] API RESULT ['usage']: {result['usage']}", flush=True)
+            except Exception:
+                pass
+            if not hasattr(result, "usage") or getattr(result, "usage", None) is None:
+                print(
+                    "[Z.AI][WARNING] No usage info found in API response.", flush=True
+                )
+
+    def _extract_usage(self, result):
+        usage = getattr(result, "usage", None)
+        if usage is not None:
+            usage_dict = self._usage_to_dict(usage)
+            if usage_dict is None:
+                print(
+                    "[Z.AI][WARNING] Could not convert usage to dict, using string fallback.",
+                    flush=True,
+                )
+                usage_dict = str(usage)
+        else:
+            usage_dict = self._extract_usage_from_result_dict(result)
+        return usage_dict
+
+    def _usage_to_dict(self, usage):
+        if hasattr(usage, "model_dump") and callable(getattr(usage, "model_dump")):
+            try:
+                return usage.model_dump()
+            except Exception:
+                pass
+        if hasattr(usage, "dict") and callable(getattr(usage, "dict")):
+            try:
+                return usage.dict()
+            except Exception:
+                pass
+        try:
+            return dict(usage)
+        except Exception:
+            try:
+                return vars(usage)
+            except Exception:
+                pass
+        return None
+
+    def _extract_usage_from_result_dict(self, result):
+        try:
+            return result["usage"]
+        except Exception:
+            return None
+
+    def convert_history_to_api_messages(self, conversation_history):
+        """
+        Convert LLMConversationHistory to the list of dicts required by Z.AI's API.
+        Handles 'tool_results' and 'tool_calls' roles for compliance.
+        """
+        api_messages = []
+        for msg in conversation_history.get_history():
+            self._append_api_message(api_messages, msg)
+        self._replace_none_content(api_messages)
+        return api_messages
+
+    def _append_api_message(self, api_messages, msg):
+        role = msg.get("role")
+        content = msg.get("content")
+        if role == "tool_results":
+            self._handle_tool_results(api_messages, content)
+        elif role == "tool_calls":
+            self._handle_tool_calls(api_messages, content)
+        else:
+            self._handle_other_roles(api_messages, msg, role, content)
+
+    def _handle_tool_results(self, api_messages, content):
+        try:
+            results = json.loads(content) if isinstance(content, str) else content
+        except Exception:
+            results = [content]
+        for result in results:
+            if isinstance(result, dict):
+                api_messages.append(
+                    {
+                        "role": "tool",
+                        "content": result.get("content", ""),
+                        "name": result.get("name", ""),
+                        "tool_call_id": result.get("tool_call_id", ""),
+                    }
+                )
+            else:
+                api_messages.append(
+                    {
+                        "role": "tool",
+                        "content": str(result),
+                        "name": "",
+                        "tool_call_id": "",
+                    }
+                )
+
+    def _handle_tool_calls(self, api_messages, content):
+        try:
+            tool_calls = json.loads(content) if isinstance(content, str) else content
+        except Exception:
+            tool_calls = []
+        api_messages.append(
+            {"role": "assistant", "content": "", "tool_calls": tool_calls}
+        )
+
+    def _handle_other_roles(self, api_messages, msg, role, content):
+        if role == "function":
+            name = ""
+            if isinstance(msg, dict):
+                metadata = msg.get("metadata", {})
+                name = metadata.get("name", "") if isinstance(metadata, dict) else ""
+            api_messages.append({"role": "tool", "content": content, "name": name})
+        else:
+            api_messages.append(msg)
+
+    def _replace_none_content(self, api_messages):
+        for m in api_messages:
+            if m.get("content", None) is None:
+                m["content"] = ""
+
+    def _convert_completion_message_to_parts(self, message):
+        """
+        Convert a Z.AI completion message object to a list of MessagePart objects.
+        Handles text, tool calls, and can be extended for other types.
+        """
+        parts = []
+        # Text content
+        content = getattr(message, "content", None)
+        if content:
+            parts.append(TextMessagePart(content=content))
+        # Tool calls
+        tool_calls = getattr(message, "tool_calls", None) or []
+        for tool_call in tool_calls:
+            parts.append(
+                FunctionCallMessagePart(
+                    tool_call_id=getattr(tool_call, "id", ""),
+                    function=getattr(tool_call, "function", None),
+                )
+            )
+        # Extend here for other message part types if needed
+        return parts

janito/mkdocs.yml

@@ -1,6 +1,6 @@
 site_name: Janito CLI Documentation
 site_description: A powerful command-line tool for running LLM-powered workflows
-site_url: https://janito.readthedocs.io/
+site_url: https://ikignosis.github.io/janito/
 
 nav:
   - Home: README.md

janito/providers/__init__.py

@@ -6,3 +6,4 @@ import janito.providers.anthropic.provider
 import janito.providers.deepseek.provider
 import janito.providers.moonshotai.provider
 import janito.providers.alibaba.provider
+import janito.providers.zai.provider

janito/providers/alibaba/model_info.py

@@ -30,4 +30,11 @@ MODEL_SPECS = {
         category="Alibaba Qwen3 Coder Plus Model (OpenAI-compatible)",
         driver="OpenAIModelDriver",
     ),
+    "qwen3-coder-480b-a35b-instruct": LLMModelInfo(
+        name="qwen3-coder-480b-a35b-instruct",
+        context=262144,
+        max_response=65536,
+        category="Alibaba Qwen3 Coder 480B A35B Instruct Model (OpenAI-compatible)",
+        driver="OpenAIModelDriver",
+    ),
 }

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 = "qwen-turbo"  # Options: qwen-turbo, qwen-plus, qwen-max
+    DEFAULT_MODEL = "qwen3-coder-plus"  # Options: qwen-turbo, qwen-plus, qwen-max, qwen3-coder-plus
 
     def __init__(
         self, auth_manager: LLMAuthManager = None, config: LLMDriverConfig = None

janito/providers/zai/__init__.py

@@ -0,0 +1 @@
+# Z.AI provider package

janito/providers/zai/model_info.py

@@ -0,0 +1,55 @@
+from janito.llm.model import LLMModelInfo
+
+MODEL_SPECS = {
+    "glm-4.5": LLMModelInfo(
+        name="glm-4.5",
+        context=128000,
+        max_input=128000,
+        max_cot=4096,
+        max_response=4096,
+        thinking_supported=True,
+        other={
+            "description": "Z.AI's GLM-4.5 model for advanced reasoning and conversation",
+            "supports_tools": True,
+            "supports_images": True,
+            "supports_audio": False,
+            "supports_video": False,
+            "input_cost_per_1k": 0.0005,
+            "output_cost_per_1k": 0.0015,
+        },
+    ),
+    "glm-4": LLMModelInfo(
+        name="glm-4",
+        context=128000,
+        max_input=128000,
+        max_cot="N/A",
+        max_response=4096,
+        thinking_supported=False,
+        other={
+            "description": "Z.AI's GLM-4 model for general purpose tasks",
+            "supports_tools": True,
+            "supports_images": True,
+            "supports_audio": False,
+            "supports_video": False,
+            "input_cost_per_1k": 0.0003,
+            "output_cost_per_1k": 0.0009,
+        },
+    ),
+    "glm-4v": LLMModelInfo(
+        name="glm-4v",
+        context=128000,
+        max_input=128000,
+        max_cot="N/A",
+        max_response=4096,
+        thinking_supported=False,
+        other={
+            "description": "Z.AI's GLM-4V vision model for image understanding",
+            "supports_tools": True,
+            "supports_images": True,
+            "supports_audio": False,
+            "supports_video": False,
+            "input_cost_per_1k": 0.0004,
+            "output_cost_per_1k": 0.0012,
+        },
+    ),
+}

janito/providers/zai/provider.py

@@ -0,0 +1,128 @@
+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.zai.driver import ZAIModelDriver
+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 = ZAIModelDriver.available
+unavailable_reason = ZAIModelDriver.unavailable_reason
+
+
+class ZAIProvider(LLMProvider):
+    name = "zai"
+    NAME = "zai"
+    MAINTAINER = "João Pinto <janito@ikignosis.org>"
+    MODEL_SPECS = MODEL_SPECS
+    DEFAULT_MODEL = "glm-4.5"  # Options: glm-4.5, glm-4, glm-4v
+
+    def __init__(
+        self, auth_manager: LLMAuthManager = None, config: LLMDriverConfig = None
+    ):
+        if not self.available:
+            self._setup_unavailable()
+        else:
+            self._setup_available(auth_manager, config)
+
+    def _setup_unavailable(self):
+        # Even when the ZAI driver is unavailable we still need a tools adapter
+        # so that any generic logic that expects `execute_tool()` to work does not
+        # crash with an AttributeError when it tries to access `self._tools_adapter`.
+        self._tools_adapter = get_local_tools_adapter()
+        self._driver = None
+
+    def _setup_available(self, auth_manager, config):
+        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 ZAI_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
+
+        self._configure_model_tokens()
+        self.fill_missing_device_info(self._driver_config)
+        self._driver = None  # to be provided by factory/agent
+
+    def _configure_model_tokens(self):
+        # Set only the correct token parameter for the model
+        model_name = self._driver_config.model
+        model_spec = self.MODEL_SPECS.get(model_name)
+        # Remove both to avoid stale values
+        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)
+
+    @property
+    def driver(self) -> ZAIModelDriver:
+        if not self.available:
+            raise ImportError(f"ZAIProvider 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 ZAIModelDriver instance with input/output queues.
+        """
+        driver = ZAIModelDriver(
+            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(ZAIProvider.NAME, ZAIProvider)

janito/providers/zai/schema_generator.py

@@ -0,0 +1,133 @@
+"""
+Generate OpenAI-compatible tool schemas for Z.AI API.
+"""
+
+import inspect
+from typing import get_type_hints, Dict, Any, Optional, List, Union
+from janito.tools import Tool
+
+
+def generate_tool_schemas(tool_classes):
+    """
+    Generate OpenAI-compatible tool schemas from tool classes.
+
+    Args:
+        tool_classes: List of Tool classes to generate schemas for
+
+    Returns:
+        List of OpenAI-compatible tool schemas
+    """
+    schemas = []
+    for tool_class in tool_classes:
+        schema = generate_tool_schema(tool_class)
+        if schema:
+            schemas.append(schema)
+    return schemas
+
+
+def generate_tool_schema(tool_class):
+    """
+    Generate an OpenAI-compatible tool schema from a Tool class.
+
+    Args:
+        tool_class: Tool class to generate schema for
+
+    Returns:
+        OpenAI-compatible tool schema dict
+    """
+    if not issubclass(tool_class, Tool):
+        return None
+
+    tool_instance = tool_class()
+
+    # Get the execute method
+    execute_method = getattr(tool_class, "execute", None)
+    if not execute_method:
+        return None
+
+    # Get method signature and type hints
+    try:
+        sig = inspect.signature(execute_method)
+        type_hints = get_type_hints(execute_method)
+    except (ValueError, TypeError):
+        return None
+
+    # Build parameters schema
+    properties = {}
+    required = []
+
+    for param_name, param in sig.parameters.items():
+        if param_name == "self":
+            continue
+
+        param_type = type_hints.get(param_name, str)
+        param_schema = python_type_to_json_schema(param_type)
+
+        # Add description if available
+        if hasattr(tool_instance, "get_parameter_description"):
+            desc = tool_instance.get_parameter_description(param_name)
+            if desc:
+                param_schema["description"] = desc
+
+        properties[param_name] = param_schema
+
+        # Check if required
+        if param.default == inspect.Parameter.empty:
+            required.append(param_name)
+
+    schema = {
+        "type": "function",
+        "function": {
+            "name": tool_class.__name__,
+            "description": getattr(
+                tool_instance, "description", f"Execute {tool_class.__name__}"
+            ),
+            "parameters": {
+                "type": "object",
+                "properties": properties,
+                "required": required,
+                "additionalProperties": False,
+            },
+        },
+    }
+
+    return schema
+
+
+def python_type_to_json_schema(python_type):
+    """
+    Convert Python type hints to JSON schema types.
+
+    Args:
+        python_type: Python type hint
+
+    Returns:
+        JSON schema dict
+    """
+    if python_type == str:
+        return {"type": "string"}
+    elif python_type == int:
+        return {"type": "integer"}
+    elif python_type == float:
+        return {"type": "number"}
+    elif python_type == bool:
+        return {"type": "boolean"}
+    elif hasattr(python_type, "__origin__"):
+        # Handle generic types
+        origin = python_type.__origin__
+        if origin == list or origin == List:
+            args = getattr(python_type, "__args__", (str,))
+            item_type = args[0] if args else str
+            return {"type": "array", "items": python_type_to_json_schema(item_type)}
+        elif origin == dict or origin == Dict:
+            return {"type": "object"}
+        elif origin == Union:
+            args = getattr(python_type, "__args__", ())
+            # Handle Optional types (Union with None)
+            if len(args) == 2 and type(None) in args:
+                non_none_type = args[0] if args[1] is type(None) else args[1]
+                schema = python_type_to_json_schema(non_none_type)
+                return schema
+
+    # Default fallback
+    return {"type": "string"}

{janito-2.10.0.dist-info → janito-2.12.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: janito
-Version: 2.10.0
+Version: 2.12.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.10.0.dist-info → janito-2.12.0.dist-info}/RECORD

@@ -11,7 +11,7 @@ janito/exceptions.py,sha256=l4AepRdWwAuLp5fUygrBBgO9rpwgfV6JvY1afOdq2pw,913
 janito/formatting.py,sha256=SMvOmL6bst3KGcI7OLa5D4DE127fQYuHZS3oY8OPsn8,2031
 janito/formatting_token.py,sha256=9Pz0svhV0pyNuGRXSmVkGDaQC8N-koTkf50AJR_gtSo,2217
 janito/gitignore_utils.py,sha256=P3iF9fMWAomqULq2xsoqHtI9uNIFSPcagljrxZshmLw,4110
-janito/mkdocs.yml,sha256=ve0ipJDpOpetaVOtzJf2oSSCx441r1FDMv0v6iSSxhk,920
+janito/mkdocs.yml,sha256=hceV1mnCuj5Eo42jJQHSAhqHC4emiMExgnISiiwqSow,925
 janito/perf_singleton.py,sha256=g1h0Sdf4ydzegeEpJlMhQt4H0GQZ2hryXrdYOTL-b30,113
 janito/performance_collector.py,sha256=RYu4av16Trj3RljJZ8-2Gbn1KlGdJUosrcVFYtwviNI,6285
 janito/platform_discovery.py,sha256=JN3kC7hkxdvuj-AyrJTlbbDJjtNHke3fdlZDqGi_uz0,4621
@@ -28,7 +28,7 @@ janito/cli/__init__.py,sha256=xaPDOrWphBbCR63Xpcx_yfpXSJIlCaaICc4j2qpWqrM,194
 janito/cli/config.py,sha256=HkZ14701HzIqrvaNyDcDhGlVHfpX_uHlLp2rHmhRm_k,872
 janito/cli/console.py,sha256=gJolqzWL7jEPLxeuH-CwBDRFpXt976KdZOEAB2tdBDs,64
 janito/cli/main.py,sha256=s5odou0txf8pzTf1ADk2yV7T5m8B6cejJ81e7iu776U,312
-janito/cli/main_cli.py,sha256=MAAQpD7VyGHveref4XtF7WDI6Qew81yA65lu23V2LYk,14182
+janito/cli/main_cli.py,sha256=lPY3080rvDvDPQE_lhAwEuzrUeQ2Fg-DfEt4J-bWblE,14381
 janito/cli/prompt_core.py,sha256=F68J4Xl6jZMYFN4oBBYZFj15Jp-HTYoLub4bw2XpNRU,11648
 janito/cli/prompt_handler.py,sha256=SnPTlL64noeAMGlI08VBDD5IDD8jlVMIYA4-fS8zVLg,215
 janito/cli/prompt_setup.py,sha256=1s5yccFaWMgDkUjkvnTYGEWJAFPJ6hIiqwbrLfzWxMI,2038
@@ -39,7 +39,7 @@ janito/cli/chat_mode/bindings.py,sha256=odjc5_-YW1t2FRhBUNRNoBMoQIg5sMz3ktV7xG0A
 janito/cli/chat_mode/chat_entry.py,sha256=RFdPd23jsA2DMHRacpjAdwI_1dFBaWrtnwyQEgb2fHA,475
 janito/cli/chat_mode/prompt_style.py,sha256=vsqQ9xxmrYjj1pWuVe9CayQf39fo2EIXrkKPkflSVn4,805
 janito/cli/chat_mode/script_runner.py,sha256=wOwEn4bgmjqHqjTqtfyaSOnRPsGf4ZVW-YAWhEeqxXU,6507
-janito/cli/chat_mode/session.py,sha256=cqc4Ug3yGA8rR6vFRe5v6U4recqD0tzqgwcf2ASaPgs,12891
+janito/cli/chat_mode/session.py,sha256=o-Eh3oGAMpSdOj38xTubVi8_z3Pz3HUfGd-ZyeDlejw,13262
 janito/cli/chat_mode/session_profile_select.py,sha256=CJ2g3VbPGWfBNrNkYYX57oIJZJ-hIZBNGB-zcdjC9vk,5379
 janito/cli/chat_mode/toolbar.py,sha256=bJ9jPaTInp2gB3yjSVJp8mpNEFiOslzNhVaiqpXJhKc,3025
 janito/cli/chat_mode/shell/autocomplete.py,sha256=lE68MaVaodbA2VfUM0_YLqQVLBJAE_BJsd5cMtwuD-g,793
@@ -85,19 +85,21 @@ janito/cli/cli_commands/show_system_prompt.py,sha256=9ZJGW7lIGJ9LX2JZiWVEm4AbaD0
 janito/cli/core/__init__.py,sha256=YH95fhgY9yBX8RgqX9dSrEkl4exjV0T4rbmJ6xUpG-Y,196
 janito/cli/core/event_logger.py,sha256=1X6lR0Ax7AgF8HlPWFoY5Ystuu7Bh4ooTo78vXzeGB0,2008
 janito/cli/core/getters.py,sha256=AO34OBhh3f1Sx2mWVYQIvH-4fcmXG7b2471XdKNZdYs,1856
-janito/cli/core/runner.py,sha256=C7eePvhzIYHgsP95WGwltIhM_T4Kzyo14M7n12RevPQ,7693
+janito/cli/core/model_guesser.py,sha256=jzkkiQ-J2buT2Omh6jYZHa8-zCJxqKQBL08Z58pe1_o,1741
+janito/cli/core/runner.py,sha256=3vP92XEUzzHeOWbMHg82iISsXVUAM7y8YKWGNSIMyA8,8337
 janito/cli/core/setters.py,sha256=PD3aT1y1q8XWQVtRNfrU0dtlW4JGdn6BMJyP7FCQWhc,4623
 janito/cli/core/unsetters.py,sha256=FEw9gCt0vRvoCt0kRSNfVB2tzi_TqppJIx2nHPP59-k,2012
 janito/cli/single_shot_mode/__init__.py,sha256=Ct99pKe9tINzVW6oedZJfzfZQKWpXz-weSSCn0hrwHY,115
 janito/cli/single_shot_mode/handler.py,sha256=U70X7c9MHbmj1vQlTI-Ao2JvRprpLbPh9wL5gAMbEhs,3790
 janito/docs/GETTING_STARTED.md,sha256=EbXV7B3XxjSy1E0XQJFOVITVbTmZBVB7pjth2Mb4_rg,2835
-janito/docs/PROVIDERS.md,sha256=ZJK6A2j7uA651K5ypDnm-UQsnorCZvcU4qUrBPxpf0Y,4775
 janito/drivers/dashscope.bak.zip,sha256=9Pv4Xyciju8jO1lEMFVgYXexoZkxmDO3Ig6vw3ODfL8,4936
 janito/drivers/driver_registry.py,sha256=sbij7R71JJqJVeMfmaU-FKsEuZVO8oEn6Qp8020hdZw,773
 janito/drivers/openai_responses.bak.zip,sha256=E43eDCHGa2tCtdjzj_pMnWDdnsOZzj8BJTR5tJp8wcM,13352
 janito/drivers/azure_openai/driver.py,sha256=rec2D4DDuMjdnbGNIsrnB0oiwuxL_zBykJeUGa-PffI,4074
 janito/drivers/openai/README.md,sha256=bgPdaYX0pyotCoJ9t3cJbYM-teQ_YM1DAFEKLCMP32Q,666
-janito/drivers/openai/driver.py,sha256=7KxJes82SNcuaTMFvG-Avv60FNjg9s3DiynTtocK6Ac,18947
+janito/drivers/openai/driver.py,sha256=O0AAp-aF3TKQLp_FSsRWm_QDG_mKliLlpDjf09fWzl4,19061
+janito/drivers/zai/__init__.py,sha256=rleES3ZJEslJ8M02TdTPyxHKXxA4-e2fDJa6yjuzY8s,22
+janito/drivers/zai/driver.py,sha256=jI_ddVK_vT-cRTpZ_8piXSJEFZ6zLTeRyT0Jzxjtd70,18926
 janito/event_bus/__init__.py,sha256=VG6GOhKMBh0O_92D-zW8a3YitJPKDajGgPiFezTXlNE,77
 janito/event_bus/bus.py,sha256=LokZbAdwcWhWOyKSp7H3Ism57x4EZhxlRPjl3NE4UKU,2847
 janito/event_bus/event.py,sha256=MtgcBPD7cvCuubiLIyo-BWcsNSO-941HLk6bScHTJtQ,427
@@ -117,12 +119,12 @@ janito/llm/driver_input.py,sha256=Zq7IO4KdQPUraeIo6XoOaRy1IdQAyYY15RQw4JU30uA,38
 janito/llm/message_parts.py,sha256=QY_0kDjaxdoErDgKPRPv1dNkkYJuXIBmHWNLiOEKAH4,1365
 janito/llm/model.py,sha256=42hjcffZDTuzjAJoVhDcDqwIXm6rUmmi5UwTOYopf5w,1131
 janito/llm/provider.py,sha256=3FbhQPrWBSEoIdIi-5DWIh0DD_CM570EFf1NcuGyGko,7961
-janito/providers/__init__.py,sha256=-FHm_JuCSNGVhF61k9wlzJFxDBnTIl9L28UngTeQVa0,369
+janito/providers/__init__.py,sha256=P2r90SUduTqn0CumjpJ9yojx2BUKDVy136xdbA8I6VU,407
 janito/providers/dashscope.bak.zip,sha256=BwXxRmZreEivvRtmqbr5BR62IFVlNjAf4y6DrF2BVJo,5998
 janito/providers/registry.py,sha256=Ygwv9eVrTXOKhv0EKxSWQXO5WMHvajWE2Q_Lc3p7dKo,730
 janito/providers/alibaba/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-janito/providers/alibaba/model_info.py,sha256=oJOTw3yr6SuQItS9ZIAch2AtsKMosgZrdYygPhOSw9s,978
-janito/providers/alibaba/provider.py,sha256=1sMp02WvtBJMjMtQjpBNUMh_nOsLfHxzz0gbuCCMjqA,4280
+janito/providers/alibaba/model_info.py,sha256=evAW2CZUX9qgRAzDhZTp47ZNj4G1T7W66gkV60Nfan8,1264
+janito/providers/alibaba/provider.py,sha256=JOkR0pKCpuG1z5KQ35TaEw6Egfp7g1gU7XiT8aeZp-0,4304
 janito/providers/anthropic/model_info.py,sha256=m6pBh0Ia8_xC1KZ7ke_4HeHIFw7nWjnYVItnRpkCSWc,1206
 janito/providers/anthropic/provider.py,sha256=JS74pDs7gSpwvG0jY-MDO5rljO0JJOffSjaL1LK1YlE,3165
 janito/providers/azure_openai/model_info.py,sha256=TMSqEpQROIIYUGAyulYJ5xGhj7CbLoaKL_JXeLbXaG0,689
@@ -140,6 +142,10 @@ janito/providers/openai/__init__.py,sha256=f0m16-sIqScjL9Mp4A0CQBZx6H3PTEy0cnE08
 janito/providers/openai/model_info.py,sha256=cz08O26Ychm-aP3T8guJRqpR96Im9Cwtgl2iMgM7tJs,3384
 janito/providers/openai/provider.py,sha256=U9Bp9g2KQ58J6-B5vDgsXM05xASsgaWQOofewC7hiXs,5145
 janito/providers/openai/schema_generator.py,sha256=hTqeLcPTR8jeKn5DUUpo7b-EZ-V-g1WwXiX7MbHnFzE,2234
+janito/providers/zai/__init__.py,sha256=qtIr9_QBFaXG8xB6cRDGhS7se6ir11CWseI9azLMRBo,24
+janito/providers/zai/model_info.py,sha256=8lwwoqwuKEkrMvXWyt1iq_H_Bf0GzZk37byjSzs_YDo,1708
+janito/providers/zai/provider.py,sha256=mzGICaeg1NX_PghH17TDMxz_fKLeF4QHq98eVTuRUes,5234
+janito/providers/zai/schema_generator.py,sha256=xIc1U_AYKX0cIU89RyJ63mo6rk-Mebx5CQ-qFfmd4ZQ,3934
 janito/tools/DOCSTRING_STANDARD.txt,sha256=VLPwNgjxRVD_xZSSVvUZ4H-4bBwM-VKh_RyfzYQsYSs,1735
 janito/tools/README.md,sha256=5HkLpF5k4PENJER7SlDPRXj0yo9mpHvAHW4uuzhq4ak,115
 janito/tools/__init__.py,sha256=W1B39PztC2UF7PS2WyLH6el32MFOETMlN1-LurOROCg,1171
@@ -201,9 +207,9 @@ janito/tools/adapters/local/validate_file_syntax/ps1_validator.py,sha256=TeIkPt0
 janito/tools/adapters/local/validate_file_syntax/python_validator.py,sha256=BfCO_K18qy92m-2ZVvHsbEU5e11OPo1pO9Vz4G4616E,130
 janito/tools/adapters/local/validate_file_syntax/xml_validator.py,sha256=AijlsP_PgNuC8ZbGsC5vOTt3Jur76otQzkd_7qR0QFY,284
 janito/tools/adapters/local/validate_file_syntax/yaml_validator.py,sha256=TgyI0HRL6ug_gBcWEm5TGJJuA4E34ZXcIzMpAbv3oJs,155
-janito-2.10.0.dist-info/licenses/LICENSE,sha256=GSAKapQH5ZIGWlpQTA7v5YrfECyaxaohUb1vJX-qepw,1090
-janito-2.10.0.dist-info/METADATA,sha256=I8q2g4vGHg3W7ctBlg3u3jSX6RrAR4RJoqOZJdcPBq4,16365
-janito-2.10.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-janito-2.10.0.dist-info/entry_points.txt,sha256=wIo5zZxbmu4fC-ZMrsKD0T0vq7IqkOOLYhrqRGypkx4,48
-janito-2.10.0.dist-info/top_level.txt,sha256=m0NaVCq0-ivxbazE2-ND0EA9Hmuijj_OGkmCbnBcCig,7
-janito-2.10.0.dist-info/RECORD,,
+janito-2.12.0.dist-info/licenses/LICENSE,sha256=GSAKapQH5ZIGWlpQTA7v5YrfECyaxaohUb1vJX-qepw,1090
+janito-2.12.0.dist-info/METADATA,sha256=28P5foSbPIT1QiWcLpVgWVSKLmzgG2JpwEJY8aEbsPE,16365
+janito-2.12.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+janito-2.12.0.dist-info/entry_points.txt,sha256=wIo5zZxbmu4fC-ZMrsKD0T0vq7IqkOOLYhrqRGypkx4,48
+janito-2.12.0.dist-info/top_level.txt,sha256=m0NaVCq0-ivxbazE2-ND0EA9Hmuijj_OGkmCbnBcCig,7
+janito-2.12.0.dist-info/RECORD,,

janito/docs/PROVIDERS.md

@@ -1,224 +0,0 @@
-# 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