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

janito/__init__.py

@@ -1 +1 @@
-__version__ = "1.8.1"
+__version__ = "1.10.0-dev"

janito/agent/api_exceptions.py

@@ -0,0 +1,4 @@
+class ApiError(Exception):
+    """Custom exception for API errors."""
+
+    pass

janito/agent/config.py

@@ -55,7 +55,7 @@ class FileConfig(BaseConfig):
 CONFIG_OPTIONS = {
     "api_key": "API key for OpenAI-compatible service (required)",
     "trust": "Trust mode: suppress all console output (bool, default: False)",
-    "model": "Model name to use (e.g., 'openai/gpt-4.1')",
+    "model": "Model name to use (e.g., 'gpt-4.1')",
     "base_url": "API base URL (OpenAI-compatible endpoint)",
     "role": "Role description for the Agent Profile (e.g., 'software engineer')",
     "system_prompt_template": "Override the entire Agent Profile prompt text",

janito/agent/config_defaults.py

@@ -1,12 +1,11 @@
 # Centralized config defaults for Janito
 CONFIG_DEFAULTS = {
     "api_key": None,  # Must be set by user
-    "model": "openai/gpt-4.1",  # Default model
-    "base_url": "https://openrouter.ai/api/v1",
+    "model": "gpt-4.1",  # Default model
     "role": "software developer",  # Part of the Agent Profile
     "system_prompt_template": None,  # None means auto-generate from Agent Profile role
     "temperature": 0.2,
-    "max_tokens": 200000,
+    "max_tokens": 32000,
     "use_azure_openai": False,
     "azure_openai_api_version": "2023-05-15",
     "profile": "base",

janito/agent/config_utils.py

@@ -1,9 +0,0 @@
-def merge_configs(*configs):
-    """
-    Merge multiple config-like objects (with .all()) into one dict.
-    Later configs override earlier ones.
-    """
-    merged = {}
-    for cfg in configs:
-        merged.update(cfg.all())
-    return merged

janito/agent/conversation.py

@@ -1,6 +1,5 @@
 from janito.agent.conversation_api import (
     get_openai_response,
-    get_openai_stream_response,
     retry_api_call,
 )
 from janito.agent.conversation_tool_calls import handle_tool_calls
@@ -11,7 +10,32 @@ from janito.agent.conversation_exceptions import (
     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:
@@ -27,24 +51,10 @@ class ConversationHandler:
         """
         return [msg for msg in messages if msg.get("role") != "system"]
 
-    def handle_conversation(
-        self,
-        messages,
-        max_rounds=50,
-        message_handler=None,
-        verbose_response=False,
-        spinner=False,
-        max_tokens=None,
-        verbose_events=False,
-        stream=False,
-        verbose_stream=False,
-    ):
-        if not messages:
-            raise ValueError("No prompt provided in messages")
-
+    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", 200000)
+            resolved_max_tokens = unified_config.get("max_tokens", 32000)
         try:
             resolved_max_tokens = int(resolved_max_tokens)
         except (TypeError, ValueError):
@@ -53,123 +63,176 @@ class ConversationHandler:
                     resolved_max_tokens=resolved_max_tokens
                 )
             )
-
-        # If vanilla mode is set and max_tokens was not provided, default to 8000
         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(
+            "\u26a0\ufe0f 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:
-                if stream:
-                    # Streaming mode
-                    def get_stream():
-                        return get_openai_stream_response(
-                            self.client,
-                            self.model,
-                            messages,
-                            resolved_max_tokens,
-                            verbose_stream=runtime_config.get("verbose_stream", False),
-                            message_handler=message_handler,
-                        )
-
-                    retry_api_call(get_stream)
-                    return None
-                else:
-                    # Non-streaming mode
-                    def api_call():
-                        return get_openai_response(
-                            self.client, self.model, messages, resolved_max_tokens
-                        )
-
-                    if spinner:
-                        response = show_spinner(
-                            "Waiting for AI response...", retry_api_call, api_call
-                        )
-                    else:
-                        response = retry_api_call(api_call)
-                        print("[DEBUG] OpenAI API raw response:", repr(response))
+                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:
-                print(
-                    "⚠️ Endpoint does not support tool use. Proceeding in vanilla mode (tools disabled)."
+                response, resolved_max_tokens = self._handle_no_tool_support(
+                    messages, max_tokens, spinner
                 )
-                runtime_config.set("vanilla_mode", True)
-                if max_tokens is None:
-                    runtime_config.set("max_tokens", 8000)
-                    resolved_max_tokens = 8000
-
-                # Remove system prompt for vanilla mode if needed (call this externally when appropriate)
-                # messages = ConversationHandler.remove_system_prompt(messages)
-                # Retry once with tools disabled
-                def api_call_vanilla():
-                    return get_openai_response(
-                        self.client, self.model, messages, resolved_max_tokens
-                    )
-
-                if spinner:
-                    response = show_spinner(
-                        "Waiting for AI response (tools disabled)...",
-                        retry_api_call,
-                        api_call_vanilla,
-                    )
-                else:
-                    response = retry_api_call(api_call_vanilla)
-                    print(
-                        "[DEBUG] OpenAI API raw response (tools disabled):",
-                        repr(response),
-                    )
-            if runtime_config.get("verbose_response", False):
-                pprint.pprint(response)
-            if response is None or not getattr(response, "choices", None):
-                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: Show usage extraction
-                    "_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
-            )
+            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 messages if m.get("role") == "agent"])
+                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,
                 }
-            # Tool calls
-            tool_responses = handle_tool_calls(
-                choice.message.tool_calls, message_handler=message_handler
+            self._handle_tool_calls(
+                choice, history, message_handler, usage_info, tool_user=tool_user
             )
-            agent_idx = len([m for m in messages if m.get("role") == "agent"])
-            self.usage_history.append({"agent_index": agent_idx, "usage": usage_info})
-            messages.append(
-                {
-                    "role": "assistant",
-                    "content": choice.message.content,
-                    "tool_calls": [tc.to_dict() for tc in choice.message.tool_calls],
-                }
-            )
-            for tool_response in tool_responses:
-                messages.append(
-                    {
-                        "role": "tool",
-                        "tool_call_id": tool_response["tool_call_id"],
-                        "content": tool_response["content"],
-                    }
-                )
         raise MaxRoundsExceededError(f"Max conversation rounds exceeded ({max_rounds})")