janito 1.14.2__py3-none-any.whl → 2.0.0__py3-none-any.whl

janito/agent/conversation.py

@@ -1,238 +0,0 @@
-from janito.agent.conversation_api import (
-    get_openai_response,
-    retry_api_call,
-)
-from janito.agent.conversation_tool_calls import handle_tool_calls
-from janito.agent.conversation_ui import show_spinner, print_verbose_event
-from janito.agent.conversation_exceptions import (
-    MaxRoundsExceededError,
-    EmptyResponseError,
-    NoToolSupportError,
-)
-from janito.agent.runtime_config import unified_config, runtime_config
-from janito.agent.api_exceptions import ApiError
-import pprint
-from janito.agent.llm_conversation_history import LLMConversationHistory
-
-
-def get_openai_response_with_content_check(client, model, messages, max_tokens):
-    response = get_openai_response(client, model, messages, max_tokens)
-    # Check for empty assistant message content, but allow tool/function calls
-    if not hasattr(response, "choices") or not response.choices:
-        return response  # Let normal error handling occur
-    choice = response.choices[0]
-    content = getattr(choice.message, "content", None)
-    # Check for function_call (legacy OpenAI) or tool_calls (OpenAI v2 and others)
-    has_function_call = (
-        hasattr(choice.message, "function_call") and choice.message.function_call
-    )
-    has_tool_calls = hasattr(choice.message, "tool_calls") and choice.message.tool_calls
-    if (content is None or str(content).strip() == "") and not (
-        has_function_call or has_tool_calls
-    ):
-        print(
-            "[DEBUG] Empty assistant message detected with no tool/function call. Will retry. Raw response:"
-        )
-        print(repr(response))
-        raise EmptyResponseError("Empty assistant message content.")
-    return response
-
-
-class ConversationHandler:
-    def __init__(self, client, model):
-        self.client = client
-        self.model = model
-        self.usage_history = []
-
-    @staticmethod
-    def remove_system_prompt(messages):
-        """
-        Return a new messages list with all system prompts removed.
-        """
-        return [msg for msg in messages if msg.get("role") != "system"]
-
-    def _resolve_max_tokens(self, max_tokens):
-        resolved_max_tokens = max_tokens
-        if resolved_max_tokens is None:
-            resolved_max_tokens = unified_config.get("max_tokens", 32000)
-        try:
-            resolved_max_tokens = int(resolved_max_tokens)
-        except (TypeError, ValueError):
-            raise ValueError(
-                "max_tokens must be an integer, got: {resolved_max_tokens!r}".format(
-                    resolved_max_tokens=resolved_max_tokens
-                )
-            )
-        if runtime_config.get("vanilla_mode", False) and max_tokens is None:
-            resolved_max_tokens = 8000
-        return resolved_max_tokens
-
-    def _call_openai_api(self, history, resolved_max_tokens, spinner):
-        def api_call():
-            return get_openai_response_with_content_check(
-                self.client,
-                self.model,
-                history.get_messages(),
-                resolved_max_tokens,
-            )
-
-        user_message_on_empty = "Received an empty message from you. Please try again."
-        if spinner:
-            response = show_spinner(
-                "Waiting for AI response...",
-                retry_api_call,
-                api_call,
-                history=history,
-                user_message_on_empty=user_message_on_empty,
-            )
-        else:
-            response = retry_api_call(
-                api_call, history=history, user_message_on_empty=user_message_on_empty
-            )
-        return response
-
-    def _handle_no_tool_support(self, messages, max_tokens, spinner):
-        print(
-            "⚠️ Endpoint does not support tool use. Proceeding in vanilla mode (tools disabled)."
-        )
-        runtime_config.set("vanilla_mode", True)
-        resolved_max_tokens = 8000
-        if max_tokens is None:
-            runtime_config.set("max_tokens", 8000)
-
-        def api_call_vanilla():
-            return get_openai_response_with_content_check(
-                self.client, self.model, messages, resolved_max_tokens
-            )
-
-        user_message_on_empty = "Received an empty message from you. Please try again."
-        if spinner:
-            response = show_spinner(
-                "Waiting for AI response (tools disabled)...",
-                retry_api_call,
-                api_call_vanilla,
-                history=None,
-                user_message_on_empty=user_message_on_empty,
-            )
-        else:
-            response = retry_api_call(
-                api_call_vanilla,
-                history=None,
-                user_message_on_empty=user_message_on_empty,
-            )
-            print(
-                "[DEBUG] OpenAI API raw response (tools disabled):",
-                repr(response),
-            )
-        return response, resolved_max_tokens
-
-    def _process_response(self, response):
-        if runtime_config.get("verbose_response", False):
-            pprint.pprint(response)
-        if response is None or not getattr(response, "choices", None):
-            error = getattr(response, "error", None)
-            if error:
-                print(f"ApiError: {error.get('message', error)}")
-                raise ApiError(error.get("message", str(error)))
-            raise EmptyResponseError(
-                f"No choices in response; possible API or LLM error. Raw response: {response!r}"
-            )
-        choice = response.choices[0]
-        usage = getattr(response, "usage", None)
-        usage_info = (
-            {
-                "_debug_raw_usage": getattr(response, "usage", None),
-                "prompt_tokens": getattr(usage, "prompt_tokens", None),
-                "completion_tokens": getattr(usage, "completion_tokens", None),
-                "total_tokens": getattr(usage, "total_tokens", None),
-            }
-            if usage
-            else None
-        )
-        return choice, usage_info
-
-    def _handle_tool_calls(
-        self, choice, history, message_handler, usage_info, tool_user=False
-    ):
-        tool_responses = handle_tool_calls(
-            choice.message.tool_calls, message_handler=message_handler
-        )
-        agent_idx = len([m for m in history.get_messages() if m.get("role") == "agent"])
-        self.usage_history.append({"agent_index": agent_idx, "usage": usage_info})
-        history.add_message(
-            {
-                "role": "assistant",
-                "content": choice.message.content,
-                "tool_calls": [tc.to_dict() for tc in choice.message.tool_calls],
-            }
-        )
-        for tool_response in tool_responses:
-            history.add_message(
-                {
-                    "role": "user" if tool_user else "tool",
-                    "tool_call_id": tool_response["tool_call_id"],
-                    "content": tool_response["content"],
-                }
-            )
-
-    def handle_conversation(
-        self,
-        messages,
-        max_rounds=100,
-        message_handler=None,
-        verbose_response=False,
-        spinner=False,
-        max_tokens=None,
-        verbose_events=False,
-        tool_user=False,
-    ):
-
-        if isinstance(messages, LLMConversationHistory):
-            history = messages
-        else:
-            history = LLMConversationHistory(messages)
-
-        if len(history) == 0:
-            raise ValueError("No prompt provided in messages")
-
-        resolved_max_tokens = self._resolve_max_tokens(max_tokens)
-
-        for _ in range(max_rounds):
-            try:
-                response = self._call_openai_api(history, resolved_max_tokens, spinner)
-                error = getattr(response, "error", None)
-                if error:
-                    print(f"ApiError: {error.get('message', error)}")
-                    raise ApiError(error.get("message", str(error)))
-            except NoToolSupportError:
-                response, resolved_max_tokens = self._handle_no_tool_support(
-                    messages, max_tokens, spinner
-                )
-            choice, usage_info = self._process_response(response)
-            event = {"type": "content", "message": choice.message.content}
-            if runtime_config.get("verbose_events", False):
-                print_verbose_event(event)
-            if message_handler is not None and choice.message.content:
-                message_handler.handle_message(event)
-            if not choice.message.tool_calls:
-                agent_idx = len(
-                    [m for m in history.get_messages() if m.get("role") == "agent"]
-                )
-                self.usage_history.append(
-                    {"agent_index": agent_idx, "usage": usage_info}
-                )
-                history.add_message(
-                    {
-                        "role": "assistant",
-                        "content": choice.message.content,
-                    }
-                )
-                return {
-                    "content": choice.message.content,
-                    "usage": usage_info,
-                    "usage_history": self.usage_history,
-                }
-            self._handle_tool_calls(
-                choice, history, message_handler, usage_info, tool_user=tool_user
-            )
-        raise MaxRoundsExceededError(f"Max conversation rounds exceeded ({max_rounds})")

janito/agent/conversation_api.py

@@ -1,306 +0,0 @@
-"""
-Handles OpenAI API calls and retry logic for conversation.
-"""
-
-import time
-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, 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):
-    if isinstance(obj, dict):
-        return {k: _sanitize_utf8_surrogates(v) for k, v in obj.items()}
-    elif isinstance(obj, list):
-        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
-
-
-def get_openai_response(
-    client, model, messages, max_tokens, tools=None, tool_choice=None, temperature=None
-):
-    """OpenAI API call."""
-    messages = _sanitize_utf8_surrogates(messages)
-    from janito.agent.conversation_exceptions import ProviderError
-
-    if runtime_config.get("vanilla_mode", False):
-        response = client.chat.completions.create(
-            model=model,
-            messages=messages,
-            max_tokens=max_tokens,
-        )
-    else:
-        response = client.chat.completions.create(
-            model=model,
-            messages=messages,
-            tools=tools or get_tool_schemas(),
-            tool_choice=tool_choice or "auto",
-            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 _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,
-):
-    status_message = tr(
-        message,
-        attempt=attempt,
-        max_retries=max_retries,
-        e=e,
-        wait_time=wait_time,
-    )
-    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,
-        )
-    )
-    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:
-            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(
-                    f"[DEBUG] Adding user message to history: {user_message_on_empty}"
-                )
-                history.add_message({"role": "user", "content": user_message_on_empty})
-                continue  # Retry with updated history
-            else:
-                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:
-            result = _handle_general_exception(e, attempt, max_retries, status=status)
-            if result is not None:
-                return result

janito/agent/conversation_exceptions.py

@@ -1,18 +0,0 @@
-class MaxRoundsExceededError(Exception):
-    pass
-
-
-class EmptyResponseError(Exception):
-    pass
-
-
-class ProviderError(Exception):
-    def __init__(self, message, error_data):
-        self.error_data = error_data
-        super().__init__(message)
-
-
-class NoToolSupportError(Exception):
-    """Raised when the API endpoint does not support tool use."""
-
-    pass

janito/agent/conversation_tool_calls.py

@@ -1,39 +0,0 @@
-"""
-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
-from janito.agent.runtime_config import runtime_config
-
-
-def handle_tool_calls(tool_calls, message_handler=None):
-    max_tools = runtime_config.get("max_tools", None)
-    tool_calls_made = 0
-    tool_responses = []
-    for tool_call in tool_calls:
-        if max_tools is not None and tool_calls_made >= max_tools:
-            raise MaxRoundsExceededError(
-                f"Maximum number of tool calls ({max_tools}) reached in this chat session."
-            )
-        tool_entry = tool_registry._tool_registry[tool_call.function.name]
-        try:
-            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": 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/conversation_ui.py

@@ -1,17 +0,0 @@
-"""
-UI helpers for conversation (spinner, verbose output).
-"""
-
-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, status=status, **kwargs)
-        status.stop()
-        return result
-
-
-def print_verbose_event(event):
-    print(f"[EVENT] {event}")

janito/agent/event.py

@@ -1,24 +0,0 @@
-from enum import Enum, auto
-from typing import Any
-
-
-class EventType(Enum):
-    CONTENT = auto()
-    INFO = auto()
-    SUCCESS = auto()
-    ERROR = auto()
-    PROGRESS = auto()
-    WARNING = auto()
-    STDOUT = auto()
-    STDERR = auto()
-    STREAM = auto()
-    STREAM_TOOL_CALL = auto()
-    STREAM_END = auto()
-    TOOL_CALL = auto()
-    TOOL_RESULT = auto()
-
-
-class Event:
-    def __init__(self, type: EventType, payload: Any = None):
-        self.type = type
-        self.payload = payload

janito/agent/event_dispatcher.py

@@ -1,24 +0,0 @@
-from typing import Callable, Dict, List
-from janito.agent.event import Event, EventType
-
-
-from janito.agent.event_handler_protocol import EventHandlerProtocol
-
-
-class EventDispatcher:
-    def __init__(self):
-        self._handlers: Dict[EventType, List[Callable[[Event], None]]] = {}
-
-    def register(self, event_type: EventType, handler: EventHandlerProtocol):
-        if event_type not in self._handlers:
-            self._handlers[event_type] = []
-        self._handlers[event_type].append(handler)
-
-    def register_all(self, handler: EventHandlerProtocol):
-        # Register handler for all event types
-        for event_type in EventType:
-            self.register(event_type, handler)
-
-    def dispatch(self, event: Event):
-        for handler in self._handlers.get(event.type, []):
-            handler.handle_event(event)

janito/agent/event_handler_protocol.py

@@ -1,5 +0,0 @@
-from typing import Protocol, Any
-
-
-class EventHandlerProtocol(Protocol):
-    def handle_event(self, event: Any) -> None: ...

janito/agent/event_system.py

@@ -1,15 +0,0 @@
-from janito.agent.event_dispatcher import EventDispatcher
-from janito.agent.rich_message_handler import RichMessageHandler
-
-# Singleton dispatcher
-shared_event_dispatcher = EventDispatcher()
-
-# Register handlers (example: RichMessageHandler for all events)
-rich_handler = RichMessageHandler()
-shared_event_dispatcher.register_all(rich_handler)
-
-# You can register other handlers as needed, e.g.:
-# queued_handler = QueuedMessageHandler(...)
-# shared_event_dispatcher.register_all(queued_handler)
-# queue_handler = QueueMessageHandler(...)
-# shared_event_dispatcher.register_all(queue_handler)