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

janito/agent/conversation_api.py

@@ -7,20 +7,21 @@ 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
+from rich.console import Console
+from rich.status import Status
+
+console = Console()
 
 
 def _sanitize_utf8_surrogates(obj):
-    """
-    Recursively sanitize a dict/list/string by replacing surrogate codepoints with the unicode replacement character.
-    """
-    if isinstance(obj, str):
-        # Encode with surrogatepass, then decode with 'utf-8', replacing errors
-        return obj.encode("utf-8", "replace").decode("utf-8", "replace")
-    elif isinstance(obj, dict):
+    if isinstance(obj, dict):
         return {k: _sanitize_utf8_surrogates(v) for k, v in obj.items()}
     elif isinstance(obj, list):
-        return [_sanitize_utf8_surrogates(x) for x in obj]
+        return [_sanitize_utf8_surrogates(i) for i in obj]
+    elif isinstance(obj, str):
+        return obj.encode("utf-8", "surrogatepass").decode("utf-8", "ignore")
     else:
         return 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,253 @@ 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,
+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")
+    elif "429" in error_message:
+        status_code = 429
+    import re
+
+    match = re.search(r"status[ _]?code[=: ]+([0-9]+)", error_message)
+    if match:
+        status_code = int(match.group(1))
+    match_retry = re.search(r"retry[-_ ]?after[=: ]+([0-9]+)", error_message)
+    if match_retry:
+        retry_after = int(match_retry.group(1))
+    return status_code, retry_after
+
+
+def _calculate_wait_time(status_code, retry_after, attempt):
+    if status_code == 429 and retry_after:
+        return max(retry_after, 2**attempt)
+    return 2**attempt
+
+
+def _log_and_sleep(
+    message,
+    attempt,
+    max_retries,
+    e=None,
+    wait_time=None,
+    status=None,
+    waiting_message=None,
+    restore_message=None,
 ):
-    """Streaming OpenAI API call."""
-    messages = _sanitize_utf8_surrogates(messages)
-    openai_args = dict(
-        model=model,
-        messages=messages,
-        max_tokens=max_tokens,
-        stream=True,
+    status_message = 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,
+    if (
+        status is not None
+        and waiting_message is not None
+        and restore_message is not None
+    ):
+        original_message = status.status
+        status.update(waiting_message)
+        time.sleep(wait_time)
+        status.update(restore_message)
+    else:
+        with Status(status_message, console=console, spinner="dots"):
+            time.sleep(wait_time)
+
+
+def _handle_json_decode_error(e, attempt, max_retries, status=None):
+    if attempt < max_retries:
+        wait_time = 2**attempt
+        if status is not None:
+            _log_and_sleep(
+                "Invalid/malformed response from OpenAI (attempt {attempt}/{max_retries}). Retrying in {wait_time} seconds...",
+                attempt,
+                max_retries,
+                wait_time=wait_time,
+                status=status,
+                waiting_message="Waiting after error...",
+                restore_message="Waiting for AI response...",
+            )
+        else:
+            _log_and_sleep(
+                "Invalid/malformed response from OpenAI (attempt {attempt}/{max_retries}). Retrying in {wait_time} seconds...",
+                attempt,
+                max_retries,
+                wait_time=wait_time,
+            )
+        return None
+    else:
+        print(tr("Max retries for invalid response reached. Raising error."))
+        raise e
+
+
+def _handle_no_tool_support(error_message):
+    if "No endpoints found that support tool use" in error_message:
+        print(tr("API does not support tool use."))
+        raise NoToolSupportError(error_message)
+
+
+def _handle_rate_limit(e, attempt, max_retries, status, status_code, retry_after):
+    wait_time = _calculate_wait_time(status_code, retry_after, attempt)
+    if attempt < max_retries:
+        if status is not None:
+            _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,
+                status=status,
+                waiting_message="Waiting after rate limit reached...",
+                restore_message="Waiting for AI response...",
+            )
+        else:
+            _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,
+            )
+        return None
+    else:
+        raise e
+
+
+def _handle_server_error(e, attempt, max_retries, status, status_code):
+    wait_time = 2**attempt
+    if attempt < max_retries:
+        if status is not None:
+            _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,
+                status=status,
+                waiting_message="Waiting after server error...",
+                restore_message="Waiting for AI response...",
+            )
+        else:
+            _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:
+        print("Max retries for OpenAI API server error reached. Raising error.")
+        raise e
+
+
+def _handle_client_error(e, status_code):
+    print(
+        tr(
+            "OpenAI API client error {status_code}: {e}. Not retrying.",
+            status_code=status_code,
+            e=e,
         )
-    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
+    )
+    raise e
+
+
+def _handle_generic_error(e, attempt, max_retries, status):
+    wait_time = 2**attempt
+    if attempt < max_retries:
+        if status is not None:
+            _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,
+                status=status,
+                waiting_message="Waiting after error...",
+                restore_message="Waiting for AI response...",
+            )
+        else:
+            _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 _handle_general_exception(e, attempt, max_retries, status=None):
+    error_message = str(e)
+    _handle_no_tool_support(error_message)
+    status_code, retry_after = _extract_status_and_retry_after(e, error_message)
+    if status_code is not None:
+        if status_code == 429:
+            return _handle_rate_limit(
+                e, attempt, max_retries, status, status_code, retry_after
+            )
+        elif 500 <= status_code < 600:
+            return _handle_server_error(e, attempt, max_retries, status, status_code)
+        elif 400 <= status_code < 500:
+            _handle_client_error(e, status_code)
+    return _handle_generic_error(e, attempt, max_retries, status)
+
+
+def retry_api_call(
+    api_func,
+    max_retries=5,
+    *args,
+    history=None,
+    user_message_on_empty=None,
+    status=None,
+    **kwargs,
+):
     for attempt in range(1, max_retries + 1):
         try:
-            return api_func(*args, **kwargs)
-        except json.JSONDecodeError as e:
-            last_exception = e
-            if attempt < max_retries:
-                wait_time = 2**attempt
+            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(
-                        "Invalid/malformed response from OpenAI (attempt {attempt}/{max_retries}). Retrying in {wait_time} seconds...",
-                        attempt=attempt,
-                        max_retries=max_retries,
-                        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 invalid response reached. Raising error."))
-                raise last_exception
+                raise
+        except json.JSONDecodeError as e:
+            result = _handle_json_decode_error(e, attempt, max_retries, status=status)
+            if result is not None:
+                return result
         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")
-            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
-                )
-                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
-                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,
-                    )
-                )
-                time.sleep(wait_time)
-            else:
-                print(tr("Max retries for OpenAI API error reached. Raising error."))
-                raise last_exception
+            result = _handle_general_exception(e, attempt, max_retries, status=status)
+            if result is not None:
+                return result

janito/agent/conversation_ui.py

@@ -8,7 +8,7 @@ from rich.console import Console
 def show_spinner(message, func, *args, **kwargs):
     console = Console()
     with console.status(message, spinner="dots") as status:
-        result = func(*args, **kwargs)
+        result = func(*args, status=status, **kwargs)
         status.stop()
         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:
@@ -51,3 +68,15 @@ class ConversationHistory:
 
     def __getitem__(self, idx):
         return self._messages[idx]
+
+    def remove_last_message(self):
+        """Remove and return the last message in the history, or None if empty."""
+        if self._messages:
+            return self._messages.pop()
+        return None
+
+    def last_message(self):
+        """Return the last message in the history, or None if empty."""
+        if self._messages:
+            return self._messages[-1]
+        return None

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 {}