janito 2.2.0__py3-none-any.whl → 2.3.0__py3-none-any.whl

janito/tools/tool_events.py

@@ -1,58 +1,58 @@
-import attr
-from typing import Any, ClassVar
-from janito.event_bus.event import Event
-
-
-@attr.s(auto_attribs=True, kw_only=True)
-class ToolEvent(Event):
-    """
-    Base class for events related to tool calls (external or internal tools).
-    Includes tool name and request ID for correlation.
-    """
-
-    category: ClassVar[str] = "tool"
-    tool_name: str
-    request_id: str
-
-
-@attr.s(auto_attribs=True, kw_only=True)
-class ToolCallStarted(ToolEvent):
-    """
-    Event indicating that a tool call has started.
-    Contains the arguments passed to the tool.
-    """
-
-    arguments: Any
-
-
-@attr.s(auto_attribs=True, kw_only=True)
-class ToolCallFinished(ToolEvent):
-    """
-    Event indicating that a tool call has finished.
-    Contains the result returned by the tool.
-    """
-
-    result: Any
-
-
-@attr.s(auto_attribs=True, kw_only=True)
-class ToolRunError(ToolEvent):
-    """
-    Event indicating that an error occurred during tool execution (for event bus, not exception handling).
-    """
-
-    error: str
-    exception: Exception = None
-    arguments: Any = None
-
-
-@attr.s(auto_attribs=True, kw_only=True)
-class ToolCallError(ToolEvent):
-    """
-    Event indicating that the tool could not be called (e.g., tool not found, invalid arguments, or invocation failure).
-    This is distinct from ToolRunError, which is for errors during execution after the tool has started running.
-    """
-
-    error: str
-    exception: Exception = None
-    arguments: Any = None
+import attr
+from typing import Any, ClassVar
+from janito.event_bus.event import Event
+
+
+@attr.s(auto_attribs=True, kw_only=True)
+class ToolEvent(Event):
+    """
+    Base class for events related to tool calls (external or internal tools).
+    Includes tool name and request ID for correlation.
+    """
+
+    category: ClassVar[str] = "tool"
+    tool_name: str
+    request_id: str
+
+
+@attr.s(auto_attribs=True, kw_only=True)
+class ToolCallStarted(ToolEvent):
+    """
+    Event indicating that a tool call has started.
+    Contains the arguments passed to the tool.
+    """
+
+    arguments: Any
+
+
+@attr.s(auto_attribs=True, kw_only=True)
+class ToolCallFinished(ToolEvent):
+    """
+    Event indicating that a tool call has finished.
+    Contains the result returned by the tool.
+    """
+
+    result: Any
+
+
+@attr.s(auto_attribs=True, kw_only=True)
+class ToolRunError(ToolEvent):
+    """
+    Event indicating that an error occurred during tool execution (for event bus, not exception handling).
+    """
+
+    error: str
+    exception: Exception = None
+    arguments: Any = None
+
+
+@attr.s(auto_attribs=True, kw_only=True)
+class ToolCallError(ToolEvent):
+    """
+    Event indicating that the tool could not be called (e.g., tool not found, invalid arguments, or invocation failure).
+    This is distinct from ToolRunError, which is for errors during execution after the tool has started running.
+    """
+
+    error: str
+    exception: Exception = None
+    arguments: Any = None

janito/tools/tool_run_exception.py

@@ -1,12 +1,12 @@
-class ToolRunException(Exception):
-    """
-    Exception raised when a tool runs but fails due to an internal error or runtime exception.
-    This is distinct from ToolRunError 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"ToolRunException: {tool_name}: {error}")
+class ToolRunException(Exception):
+    """
+    Exception raised when a tool runs but fails due to an internal error or runtime exception.
+    This is distinct from ToolRunError 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"ToolRunException: {tool_name}: {error}")

janito/tools/tool_use_tracker.py

@@ -1,81 +1,81 @@
-import threading
-import os
-from typing import Any, Dict, List
-
-
-def normalize_path(path: str) -> str:
-    if not isinstance(path, str):
-        return path
-    return os.path.normcase(os.path.abspath(path))
-
-
-class ToolUseTracker:
-    _instance = None
-    _lock = threading.Lock()
-
-    def __new__(cls):
-        if not cls._instance:
-            with cls._lock:
-                if not cls._instance:
-                    cls._instance = super().__new__(cls)
-                    cls._instance._history = []
-        return cls._instance
-
-    def record(self, tool_name: str, params: Dict[str, Any], result: Any = None):
-        # Normalize file_path in params if present
-        norm_params = params.copy()
-        if "file_path" in norm_params:
-            norm_params["file_path"] = normalize_path(norm_params["file_path"])
-        self._history.append(
-            {"tool": tool_name, "params": norm_params, "result": result}
-        )
-
-    def get_history(self) -> List[Dict[str, Any]]:
-        return list(self._history)
-
-    def get_operations_on_file(self, file_path: str) -> List[Dict[str, Any]]:
-        norm_file_path = normalize_path(file_path)
-        ops = []
-        for entry in self._history:
-            params = entry["params"]
-            # Normalize any string param values for comparison
-            for v in params.values():
-                if isinstance(v, str) and normalize_path(v) == norm_file_path:
-                    ops.append(entry)
-                    break
-        return ops
-
-    def file_fully_read(self, file_path: str) -> bool:
-        norm_file_path = normalize_path(file_path)
-        for entry in self._history:
-            if entry["tool"] == "view_file":
-                params = entry["params"]
-                if (
-                    "file_path" in params
-                    and normalize_path(params["file_path"]) == norm_file_path
-                ):
-                    # If both from_line and to_line are None, full file was read
-                    if (
-                        params.get("from_line") is None
-                        and params.get("to_line") is None
-                    ):
-                        return True
-        return False
-
-    def last_operation_is_full_read_or_replace(self, file_path: str) -> bool:
-        ops = self.get_operations_on_file(file_path)
-        if not ops:
-            return False
-        last = ops[-1]
-        if last["tool"] == "view_file":
-            params = last["params"]
-            if params.get("from_line") is None and params.get("to_line") is None:
-                return True
-        return False
-
-    def clear_history(self):
-        self._history.clear()
-
-    @classmethod
-    def instance(cls):
-        return cls()
+import threading
+import os
+from typing import Any, Dict, List
+
+
+def normalize_path(path: str) -> str:
+    if not isinstance(path, str):
+        return path
+    return os.path.normcase(os.path.abspath(path))
+
+
+class ToolUseTracker:
+    _instance = None
+    _lock = threading.Lock()
+
+    def __new__(cls):
+        if not cls._instance:
+            with cls._lock:
+                if not cls._instance:
+                    cls._instance = super().__new__(cls)
+                    cls._instance._history = []
+        return cls._instance
+
+    def record(self, tool_name: str, params: Dict[str, Any], result: Any = None):
+        # Normalize file_path in params if present
+        norm_params = params.copy()
+        if "file_path" in norm_params:
+            norm_params["file_path"] = normalize_path(norm_params["file_path"])
+        self._history.append(
+            {"tool": tool_name, "params": norm_params, "result": result}
+        )
+
+    def get_history(self) -> List[Dict[str, Any]]:
+        return list(self._history)
+
+    def get_operations_on_file(self, file_path: str) -> List[Dict[str, Any]]:
+        norm_file_path = normalize_path(file_path)
+        ops = []
+        for entry in self._history:
+            params = entry["params"]
+            # Normalize any string param values for comparison
+            for v in params.values():
+                if isinstance(v, str) and normalize_path(v) == norm_file_path:
+                    ops.append(entry)
+                    break
+        return ops
+
+    def file_fully_read(self, file_path: str) -> bool:
+        norm_file_path = normalize_path(file_path)
+        for entry in self._history:
+            if entry["tool"] == "view_file":
+                params = entry["params"]
+                if (
+                    "file_path" in params
+                    and normalize_path(params["file_path"]) == norm_file_path
+                ):
+                    # If both from_line and to_line are None, full file was read
+                    if (
+                        params.get("from_line") is None
+                        and params.get("to_line") is None
+                    ):
+                        return True
+        return False
+
+    def last_operation_is_full_read_or_replace(self, file_path: str) -> bool:
+        ops = self.get_operations_on_file(file_path)
+        if not ops:
+            return False
+        last = ops[-1]
+        if last["tool"] == "view_file":
+            params = last["params"]
+            if params.get("from_line") is None and params.get("to_line") is None:
+                return True
+        return False
+
+    def clear_history(self):
+        self._history.clear()
+
+    @classmethod
+    def instance(cls):
+        return cls()

janito/tools/tool_utils.py

@@ -1,45 +1,45 @@
-"""
-Utility functions for the janito project.
-Add your shared helper functions here.
-"""
-
-import os
-import urllib.parse
-
-
-def example_utility_function(x):
-    """A simple example utility function."""
-    return f"Processed: {x}"
-
-
-def display_path(path):
-    """
-    Returns a display-friendly path. Injects an ANSI hyperlink to a local web file viewer using a hardcoded port.
-    Args:
-        path (str): Path to display.
-    Returns:
-        str: Display path, as an ANSI hyperlink.
-    """
-    from janito.cli.config import get_termweb_port
-
-    port = get_termweb_port()
-    if os.path.isabs(path):
-        cwd = os.path.abspath(os.getcwd())
-        abs_path = os.path.abspath(path)
-        # Check if the absolute path is within the current working directory
-        if abs_path.startswith(cwd + os.sep):
-            disp = os.path.relpath(abs_path, cwd)
-        else:
-            disp = path
-    else:
-        disp = os.path.relpath(path)
-    url = f"http://localhost:{port}/?path={urllib.parse.quote(path)}"
-    # Use Rich markup for hyperlinks
-    return f"[link={url}]{disp}[/link]"
-
-
-def pluralize(word: str, count: int) -> str:
-    """Return the pluralized form of word if count != 1, unless word already ends with 's'."""
-    if count == 1 or word.endswith("s"):
-        return word
-    return word + "s"
+"""
+Utility functions for the janito project.
+Add your shared helper functions here.
+"""
+
+import os
+import urllib.parse
+
+
+def example_utility_function(x):
+    """A simple example utility function."""
+    return f"Processed: {x}"
+
+
+def display_path(path):
+    """
+    Returns a display-friendly path. Injects an ANSI hyperlink to a local web file viewer using a hardcoded port.
+    Args:
+        path (str): Path to display.
+    Returns:
+        str: Display path, as an ANSI hyperlink.
+    """
+    from janito.cli.config import get_termweb_port
+
+    port = get_termweb_port()
+    if os.path.isabs(path):
+        cwd = os.path.abspath(os.getcwd())
+        abs_path = os.path.abspath(path)
+        # Check if the absolute path is within the current working directory
+        if abs_path.startswith(cwd + os.sep):
+            disp = os.path.relpath(abs_path, cwd)
+        else:
+            disp = path
+    else:
+        disp = os.path.relpath(path)
+    url = f"http://localhost:{port}/?path={urllib.parse.quote(path)}"
+    # Use Rich markup for hyperlinks
+    return f"[link={url}]{disp}[/link]"
+
+
+def pluralize(word: str, count: int) -> str:
+    """Return the pluralized form of word if count != 1, unless word already ends with 's'."""
+    if count == 1 or word.endswith("s"):
+        return word
+    return word + "s"

janito/tools/tools_adapter.py

@@ -13,11 +13,11 @@ class ToolsAdapterBase:
     """
 
     def __init__(
-        self, tools=None, event_bus=None, allowed_tools: Optional[list] = None
+        self, tools=None, event_bus=None, enabled_tools: Optional[list] = None
     ):
         self._tools = tools or []
         self._event_bus = event_bus  # event bus can be set on all adapters
-        self._allowed_tools = set(allowed_tools) if allowed_tools is not None else None
+        self._enabled_tools = set(enabled_tools) if enabled_tools is not None else None
         self.verbose_tools = False
 
     def set_verbose_tools(self, value: bool):
@@ -32,8 +32,10 @@ class ToolsAdapterBase:
         self._event_bus = bus
 
     def get_tools(self):
-        """Return the list of tools managed by this provider."""
-        return self._tools
+        """Return the list of enabled tools managed by this provider."""
+        if self._enabled_tools is None:
+            return self._tools
+        return [tool for tool in self._tools if getattr(tool, 'tool_name', None) in self._enabled_tools]
 
     def add_tool(self, tool):
         self._tools.append(tool)
@@ -84,12 +86,82 @@ class ToolsAdapterBase:
 
         return result
 
+    def _get_tool_callable(self, tool):
+        """Helper to retrieve the primary callable of a tool instance."""
+        if callable(tool):
+            return tool
+        if hasattr(tool, "execute") and callable(getattr(tool, "execute")):
+            return getattr(tool, "execute")
+        if hasattr(tool, "run") and callable(getattr(tool, "run")):
+            return getattr(tool, "run")
+        raise ValueError("Provided tool is not executable.")
+
+    def _validate_arguments_against_signature(self, func, arguments: dict):
+        """Validate provided arguments against a callable signature.
+
+        Returns an error string if validation fails, otherwise ``None``.
+        """
+        import inspect
+
+        if arguments is None:
+            arguments = {}
+        # Ensure the input is a dict to avoid breaking the inspect-based logic
+        if not isinstance(arguments, dict):
+            return "Tool arguments should be provided as an object / mapping"
+
+        sig = inspect.signature(func)
+        params = sig.parameters
+
+        # Check for unexpected arguments (unless **kwargs is accepted)
+        accepts_kwargs = any(
+            p.kind == inspect.Parameter.VAR_KEYWORD for p in params.values()
+        )
+        if not accepts_kwargs:
+            unexpected = [k for k in arguments.keys() if k not in params]
+            if unexpected:
+                return (
+                    "Unexpected argument(s): " + ", ".join(sorted(unexpected))
+                )
+
+        # Check for missing required arguments (ignoring *args / **kwargs / self)
+        required_params = [
+            name
+            for name, p in params.items()
+            if p.kind in (
+                inspect.Parameter.POSITIONAL_OR_KEYWORD,
+                inspect.Parameter.KEYWORD_ONLY,
+            )
+            and p.default is inspect._empty
+            and name != "self"
+        ]
+        missing = [name for name in required_params if name not in arguments]
+        if missing:
+            return "Missing required argument(s): " + ", ".join(sorted(missing))
+
+        return None
+
     def execute_by_name(
         self, tool_name: str, *args, request_id=None, arguments=None, **kwargs
     ):
         self._check_tool_permissions(tool_name, request_id, arguments)
         tool = self.get_tool(tool_name)
         self._ensure_tool_exists(tool, tool_name, request_id, arguments)
+        func = self._get_tool_callable(tool)
+        # First, validate arguments against the callable signature to catch unexpected / missing params
+        sig_error = self._validate_arguments_against_signature(func, arguments)
+        if sig_error:
+            if self._event_bus:
+                self._event_bus.publish(
+                    ToolCallError(
+                        tool_name=tool_name,
+                        request_id=request_id,
+                        error=sig_error,
+                        arguments=arguments,
+                    )
+                )
+            return sig_error
+
+        # Optionally validate against JSON schema if available
         schema = getattr(tool, "schema", None)
         if schema and arguments is not None:
             validation_error = self._validate_arguments_against_schema(
@@ -159,8 +231,8 @@ class ToolsAdapterBase:
         )
 
     def _check_tool_permissions(self, tool_name, request_id, arguments):
-        if self._allowed_tools is not None and tool_name not in self._allowed_tools:
-            error_msg = f"Tool '{tool_name}' is not permitted by adapter allow-list."
+        if self._enabled_tools is not None and tool_name not in self._enabled_tools:
+            error_msg = f"Tool '{tool_name}' is not enabled in this adapter."
             if self._event_bus:
                 self._event_bus.publish(
                     ToolCallError(