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

janito/agent/conversation_api.py

@@ -7,21 +7,40 @@ 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):
+    """
+    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):
+        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]
+    else:
+        return 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
+
     if runtime_config.get("vanilla_mode", False):
-        return client.chat.completions.create(
+        response = client.chat.completions.create(
             model=model,
             messages=messages,
             max_tokens=max_tokens,
         )
     else:
-        return client.chat.completions.create(
+        response = client.chat.completions.create(
             model=model,
             messages=messages,
             tools=tools or get_tool_schemas(),
@@ -29,170 +48,171 @@ def get_openai_response(
             temperature=temperature if temperature is not None else 0.2,
             max_tokens=max_tokens,
         )
+    # Explicitly check for missing or empty choices (API/LLM error)
+    if (
+        not hasattr(response, "choices")
+        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(
+            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."""
-    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_tool_calls.py

@@ -2,6 +2,7 @@
 Helpers for handling tool calls in conversation.
 """
 
+import json
 from janito.agent.tool_executor import ToolExecutor
 from janito.agent import tool_registry
 from .conversation_exceptions import MaxRoundsExceededError
@@ -19,18 +20,20 @@ def handle_tool_calls(tool_calls, message_handler=None):
             )
         tool_entry = tool_registry._tool_registry[tool_call.function.name]
         try:
-            result = ToolExecutor(message_handler=message_handler).execute(
-                tool_entry, tool_call
-            )
-            tool_responses.append({"tool_call_id": tool_call.id, "content": result})
-        except TypeError as e:
-            # Return the error as a tool result, asking to retry with correct params
-            error_msg = str(e)
+            arguments = json.loads(tool_call.function.arguments)
+        except (TypeError, AttributeError, json.JSONDecodeError) as e:
+            error_msg = f"Invalid/malformed function parameters: {e}. Please retry with valid JSON arguments."
             tool_responses.append(
                 {
                     "tool_call_id": tool_call.id,
-                    "content": f"Tool execution error: {error_msg}. Please retry with the correct parameters.",
+                    "content": error_msg,
                 }
             )
+            tool_calls_made += 1
+            continue
+        result = ToolExecutor(message_handler=message_handler).execute(
+            tool_entry, tool_call, arguments
+        )
+        tool_responses.append({"tool_call_id": tool_call.id, "content": result})
         tool_calls_made += 1
     return tool_responses

janito/agent/llm_conversation_history.py

@@ -0,0 +1,70 @@
+from typing import List, Dict, Optional
+import json
+import sys
+import traceback
+
+
+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.
+    """
+
+    def __init__(self, messages: Optional[List[Dict]] = None):
+        self._messages = messages.copy() if messages else []
+
+    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]:
+        """
+        Return all messages, or only those matching a given role/type (e.g., 'assistant', 'user', 'tool').
+        If role is None, returns all messages.
+        """
+        if role is None:
+            return self._messages.copy()
+        return [msg for msg in self._messages if msg.get("role") == role]
+
+    def clear(self):
+        """Remove all messages from history."""
+        self._messages.clear()
+
+    def set_system_message(self, content: str):
+        """
+        Replace the first system prompt message, or insert if not present.
+        """
+        system_idx = next(
+            (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:
+            self._messages.insert(0, system_msg)
+
+    def to_json_file(self, path: str):
+        """Save the conversation history as a JSON file to the given path."""
+        with open(path, "w", encoding="utf-8") as f:
+            json.dump(self.get_messages(), f, indent=2, ensure_ascii=False)
+
+    def __len__(self):
+        return len(self._messages)
+
+    def __getitem__(self, idx):
+        return self._messages[idx]

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,
@@ -64,29 +83,34 @@ class Agent:
 
     def chat(
         self,
-        messages,
+        messages=None,
         message_handler=None,
         spinner=False,
         max_tokens=None,
-        max_rounds=50,
-        stream=False,
+        max_rounds=100,
+        tool_user=False,
     ):
         """
         Start a chat conversation with the agent.
 
         Args:
-            messages: List of message dicts.
-            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
 
+        if messages is None:
+            messages = LLMConversationHistory()
+        elif not isinstance(messages, LLMConversationHistory):
+            raise TypeError(
+                "Agent.chat expects a LLMConversationHistory instance or None."
+            )
+
         max_retries = 5
         for attempt in range(1, max_retries + 1):
             try:
@@ -98,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 {}