janito 2.1.1__py3-none-any.whl → 2.3.0__py3-none-any.whl

janito/drivers/anthropic/driver.py

@@ -1,113 +1,113 @@
-from janito.llm.driver import LLMDriver
-from janito.llm.driver_config import LLMDriverConfig
-from janito.driver_events import (
-    GenerationStarted,
-    GenerationFinished,
-    RequestStarted,
-    RequestFinished,
-    ResponseReceived,
-)
-from janito.llm.message_parts import TextMessagePart
-import uuid
-import traceback
-import time
-
-# Safe import of anthropic SDK
-try:
-    import anthropic
-
-    DRIVER_AVAILABLE = True
-    DRIVER_UNAVAILABLE_REASON = None
-except ImportError:
-    DRIVER_AVAILABLE = False
-    DRIVER_UNAVAILABLE_REASON = "Missing dependency: anthropic (pip install anthropic)"
-
-
-class AnthropicModelDriver(LLMDriver):
-    available = False
-    unavailable_reason = "AnthropicModelDriver is not implemented yet."
-
-    @classmethod
-    def is_available(cls):
-        return cls.available
-
-    """
-    LLMDriver for Anthropic's Claude API (v3), using the anthropic SDK.
-    """
-    required_config = ["api_key", "model"]
-
-    def __init__(self, tools_adapter=None):
-        raise ImportError(self.unavailable_reason)
-
-    def _create_client(self):
-        try:
-            import anthropic
-        except ImportError:
-            raise Exception(
-                "The 'anthropic' Python SDK is required. Please install via `pip install anthropic`."
-            )
-        return anthropic.Anthropic(api_key=self.api_key)
-
-    def _run_generation(
-        self, messages_or_prompt, system_prompt=None, tools=None, **kwargs
-    ):
-        request_id = str(uuid.uuid4())
-        client = self._create_client()
-        try:
-            prompt = ""
-            if isinstance(messages_or_prompt, str):
-                prompt = messages_or_prompt
-            elif isinstance(messages_or_prompt, list):
-                chat = []
-                for msg in messages_or_prompt:
-                    if msg.get("role") == "user":
-                        chat.append("Human: " + msg.get("content", ""))
-                    elif msg.get("role") == "assistant":
-                        chat.append("Assistant: " + msg.get("content", ""))
-                prompt = "\n".join(chat)
-            if system_prompt:
-                prompt = f"System: {system_prompt}\n{prompt}"
-
-            self.publish(
-                GenerationStarted,
-                request_id,
-                conversation_history=list(getattr(self, "_history", [])),
-            )
-            self.publish(RequestStarted, request_id, payload={})
-            start_time = time.time()
-            response = client.completions.create(
-                model=self.model_name,
-                max_tokens_to_sample=int(getattr(self.config, "max_response", 1024)),
-                prompt=prompt,
-                temperature=float(getattr(self.config, "default_temp", 0.7)),
-            )
-            duration = time.time() - start_time
-            content = response.completion if hasattr(response, "completion") else None
-            self.publish(
-                RequestFinished,
-                request_id,
-                response=content,
-                status=RequestStatus.SUCCESS,
-                usage={},
-            )
-            parts = []
-            if content:
-                parts.append(TextMessagePart(content=content))
-            self.publish(
-                ResponseReceived,
-                request_id=request_id,
-                parts=parts,
-                tool_results=[],
-                timestamp=time.time(),
-                metadata={"raw_response": response},
-            )
-            self.publish(GenerationFinished, request_id, total_turns=1)
-        except Exception as e:
-            self.publish(
-                RequestFinished,
-                request_id,
-                status=RequestStatus.ERROR,
-                error=str(e),
-                exception=e,
-                traceback=traceback.format_exc(),
-            )
+from janito.llm.driver import LLMDriver
+from janito.llm.driver_config import LLMDriverConfig
+from janito.driver_events import (
+    GenerationStarted,
+    GenerationFinished,
+    RequestStarted,
+    RequestFinished,
+    ResponseReceived,
+)
+from janito.llm.message_parts import TextMessagePart
+import uuid
+import traceback
+import time
+
+# Safe import of anthropic SDK
+try:
+    import anthropic
+
+    DRIVER_AVAILABLE = True
+    DRIVER_UNAVAILABLE_REASON = None
+except ImportError:
+    DRIVER_AVAILABLE = False
+    DRIVER_UNAVAILABLE_REASON = "Missing dependency: anthropic (pip install anthropic)"
+
+
+class AnthropicModelDriver(LLMDriver):
+    available = False
+    unavailable_reason = "AnthropicModelDriver is not implemented yet."
+
+    @classmethod
+    def is_available(cls):
+        return cls.available
+
+    """
+    LLMDriver for Anthropic's Claude API (v3), using the anthropic SDK.
+    """
+    required_config = ["api_key", "model"]
+
+    def __init__(self, tools_adapter=None):
+        raise ImportError(self.unavailable_reason)
+
+    def _create_client(self):
+        try:
+            import anthropic
+        except ImportError:
+            raise Exception(
+                "The 'anthropic' Python SDK is required. Please install via `pip install anthropic`."
+            )
+        return anthropic.Anthropic(api_key=self.api_key)
+
+    def _run_generation(
+        self, messages_or_prompt, system_prompt=None, tools=None, **kwargs
+    ):
+        request_id = str(uuid.uuid4())
+        client = self._create_client()
+        try:
+            prompt = ""
+            if isinstance(messages_or_prompt, str):
+                prompt = messages_or_prompt
+            elif isinstance(messages_or_prompt, list):
+                chat = []
+                for msg in messages_or_prompt:
+                    if msg.get("role") == "user":
+                        chat.append("Human: " + msg.get("content", ""))
+                    elif msg.get("role") == "assistant":
+                        chat.append("Assistant: " + msg.get("content", ""))
+                prompt = "\n".join(chat)
+            if system_prompt:
+                prompt = f"System: {system_prompt}\n{prompt}"
+
+            self.publish(
+                GenerationStarted,
+                request_id,
+                conversation_history=list(getattr(self, "_history", [])),
+            )
+            self.publish(RequestStarted, request_id, payload={})
+            start_time = time.time()
+            response = client.completions.create(
+                model=self.model_name,
+                max_tokens_to_sample=int(getattr(self.config, "max_response", 1024)),
+                prompt=prompt,
+                temperature=float(getattr(self.config, "default_temp", 0.7)),
+            )
+            duration = time.time() - start_time
+            content = response.completion if hasattr(response, "completion") else None
+            self.publish(
+                RequestFinished,
+                request_id,
+                response=content,
+                status=RequestStatus.SUCCESS,
+                usage={},
+            )
+            parts = []
+            if content:
+                parts.append(TextMessagePart(content=content))
+            self.publish(
+                ResponseReceived,
+                request_id=request_id,
+                parts=parts,
+                tool_results=[],
+                timestamp=time.time(),
+                metadata={"raw_response": response},
+            )
+            self.publish(GenerationFinished, request_id, total_turns=1)
+        except Exception as e:
+            self.publish(
+                RequestFinished,
+                request_id,
+                status=RequestStatus.ERROR,
+                error=str(e),
+                exception=e,
+                traceback=traceback.format_exc(),
+            )

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):