janito 1.4.0__py3-none-any.whl → 1.5.0__py3-none-any.whl

janito/__init__.py

@@ -1 +1 @@
-__version__ = "1.4.0"
+__version__ = "1.5.0"

janito/agent/__init__.py

@@ -1 +0,0 @@
-from . import tools

janito/agent/agent.py

@@ -1,10 +1,8 @@
 """Agent module: defines the core LLM agent with tool and conversation handling."""
 
-import os
-import json
+import time
 from openai import OpenAI
-from janito.agent.conversation import ConversationHandler
-from janito.agent.tool_handler import ToolHandler
+from janito.agent.conversation import ConversationHandler, ProviderError
 
 class Agent:
     """Agent capable of handling conversations and tool calls."""
@@ -18,36 +16,27 @@ class Agent:
         model: str = None,
         system_prompt: str | None = None,
         verbose_tools: bool = False,
-        tool_handler = None,
         base_url: str = "https://openrouter.ai/api/v1",
         azure_openai_api_version: str = "2023-05-15",
         use_azure_openai: bool = False
     ):
         """
-        Initialize Agent,
+        Initialize Agent.
 
         Args:
             api_key: API key for OpenAI-compatible service.
             model: Model name to use.
             system_prompt: Optional system prompt override.
             verbose_tools: Enable verbose tool call logging.
-            tool_handler: Optional custom ToolHandler instance.
             base_url: API base URL.
             azure_openai_api_version: Azure OpenAI API version (default: "2023-05-15").
             use_azure_openai: Whether to use Azure OpenAI client (default: False).
-
-        Args:
-            api_key: API key for OpenAI-compatible service.
-            model: Model name to use.
-            system_prompt: Optional system prompt override.
-            verbose_tools: Enable verbose tool call logging.
-            tool_handler: Optional custom ToolHandler instance.
-            base_url: API base URL.
         """
         self.api_key = api_key
         self.model = model
         self.system_prompt = system_prompt
         if use_azure_openai:
+            # Import inside conditional to avoid requiring AzureOpenAI unless needed
             from openai import AzureOpenAI
             self.client = AzureOpenAI(
                 api_key=api_key,
@@ -63,22 +52,16 @@ class Agent:
                     "X-Title": self.TITLE
                 }
             )
-        if tool_handler is not None:
-            self.tool_handler = tool_handler
-        else:
-            self.tool_handler = ToolHandler(verbose=verbose_tools)
 
         self.conversation_handler = ConversationHandler(
-            self.client, self.model, self.tool_handler
+            self.client, self.model, 
         )
 
     @property
     def usage_history(self):
         return self.conversation_handler.usage_history
 
-    def chat(self, messages, on_content=None, on_tool_progress=None, verbose_response=False, spinner=False, max_tokens=None, max_rounds=50):
-        import time
-        from janito.agent.conversation import ProviderError
+    def chat(self, messages, message_handler=None, verbose_response=False, spinner=False, max_tokens=None, max_rounds=50):
 
         max_retries = 5
         for attempt in range(1, max_retries + 1):
@@ -86,8 +69,7 @@ class Agent:
                 return self.conversation_handler.handle_conversation(
                     messages,
                     max_rounds=max_rounds,
-                    on_content=on_content,
-                    on_tool_progress=on_tool_progress,
+                    message_handler=message_handler,
                     verbose_response=verbose_response,
                     spinner=spinner,
                     max_tokens=max_tokens

janito/agent/config.py

@@ -1,7 +1,7 @@
 import json
-import os
 from pathlib import Path
 from threading import Lock
+from .config_defaults import CONFIG_DEFAULTS
 
 
 class SingletonMeta(type):
@@ -60,13 +60,13 @@ CONFIG_OPTIONS = {
     "api_key": "API key for OpenAI-compatible service (required)",
     "model": "Model name to use (e.g., 'openai/gpt-4.1')",
     "base_url": "API base URL (OpenAI-compatible endpoint)",
-    "role": "Role description for the system prompt (e.g., 'software engineer')",
-    "system_prompt": "Override the entire system prompt text",
+    "role": "Role description for the Agent Profile (e.g., 'software engineer')",
+    "system_prompt": "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 prompt rendering (nested)",
+    "template": "Template context dictionary for Agent Profile prompt rendering (nested)",
     # Note: template.* keys are validated dynamically, not statically here
 }
 
@@ -97,7 +97,6 @@ class BaseConfig:
 
 
 # Import defaults for reference
-from .config_defaults import CONFIG_DEFAULTS
 
 class EffectiveConfig:
     """Read-only merged view of local and global configs"""
@@ -106,7 +105,6 @@ class EffectiveConfig:
         self.global_cfg = global_cfg
 
     def get(self, key, default=None):
-        from .config_defaults import CONFIG_DEFAULTS
         for cfg in (self.local_cfg, self.global_cfg):
             val = cfg.get(key)
             if val is not None:

janito/agent/config_defaults.py

@@ -3,8 +3,8 @@ 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",
-    "system_prompt": None,  # None means auto-generate from role
+    "role": "software engineer",  # Part of the Agent Profile
+    "system_prompt": None,  # None means auto-generate from Agent Profile role
     "temperature": 0.2,
     "max_tokens": 200000,
     "use_azure_openai": False,

janito/agent/conversation.py

@@ -1,4 +1,7 @@
-import json
+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
+import pprint
 
 class MaxRoundsExceededError(Exception):
     pass
@@ -12,24 +15,17 @@ class ProviderError(Exception):
         super().__init__(message)
 
 class ConversationHandler:
-    def __init__(self, client, model, tool_handler):
+    def __init__(self, client, model):
         self.client = client
         self.model = model
-        self.tool_handler = tool_handler
         self.usage_history = []
 
-    def handle_conversation(self, messages, max_rounds=50, on_content=None, on_tool_progress=None, verbose_response=False, spinner=False, max_tokens=None):
-        from janito.agent.runtime_config import runtime_config
+    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
         if not messages:
             raise ValueError("No prompt provided in messages")
 
-        from rich.console import Console
-        console = Console()
-
-        from janito.agent.runtime_config import unified_config
-
         # Resolve max_tokens priority: runtime param > config > default
         resolved_max_tokens = max_tokens
         if resolved_max_tokens is None:
@@ -43,32 +39,63 @@ class ConversationHandler:
 
         for _ in range(max_rounds):
             if spinner:
-                                # Calculate word count for all messages
+                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)
-                spinner_msg = f"[bold green]Waiting for AI response... ({word_count} words in conversation)"
+                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()
+            else:
+                if runtime_config.get('vanilla_mode', False):
                     response = self.client.chat.completions.create(
                         model=self.model,
                         messages=messages,
-                        tools=self.tool_handler.get_tool_schemas(),
+                        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()
-                    # console.print("\r\033[2K", end="")  # Clear the spinner line removed
-            else:
-                response = self.client.chat.completions.create(
-                    model=self.model,
-                    messages=messages,
-                    tools=self.tool_handler.get_tool_schemas(),
-                    tool_choice="auto",
-                    temperature=0.2,
-                    max_tokens=resolved_max_tokens
-                )
 
             if verbose_response:
-                import pprint
                 pprint.pprint(response)
 
             # Check for provider errors
@@ -93,34 +120,33 @@ class ConversationHandler:
             else:
                 usage_info = None
 
-            # Call the on_content callback if provided and content is not None
-            if on_content is not None and choice.message.content is not None:
-                on_content({"content": choice.message.content})
+            # Route content through the unified message handler if provided
+            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 assistant's message and usage info
+            # If no tool calls, return the agent's message and usage info
             if not choice.message.tool_calls:
-                # Store usage info in usage_history, linked to the next assistant message index
-                assistant_idx = len([m for m in messages if m.get('role') == 'assistant'])
-                self.usage_history.append({"assistant_index": assistant_idx, "usage": usage_info})
+                # 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})
                 return {
                     "content": choice.message.content,
                     "usage": usage_info,
                     "usage_history": self.usage_history
                 }
 
-            from janito.agent.runtime_config import runtime_config
             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 = self.tool_handler.handle_tool_call(tool_call, on_progress=on_tool_progress)
+                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 assistant message index
-            assistant_idx = len([m for m in messages if m.get('role') == 'assistant'])
-            self.usage_history.append({"assistant_index": assistant_idx, "usage": usage_info})
+            # 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})
             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:

janito/agent/message_handler.py

@@ -0,0 +1,18 @@
+
+class MessageHandler:
+    def __init__(self, queue, *args, **kwargs):
+        self._queue = queue
+
+    def handle_tool_call(self, tool_call):
+        # All output is routed through the unified message handler and queue
+        return super().handle_tool_call(tool_call)
+
+    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))

janito/agent/openai_schema_generator.py

@@ -0,0 +1,116 @@
+"""
+MUST BE IMPLEMENTED:
+- check that all params found in the signature have documentation in the docstring which is provided in the parameter schema doc
+- the Return must be documented and integrated in the sechema description
+- backward compatibility is not required
+"""
+
+
+import inspect
+import re
+import typing
+
+PYTHON_TYPE_TO_JSON = {
+    str: "string",
+    int: "integer",
+    float: "number",
+    bool: "boolean",
+    list: "array",
+    dict: "object",
+}
+
+def _parse_docstring(docstring: str):
+    """
+    Parses a docstring to extract summary, parameter descriptions, and return description.
+    Expects Google or NumPy style docstrings.
+    Returns: summary, {param: description}, return_description
+    """
+    if not docstring:
+        return "", {}, ""
+    lines = docstring.strip().split("\n")
+    summary = lines[0].strip()
+    param_descs = {}
+    return_desc = ""
+    in_params = False
+    in_returns = False
+    for line in lines[1:]:
+        l = line.strip()
+        if l.lower().startswith(("args:", "parameters:")):
+            in_params = True
+            in_returns = False
+            continue
+        if l.lower().startswith("returns:"):
+            in_returns = True
+            in_params = False
+            continue
+        if in_params:
+            m = re.match(r"([a-zA-Z_][a-zA-Z0-9_]*)(?: \(([^)]+)\))?: (.+)", l)
+            if m:
+                param, _, desc = m.groups()
+                param_descs[param] = desc.strip()
+            elif l and l[0] != "-":
+                # Continuation of previous param
+                if param_descs:
+                    last = list(param_descs)[-1]
+                    param_descs[last] += " " + l
+        elif in_returns:
+            if l:
+                return_desc += (" " if return_desc else "") + l
+    return summary, param_descs, return_desc
+
+def _type_to_json_schema(tp):
+    # Handle typing.Optional, typing.Union, typing.List, etc.
+    origin = typing.get_origin(tp)
+    args = typing.get_args(tp)
+    if origin is None:
+        return {"type": PYTHON_TYPE_TO_JSON.get(tp, "string")}
+    if origin is list or origin is typing.List:
+        item_type = args[0] if args else str
+        return {"type": "array", "items": _type_to_json_schema(item_type)}
+    if origin is dict or origin is typing.Dict:
+        return {"type": "object"}
+    if origin is typing.Union:
+        # Optional[...] is Union[..., NoneType]
+        non_none = [a for a in args if a is not type(None)]
+        if len(non_none) == 1:
+            return _type_to_json_schema(non_none[0])
+        # Otherwise, fallback
+        return {"type": "string"}
+    return {"type": "string"}
+
+def generate_openai_function_schema(func, tool_name: str):
+    """
+    Generates an OpenAI-compatible function schema for a callable.
+    Raises ValueError if the return type is not explicitly str.
+    """
+    sig = inspect.signature(func)
+    # Enforce explicit str return type
+    if sig.return_annotation is inspect._empty or sig.return_annotation is not str:
+        raise ValueError(f"Tool '{tool_name}' must have an explicit return type of 'str'. Found: {sig.return_annotation}")
+    docstring = func.__doc__
+    summary, param_descs, _ = _parse_docstring(docstring)
+    # Check that all parameters in the signature have documentation
+    undocumented = [name for name, param in sig.parameters.items() if name != "self" and name not in param_descs]
+    if undocumented:
+        raise ValueError(f"Tool '{tool_name}' is missing docstring documentation for parameter(s): {', '.join(undocumented)}")
+    properties = {}
+    required = []
+    for name, param in sig.parameters.items():
+        if name == "self":
+            continue
+        annotation = param.annotation if param.annotation != inspect._empty else str
+        pdesc = param_descs.get(name, "")
+        schema = _type_to_json_schema(annotation)
+        schema["description"] = pdesc
+        properties[name] = schema
+        if param.default == inspect._empty:
+            required.append(name)
+    return {
+        "name": tool_name,
+        "description": summary,
+        "parameters": {
+            "type": "object",
+            "properties": properties,
+            "required": required,
+        }
+    }

janito/agent/queued_message_handler.py

@@ -0,0 +1,32 @@
+class QueuedMessageHandler:
+    def __init__(self, queue, *args, **kwargs):
+        self._queue = queue
+
+    def handle_message(self, msg, msg_type=None):
+        # Unified: send content (agent/LLM) messages to the frontend via queue
+        if isinstance(msg, dict):
+            msg_type = msg.get('type', 'info')
+            # For tool_call and tool_result, print and forward the full dict
+            if msg_type in ("tool_call", "tool_result"):
+                print(f"[QueuedMessageHandler] {msg_type}: {msg}")
+                self._queue.put(msg)
+                return
+            message = msg.get('message', '')
+        else:
+            message = msg
+            msg_type = msg_type or 'info'
+        # For normal agent/user/info messages, emit type 'content' for frontend compatibility
+        print(f"[QueuedMessageHandler] {msg_type}: {message}")
+        if msg_type == "content":
+            self._queue.put({"type": "content", "content": message})
+        elif msg_type == "info":
+            out = {"type": "info", "message": message}
+            if 'tool' in msg:
+                out["tool"] = msg["tool"]
+            self._queue.put(out)
+        else:
+            out = {"type": msg_type, "message": message}
+            if 'tool' in msg:
+                out["tool"] = msg["tool"]
+            self._queue.put(out)
+

janito/agent/rich_tool_handler.py

@@ -0,0 +1,43 @@
+from rich.console import Console
+console = Console()
+
+class MessageHandler:
+    """
+    Unified message handler for all output (tool, agent, system) using Rich for styled output.
+    """
+    def __init__(self):
+        self.console = console
+
+    def handle_message(self, msg, msg_type=None):
+        """
+        Handles either a dict (with 'type' and 'message') or a plain string.
+        If dict: uses type/message. If str: uses msg_type or defaults to 'info'.
+        """
+        from rich.markdown import Markdown
+        if isinstance(msg, dict):
+            msg_type = msg.get("type", "info")
+            message = msg.get("message", "")
+            if msg_type == "content":
+                self.console.print(Markdown(message))
+            elif msg_type == "info":
+                self.console.print(message, style="cyan", end="")
+            elif msg_type == "success":
+                self.console.print(message, style="bold green", end="\n")
+            elif msg_type == "error":
+                self.console.print(message, style="bold red", end="\n")
+            elif msg_type == "progress":
+                self._handle_progress(message)
+            elif msg_type == "warning":
+                self.console.print(message, style="bold yellow", end="\n")
+            elif msg_type == "stdout":
+                from rich.text import Text
+                self.console.print(Text(message, style="on #003300", no_wrap=True, overflow=None), end="")
+            elif msg_type == "stderr":
+                from rich.text import Text
+                self.console.print(Text(message, style="on #330000", no_wrap=True, overflow=None), end="")
+            else:
+                # Ignore unsupported message types silently
+                return
+        else:
+            # Print plain strings as markdown/markup
+            self.console.print(Markdown(str(msg)))

janito/agent/runtime_config.py

@@ -1,4 +1,4 @@
-from .config import BaseConfig, EffectiveConfig, effective_config
+from .config import BaseConfig, effective_config
 
 class RuntimeConfig(BaseConfig):
     """In-memory only config, reset on restart"""

janito/agent/templates/system_instructions.j2

@@ -1,9 +1,14 @@
-Your main role is {{ role }} .
+Your Agent Profile:
+- Role: {{ role }}
 
-You are an assistant for a analysis and development tool that operates on files and
-directories using text-based operations.
+You are an Agent for an analysis and development tool that operates on files and directories using text-based operations.
+
+<agent_profile>
+This Agent operates according to its Agent Profile, which includes system settings, role, and tools.
+</agent_profile>
 
 Provide a concise plan before calling any tool.
+Plan changes only after gathering all the necessary information.
 Always execute the plan immediately after presenting it, unless the user requests otherwise.
 
 <context>
@@ -23,10 +28,11 @@ When you need to make changes to a file, consider the following:
 - It is preferred to replace exact text occurrences over file overwriting.
 - When replacing files, review their current content before requesting the update.
 - When reorganizing, moving files, or functions, search for references in other files that might need to be updated accordingly.
+- After making changes to files, use available tools (such as syntax checkers, linters, or test runners) to validate the files and ensure correctness before proceeding.
 </editing>
 
 <finishing>
-- When asked to commit and no message is provided, check the git diff and summarize the changes in the commit message.
+- When asked to commit, check the git diff and summarize the changes in the commit message.
 - Review the README content if there are user-exposed or public API changes.
 - Update `README_structure.txt` considering discovered, created, or modified files.
 </finishing>

janito/agent/tool_registry.py

@@ -0,0 +1,92 @@
+# janito/agent/tool_registry.py
+import json
+from janito.agent.tools.tool_base import ToolBase
+
+from janito.agent.openai_schema_generator import generate_openai_function_schema
+
+_tool_registry = {}
+
+def register_tool(tool=None, *, name: str = None):
+    if tool is None:
+        return lambda t: register_tool(t, name=name)
+    override_name = name
+    if not (isinstance(tool, type) and issubclass(tool, ToolBase)):
+        raise TypeError("Tool must be a class derived from ToolBase.")
+    instance = tool()
+    func = instance.call
+    default_name = tool.__name__
+    tool_name = override_name or default_name
+    schema = generate_openai_function_schema(func, tool_name)
+
+
+    _tool_registry[tool_name] = {
+        "function": func,
+        "description": schema["description"],
+        "parameters": schema["parameters"]
+    }
+    return tool
+
+def get_tool_schemas():
+    schemas = []
+    for name, entry in _tool_registry.items():
+        schemas.append({
+            "type": "function",
+            "function": {
+                "name": name,
+                "description": entry["description"],
+                "parameters": entry["parameters"]
+            }
+        })
+    return schemas
+
+def handle_tool_call(tool_call, message_handler=None, verbose=False):
+    import uuid
+    call_id = getattr(tool_call, 'id', None) or str(uuid.uuid4())
+    tool_entry = _tool_registry.get(tool_call.function.name)
+    if not tool_entry:
+        return f"Unknown tool: {tool_call.function.name}"
+    func = tool_entry["function"]
+    args = json.loads(tool_call.function.arguments)
+    if verbose:
+        print(f"[Tool Call] {tool_call.function.name} called with arguments: {args}")
+    instance = None
+    if hasattr(func, '__self__') and isinstance(func.__self__, ToolBase):
+        instance = func.__self__
+        if message_handler:
+            instance._progress_callback = message_handler.handle_message
+    # Emit tool_call event before calling the tool
+    if message_handler:
+        message_handler.handle_message({
+            'type': 'tool_call',
+            'tool': tool_call.function.name,
+            'args': args,
+            'call_id': call_id
+        })
+    try:
+        result = func(**args)
+    except Exception as e:
+        import traceback  # Kept here: only needed on error
+        error_message = f"[Tool Error] {type(e).__name__}: {e}\n" + traceback.format_exc()
+        if message_handler:
+            message_handler.handle_message({'type': 'error', 'message': error_message})
+        result = error_message
+    # Emit tool_result event after tool execution
+    if message_handler:
+        message_handler.handle_message({
+            'type': 'tool_result',
+            'tool': tool_call.function.name,
+            'call_id': call_id,
+            'result': result
+        })
+    if verbose:
+        preview = result
+        if isinstance(result, str):
+            lines = result.splitlines()
+            if len(lines) > 10:
+                preview = "\n".join(lines[:10]) + "\n... (truncated)"
+            elif len(result) > 500:
+                preview = result[:500] + "... (truncated)"
+        print(f"[Tool Result] {tool_call.function.name} returned:\n{preview}")
+    if instance is not None:
+        instance._progress_callback = None
+    return result