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

janito/exceptions.py

@@ -0,0 +1,23 @@
+class ToolCallException(Exception):
+    """
+    Exception raised when a tool call fails (e.g., not found, invalid arguments, invocation failure).
+    This is distinct from ToolCallError event, which is for event bus notification.
+    """
+
+    def __init__(self, tool_name, error, arguments=None, exception=None):
+        self.tool_name = tool_name
+        self.error = error
+        self.arguments = arguments
+        self.original_exception = exception
+        super().__init__(f"ToolCallException: {tool_name}: {error}")
+
+
+class MissingProviderSelectionException(Exception):
+    """
+    Raised when no provider is specified and no default provider is set.
+    """
+
+    def __init__(self, configured=None, supported=None):
+        self.configured = configured or []
+        self.supported = supported or []
+        super().__init__("No provider specified and no default provider is set.")

janito/formatting_token.py

@@ -0,0 +1,54 @@
+"""
+Token summary formatter for rich and pt markup.
+- Used to display token/message counters after completions.
+"""
+
+from janito.perf_singleton import performance_collector
+
+from rich.rule import Rule
+
+
+def format_tokens(n, tag=None, use_rich=False):
+    if n is None:
+        return "?"
+    if n < 1000:
+        val = str(n)
+    elif n < 1000000:
+        val = f"{n/1000:.1f}k"
+    else:
+        val = f"{n/1000000:.1f}M"
+    if tag:
+        if use_rich:
+            return f"[{tag}]{val}[/{tag}]"
+        else:
+            return f"<{tag}>{val}</{tag}>"
+    return val
+
+
+def format_token_message_summary(msg_count, usage, width=96, use_rich=False):
+    """
+    Returns a string (rich or pt markup) summarizing message count and last token usage.
+    """
+    left = f" Messages: {'[' if use_rich else '<'}msg_count{']' if use_rich else '>'}{msg_count}{'[/msg_count]' if use_rich else '</msg_count>'}"
+    tokens_part = ""
+    if usage:
+        prompt_tokens = usage.get("prompt_tokens")
+        completion_tokens = usage.get("completion_tokens")
+        total_tokens = usage.get("total_tokens")
+        tokens_part = (
+            f" | Tokens - Prompt: {format_tokens(prompt_tokens, 'tokens_in', use_rich)}, "
+            f"Completion: {format_tokens(completion_tokens, 'tokens_out', use_rich)}, "
+            f"Total: {format_tokens(total_tokens, 'tokens_total', use_rich)}"
+        )
+    return f"{left}{tokens_part}"
+
+
+def print_token_message_summary(console, msg_count=None, usage=None, width=96):
+    """Prints the summary using rich markup, using defaults from perf_singleton if not given."""
+    if usage is None:
+        usage = performance_collector.get_last_request_usage()
+    if msg_count is None:
+        msg_count = performance_collector.get_total_turns() or 0
+    line = format_token_message_summary(msg_count, usage, width, use_rich=True)
+    if line.strip():
+        console.print(Rule(line))

janito/i18n/pt.py

@@ -1,3 +1,4 @@
+# pragma: allowlist secret
 translations = {
     "36107ed78ab25f6fb12ad8ce13018cd1ce6735d1": "Iniciando servidor web...",
     "70a0d194687568a47aa617fd85036ace1e69a982": "Deseja realmente sair? (s/n): ",

janito/llm/__init__.py

@@ -0,0 +1,5 @@
+# janito.llm package
+
+from .driver import LLMDriver
+from .provider import LLMProvider
+from .driver_config import LLMDriverConfig

janito/llm/agent.py

@@ -0,0 +1,443 @@
+from janito.llm.driver_input import DriverInput
+from janito.llm.driver_config import LLMDriverConfig
+from janito.conversation_history import LLMConversationHistory
+from janito.tools.tools_adapter import ToolsAdapterBase
+from queue import Queue, Empty
+from janito.driver_events import RequestStatus
+from typing import Any, Optional, List, Iterator, Union
+import threading
+import logging
+from jinja2 import Environment, FileSystemLoader, select_autoescape
+from pathlib import Path
+import time
+from janito.event_bus.bus import event_bus
+
+
+class LLMAgent:
+    _event_lock: threading.Lock
+    _latest_event: Optional[str]
+
+    @property
+    def template_vars(self):
+        if not hasattr(self, "_template_vars"):
+            self._template_vars = {}
+        return self._template_vars
+
+    """
+    Represents an agent that interacts with an LLM driver to generate responses.
+    Maintains conversation history as required by the new driver interface.
+    """
+
+    def __init__(
+        self,
+        llm_provider,
+        tools_adapter: ToolsAdapterBase,
+        agent_name: Optional[str] = None,
+        system_prompt: Optional[str] = None,
+        temperature: Optional[float] = None,
+        conversation_history: Optional[LLMConversationHistory] = None,
+        input_queue: Queue = None,
+        output_queue: Queue = None,
+        verbose_agent: bool = False,
+        **kwargs: Any,
+    ):
+        self.llm_provider = llm_provider
+        self.tools_adapter = tools_adapter
+        self.agent_name = agent_name
+        self.system_prompt = system_prompt
+        self.temperature = temperature
+        self.conversation_history = conversation_history or LLMConversationHistory()
+        self.input_queue = input_queue if input_queue is not None else Queue()
+        self.output_queue = output_queue if output_queue is not None else Queue()
+        self._event_lock = threading.Lock()
+        self._latest_event = None
+        self.verbose_agent = verbose_agent
+        self.driver = None  # Will be set by setup_agent if available
+
+    def get_provider_name(self):
+        # Try to get provider name from driver, fallback to llm_provider, else '?'
+        if self.driver and hasattr(self.driver, "name"):
+            return self.driver.name
+        elif hasattr(self.llm_provider, "name"):
+            return self.llm_provider.name
+        return "?"
+
+    def get_model_name(self):
+        # Try to get model name from driver, fallback to llm_provider, else '?'
+        if self.driver and hasattr(self.driver, "model_name"):
+            return self.driver.model_name
+        elif hasattr(self.llm_provider, "model_name"):
+            return self.llm_provider.model_name
+        return "?"
+
+    def set_template_var(self, key: str, value: str) -> None:
+        """Set a variable for system prompt templating."""
+        if not hasattr(self, "_template_vars"):
+            self._template_vars = {}
+        self._template_vars[key] = value
+
+    def set_system_prompt(self, prompt: str) -> None:
+        self.system_prompt = prompt
+
+    def set_system_using_template(self, template_path: str, **kwargs) -> None:
+        env = Environment(
+            loader=FileSystemLoader(Path(template_path).parent),
+            autoescape=select_autoescape(),
+        )
+        template = env.get_template(Path(template_path).name)
+        self.system_prompt = template.render(**kwargs)
+
+    def _refresh_system_prompt_from_template(self):
+        if hasattr(self, "_template_vars") and hasattr(self, "system_prompt_template"):
+            env = Environment(
+                loader=FileSystemLoader(Path(self.system_prompt_template).parent),
+                autoescape=select_autoescape(),
+            )
+            template = env.get_template(Path(self.system_prompt_template).name)
+            self.system_prompt = template.render(**self._template_vars)
+
+    def get_system_prompt(self) -> str:
+        return self.system_prompt
+
+    def _add_prompt_to_history(self, prompt_or_messages, role):
+        if isinstance(prompt_or_messages, str):
+            self.conversation_history.add_message(role, prompt_or_messages)
+        elif isinstance(prompt_or_messages, list):
+            for msg in prompt_or_messages:
+                self.conversation_history.add_message(
+                    msg.get("role", role), msg.get("content", "")
+                )
+
+    def _ensure_system_prompt(self):
+        if self.system_prompt and (
+            not self.conversation_history._history
+            or self.conversation_history._history[0]["role"] != "system"
+        ):
+            self.conversation_history._history.insert(
+                0, {"role": "system", "content": self.system_prompt}
+            )
+
+    def _validate_and_update_history(
+        self,
+        prompt: str = None,
+        messages: Optional[List[dict]] = None,
+        role: str = "user",
+    ):
+        if prompt is None and not messages:
+            raise ValueError(
+                "Either prompt or messages must be provided to Agent.chat."
+            )
+        if prompt is not None:
+            self._add_prompt_to_history(prompt, role)
+        elif messages:
+            self._add_prompt_to_history(messages, role)
+
+    def _log_event_verbose(self, event):
+        if getattr(self, "verbose_agent", False):
+            if hasattr(event, "parts"):
+                for i, part in enumerate(getattr(event, "parts", [])):
+                    pass  # Add detailed logging here if needed
+            else:
+                pass  # Add detailed logging here if needed
+
+    def _handle_event_type(self, event):
+        event_class = getattr(event, "__class__", None)
+        if event_class is not None and event_class.__name__ == "ResponseReceived":
+            added_tool_results = self._handle_response_received(event)
+            return event, added_tool_results
+        # For all other events (including RequestFinished with status='error', RequestStarted), do not exit loop
+        return None, False
+
+    def _prepare_driver_input(self, config, cancel_event=None):
+        return DriverInput(
+            config=config,
+            conversation_history=self.conversation_history,
+            cancel_event=cancel_event,
+        )
+
+    def _process_next_response(
+        self, poll_timeout: float = 1.0, max_wait_time: float = 300.0
+    ):
+        """
+        Wait for a single event from the output queue (with timeout), process it, and return the result.
+        This function is intended to be called from the main agent loop, which controls the overall flow.
+        """
+        if getattr(self, "verbose_agent", False):
+            print("[agent] [DEBUG] Entered _process_next_response")
+        elapsed = 0.0
+        try:
+            if getattr(self, "verbose_agent", False):
+                print("[agent] [DEBUG] Waiting for event from output_queue...")
+            return self._poll_for_event(poll_timeout, max_wait_time)
+        except KeyboardInterrupt:
+            self._handle_keyboard_interrupt()
+            return None, False
+
+    def _poll_for_event(self, poll_timeout, max_wait_time):
+        elapsed = 0.0
+        while True:
+            event = self._get_event_from_output_queue(poll_timeout)
+            if event is None:
+                elapsed += poll_timeout
+                if elapsed >= max_wait_time:
+                    error_msg = f"[ERROR] No output from driver in agent.chat() after {max_wait_time} seconds (timeout exit)"
+                    print(error_msg)
+                    print("[DEBUG] Exiting _process_next_response due to timeout")
+                    return None, False
+                continue
+            if getattr(self, "verbose_agent", False):
+                print(f"[agent] [DEBUG] Received event from output_queue: {event}")
+            event_bus.publish(event)
+            self._log_event_verbose(event)
+            event_class = getattr(event, "__class__", None)
+            event_name = event_class.__name__ if event_class else None
+            if event_name == "ResponseReceived":
+                result = self._handle_event_type(event)
+                return result
+            elif event_name == "RequestFinished" and getattr(event, "status", None) in [
+                RequestStatus.ERROR,
+                RequestStatus.EMPTY_RESPONSE,
+                RequestStatus.TIMEOUT,
+            ]:
+                return (event, False)
+
+    def _handle_keyboard_interrupt(self):
+        if hasattr(self, "input_queue") and self.input_queue is not None:
+            from janito.driver_events import RequestFinished
+
+            cancel_event = RequestFinished(
+                status=RequestStatus.CANCELLED,
+                reason="User interrupted (KeyboardInterrupt)",
+            )
+            self.input_queue.put(cancel_event)
+
+    def _get_event_from_output_queue(self, poll_timeout):
+        try:
+            return self.output_queue.get(timeout=poll_timeout)
+        except Empty:
+            return None
+
+    def _handle_response_received(self, event) -> bool:
+        """
+        Handle a ResponseReceived event: execute tool calls if present, update history.
+        Returns True if the agent loop should continue (tool calls found), False otherwise.
+        """
+        if getattr(self, "verbose_agent", False):
+            print("[agent] [INFO] Handling ResponseReceived event.")
+        from janito.llm.message_parts import FunctionCallMessagePart
+
+        tool_calls = []
+        tool_results = []
+        for part in event.parts:
+            if isinstance(part, FunctionCallMessagePart):
+                if getattr(self, "verbose_agent", False):
+                    print(
+                        f"[agent] [DEBUG] Tool call detected: {getattr(part, 'name', repr(part))} with arguments: {getattr(part, 'arguments', None)}"
+                    )
+                tool_calls.append(part)
+                result = self.tools_adapter.execute_function_call_message_part(part)
+                tool_results.append(result)
+        if tool_calls:
+            # Prepare tool_calls message for assistant
+            tool_calls_list = []
+            tool_results_list = []
+            for call, result in zip(tool_calls, tool_results):
+                function_name = (
+                    getattr(call, "name", None)
+                    or (
+                        getattr(call, "function", None)
+                        and getattr(call.function, "name", None)
+                    )
+                    or "function"
+                )
+                arguments = getattr(call, "function", None) and getattr(
+                    call.function, "arguments", None
+                )
+                tool_call_id = getattr(call, "tool_call_id", None)
+                tool_calls_list.append(
+                    {
+                        "id": tool_call_id,
+                        "type": "function",
+                        "function": {
+                            "name": function_name,
+                            "arguments": (
+                                arguments
+                                if isinstance(arguments, str)
+                                else str(arguments) if arguments else ""
+                            ),
+                        },
+                    }
+                )
+                tool_results_list.append(
+                    {
+                        "name": function_name,
+                        "content": str(result),
+                        "tool_call_id": tool_call_id,
+                    }
+                )
+            # Add assistant tool_calls message
+            import json
+
+            self.conversation_history.add_message(
+                "tool_calls", json.dumps(tool_calls_list)
+            )
+            # Add tool_results message
+            self.conversation_history.add_message(
+                "tool_results", json.dumps(tool_results_list)
+            )
+            return True  # Continue the loop
+        else:
+            return False  # No tool calls, return event
+
+    def chat(
+        self,
+        prompt: str = None,
+        messages: Optional[List[dict]] = None,
+        role: str = "user",
+        config=None,
+    ):
+        if (
+            hasattr(self, "driver")
+            and self.driver
+            and hasattr(self.driver, "clear_output_queue")
+        ):
+            self.driver.clear_output_queue()
+        """
+        Main agent conversation loop supporting function/tool calls and conversation history extension, now as a blocking event-driven loop with event publishing.
+
+        Args:
+            prompt: The user prompt as a string (optional if messages is provided).
+            messages: A list of message dicts (optional if prompt is provided).
+            role: The role for the prompt (default: 'user').
+            config: Optional driver config (defaults to provider config).
+
+        Returns:
+            The final ResponseReceived event (or error event) when the conversation is complete.
+        """
+        self._validate_and_update_history(prompt, messages, role)
+        self._ensure_system_prompt()
+        if config is None:
+            config = self.llm_provider.driver_config
+        loop_count = 1
+        import threading
+
+        cancel_event = threading.Event()
+        while True:
+            self._print_verbose_chat_loop(loop_count)
+            driver_input = self._prepare_driver_input(config, cancel_event=cancel_event)
+            self.input_queue.put(driver_input)
+            try:
+                result, added_tool_results = self._process_next_response()
+            except KeyboardInterrupt:
+                cancel_event.set()
+                raise
+            if getattr(self, "verbose_agent", False):
+                print(
+                    f"[agent] [DEBUG] Returned from _process_next_response: result={result}, added_tool_results={added_tool_results}"
+                )
+            if result is None:
+                if getattr(self, "verbose_agent", False):
+                    print(
+                        f"[agent] [INFO] Exiting chat loop: _process_next_response returned None result (likely timeout or error). Returning (None, False)."
+                    )
+                return None, False
+            if not added_tool_results:
+                if getattr(self, "verbose_agent", False):
+                    print(
+                        f"[agent] [INFO] Exiting chat loop: _process_next_response returned added_tool_results=False (final response or no more tool calls). Returning result: {result}"
+                    )
+                return result
+            loop_count += 1
+
+    def _print_verbose_chat_loop(self, loop_count):
+        if getattr(self, "verbose_agent", False):
+            print(
+                f"[agent] [DEBUG] Preparing new driver_input (loop_count={loop_count}) with updated conversation history:"
+            )
+            for msg in self.conversation_history.get_history():
+                print("   ", msg)
+
+    def set_latest_event(self, event: str) -> None:
+        with self._event_lock:
+            self._latest_event = event
+
+    def get_latest_event(self) -> Optional[str]:
+        with self._event_lock:
+            return self._latest_event
+
+    def get_history(self) -> LLMConversationHistory:
+        """Get the agent's interaction history."""
+        return self.conversation_history
+
+    def reset_conversation_history(self) -> None:
+        """Reset/clear the interaction history."""
+        self.conversation_history = LLMConversationHistory()
+
+    def get_provider_name(self) -> str:
+        """Return the provider name, if available."""
+        if hasattr(self.llm_provider, "name"):
+            return getattr(self.llm_provider, "name", "?")
+        if self.driver and hasattr(self.driver, "name"):
+            return getattr(self.driver, "name", "?")
+        return "?"
+
+    def get_model_name(self) -> str:
+        """Return the model name, if available."""
+        if self.driver and hasattr(self.driver, "model_name"):
+            return getattr(self.driver, "model_name", "?")
+        return "?"
+
+    def get_name(self) -> Optional[str]:
+        return self.agent_name
+
+    def get_provider_name(self) -> str:
+        """
+        Return the provider name for this agent, if available.
+        """
+        if hasattr(self, "llm_provider") and hasattr(self.llm_provider, "name"):
+            return self.llm_provider.name
+        if (
+            hasattr(self, "driver")
+            and self.driver
+            and hasattr(self.driver, "provider_name")
+        ):
+            return self.driver.provider_name
+        if hasattr(self, "driver") and self.driver and hasattr(self.driver, "name"):
+            return self.driver.name
+        return "?"
+
+    def get_model_name(self) -> str:
+        """
+        Return the model name for this agent, if available.
+        """
+        if (
+            hasattr(self, "driver")
+            and self.driver
+            and hasattr(self.driver, "model_name")
+        ):
+            return self.driver.model_name
+        if hasattr(self, "llm_provider") and hasattr(self.llm_provider, "model_name"):
+            return self.llm_provider.model_name
+        return "?"
+
+    def join_driver(self, timeout=None):
+        """
+        Wait for the driver's background thread to finish. Call this before exiting to avoid daemon thread shutdown errors.
+        :param timeout: Optional timeout in seconds.
+        Handles KeyboardInterrupt gracefully.
+        """
+        if (
+            hasattr(self, "driver")
+            and self.driver
+            and hasattr(self.driver, "_thread")
+            and self.driver._thread
+        ):
+            try:
+                self.driver._thread.join(timeout)
+            except KeyboardInterrupt:
+                print(
+                    "\n[INFO] Interrupted by user during driver shutdown. Cleaning up..."
+                )
+                # Optionally, perform additional cleanup here
+                # Do not re-raise to suppress traceback and exit gracefully
+                return

janito/llm/auth.py

@@ -0,0 +1,62 @@
+"""
+LLMAuthManager: Handles authentication credentials for LLM providers, persisted in ~/.janito/auth.json or a custom path.
+"""
+
+import os
+import json
+from typing import Dict, Optional
+
+
+class LLMAuthManager:
+    """
+    Manages authentication tokens, API keys, or credentials for LLM providers.
+    Persists credentials in ~/.janito/auth.json or a custom path.
+    """
+
+    def __init__(self, auth_file: Optional[str] = None):
+        if auth_file is not None:
+            self._auth_file = os.path.expanduser(auth_file)
+        else:
+            self._auth_file = os.path.expanduser("~/.janito/auth.json")
+        self._credentials: Dict[str, str] = {}
+        self._load_credentials()
+
+    def _load_credentials(self):
+        if os.path.exists(self._auth_file):
+            try:
+                with open(self._auth_file, "r") as f:
+                    self._credentials = json.load(f)
+            except Exception:
+                self._credentials = {}
+        else:
+            self._credentials = {}
+
+    def _save_credentials(self):
+        os.makedirs(os.path.dirname(self._auth_file), exist_ok=True)
+        with open(self._auth_file, "w") as f:
+            json.dump(self._credentials, f, indent=2)
+
+    def set_credentials(self, provider_name: str, credentials: str) -> None:
+        """
+        Store credentials for a given provider and persist to disk. Raises ValueError if provider is unknown.
+        """
+        from janito.providers.registry import LLMProviderRegistry
+
+        if provider_name not in LLMProviderRegistry.list_providers():
+            raise ValueError(f"Unknown provider: {provider_name}")
+        self._credentials[provider_name] = credentials
+        self._save_credentials()
+
+    def get_credentials(self, provider_name: str) -> Optional[str]:
+        """
+        Retrieve credentials for a given provider.
+        """
+        return self._credentials.get(provider_name)
+
+    def remove_credentials(self, provider_name: str) -> None:
+        """
+        Remove credentials for a given provider and update disk.
+        """
+        if provider_name in self._credentials:
+            del self._credentials[provider_name]
+            self._save_credentials()