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

janito/tools/tools_adapter.py

@@ -1,8 +1,7 @@
 from janito.tools.tool_base import ToolBase
 from janito.tools.tool_events import ToolCallStarted, ToolCallFinished, ToolCallError
 from janito.exceptions import ToolCallException
-from typing import Optional
-
+from janito.tools.tool_base import ToolPermissions
 
 class ToolsAdapterBase:
     """
@@ -13,11 +12,10 @@ class ToolsAdapterBase:
     """
 
     def __init__(
-        self, tools=None, event_bus=None, enabled_tools: Optional[list] = None
+        self, tools=None, event_bus=None
     ):
         self._tools = tools or []
         self._event_bus = event_bus  # event bus can be set on all adapters
-        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):
@@ -31,11 +29,28 @@ class ToolsAdapterBase:
     def event_bus(self, bus):
         self._event_bus = bus
 
+    def is_tool_allowed(self, tool):
+        """Check if a tool is allowed based on current global AllowedPermissionsState."""
+        from janito.tools.permissions import get_global_allowed_permissions
+        allowed_permissions = get_global_allowed_permissions()
+        perms = tool.permissions  # permissions are mandatory and type-checked
+        # If all permissions are False, block all tools
+        if not (allowed_permissions.read or allowed_permissions.write or allowed_permissions.execute):
+            return False
+        for perm in ['read', 'write', 'execute']:
+            if getattr(perms, perm) and not getattr(allowed_permissions, perm):
+                return False
+        return True
+
     def get_tools(self):
-        """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]
+        """Return the list of enabled tools managed by this provider, filtered by allowed permissions."""
+        tools = [tool for tool in self._tools if self.is_tool_allowed(tool)]
+        return tools
+
+    def set_allowed_permissions(self, allowed_permissions):
+        """Set the allowed permissions at runtime. This now updates the global AllowedPermissionsState only."""
+        from janito.tools.permissions import set_global_allowed_permissions
+        set_global_allowed_permissions(allowed_permissions)
 
     def add_tool(self, tool):
         self._tools.append(tool)
@@ -231,18 +246,8 @@ class ToolsAdapterBase:
         )
 
     def _check_tool_permissions(self, tool_name, request_id, arguments):
-        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(
-                        tool_name=tool_name,
-                        request_id=request_id,
-                        error=error_msg,
-                        arguments=arguments,
-                    )
-                )
-            raise ToolCallException(tool_name, error_msg, arguments=arguments)
+        # No enabled_tools check anymore; permission checks are handled by is_tool_allowed
+        pass
 
     def _ensure_tool_exists(self, tool, tool_name, request_id, arguments):
         if tool is None:

janito/tools/tools_schema.py

@@ -1,104 +1,104 @@
-import inspect
-import typing
-import re
-
-
-class ToolSchemaBase:
-    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):
-        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 validate_tool_class(self, tool_class):
-        if not hasattr(tool_class, "tool_name") or not isinstance(
-            tool_class.tool_name, str
-        ):
-            raise ValueError(
-                "Tool class must have a class-level 'tool_name' attribute (str) for registry and schema generation."
-            )
-        if not hasattr(tool_class, "run") or not callable(getattr(tool_class, "run")):
-            raise ValueError("Tool class must have a callable 'run' method.")
-        func = tool_class.run
-        tool_name = tool_class.tool_name
-        sig = inspect.signature(func)
-        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}"
-            )
-        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)}.\nAll parameters must have explicit type hints 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}"
-        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)}.\nParameter documentation must be provided in the Tool class docstring, not the method docstring."
-            )
-        return func, tool_name, sig, summary, param_descs, return_desc, description
+import inspect
+import typing
+import re
+
+
+class ToolSchemaBase:
+    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):
+        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 validate_tool_class(self, tool_class):
+        if not hasattr(tool_class, "tool_name") or not isinstance(
+            tool_class.tool_name, str
+        ):
+            raise ValueError(
+                "Tool class must have a class-level 'tool_name' attribute (str) for registry and schema generation."
+            )
+        if not hasattr(tool_class, "run") or not callable(getattr(tool_class, "run")):
+            raise ValueError("Tool class must have a callable 'run' method.")
+        func = tool_class.run
+        tool_name = tool_class.tool_name
+        sig = inspect.signature(func)
+        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}"
+            )
+        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)}.\nAll parameters must have explicit type hints 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}"
+        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)}.\nParameter documentation must be provided in the Tool class docstring, not the method docstring."
+            )
+        return func, tool_name, sig, summary, param_descs, return_desc, description