janito 1.7.0__py3-none-any.whl → 1.8.0__py3-none-any.whl

janito/__init__.py

@@ -1 +1 @@
-__version__ = "1.7.0"
+__version__ = "1.8.0"

janito/agent/config.py

@@ -64,7 +64,7 @@ CONFIG_OPTIONS = {
     "use_azure_openai": "Whether to use Azure OpenAI client (default: False)",
     # Accept template.* keys as valid config keys (for CLI validation, etc.)
     "template": "Template context dictionary for Agent Profile prompt rendering (nested)",
-    "interaction_style": "Interaction style for the Agent Profile (e.g., 'default' or 'technical')",
+    "profile": "Agent Profile name (only 'base' is supported)",
     # Note: template.* keys are validated dynamically, not statically here
 }
 

janito/agent/config_defaults.py

@@ -3,11 +3,11 @@ CONFIG_DEFAULTS = {
     "api_key": None,  # Must be set by user
     "model": "openai/gpt-4.1",  # Default model
     "base_url": "https://openrouter.ai/api/v1",
-    "role": "software engineer",  # Part of the Agent Profile
+    "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,
     "use_azure_openai": False,
     "azure_openai_api_version": "2023-05-15",
-    "interaction_style": "default",
+    "profile": "base",
 }

janito/agent/conversation.py

@@ -8,8 +8,9 @@ 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
+from janito.agent.runtime_config import unified_config, runtime_config
 import pprint
 
 
@@ -19,6 +20,13 @@ class ConversationHandler:
         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 handle_conversation(
         self,
         messages,
@@ -41,40 +49,75 @@ class ConversationHandler:
             resolved_max_tokens = int(resolved_max_tokens)
         except (TypeError, ValueError):
             raise ValueError(
-                f"max_tokens must be an integer, got: {resolved_max_tokens!r}"
+                "max_tokens must be an integer, got: {resolved_max_tokens!r}".format(
+                    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
+
         for _ in range(max_rounds):
-            if stream:
-                # Streaming mode
-                def get_stream():
-                    return get_openai_stream_response(
-                        self.client,
-                        self.model,
-                        messages,
-                        resolved_max_tokens,
-                        verbose_stream=verbose_stream,
-                        message_handler=message_handler,
-                    )
+            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))
+            except NoToolSupportError:
+                print(
+                    "⚠️ Endpoint does not support tool use. Proceeding in vanilla mode (tools disabled)."
+                )
+                runtime_config.set("vanilla_mode", True)
+                if max_tokens is None:
+                    runtime_config.set("max_tokens", 8000)
+                    resolved_max_tokens = 8000
 
-                retry_api_call(get_stream)
-                return None
-            else:
-                # Non-streaming mode
-                def api_call():
+                # 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...", retry_api_call, api_call
+                        "Waiting for AI response (tools disabled)...",
+                        retry_api_call,
+                        api_call_vanilla,
                     )
                 else:
-                    response = retry_api_call(api_call)
-                    print("[DEBUG] OpenAI API raw response:", repr(response))
-
-            if verbose_response:
+                    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(
@@ -94,7 +137,7 @@ class ConversationHandler:
                 else None
             )
             event = {"type": "content", "message": choice.message.content}
-            if verbose_events:
+            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)
@@ -121,12 +164,12 @@ class ConversationHandler:
                     "tool_calls": [tc.to_dict() for tc in choice.message.tool_calls],
                 }
             )
-            for tr in tool_responses:
+            for tool_response in tool_responses:
                 messages.append(
                     {
                         "role": "tool",
-                        "tool_call_id": tr["tool_call_id"],
-                        "content": tr["content"],
+                        "tool_call_id": tool_response["tool_call_id"],
+                        "content": tool_response["content"],
                     }
                 )
         raise MaxRoundsExceededError(f"Max conversation rounds exceeded ({max_rounds})")

janito/agent/conversation_api.py

@@ -3,9 +3,11 @@ 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
 
 
 def get_openai_response(
@@ -79,20 +81,118 @@ def retry_api_call(api_func, max_retries=5, *args, **kwargs):
             if attempt < max_retries:
                 wait_time = 2**attempt
                 print(
-                    f"Invalid/malformed response from OpenAI (attempt {attempt}/{max_retries}). Retrying in {wait_time} seconds..."
+                    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,
+                    )
                 )
                 time.sleep(wait_time)
             else:
-                print("Max retries for invalid response reached. Raising error.")
+                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")
+            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(
-                    f"OpenAI API error (attempt {attempt}/{max_retries}): {e}. Retrying in {wait_time} seconds..."
+                    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("Max retries for OpenAI API error reached. Raising error.")
+                print(tr("Max retries for OpenAI API error reached. Raising error."))
                 raise last_exception

janito/agent/conversation_exceptions.py

@@ -10,3 +10,9 @@ 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

@@ -2,7 +2,8 @@
 Helpers for handling tool calls in conversation.
 """
 
-from janito.agent.tool_registry import handle_tool_call
+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
 
@@ -16,7 +17,20 @@ def handle_tool_calls(tool_calls, message_handler=None):
             raise MaxRoundsExceededError(
                 f"Maximum number of tool calls ({max_tools}) reached in this chat session."
             )
-        result = handle_tool_call(tool_call, message_handler=message_handler)
-        tool_responses.append({"tool_call_id": tool_call.id, "content": result})
+        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)
+            tool_responses.append(
+                {
+                    "tool_call_id": tool_call.id,
+                    "content": f"Tool execution error: {error_msg}. Please retry with the correct parameters.",
+                }
+            )
         tool_calls_made += 1
     return tool_responses

janito/agent/event.py

@@ -0,0 +1,24 @@
+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

@@ -0,0 +1,24 @@
+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

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

janito/agent/event_system.py

@@ -0,0 +1,15 @@
+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)

janito/agent/message_handler.py

@@ -1,4 +1,7 @@
-class QueueMessageHandler:
+from janito.agent.message_handler_protocol import MessageHandlerProtocol
+
+
+class QueueMessageHandler(MessageHandlerProtocol):
     def __init__(self, queue, *args, **kwargs):
         self._queue = queue
 

janito/agent/message_handler_protocol.py

@@ -0,0 +1,5 @@
+from typing import Protocol
+
+
+class MessageHandlerProtocol(Protocol):
+    def handle_message(self, msg: dict, msg_type: str = None) -> None: ...

janito/agent/openai_client.py

@@ -66,13 +66,10 @@ class Agent:
         self,
         messages,
         message_handler=None,
-        verbose_response=False,
         spinner=False,
         max_tokens=None,
         max_rounds=50,
-        verbose_events=False,
         stream=False,
-        verbose_stream=False,
     ):
         """
         Start a chat conversation with the agent.
@@ -80,16 +77,16 @@ class Agent:
         Args:
             messages: List of message dicts.
             message_handler: Optional handler for streaming or event messages.
-            verbose_response: Print full response for debugging.
             spinner: Show spinner during request.
             max_tokens: Max tokens for completion.
             max_rounds: Max conversation rounds.
-            verbose_events: Print all events for debugging.
             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.
         """
+        from janito.agent.runtime_config import runtime_config
+
         max_retries = 5
         for attempt in range(1, max_retries + 1):
             try:
@@ -97,12 +94,12 @@ class Agent:
                     messages,
                     max_rounds=max_rounds,
                     message_handler=message_handler,
-                    verbose_response=verbose_response,
+                    verbose_response=runtime_config.get("verbose_response", False),
                     spinner=spinner,
                     max_tokens=max_tokens,
-                    verbose_events=verbose_events,
+                    verbose_events=runtime_config.get("verbose_events", False),
                     stream=stream,
-                    verbose_stream=verbose_stream,
+                    verbose_stream=runtime_config.get("verbose_stream", False),
                 )
             except ProviderError as e:
                 error_data = getattr(e, "error_data", {}) or {}

janito/agent/openai_schema_generator.py

@@ -8,6 +8,7 @@ MUST BE IMPLEMENTED:
 import inspect
 import re
 import typing
+from collections import OrderedDict
 
 PYTHON_TYPE_TO_JSON = {
     str: "string",
@@ -85,7 +86,7 @@ def _parse_docstring(docstring: str):
 def generate_openai_function_schema(func, tool_name: str, tool_class=None):
     """
     Generates an OpenAI-compatible function schema for a callable.
-    Raises ValueError if the return type is not explicitly str.
+    Raises ValueError if the return type is not explicitly str or if any parameter is missing a type hint.
     """
     sig = inspect.signature(func)
     # Enforce explicit str return type
@@ -93,6 +94,17 @@ def generate_openai_function_schema(func, tool_name: str, tool_class=None):
         raise ValueError(
             f"Tool '{tool_name}' must have an explicit return type of 'str'. Found: {sig.return_annotation}"
         )
+    # Enforce type hints for all parameters (except self)
+    missing_type_hints = [
+        name
+        for name, param in sig.parameters.items()
+        if name != "self" and param.annotation is inspect._empty
+    ]
+    if missing_type_hints:
+        raise ValueError(
+            f"Tool '{tool_name}' is missing type hints for parameter(s): {', '.join(missing_type_hints)}.\n"
+            f"All parameters must have explicit type hints for schema generation."
+        )
     # Only use the class docstring for schema generation
     class_doc = tool_class.__doc__.strip() if tool_class and tool_class.__doc__ else ""
     summary, param_descs, return_desc = _parse_docstring(class_doc)
@@ -107,14 +119,21 @@ def generate_openai_function_schema(func, tool_name: str, tool_class=None):
     ]
     if undocumented:
         raise ValueError(
-            f"Tool '{tool_name}' is missing docstring documentation for parameter(s): {', '.join(undocumented)}"
+            f"Tool '{tool_name}' is missing docstring documentation for parameter(s): {', '.join(undocumented)}.\n"
+            f"Parameter documentation must be provided in the Tool class docstring, not the method docstring."
         )
-    properties = {}
+    properties = OrderedDict()
     required = []
+    # Inject tool_call_reason as the first required parameter
+    properties["tool_call_reason"] = {
+        "type": "string",
+        "description": "The reason or context for why this tool is being called. This is required for traceability.",
+    }
+    required.append("tool_call_reason")
     for name, param in sig.parameters.items():
         if name == "self":
             continue
-        annotation = param.annotation if param.annotation != inspect._empty else str
+        annotation = param.annotation
         pdesc = param_descs.get(name, "")
         schema = _type_to_json_schema(annotation)
         schema["description"] = pdesc