janito 1.5.1__py3-none-any.whl → 1.6.0__py3-none-any.whl

janito/__init__.py

@@ -1 +1 @@
-__version__ = "1.5.1"
+__version__ = "1.6.0"

janito/__main__.py

@@ -1,5 +1,4 @@
 from janito.cli.main import main
 
-
 if __name__ == "__main__":
     main()

janito/agent/config.py

@@ -30,8 +30,6 @@ class BaseConfig:
         return self._data
 
 
-
-
 class FileConfig(BaseConfig):
     def __init__(self, path):
         super().__init__()
@@ -40,36 +38,37 @@ class FileConfig(BaseConfig):
 
     def load(self):
         if self.path.exists():
-            with open(self.path, 'r') as f:
+            with open(self.path, "r") as f:
                 self._data = json.load(f)
                 # Remove keys with value None (null in JSON)
                 self._data = {k: v for k, v in self._data.items() if v is not None}
 
-
         else:
             self._data = {}
 
     def save(self):
         self.path.parent.mkdir(parents=True, exist_ok=True)
-        with open(self.path, 'w') as f:
+        with open(self.path, "w") as f:
             json.dump(self._data, f, indent=2)
 
 
-
 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')",
     "base_url": "API base URL (OpenAI-compatible endpoint)",
     "role": "Role description for the Agent Profile (e.g., 'software engineer')",
-    "system_prompt": "Override the entire Agent Profile prompt text",
+    "system_prompt_template": "Override the entire Agent Profile prompt text",
     "temperature": "Sampling temperature (float, e.g., 0.0 - 2.0)",
     "max_tokens": "Maximum tokens for model response (int)",
     "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')",
     # Note: template.* keys are validated dynamically, not statically here
 }
 
+
 class BaseConfig:
     def __init__(self):
         self._data = {}
@@ -83,7 +82,6 @@ class BaseConfig:
     def all(self):
         return self._data
 
-
         """
         Returns a dictionary suitable for passing as Jinja2 template variables.
         Merges the nested 'template' dict (if present) and all flat 'template.*' keys.
@@ -98,8 +96,10 @@ class BaseConfig:
 
 # Import defaults for reference
 
+
 class EffectiveConfig:
     """Read-only merged view of local and global configs"""
+
     def __init__(self, local_cfg, global_cfg):
         self.local_cfg = local_cfg
         self.global_cfg = global_cfg
@@ -127,11 +127,12 @@ class EffectiveConfig:
 
 # Singleton instances
 
-local_config = FileConfig(Path('.janito/config.json'))
-global_config = FileConfig(Path.home() / '.janito/config.json')
+local_config = FileConfig(Path(".janito/config.json"))
+global_config = FileConfig(Path.home() / ".janito/config.json")
 
 effective_config = EffectiveConfig(local_config, global_config)
 
+
 def get_api_key():
     """Retrieve API key from config files (local, then global)."""
     api_key = effective_config.get("api_key")

janito/agent/config_defaults.py

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

janito/agent/conversation.py

@@ -1,18 +1,17 @@
-from janito.agent.tool_registry import get_tool_schemas, handle_tool_call
-from janito.agent.runtime_config import runtime_config, unified_config
-from rich.console import Console
+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
+from janito.agent.conversation_ui import show_spinner, print_verbose_event
+from janito.agent.conversation_exceptions import (
+    MaxRoundsExceededError,
+    EmptyResponseError,
+)
+from janito.agent.runtime_config import unified_config
 import pprint
 
-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 ConversationHandler:
     def __init__(self, client, model):
@@ -20,136 +19,111 @@ class ConversationHandler:
         self.model = model
         self.usage_history = []
 
-    def handle_conversation(self, messages, max_rounds=50, message_handler=None, verbose_response=False, spinner=False, max_tokens=None):
-        max_tools = runtime_config.get('max_tools', None)
-        tool_calls_made = 0
+    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")
 
-        # Resolve max_tokens priority: runtime param > config > default
         resolved_max_tokens = max_tokens
         if resolved_max_tokens is None:
-            resolved_max_tokens = unified_config.get('max_tokens', 200000)
-
-        # Ensure max_tokens is always an int (handles config/CLI string values)
+            resolved_max_tokens = unified_config.get("max_tokens", 200000)
         try:
             resolved_max_tokens = int(resolved_max_tokens)
         except (TypeError, ValueError):
-            raise ValueError(f"max_tokens must be an integer, got: {resolved_max_tokens!r}")
+            raise ValueError(
+                f"max_tokens must be an integer, got: {resolved_max_tokens!r}"
+            )
 
         for _ in range(max_rounds):
-            if spinner:
-                console = Console()
-                # Calculate word count for all messages
-                word_count = sum(len(str(m.get('content', '')).split()) for m in messages if 'content' in m)
-                def format_count(n):
-                    if n >= 1_000_000:
-                        return f"{n/1_000_000:.1f}m"
-                    elif n >= 1_000:
-                        return f"{n/1_000:.1f}k"
-                    return str(n)
-                # Count message types
-                user_msgs = sum(1 for m in messages if m.get('role') == 'user')
-                agent_msgs = sum(1 for m in messages if m.get('role') == 'assistant')
-                tool_msgs = sum(1 for m in messages if m.get('role') == 'tool')
-                # Tool uses: count tool_calls in all agent messages
-                tool_uses = sum(len(m.get('tool_calls', [])) for m in messages if m.get('role') == 'assistant')
-                # Tool responses: tool_msgs
-                spinner_msg = (
-                    f"[bold green]Waiting for AI response... ("
-                    f"{format_count(word_count)} words, "
-                    f"{user_msgs} user, {agent_msgs} agent, "
-                    f"{tool_uses} tool uses, {tool_msgs} tool responses)"
-                )
-                with console.status(spinner_msg, spinner="dots") as status:
-                    if runtime_config.get('vanilla_mode', False):
-                        response = self.client.chat.completions.create(
-                            model=self.model,
-                            messages=messages,
-                            max_tokens=resolved_max_tokens
-                        )
-                    else:
-                        response = self.client.chat.completions.create(
-                            model=self.model,
-                            messages=messages,
-                            tools=get_tool_schemas(),
-                            tool_choice="auto",
-                            temperature=0.2,
-                            max_tokens=resolved_max_tokens
-                        )
-                    status.stop()
+            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,
+                    )
+
+                retry_api_call(get_stream)
+                return None
             else:
-                if runtime_config.get('vanilla_mode', False):
-                    response = self.client.chat.completions.create(
-                        model=self.model,
-                        messages=messages,
-                        max_tokens=resolved_max_tokens
+                # Non-streaming mode
+                def api_call():
+                    return get_openai_response(
+                        self.client, self.model, messages, resolved_max_tokens
                     )
-                else:
-                    response = self.client.chat.completions.create(
-                        model=self.model,
-                        messages=messages,
-                        tools=get_tool_schemas(),
-                        tool_choice="auto",
-                        temperature=0.2,
-                        max_tokens=resolved_max_tokens
+
+                if spinner:
+                    response = show_spinner(
+                        "Waiting for AI response...", retry_api_call, api_call
                     )
+                else:
+                    response = retry_api_call(api_call)
 
             if verbose_response:
                 pprint.pprint(response)
-
-            # Check for provider errors
-            if hasattr(response, 'error') and response.error:
-                error_msg = response.error.get('message', 'Unknown provider error')
-                error_code = response.error.get('code', 'unknown')
-                raise ProviderError(f"Provider error: {error_msg} (Code: {error_code})", response.error)
-                
-            if not response.choices:
-                raise EmptyResponseError("The LLM API returned no choices in the 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]
-
-            # Extract token usage info if available
-            usage = getattr(response, 'usage', None)
-            if usage:
-                usage_info = {
-                    'prompt_tokens': getattr(usage, 'prompt_tokens', None),
-                    'completion_tokens': getattr(usage, 'completion_tokens', None),
-                    'total_tokens': getattr(usage, 'total_tokens', None)
+            usage = getattr(response, "usage", None)
+            usage_info = (
+                {
+                    "prompt_tokens": getattr(usage, "prompt_tokens", None),
+                    "completion_tokens": getattr(usage, "completion_tokens", None),
+                    "total_tokens": getattr(usage, "total_tokens", None),
                 }
-            else:
-                usage_info = None
-
-            # Route content through the unified message handler if provided
+                if usage
+                else None
+            )
+            event = {"type": "content", "message": choice.message.content}
+            if verbose_events:
+                print_verbose_event(event)
             if message_handler is not None and choice.message.content:
-                message_handler.handle_message(choice.message.content, msg_type="content")
-
-            # If no tool calls, return the agent's message and usage info
+                message_handler.handle_message(event)
             if not choice.message.tool_calls:
-                # Store usage info in usage_history, linked to the next agent message index
-                agent_idx = len([m for m in messages if m.get('role') == 'agent'])
-                self.usage_history.append({"agent_index": agent_idx, "usage": usage_info})
+                agent_idx = len([m for m in messages if m.get("role") == "agent"])
+                self.usage_history.append(
+                    {"agent_index": agent_idx, "usage": usage_info}
+                )
                 return {
                     "content": choice.message.content,
                     "usage": usage_info,
-                    "usage_history": self.usage_history
+                    "usage_history": self.usage_history,
                 }
-
-            tool_responses = []
-            # Sequential tool execution (default, only mode)
-            for tool_call in choice.message.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.")
-                result = handle_tool_call(tool_call, message_handler=message_handler)
-                tool_responses.append({"tool_call_id": tool_call.id, "content": result})
-                tool_calls_made += 1
-
-            # Store usage info in usage_history, linked to the next agent message index
-            agent_idx = len([m for m in messages if m.get('role') == 'agent'])
+            # Tool calls
+            tool_responses = handle_tool_calls(
+                choice.message.tool_calls, message_handler=message_handler
+            )
+            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]})
-
+            messages.append(
+                {
+                    "role": "assistant",
+                    "content": choice.message.content,
+                    "tool_calls": [tc.to_dict() for tc in choice.message.tool_calls],
+                }
+            )
             for tr in tool_responses:
-                messages.append({"role": "tool", "tool_call_id": tr["tool_call_id"], "content": tr["content"]})
-
+                messages.append(
+                    {
+                        "role": "tool",
+                        "tool_call_id": tr["tool_call_id"],
+                        "content": tr["content"],
+                    }
+                )
         raise MaxRoundsExceededError("Max conversation rounds exceeded")

janito/agent/conversation_api.py

@@ -0,0 +1,98 @@
+"""
+Handles OpenAI API calls and retry logic for conversation.
+"""
+
+import time
+import json
+from janito.agent.runtime_config import runtime_config
+from janito.agent.tool_registry import get_tool_schemas
+
+
+def get_openai_response(
+    client, model, messages, max_tokens, tools=None, tool_choice=None, temperature=None
+):
+    """Non-streaming OpenAI API call."""
+    if runtime_config.get("vanilla_mode", False):
+        return client.chat.completions.create(
+            model=model,
+            messages=messages,
+            max_tokens=max_tokens,
+        )
+    else:
+        return 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,
+        )
+
+
+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,
+    )
+    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,
+        )
+    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
+            if attempt < max_retries:
+                wait_time = 2**attempt
+                print(
+                    f"Invalid/malformed response from OpenAI (attempt {attempt}/{max_retries}). Retrying in {wait_time} seconds..."
+                )
+                time.sleep(wait_time)
+            else:
+                print("Max retries for invalid response reached. Raising error.")
+                raise last_exception
+        except Exception as e:
+            last_exception = e
+            if attempt < max_retries:
+                wait_time = 2**attempt
+                print(
+                    f"OpenAI API error (attempt {attempt}/{max_retries}): {e}. Retrying in {wait_time} seconds..."
+                )
+                time.sleep(wait_time)
+            else:
+                print("Max retries for OpenAI API error reached. Raising error.")
+                raise last_exception

janito/agent/conversation_exceptions.py

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

janito/agent/conversation_tool_calls.py

@@ -0,0 +1,22 @@
+"""
+Helpers for handling tool calls in conversation.
+"""
+
+from janito.agent.tool_registry import handle_tool_call
+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."
+            )
+        result = handle_tool_call(tool_call, message_handler=message_handler)
+        tool_responses.append({"tool_call_id": tool_call.id, "content": result})
+        tool_calls_made += 1
+    return tool_responses

janito/agent/conversation_ui.py

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

janito/agent/message_handler.py

@@ -1,5 +1,4 @@
-
-class MessageHandler:
+class QueueMessageHandler:
     def __init__(self, queue, *args, **kwargs):
         self._queue = queue
 
@@ -9,10 +8,10 @@ class MessageHandler:
 
     def handle_message(self, msg, msg_type=None):
         # Unified: send content (agent/LLM) messages to the frontend
-        if isinstance(msg, dict):
-            msg_type = msg.get('type', 'info')
-            message = msg.get('message', '')
-        else:
-            message = msg
-            msg_type = msg_type or 'info'
-        self._queue.put(('message', message, msg_type))
+        if not isinstance(msg, dict):
+            raise TypeError(
+                f"QueueMessageHandler.handle_message expects a dict with 'type' and 'message', got {type(msg)}: {msg!r}"
+            )
+        msg_type = msg.get("type", "info")
+        message = msg.get("message", "")
+        self._queue.put(("message", message, msg_type))