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

janito/providers/deepseek/provider.py

@@ -1,91 +1,94 @@
-from janito.llm.provider import LLMProvider
-from janito.llm.model import LLMModelInfo
-from janito.llm.auth import LLMAuthManager
-from janito.llm.driver_config import LLMDriverConfig
-from janito.drivers.openai.driver import OpenAIModelDriver
-from janito.tools import get_local_tools_adapter
-from janito.providers.registry import LLMProviderRegistry
-from .model_info import MODEL_SPECS
-from queue import Queue
-
-available = OpenAIModelDriver.available
-unavailable_reason = OpenAIModelDriver.unavailable_reason
-
-
-class DeepseekProvider(LLMProvider):
-    name = "deepseek"
-    maintainer = "Needs maintainer"
-    MODEL_SPECS = MODEL_SPECS
-    DEFAULT_MODEL = "deepseek-chat"  # Options: deepseek-chat, deepseek-reasoner
-
-    def __init__(
-        self, auth_manager: LLMAuthManager = None, config: LLMDriverConfig = None
-    ):
-        if not self.available:
-            self._driver = None
-        else:
-            self.auth_manager = auth_manager or LLMAuthManager()
-            self._api_key = self.auth_manager.get_credentials(type(self).name)
-            self._tools_adapter = get_local_tools_adapter()
-            self._driver_config = config or LLMDriverConfig(model=None)
-            if not self._driver_config.model:
-                self._driver_config.model = self.DEFAULT_MODEL
-            if not self._driver_config.api_key:
-                self._driver_config.api_key = self._api_key
-            # Set DeepSeek public endpoint as default base_url if not provided
-            if not getattr(self._driver_config, "base_url", None):
-                self._driver_config.base_url = "https://api.deepseek.com/v1"
-            self.fill_missing_device_info(self._driver_config)
-            self._driver = None  # to be provided by factory/agent
-
-    @property
-    def driver(self) -> OpenAIModelDriver:
-        if not self.available:
-            raise ImportError(f"OpenAIProvider unavailable: {self.unavailable_reason}")
-        return self._driver
-
-    @property
-    def available(self):
-        return available
-
-    @property
-    def unavailable_reason(self):
-        return unavailable_reason
-
-    def create_driver(self):
-        """
-        Creates and returns a new OpenAIModelDriver instance with input/output queues.
-        """
-        driver = OpenAIModelDriver(
-            tools_adapter=self._tools_adapter, provider_name=self.name
-        )
-        driver.config = self._driver_config
-        # NOTE: The caller is responsible for calling driver.start() if background processing is needed.
-        return driver
-
-    def create_agent(self, tools_adapter=None, agent_name: str = None, **kwargs):
-        from janito.llm.agent import LLMAgent
-
-        # Always create a new driver with the passed-in tools_adapter
-        if tools_adapter is None:
-            tools_adapter = get_local_tools_adapter()
-        # Should use new-style driver construction via queues/factory (handled elsewhere)
-        raise NotImplementedError(
-            "create_agent must be constructed via new factory using input/output queues and config."
-        )
-
-    @property
-    def model_name(self):
-        return self._driver_config.model
-
-    @property
-    def driver_config(self):
-        """Public, read-only access to the provider's LLMDriverConfig object."""
-        return self._driver_config
-
-    def execute_tool(self, tool_name: str, event_bus, *args, **kwargs):
-        self._tools_adapter.event_bus = event_bus
-        return self._tools_adapter.execute_by_name(tool_name, *args, **kwargs)
-
-
-LLMProviderRegistry.register(DeepseekProvider.name, DeepseekProvider)
+from janito.llm.provider import LLMProvider
+from janito.llm.model import LLMModelInfo
+from janito.llm.auth import LLMAuthManager
+from janito.llm.driver_config import LLMDriverConfig
+from janito.drivers.openai.driver import OpenAIModelDriver
+from janito.tools import get_local_tools_adapter
+from janito.providers.registry import LLMProviderRegistry
+from .model_info import MODEL_SPECS
+from queue import Queue
+
+available = OpenAIModelDriver.available
+unavailable_reason = OpenAIModelDriver.unavailable_reason
+
+
+class DeepseekProvider(LLMProvider):
+    name = "deepseek"
+    maintainer = "Needs maintainer"
+    MODEL_SPECS = MODEL_SPECS
+    DEFAULT_MODEL = "deepseek-chat"  # Options: deepseek-chat, deepseek-reasoner
+
+    def __init__(
+        self, auth_manager: LLMAuthManager = None, config: LLMDriverConfig = None
+    ):
+        # Always set a tools adapter so that even if the driver is unavailable,
+        # generic code paths that expect provider.execute_tool() continue to work.
+        self._tools_adapter = get_local_tools_adapter()
+        if not self.available:
+            self._driver = None
+        else:
+            self.auth_manager = auth_manager or LLMAuthManager()
+            self._api_key = self.auth_manager.get_credentials(type(self).name)
+            self._tools_adapter = get_local_tools_adapter()
+            self._driver_config = config or LLMDriverConfig(model=None)
+            if not self._driver_config.model:
+                self._driver_config.model = self.DEFAULT_MODEL
+            if not self._driver_config.api_key:
+                self._driver_config.api_key = self._api_key
+            # Set DeepSeek public endpoint as default base_url if not provided
+            if not getattr(self._driver_config, "base_url", None):
+                self._driver_config.base_url = "https://api.deepseek.com/v1"
+            self.fill_missing_device_info(self._driver_config)
+            self._driver = None  # to be provided by factory/agent
+
+    @property
+    def driver(self) -> OpenAIModelDriver:
+        if not self.available:
+            raise ImportError(f"OpenAIProvider unavailable: {self.unavailable_reason}")
+        return self._driver
+
+    @property
+    def available(self):
+        return available
+
+    @property
+    def unavailable_reason(self):
+        return unavailable_reason
+
+    def create_driver(self):
+        """
+        Creates and returns a new OpenAIModelDriver instance with input/output queues.
+        """
+        driver = OpenAIModelDriver(
+            tools_adapter=self._tools_adapter, provider_name=self.name
+        )
+        driver.config = self._driver_config
+        # NOTE: The caller is responsible for calling driver.start() if background processing is needed.
+        return driver
+
+    def create_agent(self, tools_adapter=None, agent_name: str = None, **kwargs):
+        from janito.llm.agent import LLMAgent
+
+        # Always create a new driver with the passed-in tools_adapter
+        if tools_adapter is None:
+            tools_adapter = get_local_tools_adapter()
+        # Should use new-style driver construction via queues/factory (handled elsewhere)
+        raise NotImplementedError(
+            "create_agent must be constructed via new factory using input/output queues and config."
+        )
+
+    @property
+    def model_name(self):
+        return self._driver_config.model
+
+    @property
+    def driver_config(self):
+        """Public, read-only access to the provider's LLMDriverConfig object."""
+        return self._driver_config
+
+    def execute_tool(self, tool_name: str, event_bus, *args, **kwargs):
+        self._tools_adapter.event_bus = event_bus
+        return self._tools_adapter.execute_by_name(tool_name, *args, **kwargs)
+
+
+LLMProviderRegistry.register(DeepseekProvider.name, DeepseekProvider)

janito/providers/google/provider.py

@@ -22,6 +22,9 @@ class GoogleProvider(LLMProvider):
     def __init__(
         self, auth_manager: LLMAuthManager = None, config: LLMDriverConfig = None
     ):
+        # Always have a tools adapter available to avoid AttributeError downstream when
+        # the driver is missing but other logic still relies on tools execution.
+        self._tools_adapter = get_local_tools_adapter()
         if not self.available:
             self._driver = None
         else:

janito/providers/mistralai/provider.py

@@ -24,6 +24,9 @@ class MistralAIProvider(LLMProvider):
     def __init__(
         self, config: LLMDriverConfig = None, auth_manager: LLMAuthManager = None
     ):
+        # Always instantiate a tools adapter so that provider.execute_tool() remains functional
+        # even when the driver cannot be constructed due to missing dependencies.
+        self._tools_adapter = get_local_tools_adapter()
         if not self.available:
             self._driver = None
             return

janito/providers/openai/provider.py

@@ -24,6 +24,10 @@ class OpenAIProvider(LLMProvider):
         self, auth_manager: LLMAuthManager = None, config: LLMDriverConfig = None
     ):
         if not self.available:
+            # Even when the OpenAI driver is unavailable we still need a tools adapter
+            # so that any generic logic that expects `execute_tool()` to work does not
+            # crash with an AttributeError when it tries to access `self._tools_adapter`.
+            self._tools_adapter = get_local_tools_adapter()
             self._driver = None
         else:
             self.auth_manager = auth_manager or LLMAuthManager()

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/__init__.py

@@ -1 +1 @@
-# Tools providers package: for plug-and-play tool collections, integrations, and adapters.
+# Tools providers package: for plug-and-play tool collections, integrations, and adapters.

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