janito 1.14.3__py3-none-any.whl → 2.0.1__py3-none-any.whl

janito/agent/llm_conversation_history.py

@@ -1,82 +0,0 @@
-from typing import List, Dict, Optional
-import json
-import sys
-import traceback
-
-
-class LLMConversationHistory:
-    """
-    Manages the message history for a conversation, supporting OpenAI-style roles.
-    Intended to be used by ConversationHandler and chat loop for all history operations.
-    """
-
-    def __init__(self, messages: Optional[List[Dict]] = None):
-        self._messages = messages.copy() if messages else []
-
-    def add_message(self, message: Dict):
-        """Append a message dict to the history."""
-        content = message.get("content")
-        if isinstance(content, str) and any(
-            0xD800 <= ord(ch) <= 0xDFFF for ch in content
-        ):
-            print(
-                f"Surrogate code point detected in message content: {content!r}\nStack trace:\n{''.join(traceback.format_stack())}",
-                file=sys.stderr,
-            )
-        self._messages.append(message)
-
-    def get_messages(self, role: Optional[str] = None) -> List[Dict]:
-        """
-        Return all messages, or only those matching a given role/type (e.g., 'assistant', 'user', 'tool').
-        If role is None, returns all messages.
-        """
-        if role is None:
-            return self._messages.copy()
-        return [msg for msg in self._messages if msg.get("role") == role]
-
-    def clear(self):
-        """Remove all messages from history."""
-        self._messages.clear()
-
-    def set_system_message(self, content: str):
-        """
-        Replace the first system prompt message, or insert if not present.
-        """
-        system_idx = next(
-            (i for i, m in enumerate(self._messages) if m.get("role") == "system"), None
-        )
-        system_msg = {"role": "system", "content": content}
-        if isinstance(content, str) and any(
-            0xD800 <= ord(ch) <= 0xDFFF for ch in content
-        ):
-            print(
-                f"Surrogate code point detected in system message content: {content!r}\nStack trace:\n{''.join(traceback.format_stack())}",
-                file=sys.stderr,
-            )
-        if system_idx is not None:
-            self._messages[system_idx] = system_msg
-        else:
-            self._messages.insert(0, system_msg)
-
-    def to_json_file(self, path: str):
-        """Save the conversation history as a JSON file to the given path."""
-        with open(path, "w", encoding="utf-8") as f:
-            json.dump(self.get_messages(), f, indent=2, ensure_ascii=False)
-
-    def __len__(self):
-        return len(self._messages)
-
-    def __getitem__(self, idx):
-        return self._messages[idx]
-
-    def remove_last_message(self):
-        """Remove and return the last message in the history, or None if empty."""
-        if self._messages:
-            return self._messages.pop()
-        return None
-
-    def last_message(self):
-        """Return the last message in the history, or None if empty."""
-        if self._messages:
-            return self._messages[-1]
-        return None

janito/agent/message_handler.py

@@ -1,20 +0,0 @@
-from janito.agent.message_handler_protocol import MessageHandlerProtocol
-
-
-class QueueMessageHandler(MessageHandlerProtocol):
-    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 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))

janito/agent/message_handler_protocol.py

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

janito/agent/openai_client.py

@@ -1,149 +0,0 @@
-"""Agent module: defines the core LLM agent with tool and conversation handling."""
-
-import time
-from openai import OpenAI
-from janito.agent.conversation import ConversationHandler
-from janito.agent.conversation_exceptions import ProviderError
-from janito.agent.llm_conversation_history import LLMConversationHistory
-
-
-class Agent:
-    """Agent capable of handling conversations and tool calls."""
-
-    REFERER = "www.janito.dev"
-    TITLE = "Janito"
-
-    def __init__(
-        self,
-        api_key: str,
-        model: str = None,
-        system_prompt_template: str | None = None,
-        verbose_tools: bool = False,
-        base_url: str = None,
-        azure_openai_api_version: str = "2023-05-15",
-        use_azure_openai: bool = False,
-    ):
-        """
-        Initialize Agent.
-
-        Args:
-            api_key: API key for OpenAI-compatible service.
-            model: Model name to use.
-            system_prompt_template: Optional system prompt override.
-            verbose_tools: Enable verbose tool call logging.
-            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).
-        """
-        self.api_key = api_key
-        self.model = model
-        self.system_prompt_template = system_prompt_template
-        if use_azure_openai:
-            # Import inside conditional to avoid requiring AzureOpenAI unless needed
-            from openai import AzureOpenAI
-
-            if base_url:
-                self.client = AzureOpenAI(
-                    api_key=api_key,
-                    azure_endpoint=base_url,
-                    api_version=azure_openai_api_version,
-                )
-            else:
-                self.client = AzureOpenAI(
-                    api_key=api_key,
-                    api_version=azure_openai_api_version,
-                )
-        else:
-            if base_url:
-                self.client = OpenAI(
-                    base_url=base_url,
-                    api_key=api_key,
-                    default_headers={
-                        "HTTP-Referer": self.REFERER,
-                        "X-Title": self.TITLE,
-                    },
-                )
-            else:
-                self.client = OpenAI(
-                    api_key=api_key,
-                    default_headers={
-                        "HTTP-Referer": self.REFERER,
-                        "X-Title": self.TITLE,
-                    },
-                )
-
-        self.conversation_handler = ConversationHandler(
-            self.client,
-            self.model,
-        )
-
-    @property
-    def usage_history(self):
-        return self.conversation_handler.usage_history
-
-    def chat(
-        self,
-        messages=None,
-        message_handler=None,
-        spinner=False,
-        max_tokens=None,
-        max_rounds=100,
-        tool_user=False,
-    ):
-        """
-        Start a chat conversation with the agent.
-
-        Args:
-            messages: LLMConversationHistory instance or None.
-            message_handler: Optional handler for event messages.
-            spinner: Show spinner during request.
-            max_tokens: Max tokens for completion.
-            max_rounds: Max conversation rounds.
-        Returns:
-            dict with 'content', 'usage', and 'usage_history'.
-        """
-        from janito.agent.runtime_config import runtime_config
-
-        if messages is None:
-            messages = LLMConversationHistory()
-        elif not isinstance(messages, LLMConversationHistory):
-            raise TypeError(
-                "Agent.chat expects a LLMConversationHistory instance or None."
-            )
-
-        max_retries = 5
-        for attempt in range(1, max_retries + 1):
-            try:
-                return self.conversation_handler.handle_conversation(
-                    messages,
-                    max_rounds=max_rounds,
-                    message_handler=message_handler,
-                    verbose_response=runtime_config.get("verbose_response", False),
-                    spinner=spinner,
-                    max_tokens=max_tokens,
-                    verbose_events=runtime_config.get("verbose_events", False),
-                    tool_user=tool_user,
-                )
-            except ProviderError as e:
-                error_data = getattr(e, "error_data", {}) or {}
-                code = error_data.get("code", "")
-                # Retry only on 5xx errors
-                if isinstance(code, int) and 500 <= code < 600:
-                    pass
-                elif (
-                    isinstance(code, str) and code.isdigit() and 500 <= int(code) < 600
-                ):
-                    code = int(code)
-                else:
-                    raise
-
-                if attempt < max_retries:
-                    print(
-                        f"ProviderError with 5xx code encountered (attempt {attempt}/{max_retries}). Retrying in 5 seconds..."
-                    )
-                    time.sleep(5)
-                else:
-                    print("Max retries reached. Raising error.")
-                    raise
-
-                raise

janito/agent/openai_schema_generator.py

@@ -1,187 +0,0 @@
-"""
-Generates OpenAI-compatible function schemas from Python callables and class docstrings.
-
-- Ensures all parameters are documented and type-annotated.
-- Integrates return documentation into the schema description.
-- Supports Google, NumPy, and relaxed docstring formats.
-"""
-
-import inspect
-import re
-import typing
-from collections import OrderedDict
-
-PYTHON_TYPE_TO_JSON = {
-    str: "string",
-    int: "integer",
-    float: "number",
-    bool: "boolean",
-    list: "array",
-    dict: "object",
-}
-
-
-class OpenAISchemaGenerator:
-    """
-    Generates OpenAI-compatible function schemas from Python callables and class docstrings.
-
-    - Ensures all parameters are documented and type-annotated.
-    - Integrates return documentation into the schema description.
-    - Supports Google, NumPy, and relaxed docstring formats.
-    """
-
-    def __init__(self):
-        pass
-
-    def type_to_json_schema(self, annotation):
-        if hasattr(annotation, "__origin__"):
-            if annotation.__origin__ is list or annotation.__origin__ is typing.List:
-                return {
-                    "type": "array",
-                    "items": self.type_to_json_schema(annotation.__args__[0]),
-                }
-            if annotation.__origin__ is dict or annotation.__origin__ is typing.Dict:
-                return {"type": "object"}
-        return {"type": PYTHON_TYPE_TO_JSON.get(annotation, "string")}
-
-    def parse_param_section(self, lines, param_section_headers):
-        param_descs = {}
-        in_params = False
-        for line in lines:
-            stripped_line = line.strip()
-            if any(
-                stripped_line.lower().startswith(h + ":") or stripped_line.lower() == h
-                for h in param_section_headers
-            ):
-                in_params = True
-                continue
-            if in_params:
-                m = re.match(
-                    r"([a-zA-Z_][a-zA-Z0-9_]*)\s*(?:\(([^)]+)\))?\s*[:\-]?\s*(.+)",
-                    stripped_line,
-                )
-                if m:
-                    param, _, desc = m.groups()
-                    param_descs[param] = desc.strip()
-                elif stripped_line and stripped_line[0] != "-":
-                    if param_descs:
-                        last = list(param_descs)[-1]
-                        param_descs[last] += " " + stripped_line
-            if (
-                stripped_line.lower().startswith("returns:")
-                or stripped_line.lower() == "returns"
-            ):
-                break
-        return param_descs
-
-    def parse_return_section(self, lines):
-        in_returns = False
-        return_desc = ""
-        for line in lines:
-            stripped_line = line.strip()
-            if (
-                stripped_line.lower().startswith("returns:")
-                or stripped_line.lower() == "returns"
-            ):
-                in_returns = True
-                continue
-            if in_returns:
-                if stripped_line:
-                    return_desc += (" " if return_desc else "") + stripped_line
-        return return_desc
-
-    def parse_docstring(self, docstring: str):
-        """
-        Parses a docstring to extract summary, parameter descriptions, and return description.
-        Accepts Google, NumPy, and relaxed formats.
-        Returns: summary, {param: description}, return_description
-        """
-        if not docstring:
-            return "", {}, ""
-        lines = docstring.strip().split("\n")
-        summary = lines[0].strip()
-        param_section_headers = ("args", "arguments", "params", "parameters")
-        param_descs = self.parse_param_section(lines[1:], param_section_headers)
-        return_desc = self.parse_return_section(lines[1:])
-        return summary, param_descs, return_desc
-
-    def generate_schema(self, tool_class):
-        """
-        Generates an OpenAI-compatible function schema for a tool class.
-        The tool class must have _tool_run_method and _tool_name attributes set by the tool registration decorator.
-        Raises ValueError if the return type is not explicitly str or if any parameter is missing a type hint.
-        """
-        if not hasattr(tool_class, "_tool_run_method") or not hasattr(
-            tool_class, "_tool_name"
-        ):
-            raise ValueError(
-                "Tool class must have _tool_run_method and _tool_name attributes (set by @register_tool)."
-            )
-        func = tool_class._tool_run_method
-        tool_name = tool_class._tool_name
-        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}"
-            )
-        # 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 = self.parse_docstring(class_doc)
-        description = summary
-        if return_desc:
-            description += f"\n\nReturns: {return_desc}"
-        # 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)}.\n"
-                f"Parameter documentation must be provided in the Tool class docstring, not the method docstring."
-            )
-        properties = OrderedDict()
-        required = []
-        # Inject tool_call_reason as the first required parameter, unless --ntt is set
-        from janito.agent.runtime_config import runtime_config
-
-        if not runtime_config.get("no_tools_tracking", False):
-            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
-            pdesc = param_descs.get(name, "")
-            schema = self.type_to_json_schema(annotation)
-            schema["description"] = pdesc
-            properties[name] = schema
-            if param.default == inspect._empty:
-                required.append(name)
-        return {
-            "name": tool_name,
-            "description": description,
-            "parameters": {
-                "type": "object",
-                "properties": properties,
-                "required": required,
-            },
-        }

janito/agent/profile_manager.py

@@ -1,96 +0,0 @@
-from openai import OpenAI
-from jinja2 import Environment, FileSystemLoader, select_autoescape
-from pathlib import Path
-from janito.agent.platform_discovery import PlatformDiscovery
-
-
-class AgentProfileManager:
-    REFERER = "www.janito.dev"
-    TITLE = "Janito"
-
-    def set_role(self, new_role):
-        """Set the agent's role and force prompt re-rendering."""
-        self.role = new_role
-        self.refresh_prompt()
-
-    def render_prompt(self):
-        base_dir = Path(__file__).parent / "templates"
-        profiles_dir = base_dir / "profiles"
-        if getattr(self, "lang", "en") == "pt":
-            main_template_name = "system_prompt_template_base_pt.txt.j2"
-        else:
-            main_template_name = "system_prompt_template_base.txt.j2"
-        pd = PlatformDiscovery()
-        platform_name = pd.get_platform_name()
-        python_version = pd.get_python_version()
-        shell_info = pd.detect_shell()
-
-        context = {
-            "role": self.role,
-            "interaction_mode": self.interaction_mode,
-            "platform": platform_name,
-            "python_version": python_version,
-            "shell_info": shell_info,
-        }
-        env = Environment(
-            loader=FileSystemLoader(str(profiles_dir)),
-            autoescape=select_autoescape(["txt", "j2"]),
-        )
-        template = env.get_template(main_template_name)
-        prompt = template.render(**context)
-        return prompt
-
-    def __init__(
-        self,
-        api_key,
-        model,
-        role,
-        profile_name,
-        interaction_mode,
-        verbose_tools,
-        base_url,
-        azure_openai_api_version,
-        use_azure_openai,
-        lang="en",
-    ):
-        self.api_key = api_key
-        self.model = model
-        self.role = role
-        self.profile_name = "base"
-        self.interaction_mode = interaction_mode
-        self.verbose_tools = verbose_tools
-        self.base_url = base_url
-        self.azure_openai_api_version = azure_openai_api_version
-        self.use_azure_openai = use_azure_openai
-        self.lang = lang
-        if use_azure_openai:
-            from openai import AzureOpenAI
-
-            self.client = AzureOpenAI(
-                api_key=api_key,
-                azure_endpoint=base_url,
-                api_version=azure_openai_api_version,
-            )
-        else:
-            self.client = OpenAI(
-                base_url=base_url,
-                api_key=api_key,
-                default_headers={"HTTP-Referer": self.REFERER, "X-Title": self.TITLE},
-            )
-        from janito.agent.openai_client import Agent
-
-        self.agent = Agent(
-            api_key=api_key,
-            model=model,
-            base_url=base_url,
-            use_azure_openai=use_azure_openai,
-            azure_openai_api_version=azure_openai_api_version,
-        )
-        self.system_prompt_template = None
-
-    def refresh_prompt(self):
-        self.system_prompt_template = self.render_prompt()
-        self.agent.system_prompt_template = self.system_prompt_template
-
-
-# All prompt rendering is now handled by AgentProfileManager.

janito/agent/queued_message_handler.py

@@ -1,50 +0,0 @@
-from janito.i18n import tr
-
-
-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 not isinstance(msg, dict):
-            raise TypeError(
-                tr(
-                    "QueuedMessageHandler.handle_message expects a dict with 'type' and 'message', got {msg_type}: {msg!r}",
-                    msg_type=type(msg),
-                    msg=msg,
-                )
-            )
-        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(
-                tr(
-                    "[QueuedMessageHandler] {msg_type}: {msg}",
-                    msg_type=msg_type,
-                    msg=msg,
-                )
-            )
-            self._queue.put(msg)
-            return
-        message = msg.get("message", "")
-        # For normal agent/user/info messages, emit type 'content' for frontend compatibility
-        print(
-            tr(
-                "[QueuedMessageHandler] {msg_type}: {message}",
-                msg_type=msg_type,
-                message=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_live.py

@@ -1,32 +0,0 @@
-from rich.live import Live
-from rich.markdown import Markdown
-from rich.console import Console
-
-
-class LiveMarkdownDisplay:
-    def __init__(self, console=None):
-        self.console = console or Console()
-        self._accumulated = ""
-        self._live = None
-
-    def start(self):
-        self._live = Live(
-            Markdown(self._accumulated), console=self.console, refresh_per_second=8
-        )
-        self._live.__enter__()
-
-    def update(self, part):
-        self._accumulated += part
-        # Only re-render on newlines for efficiency
-        if "\n" in part:
-            self._live.update(Markdown(self._accumulated))
-
-    def stop(self):
-        if self._live:
-            self._live.__exit__(None, None, None)
-            self._live = None
-
-    def reset(self):
-        self._accumulated = ""
-        if self._live:
-            self._live.update(Markdown(self._accumulated))