janito 2.2.0__py3-none-any.whl → 2.3.1__py3-none-any.whl

janito/config_manager.py

@@ -1,110 +1,112 @@
-import json
-from pathlib import Path
-from threading import Lock
-
-
-class ConfigManager:
-    """
-    Unified configuration manager supporting:
-      - Defaults
-      - File-based configuration
-      - Runtime overrides (e.g., CLI args)
-    """
-
-    _instance = None
-    _lock = Lock()
-
-    def __new__(cls, *args, **kwargs):
-        with cls._lock:
-            if not cls._instance:
-                cls._instance = super(ConfigManager, cls).__new__(cls)
-        return cls._instance
-
-    def __init__(self, config_path=None, defaults=None, runtime_overrides=None):
-        # Lazy single-init
-        if hasattr(self, "_initialized") and self._initialized:
-            return
-        self._initialized = True
-
-        self.config_path = Path(config_path or Path.home() / ".janito" / "config.json")
-        self.defaults = dict(defaults) if defaults else {}
-        self.file_config = {}
-        self.runtime_overrides = dict(runtime_overrides) if runtime_overrides else {}
-        self._load_file_config()
-
-    def _load_file_config(self):
-        if self.config_path.exists():
-            with open(self.config_path, "r", encoding="utf-8") as f:
-                try:
-                    self.file_config = json.load(f)
-                except Exception:
-                    self.file_config = {}
-        else:
-            self.file_config = {}
-
-    def save(self):
-        self.config_path.parent.mkdir(parents=True, exist_ok=True)
-        with open(self.config_path, "w", encoding="utf-8") as f:
-            json.dump(self.file_config, f, indent=2)
-
-    def get(self, key, default=None):
-        # Precedence: runtime_overrides > file_config > defaults
-        for layer in (self.runtime_overrides, self.file_config, self.defaults):
-            if key in layer and layer[key] is not None:
-                return layer[key]
-        return default
-
-    def runtime_set(self, key, value):
-        self.runtime_overrides[key] = value
-
-    def file_set(self, key, value):
-        # Always reload, update, and persist
-        self._load_file_config()
-        self.file_config[key] = value
-        with open(self.config_path, "w", encoding="utf-8") as f:
-            json.dump(self.file_config, f, indent=2)
-
-    def all(self, layered=False):
-        merged = dict(self.defaults)
-        merged.update(self.file_config)
-        merged.update(self.runtime_overrides)
-        if layered:
-            # Only file+runtime, i.e., what is saved to disk
-            d = dict(self.file_config)
-            d.update(self.runtime_overrides)
-            return d
-        return merged
-
-    # Namespaced provider/model config
-    def get_provider_config(self, provider, default=None):
-        providers = self.file_config.get("providers") or {}
-        return providers.get(provider) or (default or {})
-
-    def set_provider_config(self, provider, key, value):
-        if "providers" not in self.file_config:
-            self.file_config["providers"] = {}
-        if provider not in self.file_config["providers"]:
-            self.file_config["providers"][provider] = {}
-        self.file_config["providers"][provider][key] = value
-
-    def get_provider_model_config(self, provider, model, default=None):
-        return (
-            self.file_config.get("providers")
-            or {}.get(provider, {}).get("models", {}).get(model)
-            or (default or {})
-        )
-
-    def set_provider_model_config(self, provider, model, key, value):
-        if "providers" not in self.file_config:
-            self.file_config["providers"] = {}
-        if provider not in self.file_config["providers"]:
-            self.file_config["providers"][provider] = {}
-        if "models" not in self.file_config["providers"][provider]:
-            self.file_config["providers"][provider]["models"] = {}
-        if model not in self.file_config["providers"][provider]["models"]:
-            self.file_config["providers"][provider]["models"][model] = {}
-        self.file_config["providers"][provider]["models"][model][key] = value
-
-    # Support loading runtime overrides after init (e.g. after parsing CLI args)
-    def apply_runtime_overrides(self, overrides_dict):
-        self.runtime_overrides.update(overrides_dict)
+import json
+from pathlib import Path
+from threading import Lock
+
+
+class ConfigManager:
+    """
+    Unified configuration manager supporting:
+      - Defaults
+      - File-based configuration
+      - Runtime overrides (e.g., CLI args)
+    """
+
+    _instance = None
+    _lock = Lock()
+
+    def __new__(cls, *args, **kwargs):
+        with cls._lock:
+            if not cls._instance:
+                cls._instance = super(ConfigManager, cls).__new__(cls)
+        return cls._instance
+
+    def __init__(self, config_path=None, defaults=None, runtime_overrides=None):
+        # Lazy single-init
+        if hasattr(self, "_initialized") and self._initialized:
+            return
+        self._initialized = True
+
+        self.config_path = Path(config_path or Path.home() / ".janito" / "config.json")
+        self.defaults = dict(defaults) if defaults else {}
+        self.file_config = {}
+        self.runtime_overrides = dict(runtime_overrides) if runtime_overrides else {}
+        self._load_file_config()
+
+    def _load_file_config(self):
+        if self.config_path.exists():
+            with open(self.config_path, "r", encoding="utf-8") as f:
+                try:
+                    self.file_config = json.load(f)
+                except Exception:
+                    self.file_config = {}
+        else:
+            self.file_config = {}
+
+    def save(self):
+        self.config_path.parent.mkdir(parents=True, exist_ok=True)
+        with open(self.config_path, "w", encoding="utf-8") as f:
+            json.dump(self.file_config, f, indent=2)
+            f.write("\n")
+
+    def get(self, key, default=None):
+        # Precedence: runtime_overrides > file_config > defaults
+        for layer in (self.runtime_overrides, self.file_config, self.defaults):
+            if key in layer and layer[key] is not None:
+                return layer[key]
+        return default
+
+    def runtime_set(self, key, value):
+        self.runtime_overrides[key] = value
+
+    def file_set(self, key, value):
+        # Always reload, update, and persist
+        self._load_file_config()
+        self.file_config[key] = value
+        with open(self.config_path, "w", encoding="utf-8") as f:
+            json.dump(self.file_config, f, indent=2)
+            f.write("\n")
+
+    def all(self, layered=False):
+        merged = dict(self.defaults)
+        merged.update(self.file_config)
+        merged.update(self.runtime_overrides)
+        if layered:
+            # Only file+runtime, i.e., what is saved to disk
+            d = dict(self.file_config)
+            d.update(self.runtime_overrides)
+            return d
+        return merged
+
+    # Namespaced provider/model config
+    def get_provider_config(self, provider, default=None):
+        providers = self.file_config.get("providers") or {}
+        return providers.get(provider) or (default or {})
+
+    def set_provider_config(self, provider, key, value):
+        if "providers" not in self.file_config:
+            self.file_config["providers"] = {}
+        if provider not in self.file_config["providers"]:
+            self.file_config["providers"][provider] = {}
+        self.file_config["providers"][provider][key] = value
+
+    def get_provider_model_config(self, provider, model, default=None):
+        return (
+            self.file_config.get("providers")
+            or {}.get(provider, {}).get("models", {}).get(model)
+            or (default or {})
+        )
+
+    def set_provider_model_config(self, provider, model, key, value):
+        if "providers" not in self.file_config:
+            self.file_config["providers"] = {}
+        if provider not in self.file_config["providers"]:
+            self.file_config["providers"][provider] = {}
+        if "models" not in self.file_config["providers"][provider]:
+            self.file_config["providers"][provider]["models"] = {}
+        if model not in self.file_config["providers"][provider]["models"]:
+            self.file_config["providers"][provider]["models"][model] = {}
+        self.file_config["providers"][provider]["models"][model][key] = value
+
+    # Support loading runtime overrides after init (e.g. after parsing CLI args)
+    def apply_runtime_overrides(self, overrides_dict):
+        self.runtime_overrides.update(overrides_dict)

janito/driver_events.py

@@ -90,6 +90,20 @@ class ToolCallFinished(DriverEvent):
         return self.name
 
 
+@attr.s(auto_attribs=True, kw_only=True)
+@attr.s(auto_attribs=True, kw_only=True)
+class RateLimitRetry(DriverEvent):
+    """Emitted by a driver when it encounters a provider rate-limit (HTTP 429) and
+    decides to retry the request after a delay. This allows UIs or logging layers
+    to give feedback to the user while the driver automatically waits.
+    """
+
+    attempt: int = 0  # Retry attempt number (starting at 1)
+    retry_delay: float = 0  # Delay in seconds before the next attempt
+    error: str = None  # The original error message
+    details: dict = None  # Additional details extracted from the provider response
+
+
 @attr.s(auto_attribs=True, kw_only=True)
 class ResponseReceived(DriverEvent):
     parts: list = None

janito/drivers/azure_openai/driver.py

@@ -14,6 +14,18 @@ from janito.llm.driver_config import LLMDriverConfig
 
 
 class AzureOpenAIModelDriver(OpenAIModelDriver):
+    def start(self, *args, **kwargs):
+        # Ensure azure_deployment_name is set before starting
+        config = getattr(self, 'config', None)
+        deployment_name = None
+        if config and hasattr(config, 'extra'):
+            deployment_name = config.extra.get('azure_deployment_name')
+        if not deployment_name:
+            raise RuntimeError("AzureOpenAIModelDriver requires 'azure_deployment_name' to be set in config.extra['azure_deployment_name'] before starting.")
+        # Call parent start if exists
+        if hasattr(super(), 'start'):
+            return super().start(*args, **kwargs)
+
     available = DRIVER_AVAILABLE
     unavailable_reason = DRIVER_UNAVAILABLE_REASON
 
@@ -23,17 +35,39 @@ class AzureOpenAIModelDriver(OpenAIModelDriver):
 
     required_config = {"base_url"}  # Update key as used in your config logic
 
-    def __init__(self, tools_adapter=None):
+    def __init__(self, tools_adapter=None, provider_name=None):
         if not self.available:
             raise ImportError(
                 f"AzureOpenAIModelDriver unavailable: {self.unavailable_reason}"
             )
-        # Do NOT call super().__init__ if Azure SDK is not available
-        OpenAIModelDriver.__init__(self, tools_adapter=tools_adapter)
+        # Ensure proper parent initialization
+        super().__init__(tools_adapter=tools_adapter, provider_name=provider_name)
         self.azure_endpoint = None
         self.api_version = None
         self.api_key = None
 
+    def _prepare_api_kwargs(self, config, conversation):
+        """
+        Prepares API kwargs for Azure OpenAI, using the deployment name as the model parameter.
+        Also ensures tool schemas are included if tools_adapter is present.
+        """
+        api_kwargs = super()._prepare_api_kwargs(config, conversation)
+        deployment_name = config.extra.get("azure_deployment_name") if hasattr(config, "extra") else None
+        if deployment_name:
+            api_kwargs["model"] = deployment_name
+        # Patch: Ensure tools are included for Azure as for OpenAI
+        if self.tools_adapter:
+            try:
+                from janito.providers.openai.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"[AzureOpenAIModelDriver] Tool schema generation failed: {e}")
+        return api_kwargs
+
     def _instantiate_openai_client(self, config):
         try:
             from openai import AzureOpenAI
@@ -45,6 +79,7 @@ class AzureOpenAIModelDriver(OpenAIModelDriver):
                 "azure_endpoint": getattr(config, "base_url", None),
                 "api_version": config.extra.get("api_version", "2023-05-15"),
             }
+            # Do NOT pass azure_deployment; deployment name is used as the 'model' param in API calls
             client = AzureOpenAI(**client_kwargs)
             return client
         except Exception as e:

janito/drivers/driver_registry.py

@@ -8,14 +8,12 @@ from typing import Dict, Type
 # --- Import driver classes ---
 from janito.drivers.anthropic.driver import AnthropicModelDriver
 from janito.drivers.azure_openai.driver import AzureOpenAIModelDriver
-from janito.drivers.google_genai.driver import GoogleGenaiModelDriver
 from janito.drivers.mistralai.driver import MistralAIModelDriver
 from janito.drivers.openai.driver import OpenAIModelDriver
 
 _DRIVER_REGISTRY: Dict[str, Type] = {
     "AnthropicModelDriver": AnthropicModelDriver,
     "AzureOpenAIModelDriver": AzureOpenAIModelDriver,
-    "GoogleGenaiModelDriver": GoogleGenaiModelDriver,
     "MistralAIModelDriver": MistralAIModelDriver,
     "OpenAIModelDriver": OpenAIModelDriver,
 }

janito/drivers/openai/driver.py

@@ -1,9 +1,10 @@
 import uuid
 import traceback
 from rich import pretty
+import os
 from janito.llm.driver import LLMDriver
 from janito.llm.driver_input import DriverInput
-from janito.driver_events import RequestFinished, RequestStatus
+from janito.driver_events import RequestFinished, RequestStatus, RateLimitRetry
 
 # Safe import of openai SDK
 try:
@@ -70,6 +71,7 @@ class OpenAIModelDriver(LLMDriver):
             "presence_penalty",
             "frequency_penalty",
             "stop",
+            "reasoning_effort",
         ):
             v = getattr(config, p, None)
             if v is not None:
@@ -79,6 +81,21 @@ class OpenAIModelDriver(LLMDriver):
         return api_kwargs
 
     def _call_api(self, driver_input: DriverInput):
+        """Call the OpenAI-compatible chat completion endpoint.
+
+        Implements automatic retry logic when the provider returns a *retriable*
+        HTTP 429 or ``RESOURCE_EXHAUSTED`` error **that is not caused by quota
+        exhaustion**. A ``RateLimitRetry`` driver event is emitted each time a
+        retry is scheduled so that user-interfaces can inform the user about
+        the wait.
+
+        OpenAI uses the 429 status code both for temporary rate-limit errors *and*
+        for permanent quota-exceeded errors (``insufficient_quota``).  Retrying
+        the latter is pointless, so we inspect the error payload for
+        ``insufficient_quota`` or common quota-exceeded wording and treat those
+        as fatal, bubbling them up as a regular RequestFinished/ERROR instead of
+        emitting a RateLimitRetry.
+        """
         cancel_event = getattr(driver_input, "cancel_event", None)
         config = driver_input.config
         conversation = self.convert_history_to_api_messages(
@@ -86,45 +103,172 @@ class OpenAIModelDriver(LLMDriver):
         )
         request_id = getattr(config, "request_id", None)
         if config.verbose_api:
+            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] OpenAI API call about to be sent. Model: {config.model}, max_tokens: {config.max_tokens}, tools_adapter: {type(self.tools_adapter).__name__ if self.tools_adapter else None}",
+                f"[verbose-api] OpenAI 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,
             )
-        try:
-            client = self._instantiate_openai_client(config)
-            api_kwargs = self._prepare_api_kwargs(config, conversation)
-            if config.verbose_api:
-                print(
-                    f"[OpenAI] API CALL: chat.completions.create(**{api_kwargs})",
-                    flush=True,
+        import time, re, json
+
+        client = self._instantiate_openai_client(config)
+        api_kwargs = self._prepare_api_kwargs(config, conversation)
+        max_retries = getattr(config, "max_retries", 3)
+        attempt = 1
+        while True:
+            try:
+                if config.verbose_api:
+                    print(
+                        f"[OpenAI] API CALL (attempt {attempt}/{max_retries}): chat.completions.create(**{api_kwargs})",
+                        flush=True,
+                    )
+                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
+                # Success path
+                self._print_verbose_result(config, result)
+                usage_dict = self._extract_usage(result)
+                if config.verbose_api:
+                    print(
+                        f"[OpenAI][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 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._print_verbose_result(config, result)
-            usage_dict = self._extract_usage(result)
-            if config.verbose_api:
-                print(
-                    f"[OpenAI][DEBUG] Attaching usage info to RequestFinished: {usage_dict}",
-                    flush=True,
+                if config.verbose_api:
+                    pretty.install()
+                    print("[OpenAI] API RESPONSE:", flush=True)
+                    pretty.pprint(result)
+                return result
+            except Exception as e:
+                # Check for rate-limit errors (HTTP 429 or RESOURCE_EXHAUSTED)
+                status_code = getattr(e, "status_code", None)
+                err_str = str(e)
+                # Determine if this is a retriable rate-limit error (HTTP 429) or a non-retriable
+                # quota exhaustion error. OpenAI returns the same 429 status code for both, so we
+                # additionally check for the ``insufficient_quota`` code or typical quota-related
+                # strings in the error message. If the error is quota-related we treat it as fatal
+                # so that the caller can surface a proper error message instead of silently
+                # retrying forever.
+                lower_err = err_str.lower()
+                is_insufficient_quota = (
+                    "insufficient_quota" in lower_err
+                    or "exceeded your current quota" in lower_err
                 )
-            self.output_queue.put(
-                RequestFinished(
-                    driver_name=self.__class__.__name__,
-                    request_id=request_id,
-                    response=result,
-                    status=RequestStatus.SUCCESS,
-                    usage=usage_dict,
+                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:
+                    # If it's not a rate-limit error or we've exhausted retries, handle as fatal
+                    self._handle_fatal_exception(e, config, api_kwargs)
+                # Parse retry delay from error message (default 1s)
+                retry_delay = self._extract_retry_delay_seconds(e)
+                if retry_delay is None:
+                    # simple exponential backoff if not provided
+                    retry_delay = min(2 ** (attempt - 1), 30)
+                # Emit RateLimitRetry event so UIs can show a spinner / message
+                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 config.verbose_api:
+                    print(
+                        f"[OpenAI][RateLimit] Attempt {attempt}/{max_retries} failed with rate-limit. Waiting {retry_delay}s before retry.",
+                        flush=True,
+                    )
+                # Wait while still allowing cancellation
+                start_wait = time.time()
+                while time.time() - start_wait < retry_delay:
+                    if self._check_cancel(cancel_event, request_id, before_call=False):
+                        return None
+                    time.sleep(0.1)
+                attempt += 1
+                continue
+            # console with large JSON payloads when the service returns HTTP 429.
+            # We still surface the exception to the caller so that standard error
+            # handling (e.g. retries in higher-level code) continues to work.
+            status_code = getattr(e, "status_code", None)
+            err_str = str(e)
+            is_rate_limit = (
+                status_code == 429
+                or "Error code: 429" in err_str
+                or "RESOURCE_EXHAUSTED" in err_str
             )
-            if config.verbose_api:
-                pretty.install()
-                print("[OpenAI] API RESPONSE:", flush=True)
-                pretty.pprint(result)
-            return result
-        except Exception as e:
+            is_verbose = getattr(config, "verbose_api", False)
+
+            # Only print the full diagnostics if the user explicitly requested
+            # verbose output or if the problem is not a rate-limit situation.
+            if is_verbose or not is_rate_limit:
+                print(f"[ERROR] Exception during OpenAI 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,
+                )
+                import traceback
+
+                print("[ERROR] Full stack trace:", flush=True)
+                print(traceback.format_exc(), flush=True)
+            # Re-raise so that the calling logic can convert this into a
+            # RequestFinished event with status=ERROR.
+            raise
+
+    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.
+        """
+        import re, json, math
+
+        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 OpenAI API call: {e}", flush=True)
             print(f"[ERROR] config: {config}", flush=True)
             print(
@@ -132,10 +276,9 @@ class OpenAIModelDriver(LLMDriver):
                 flush=True,
             )
             import traceback
-
             print("[ERROR] Full stack trace:", flush=True)
             print(traceback.format_exc(), flush=True)
-            raise
+        raise
 
     def _instantiate_openai_client(self, config):
         try:
@@ -145,6 +288,19 @@ class OpenAIModelDriver(LLMDriver):
             client_kwargs = {"api_key": config.api_key}
             if getattr(config, "base_url", None):
                 client_kwargs["base_url"] = config.base_url
+
+            # HTTP debug wrapper
+            if os.environ.get("OPENAI_DEBUG_HTTP", "0") == "1":
+                from http.client import HTTPConnection
+                HTTPConnection.debuglevel = 1
+                import logging
+                logging.basicConfig()
+                logging.getLogger().setLevel(logging.DEBUG)
+                requests_log = logging.getLogger("http.client")
+                requests_log.setLevel(logging.DEBUG)
+                requests_log.propagate = True
+                print("[OpenAIModelDriver] HTTP debug enabled via OPENAI_DEBUG_HTTP=1", flush=True)
+
             client = openai.OpenAI(**client_kwargs)
             return client
         except Exception as e:
@@ -289,7 +445,7 @@ class OpenAIModelDriver(LLMDriver):
                 except Exception:
                     tool_calls = []
                 api_messages.append(
-                    {"role": "assistant", "content": None, "tool_calls": tool_calls}
+                    {"role": "assistant", "content": "", "tool_calls": tool_calls}
                 )
             else:
                 # Special handling for 'function' role: extract 'name' from metadata if present
@@ -307,6 +463,10 @@ class OpenAIModelDriver(LLMDriver):
                     )
                 else:
                     api_messages.append(msg)
+        # Post-processing: Google Gemini API (OpenAI-compatible) rejects null content. Replace None with empty string.
+        for m in api_messages:
+            if m.get("content", None) is None:
+                m["content"] = ""
         return api_messages
 
     def _convert_completion_message_to_parts(self, message):