janito 1.9.0__py3-none-any.whl → 1.10.0__py3-none-any.whl

janito/agent/conversation_api.py

@@ -7,7 +7,8 @@ from janito.i18n import tr
 import json
 from janito.agent.runtime_config import runtime_config
 from janito.agent.tool_registry import get_tool_schemas
-from janito.agent.conversation_exceptions import NoToolSupportError
+from janito.agent.conversation_exceptions import NoToolSupportError, EmptyResponseError
+from janito.agent.api_exceptions import ApiError
 
 
 def _sanitize_utf8_surrogates(obj):
@@ -28,7 +29,7 @@ def _sanitize_utf8_surrogates(obj):
 def get_openai_response(
     client, model, messages, max_tokens, tools=None, tool_choice=None, temperature=None
 ):
-    """Non-streaming OpenAI API call."""
+    """OpenAI API call."""
     messages = _sanitize_utf8_surrogates(messages)
     from janito.agent.conversation_exceptions import ProviderError
 
@@ -53,176 +54,165 @@ def get_openai_response(
         or response.choices is None
         or len(response.choices) == 0
     ):
+        # Always check for error before raising ProviderError
+        error = getattr(response, "error", None)
+        if error:
+            print(f"ApiError: {error.get('message', error)}")
+            print(f"Full error object: {error}")
+            print(f"Raw response: {response}")
+            raise ApiError(error.get("message", str(error)))
         raise ProviderError(
-            "No choices in response; possible API or LLM error.",
+            f"No choices in response; possible API or LLM error. Raw response: {response!r}",
             {"code": 502, "raw_response": str(response)},
         )
     return response
 
 
-def get_openai_stream_response(
-    client,
-    model,
-    messages,
-    max_tokens,
-    tools=None,
-    tool_choice=None,
-    temperature=None,
-    verbose_stream=False,
-    message_handler=None,
-):
-    """Streaming OpenAI API call."""
-    messages = _sanitize_utf8_surrogates(messages)
-    openai_args = dict(
-        model=model,
-        messages=messages,
-        max_tokens=max_tokens,
-        stream=True,
+def _extract_status_and_retry_after(e, error_message):
+    status_code = None
+    retry_after = None
+    if hasattr(e, "status_code"):
+        status_code = getattr(e, "status_code")
+    elif hasattr(e, "response") and hasattr(e.response, "status_code"):
+        status_code = getattr(e.response, "status_code")
+        if hasattr(e.response, "headers") and e.response.headers:
+            retry_after = e.response.headers.get("Retry-After")
+    else:
+        import re
+
+        match = re.search(r"[Ee]rror code: (\d{3})", error_message)
+        if match:
+            status_code = int(match.group(1))
+        retry_after_match = re.search(r"Retry-After\['\"]?:?\s*(\d+)", error_message)
+        if retry_after_match:
+            retry_after = retry_after_match.group(1)
+    return status_code, retry_after
+
+
+def _calculate_wait_time(status_code, retry_after, attempt):
+    if status_code == 429 and retry_after is not None:
+        try:
+            return int(float(retry_after))
+        except Exception:
+            return 2**attempt
+    return 2**attempt
+
+
+def _log_and_sleep(message, attempt, max_retries, e=None, wait_time=None):
+    print(
+        tr(
+            message,
+            attempt=attempt,
+            max_retries=max_retries,
+            e=e,
+            wait_time=wait_time,
+        )
     )
-    if not runtime_config.get("vanilla_mode", False):
-        openai_args.update(
-            tools=tools or get_tool_schemas(),
-            tool_choice=tool_choice or "auto",
-            temperature=temperature if temperature is not None else 0.2,
+    time.sleep(wait_time)
+
+
+def _handle_json_decode_error(e, attempt, max_retries):
+    if attempt < max_retries:
+        wait_time = 2**attempt
+        _log_and_sleep(
+            "Invalid/malformed response from OpenAI (attempt {attempt}/{max_retries}). Retrying in {wait_time} seconds...",
+            attempt,
+            max_retries,
+            wait_time=wait_time,
         )
-    response_stream = client.chat.completions.create(**openai_args)
-    content_accum = ""
-    for event in response_stream:
-        if verbose_stream or runtime_config.get("verbose_stream", False):
-            print(repr(event), flush=True)
-        delta = getattr(event.choices[0], "delta", None)
-        if delta and getattr(delta, "content", None):
-            chunk = delta.content
-            content_accum += chunk
-            if message_handler:
-                message_handler.handle_message({"type": "stream", "content": chunk})
-    if message_handler:
-        message_handler.handle_message({"type": "stream_end", "content": content_accum})
-    return None
-
-
-def retry_api_call(api_func, max_retries=5, *args, **kwargs):
-    last_exception = None
-    for attempt in range(1, max_retries + 1):
-        try:
-            return api_func(*args, **kwargs)
-        except json.JSONDecodeError as e:
-            last_exception = e
+        return None
+    else:
+        print(tr("Max retries for invalid response reached. Raising error."))
+        raise e
+
+
+def _handle_general_exception(e, attempt, max_retries):
+    error_message = str(e)
+    if "No endpoints found that support tool use" in error_message:
+        print(tr("API does not support tool use."))
+        raise NoToolSupportError(error_message)
+    status_code, retry_after = _extract_status_and_retry_after(e, error_message)
+    if status_code is not None:
+        if status_code == 429:
+            wait_time = _calculate_wait_time(status_code, retry_after, attempt)
             if attempt < max_retries:
-                wait_time = 2**attempt
-                print(
-                    tr(
-                        "Invalid/malformed response from OpenAI (attempt {attempt}/{max_retries}). Retrying in {wait_time} seconds...",
-                        attempt=attempt,
-                        max_retries=max_retries,
-                        wait_time=wait_time,
-                    )
+                _log_and_sleep(
+                    "OpenAI API rate limit (429) (attempt {attempt}/{max_retries}): {e}. Retrying in {wait_time} seconds...",
+                    attempt,
+                    max_retries,
+                    e=e,
+                    wait_time=wait_time,
                 )
-                time.sleep(wait_time)
+                return None
             else:
-                print(tr("Max retries for invalid response reached. Raising error."))
-                raise last_exception
-        except Exception as e:
-            last_exception = e
-            status_code = None
-            error_message = str(e)
-            retry_after = None
-            # Detect specific tool support error
-            if "No endpoints found that support tool use" in error_message:
-                print(tr("API does not support tool use."))
-                raise NoToolSupportError(error_message)
-            # Try to extract status code and Retry-After from known exception types or message
-            if hasattr(e, "status_code"):
-                status_code = getattr(e, "status_code")
-            elif hasattr(e, "response") and hasattr(e.response, "status_code"):
-                status_code = getattr(e.response, "status_code")
-                # Check for Retry-After header
-                if hasattr(e.response, "headers") and e.response.headers:
-                    retry_after = e.response.headers.get("Retry-After")
+                print("Max retries for OpenAI API rate limit reached. Raising error.")
+                raise e
+        elif 500 <= status_code < 600:
+            wait_time = 2**attempt
+            if attempt < max_retries:
+                _log_and_sleep(
+                    "OpenAI API server error (attempt {attempt}/{max_retries}): {e}. Retrying in {wait_time} seconds...",
+                    attempt,
+                    max_retries,
+                    e=e,
+                    wait_time=wait_time,
+                )
+                return None
             else:
-                # Try to parse from error message
-                import re
-
-                match = re.search(r"[Ee]rror code: (\d{3})", error_message)
-                if match:
-                    status_code = int(match.group(1))
-                # Try to find Retry-After in message
-                retry_after_match = re.search(
-                    r"Retry-After['\"]?:?\s*(\d+)", error_message
+                print("Max retries for OpenAI API server error reached. Raising error.")
+                raise e
+        elif 400 <= status_code < 500:
+            print(
+                tr(
+                    "OpenAI API client error {status_code}: {e}. Not retrying.",
+                    status_code=status_code,
+                    e=e,
                 )
-                if retry_after_match:
-                    retry_after = retry_after_match.group(1)
-            # Decide retry logic based on status code
-            if status_code is not None:
-                if status_code == 429:
-                    # Use Retry-After if available, else exponential backoff
-                    if retry_after is not None:
-                        try:
-                            wait_time = int(float(retry_after))
-                        except Exception:
-                            wait_time = 2**attempt
-                    else:
-                        wait_time = 2**attempt
-                    if attempt < max_retries:
-                        print(
-                            tr(
-                                "OpenAI API rate limit (429) (attempt {attempt}/{max_retries}): {e}. Retrying in {wait_time} seconds...",
-                                attempt=attempt,
-                                max_retries=max_retries,
-                                e=e,
-                                wait_time=wait_time,
-                            )
-                        )
-                        time.sleep(wait_time)
-                        continue
-                    else:
-                        print(
-                            "Max retries for OpenAI API rate limit reached. Raising error."
-                        )
-                        raise last_exception
-                elif 500 <= status_code < 600:
-                    # Retry on server errors
-                    if attempt < max_retries:
-                        wait_time = 2**attempt
-                        print(
-                            tr(
-                                "OpenAI API server error (attempt {attempt}/{max_retries}): {e}. Retrying in {wait_time} seconds...",
-                                attempt=attempt,
-                                max_retries=max_retries,
-                                e=e,
-                                wait_time=wait_time,
-                            )
-                        )
-                        time.sleep(wait_time)
-                        continue
-                    else:
-                        print(
-                            "Max retries for OpenAI API server error reached. Raising error."
-                        )
-                        raise last_exception
-                elif 400 <= status_code < 500:
-                    # Do not retry on client errors (except 429)
-                    print(
-                        tr(
-                            "OpenAI API client error {status_code}: {e}. Not retrying.",
-                            status_code=status_code,
-                            e=e,
-                        )
-                    )
-                    raise last_exception
-            # If status code not detected, fallback to previous behavior
-            if attempt < max_retries:
-                wait_time = 2**attempt
+            )
+            raise e
+    if attempt < max_retries:
+        wait_time = 2**attempt
+        _log_and_sleep(
+            "OpenAI API error (attempt {attempt}/{max_retries}): {e}. Retrying in {wait_time} seconds...",
+            attempt,
+            max_retries,
+            e=e,
+            wait_time=wait_time,
+        )
+        print(f"[DEBUG] Exception repr: {repr(e)}")
+        return None
+    else:
+        print(tr("Max retries for OpenAI API error reached. Raising error."))
+        raise e
+
+
+def retry_api_call(
+    api_func, max_retries=5, *args, history=None, user_message_on_empty=None, **kwargs
+):
+    for attempt in range(1, max_retries + 1):
+        try:
+            response = api_func(*args, **kwargs)
+            error = getattr(response, "error", None)
+            if error:
+                print(f"ApiError: {error.get('message', error)}")
+                raise ApiError(error.get("message", str(error)))
+            return response
+        except ApiError:
+            raise
+        except EmptyResponseError:
+            if history is not None and user_message_on_empty is not None:
                 print(
-                    tr(
-                        "OpenAI API error (attempt {attempt}/{max_retries}): {e}. Retrying in {wait_time} seconds...",
-                        attempt=attempt,
-                        max_retries=max_retries,
-                        e=e,
-                        wait_time=wait_time,
-                    )
+                    f"[DEBUG] Adding user message to history: {user_message_on_empty}"
                 )
-                time.sleep(wait_time)
+                history.add_message({"role": "user", "content": user_message_on_empty})
+                continue  # Retry with updated history
             else:
-                print(tr("Max retries for OpenAI API error reached. Raising error."))
-                raise last_exception
+                raise
+        except json.JSONDecodeError as e:
+            result = _handle_json_decode_error(e, attempt, max_retries)
+            if result is not None:
+                return result
+        except Exception as e:
+            result = _handle_general_exception(e, attempt, max_retries)
+            if result is not None:
+                return result

janito/agent/{conversation_history.py → llm_conversation_history.py}

@@ -1,8 +1,10 @@
 from typing import List, Dict, Optional
 import json
+import sys
+import traceback
 
 
-class ConversationHistory:
+class LLMConversationHistory:
     """
     Manages the message history for a conversation, supporting OpenAI-style roles.
     Intended to be used by ConversationHandler and chat loop for all history operations.
@@ -13,6 +15,14 @@ class ConversationHistory:
 
     def add_message(self, message: Dict):
         """Append a message dict to the history."""
+        content = message.get("content")
+        if isinstance(content, str) and any(
+            0xD800 <= ord(ch) <= 0xDFFF for ch in content
+        ):
+            print(
+                f"Surrogate code point detected in message content: {content!r}\nStack trace:\n{''.join(traceback.format_stack())}",
+                file=sys.stderr,
+            )
         self._messages.append(message)
 
     def get_messages(self, role: Optional[str] = None) -> List[Dict]:
@@ -36,6 +46,13 @@ class ConversationHistory:
             (i for i, m in enumerate(self._messages) if m.get("role") == "system"), None
         )
         system_msg = {"role": "system", "content": content}
+        if isinstance(content, str) and any(
+            0xD800 <= ord(ch) <= 0xDFFF for ch in content
+        ):
+            print(
+                f"Surrogate code point detected in system message content: {content!r}\nStack trace:\n{''.join(traceback.format_stack())}",
+                file=sys.stderr,
+            )
         if system_idx is not None:
             self._messages[system_idx] = system_msg
         else:

janito/agent/openai_client.py

@@ -4,6 +4,7 @@ import time
 from openai import OpenAI
 from janito.agent.conversation import ConversationHandler
 from janito.agent.conversation_exceptions import ProviderError
+from janito.agent.llm_conversation_history import LLMConversationHistory
 
 
 class Agent:
@@ -18,7 +19,7 @@ class Agent:
         model: str = None,
         system_prompt_template: str | None = None,
         verbose_tools: bool = False,
-        base_url: str = "https://openrouter.ai/api/v1",
+        base_url: str = None,
         azure_openai_api_version: str = "2023-05-15",
         use_azure_openai: bool = False,
     ):
@@ -41,17 +42,35 @@ class Agent:
             # Import inside conditional to avoid requiring AzureOpenAI unless needed
             from openai import AzureOpenAI
 
-            self.client = AzureOpenAI(
-                api_key=api_key,
-                azure_endpoint=base_url,
-                api_version=azure_openai_api_version,
-            )
+            if base_url:
+                self.client = AzureOpenAI(
+                    api_key=api_key,
+                    azure_endpoint=base_url,
+                    api_version=azure_openai_api_version,
+                )
+            else:
+                self.client = AzureOpenAI(
+                    api_key=api_key,
+                    api_version=azure_openai_api_version,
+                )
         else:
-            self.client = OpenAI(
-                base_url=base_url,
-                api_key=api_key,
-                default_headers={"HTTP-Referer": self.REFERER, "X-Title": self.TITLE},
-            )
+            if base_url:
+                self.client = OpenAI(
+                    base_url=base_url,
+                    api_key=api_key,
+                    default_headers={
+                        "HTTP-Referer": self.REFERER,
+                        "X-Title": self.TITLE,
+                    },
+                )
+            else:
+                self.client = OpenAI(
+                    api_key=api_key,
+                    default_headers={
+                        "HTTP-Referer": self.REFERER,
+                        "X-Title": self.TITLE,
+                    },
+                )
 
         self.conversation_handler = ConversationHandler(
             self.client,
@@ -69,30 +88,27 @@ class Agent:
         spinner=False,
         max_tokens=None,
         max_rounds=100,
-        stream=False,
+        tool_user=False,
     ):
         """
         Start a chat conversation with the agent.
 
         Args:
-            messages: ConversationHistory instance or None.
-            message_handler: Optional handler for streaming or event messages.
+            messages: LLMConversationHistory instance or None.
+            message_handler: Optional handler for event messages.
             spinner: Show spinner during request.
             max_tokens: Max tokens for completion.
             max_rounds: Max conversation rounds.
-            stream: If True, enable OpenAI streaming mode (yields tokens incrementally).
         Returns:
-            If stream=False: dict with 'content', 'usage', and 'usage_history'.
-            If stream=True: generator yielding content chunks or events.
+            dict with 'content', 'usage', and 'usage_history'.
         """
         from janito.agent.runtime_config import runtime_config
-        from janito.agent.conversation_history import ConversationHistory
 
         if messages is None:
-            messages = ConversationHistory()
-        elif not isinstance(messages, ConversationHistory):
+            messages = LLMConversationHistory()
+        elif not isinstance(messages, LLMConversationHistory):
             raise TypeError(
-                "Agent.chat expects a ConversationHistory instance or None."
+                "Agent.chat expects a LLMConversationHistory instance or None."
             )
 
         max_retries = 5
@@ -106,8 +122,7 @@ class Agent:
                     spinner=spinner,
                     max_tokens=max_tokens,
                     verbose_events=runtime_config.get("verbose_events", False),
-                    stream=stream,
-                    verbose_stream=runtime_config.get("verbose_stream", False),
+                    tool_user=tool_user,
                 )
             except ProviderError as e:
                 error_data = getattr(e, "error_data", {}) or {}