janito 2.3.1__py3-none-any.whl → 2.5.0__py3-none-any.whl

janito/providers/azure_openai/model_info.py

@@ -1,16 +1,16 @@
-from janito.llm.model import LLMModelInfo
-from janito.providers.openai.model_info import MODEL_SPECS as OPENAI_MODEL_SPECS
-
-MODEL_SPECS = {
-    "azure_openai_deployment": LLMModelInfo(
-        name="azure_openai_deployment",
-        context=OPENAI_MODEL_SPECS["gpt-4o"].context,
-        max_input=OPENAI_MODEL_SPECS["gpt-4o"].max_input,
-        max_cot=OPENAI_MODEL_SPECS["gpt-4o"].max_cot,
-        max_response=OPENAI_MODEL_SPECS["gpt-4o"].max_response,
-        thinking_supported=OPENAI_MODEL_SPECS["gpt-4o"].thinking_supported,
-        default_temp=OPENAI_MODEL_SPECS["gpt-4o"].default_temp,
-        open="azure_openai",
-        driver="AzureOpenAIModelDriver",
-    )
-}
+from janito.llm.model import LLMModelInfo
+from janito.providers.openai.model_info import MODEL_SPECS as OPENAI_MODEL_SPECS
+
+MODEL_SPECS = {
+    "azure_openai_deployment": LLMModelInfo(
+        name="azure_openai_deployment",
+        context=OPENAI_MODEL_SPECS["gpt-4o"].context,
+        max_input=OPENAI_MODEL_SPECS["gpt-4o"].max_input,
+        max_cot=OPENAI_MODEL_SPECS["gpt-4o"].max_cot,
+        max_response=OPENAI_MODEL_SPECS["gpt-4o"].max_response,
+        thinking_supported=OPENAI_MODEL_SPECS["gpt-4o"].thinking_supported,
+        default_temp=OPENAI_MODEL_SPECS["gpt-4o"].default_temp,
+        open="azure_openai",
+        driver="AzureOpenAIModelDriver",
+    )
+}

janito/providers/provider_static_info.py

@@ -8,9 +8,6 @@ STATIC_PROVIDER_METADATA = {
     "azure_openai": {
         "maintainer": "João Pinto <lamego.pinto@gmail.com>",
     },
-    "mistralai": {
-        "maintainer": "Needs maintainer",
-    },
     "anthropic": {
         "maintainer": "Needs maintainer",
     },

janito/providers/registry.py

@@ -1,26 +1,26 @@
-from typing import Type, Dict
-from janito.llm.provider import LLMProvider
-
-
-class LLMProviderRegistry:
-    """
-    Registry for LLM provider classes.
-    """
-
-    _providers: Dict[str, Type[LLMProvider]] = {}
-
-    @classmethod
-    def register(cls, name: str, provider_cls: Type[LLMProvider]):
-        if name in cls._providers:
-            raise ValueError(f"Provider '{name}' is already registered.")
-        cls._providers[name] = provider_cls
-
-    @classmethod
-    def get(cls, name: str) -> Type[LLMProvider]:
-        if name not in cls._providers:
-            return None
-        return cls._providers[name]
-
-    @classmethod
-    def list_providers(cls):
-        return list(cls._providers.keys())
+from typing import Type, Dict
+from janito.llm.provider import LLMProvider
+
+
+class LLMProviderRegistry:
+    """
+    Registry for LLM provider classes.
+    """
+
+    _providers: Dict[str, Type[LLMProvider]] = {}
+
+    @classmethod
+    def register(cls, name: str, provider_cls: Type[LLMProvider]):
+        if name in cls._providers:
+            raise ValueError(f"Provider '{name}' is already registered.")
+        cls._providers[name] = provider_cls
+
+    @classmethod
+    def get(cls, name: str) -> Type[LLMProvider]:
+        if name not in cls._providers:
+            return None
+        return cls._providers[name]
+
+    @classmethod
+    def list_providers(cls):
+        return list(cls._providers.keys())

janito/tools/DOCSTRING_STANDARD.txt

@@ -0,0 +1,33 @@
+# Docstring Format Standard for Tools
+
+All tool classes must use the following docstring style for schema compatibility and consistency:
+
+- Use a single docstring in the tool class describing Args and Returns for all parameters of the `call` method.
+- Args: List each parameter as `name (type): description` (type hints required for clarity).
+- No blank lines between Args entries.
+- Returns: Single line description, followed by examples if needed (no list markers).
+- Keep formatting simple and consistent for schema compatibility.
+
+Example:
+
+    class FindFilesTool(ToolBase):
+        """
+        Find files in one or more directories matching a pattern.
+
+        Args:
+            directories (list[str]): List of directories to search in.
+            pattern (str): File pattern to match. Uses Unix shell-style wildcards (fnmatch), e.g. '*.py', 'data_??.csv', '[a-z]*.txt'.
+            
+            max_results (int, optional): Maximum number of results to return. Defaults to 100.
+        Returns:
+            str: Newline-separated list of matching file paths. Example:
+                "/path/to/file1.py\n/path/to/file2.py"
+                "Warning: Empty file pattern provided. Operation skipped."
+        """
+
+# Tool Class Docstring Requirement
+
+- All parameter documentation for OpenAI function tools must be in the class docstring, not the `call` method docstring.
+- The class docstring is prepended to the tool's description in the OpenAI schema and is user-facing.
+- Write class docstrings as concise, clear summaries of the tool's purpose and behavior, including parameter and return descriptions as shown above.
+- Avoid implementation details; focus on what the tool does for the user.

janito/tools/README.md

@@ -0,0 +1,3 @@
+# Tools Reference
+
+This documentation has moved to [docs/TOOLS_REFERENCE.md](../../../docs/TOOLS_REFERENCE.md).

janito/tools/__init__.py

@@ -4,17 +4,31 @@ from janito.tools.adapters.local import (
 )
 
 
-def get_local_tools_adapter(workdir=None):
+def get_local_tools_adapter(workdir=None, allowed_permissions=None):
     # Use set_verbose_tools on the returned adapter to set verbosity as needed
+    import os
+    if workdir is not None and not os.path.exists(workdir):
+        os.makedirs(workdir, exist_ok=True)
+    # Permissions are now managed globally; ignore allowed_permissions argument except for backward compatibility
+    # Reuse the singleton adapter defined in janito.tools.adapters.local to maintain tool registrations
+    registry = _internal_local_tools_adapter
+    # Change workdir if requested
     if workdir is not None:
-        import os
-        if not os.path.exists(workdir):
-            os.makedirs(workdir, exist_ok=True)
-        return LocalToolsAdapter(workdir=workdir)
-    return _internal_local_tools_adapter
+        try:
+            import os
+            if not os.path.exists(workdir):
+                os.makedirs(workdir, exist_ok=True)
+            os.chdir(workdir)
+            registry.workdir = workdir
+        except Exception:
+            pass
+    return registry
 
 
+local_tools_adapter = _internal_local_tools_adapter
+
 __all__ = [
     "LocalToolsAdapter",
     "get_local_tools_adapter",
+    "local_tools_adapter",
 ]

janito/tools/adapters/local/__init__.py

@@ -1,62 +1,65 @@
-from .adapter import LocalToolsAdapter
-
-from .ask_user import AskUserTool
-from .copy_file import CopyFileTool
-from .create_directory import CreateDirectoryTool
-from .create_file import CreateFileTool
-from .fetch_url import FetchUrlTool
-from .find_files import FindFilesTool
-from .view_file import ViewFileTool
-from .move_file import MoveFileTool
-from .open_url import OpenUrlTool
-from .open_html_in_browser import OpenHtmlInBrowserTool
-from .python_code_run import PythonCodeRunTool
-from .python_command_run import PythonCommandRunTool
-from .python_file_run import PythonFileRunTool
-from .remove_directory import RemoveDirectoryTool
-from .remove_file import RemoveFileTool
-from .replace_text_in_file import ReplaceTextInFileTool
-from .run_bash_command import RunBashCommandTool
-from .run_powershell_command import RunPowershellCommandTool
-from .get_file_outline.core import GetFileOutlineTool
-from .get_file_outline.search_outline import SearchOutlineTool
-from .search_text.core import SearchTextTool
-from .validate_file_syntax.core import ValidateFileSyntaxTool
-
-# Singleton tools adapter with all standard tools registered
-import os
-local_tools_adapter = LocalToolsAdapter(workdir=os.getcwd())
-
-def get_local_tools_adapter(workdir=None):
-    import os
-    return LocalToolsAdapter(workdir=workdir or os.getcwd())
-
-# Register tools
-for tool_class in [
-    AskUserTool,
-    CopyFileTool,
-    CreateDirectoryTool,
-    CreateFileTool,
-    FetchUrlTool,
-    FindFilesTool,
-    ViewFileTool,
-    MoveFileTool,
-    OpenUrlTool,
-    OpenHtmlInBrowserTool,
-    PythonCodeRunTool,
-    PythonCommandRunTool,
-    PythonFileRunTool,
-    RemoveDirectoryTool,
-    RemoveFileTool,
-    ReplaceTextInFileTool,
-    RunBashCommandTool,
-    RunPowershellCommandTool,
-    GetFileOutlineTool,
-    SearchOutlineTool,
-    SearchTextTool,
-    ValidateFileSyntaxTool,
-]:
-    local_tools_adapter.register_tool(tool_class)
-
-# DEBUG: Print registered tools at startup
-
+from .adapter import LocalToolsAdapter
+
+from .ask_user import AskUserTool
+from .copy_file import CopyFileTool
+from .create_directory import CreateDirectoryTool
+from .create_file import CreateFileTool
+from .fetch_url import FetchUrlTool
+from .find_files import FindFilesTool
+from .view_file import ViewFileTool
+from .move_file import MoveFileTool
+from .open_url import OpenUrlTool
+from .open_html_in_browser import OpenHtmlInBrowserTool
+from .python_code_run import PythonCodeRunTool
+from .python_command_run import PythonCommandRunTool
+from .python_file_run import PythonFileRunTool
+from .remove_directory import RemoveDirectoryTool
+from .remove_file import RemoveFileTool
+from .replace_text_in_file import ReplaceTextInFileTool
+from .run_bash_command import RunBashCommandTool
+from .run_powershell_command import RunPowershellCommandTool
+from .get_file_outline.core import GetFileOutlineTool
+from .get_file_outline.search_outline import SearchOutlineTool
+from .search_text.core import SearchTextTool
+from .validate_file_syntax.core import ValidateFileSyntaxTool
+
+# Singleton tools adapter with all standard tools registered
+from janito.tools.tool_base import ToolPermissions
+import os
+local_tools_adapter = LocalToolsAdapter(workdir=os.getcwd())
+
+from janito.tools.permissions import get_global_allowed_permissions
+
+def get_local_tools_adapter(workdir=None):
+    import os
+    return LocalToolsAdapter(workdir=workdir or os.getcwd())
+
+# Register tools
+for tool_class in [
+    AskUserTool,
+    CopyFileTool,
+    CreateDirectoryTool,
+    CreateFileTool,
+    FetchUrlTool,
+    FindFilesTool,
+    ViewFileTool,
+    MoveFileTool,
+    OpenUrlTool,
+    OpenHtmlInBrowserTool,
+    PythonCodeRunTool,
+    PythonCommandRunTool,
+    PythonFileRunTool,
+    RemoveDirectoryTool,
+    RemoveFileTool,
+    ReplaceTextInFileTool,
+    RunBashCommandTool,
+    RunPowershellCommandTool,
+    GetFileOutlineTool,
+    SearchOutlineTool,
+    SearchTextTool,
+    ValidateFileSyntaxTool,
+]:
+    local_tools_adapter.register_tool(tool_class)
+
+# DEBUG: Print registered tools at startup
+

janito/tools/adapters/local/adapter.py

@@ -3,35 +3,22 @@ from janito.tools.tools_adapter import ToolsAdapterBase as ToolsAdapter
 
 
 class LocalToolsAdapter(ToolsAdapter):
-    def set_execution_tools_enabled(self, enabled: bool):
-        """
-        Dynamically include or exclude execution tools from the enabled_tools set.
-        If enabled_tools is None, all tools are enabled (default). If set, restricts enabled tools.
-        """
-        all_tool_names = set(self._tools.keys())
-        exec_tool_names = {
-            name for name, entry in self._tools.items()
-            if getattr(entry["instance"], "provides_execution", False)
-        }
-        if self._enabled_tools is None:
-            # If not restricted, create a new enabled-tools set excluding execution tools if disabling
-            if enabled:
-                self._enabled_tools = None  # all tools enabled
-            else:
-                self._enabled_tools = all_tool_names - exec_tool_names
-        else:
-            if enabled:
-                self._enabled_tools |= exec_tool_names
-            else:
-                self._enabled_tools -= exec_tool_names
+    """Local, in-process implementation of :class:`ToolsAdapterBase`.
 
-    """
-    Adapter for local, statically registered tools in the agent/tools system.
-    Handles registration, lookup, enabling/disabling, listing, and now, tool execution (merged from executor).
+    This adapter keeps an **in-memory registry** of tool classes and manages
+    permission filtering (read/write/execute) as required by the janito CLI.
+
+    The legacy ``set_execution_tools_enabled()`` helper has been removed – use
+    ``janito.tools.permissions.set_global_allowed_permissions`` or
+    :py:meth:`LocalToolsAdapter.set_allowed_permissions` to adjust the
+    permission mask at runtime.
+
+    Apart from registration/lookup helpers the class derives all execution
+    logic from :class:`janito.tools.tools_adapter.ToolsAdapterBase`.
     """
 
-    def __init__(self, tools=None, event_bus=None, enabled_tools=None, workdir=None):
-        super().__init__(tools=tools, event_bus=event_bus, enabled_tools=enabled_tools)
+    def __init__(self, tools=None, event_bus=None, workdir=None):
+        super().__init__(tools=tools, event_bus=event_bus)
         self._tools: Dict[str, Dict[str, Any]] = {}
         self.workdir = workdir
         if self.workdir:
@@ -71,19 +58,13 @@ class LocalToolsAdapter(ToolsAdapter):
         return self._tools[name]["instance"] if name in self._tools else None
 
     def list_tools(self):
-        if self._enabled_tools is None:
-            return list(self._tools.keys())
-        return [name for name in self._tools.keys() if name in self._enabled_tools]
+        return [name for name, entry in self._tools.items() if self.is_tool_allowed(entry["instance"])]
 
     def get_tool_classes(self):
-        if self._enabled_tools is None:
-            return [entry["class"] for entry in self._tools.values()]
-        return [entry["class"] for name, entry in self._tools.items() if name in self._enabled_tools]
+        return [entry["class"] for entry in self._tools.values() if self.is_tool_allowed(entry["instance"])]
 
     def get_tools(self):
-        if self._enabled_tools is None:
-            return [entry["instance"] for entry in self._tools.values()]
-        return [entry["instance"] for name, entry in self._tools.items() if name in self._enabled_tools]
+        return [entry["instance"] for entry in self._tools.values() if self.is_tool_allowed(entry["instance"])]
 
 
     def add_tool(self, tool):
@@ -109,6 +90,8 @@ class LocalToolsAdapter(ToolsAdapter):
 
 def register_local_tool(tool=None):
     def decorator(cls):
+        from janito.tools.tool_base import ToolPermissions
+        from janito.tools.permissions import get_global_allowed_permissions
         LocalToolsAdapter().register_tool(cls)
         return cls
 

janito/tools/adapters/local/ask_user.py

@@ -1,4 +1,4 @@
-from janito.tools.tool_base import ToolBase
+from janito.tools.tool_base import ToolBase, ToolPermissions
 from janito.tools.adapters.local.adapter import register_local_tool
 
 from rich import print as rich_print
@@ -20,15 +20,14 @@ class AskUserTool(ToolBase):
     Prompts the user for clarification or input with a question.
 
     Args:
-        question (str): The question to ask the user.
-
+        question (str): The question to ask the user. This parameter is required and should be a string containing the prompt or question to display to the user.
     Returns:
         str: The user's response as a string. Example:
             - "Yes"
             - "No"
             - "Some detailed answer..."
     """
-
+    permissions = ToolPermissions(read=True)
     tool_name = "ask_user"
 
     def run(self, question: str) -> str:

janito/tools/adapters/local/copy_file.py

@@ -2,7 +2,7 @@ import os
 import shutil
 from typing import List, Union
 from janito.tools.adapters.local.adapter import register_local_tool
-from janito.tools.tool_base import ToolBase
+from janito.tools.tool_base import ToolBase, ToolPermissions
 from janito.tools.tool_utils import display_path
 from janito.report_events import ReportAction
 from janito.i18n import tr
@@ -21,7 +21,7 @@ class CopyFileTool(ToolBase):
     Returns:
         str: Status string for each copy operation.
     """
-
+    permissions = ToolPermissions(read=True, write=True)
     tool_name = "copy_file"
 
     def run(self, sources: str, target: str, overwrite: bool = False) -> str:

janito/tools/adapters/local/create_directory.py

@@ -1,7 +1,7 @@
 from janito.tools.adapters.local.adapter import register_local_tool
 
 from janito.tools.tool_utils import display_path
-from janito.tools.tool_base import ToolBase
+from janito.tools.tool_base import ToolBase, ToolPermissions
 from janito.report_events import ReportAction
 from janito.i18n import tr
 import os
@@ -18,7 +18,7 @@ class CreateDirectoryTool(ToolBase):
             - "5c5 Successfully created the directory at ..."
             - "5d7 Cannot create directory: ..."
     """
-
+    permissions = ToolPermissions(write=True)
     tool_name = "create_directory"
 
     def run(self, file_path: str) -> str:

janito/tools/adapters/local/create_file.py

@@ -2,7 +2,7 @@ import os
 from janito.tools.adapters.local.adapter import register_local_tool
 
 from janito.tools.tool_utils import display_path
-from janito.tools.tool_base import ToolBase
+from janito.tools.tool_base import ToolBase, ToolPermissions
 from janito.report_events import ReportAction
 from janito.i18n import tr
 
@@ -25,7 +25,7 @@ class CreateFileTool(ToolBase):
 
     Note: Syntax validation is automatically performed after this operation.
     """
-
+    permissions = ToolPermissions(write=True)
     tool_name = "create_file"
 
     def run(self, file_path: str, content: str, overwrite: bool = False) -> str:

janito/tools/adapters/local/delete_text_in_file.py

@@ -1,4 +1,4 @@
-from janito.tools.tool_base import ToolBase
+from janito.tools.tool_base import ToolBase, ToolPermissions
 from janito.report_events import ReportAction
 from janito.tools.adapters.local.adapter import register_local_tool
 from janito.i18n import tr
@@ -19,7 +19,7 @@ class DeleteTextInFileTool(ToolBase):
     Returns:
         str: Status message indicating the result.
     """
-
+    permissions = ToolPermissions(read=True, write=True)
     tool_name = "delete_text_in_file"
 
     def run(

janito/tools/adapters/local/fetch_url.py

@@ -1,7 +1,7 @@
 import requests
 from bs4 import BeautifulSoup
 from janito.tools.adapters.local.adapter import register_local_tool
-from janito.tools.tool_base import ToolBase
+from janito.tools.tool_base import ToolBase, ToolPermissions
 from janito.report_events import ReportAction
 from janito.i18n import tr
 from janito.tools.tool_utils import pluralize
@@ -21,7 +21,7 @@ class FetchUrlTool(ToolBase):
             - "No lines found for the provided search strings."
             - "Warning: Empty URL provided. Operation skipped."
     """
-
+    permissions = ToolPermissions(read=True)
     tool_name = "fetch_url"
 
     def run(self, url: str, search_strings: list[str] = None) -> str:

janito/tools/adapters/local/find_files.py

@@ -1,4 +1,4 @@
-from janito.tools.tool_base import ToolBase
+from janito.tools.tool_base import ToolBase, ToolPermissions
 from janito.report_events import ReportAction
 from janito.tools.adapters.local.adapter import register_local_tool
 from janito.tools.tool_utils import pluralize, display_path
@@ -27,6 +27,7 @@ class FindFilesTool(ToolBase):
             "Warning: Empty file pattern provided. Operation skipped."
     """
 
+    permissions = ToolPermissions(read=True)
     tool_name = "find_files"
 
     def _match_directories(self, root, dirs, pat):

janito/tools/adapters/local/get_file_outline/core.py

@@ -4,7 +4,7 @@ from .markdown_outline import parse_markdown_outline
 from janito.formatting import OutlineFormatter
 from .java_outline import parse_java_outline
 import os
-from janito.tools.tool_base import ToolBase
+from janito.tools.tool_base import ToolBase, ToolPermissions
 from janito.report_events import ReportAction
 from janito.tools.tool_utils import display_path, pluralize
 from janito.i18n import tr
@@ -20,7 +20,7 @@ class GetFileOutlineTool(ToolBase):
     Args:
         file_path (str): Path to the file to outline.
     """
-
+    permissions = ToolPermissions(read=True)
     tool_name = "get_file_outline"
 
     def run(self, file_path: str) -> str:

janito/tools/adapters/local/get_file_outline/search_outline.py

@@ -1,4 +1,4 @@
-from janito.tools.tool_base import ToolBase
+from janito.tools.tool_base import ToolBase, ToolPermissions
 from janito.report_events import ReportAction
 
 
@@ -11,7 +11,7 @@ class SearchOutlineTool(ToolBase):
     Returns:
         str: Outline search result or status message.
     """
-
+    permissions = ToolPermissions(read=True)
     tool_name = "search_outline"
 
     def run(self, file_path: str) -> str:

janito/tools/adapters/local/move_file.py

@@ -2,7 +2,7 @@ import os
 import shutil
 from janito.tools.adapters.local.adapter import register_local_tool
 from janito.tools.tool_utils import display_path
-from janito.tools.tool_base import ToolBase
+from janito.tools.tool_base import ToolBase, ToolPermissions
 from janito.report_events import ReportAction
 from janito.i18n import tr
 
@@ -20,7 +20,7 @@ class MoveFileTool(ToolBase):
     Returns:
         str: Status message indicating the result.
     """
-
+    permissions = ToolPermissions(read=True, write=True)
     tool_name = "move_file"
 
     def run(

janito/tools/adapters/local/open_html_in_browser.py

@@ -1,7 +1,7 @@
 import os
 import webbrowser
 from janito.tools.adapters.local.adapter import register_local_tool
-from janito.tools.tool_base import ToolBase
+from janito.tools.tool_base import ToolBase, ToolPermissions
 from janito.report_events import ReportAction
 from janito.i18n import tr
 
@@ -15,6 +15,7 @@ class OpenHtmlInBrowserTool(ToolBase):
     Returns:
         str: Status message indicating the result.
     """
+    permissions = ToolPermissions(read=True)
     tool_name = "open_html_in_browser"
 
     def run(self, file_path: str) -> str:

janito/tools/adapters/local/open_url.py

@@ -1,6 +1,6 @@
 import webbrowser
 from janito.tools.adapters.local.adapter import register_local_tool
-from janito.tools.tool_base import ToolBase
+from janito.tools.tool_base import ToolBase, ToolPermissions
 from janito.report_events import ReportAction
 from janito.i18n import tr
 
@@ -15,7 +15,7 @@ class OpenUrlTool(ToolBase):
     Returns:
         str: Status message indicating the result.
     """
-
+    permissions = ToolPermissions(read=True)
     tool_name = "open_url"
 
     def run(self, url: str) -> str:

janito/tools/adapters/local/python_code_run.py

@@ -3,7 +3,7 @@ import os
 import sys
 import tempfile
 import threading
-from janito.tools.tool_base import ToolBase
+from janito.tools.tool_base import ToolBase, ToolPermissions
 from janito.report_events import ReportAction
 from janito.tools.adapters.local.adapter import register_local_tool
 from janito.i18n import tr
@@ -14,14 +14,14 @@ class PythonCodeRunTool(ToolBase):
     """
     Tool to execute Python code by passing it to the interpreter via standard input (stdin).
 
-    Parameters:
+    Args:
         code (str): The Python code to execute as a string.
         timeout (int): Timeout in seconds for the command. Defaults to 60.
 
     Returns:
         str: Output and status message, or file paths/line counts if output is large.
     """
-    provides_execution = True
+    permissions = ToolPermissions(execute=True)
     tool_name = "python_code_run"
 
     def run(self, code: str, timeout: int = 60) -> str:

janito/tools/adapters/local/python_command_run.py

@@ -3,7 +3,7 @@ import os
 import sys
 import tempfile
 import threading
-from janito.tools.tool_base import ToolBase
+from janito.tools.tool_base import ToolBase, ToolPermissions
 from janito.report_events import ReportAction
 from janito.tools.adapters.local.adapter import register_local_tool
 from janito.i18n import tr
@@ -14,14 +14,14 @@ class PythonCommandRunTool(ToolBase):
     """
     Tool to execute Python code using the `python -c` command-line flag.
 
-    Parameters:
+    Args:
         code (str): The Python code to execute as a string.
         timeout (int): Timeout in seconds for the command. Defaults to 60.
 
     Returns:
         str: Output and status message, or file paths/line counts if output is large.
     """
-    provides_execution = True
+    permissions = ToolPermissions(execute=True)
     tool_name = "python_command_run"
 
     def run(self, code: str, timeout: int = 60) -> str: