janito 2.22.0__py3-none-any.whl → 2.24.1__py3-none-any.whl

janito/tools/adapters/local/adapter.py

@@ -1,5 +1,6 @@
 from typing import Type, Dict, Any
 from janito.tools.tools_adapter import ToolsAdapterBase as ToolsAdapter
+from janito.tools.tool_use_tracker import ToolUseTracker
 
 
 class LocalToolsAdapter(ToolsAdapter):
@@ -58,6 +59,9 @@ class LocalToolsAdapter(ToolsAdapter):
         # consistency with many file-system tools.
         os.chdir(self.workdir)
 
+        # Initialize tool tracker
+        self.tool_tracker = ToolUseTracker.instance()
+
         if tools:
             for tool in tools:
                 self.register_tool(tool)
@@ -130,6 +134,57 @@ class LocalToolsAdapter(ToolsAdapter):
             and not is_tool_disabled(entry["instance"].tool_name)
         ]
 
+    # ------------------------------------------------------------------
+    # Tool execution with error handling
+    # ------------------------------------------------------------------
+    def execute_tool(self, name: str, **kwargs):
+        """
+        Execute a tool with proper error handling.
+        
+        This method extends the base execute_tool functionality by adding
+        error handling for RuntimeError exceptions that may be raised by
+        tools with loop protection decorators.
+        
+        Args:
+            name: The name of the tool to execute
+            **kwargs: Arguments to pass to the tool
+            
+        Returns:
+            The result of the tool execution
+            
+        Raises:
+            ToolCallException: If tool execution fails for any reason
+            ValueError: If the tool is not found or not allowed
+        """
+        # First check if tool exists and is allowed
+        tool = self.get_tool(name)
+        if not tool:
+            raise ValueError(f"Tool '{name}' not found or not allowed.")
+        
+        # Record tool usage
+        self.tool_tracker.record(name, kwargs)
+        
+        # Execute the tool and handle any RuntimeError from loop protection
+        try:
+            return super().execute_tool(name, **kwargs)
+        except RuntimeError as e:
+            # Check if this is a loop protection error
+            if "Loop protection:" in str(e):
+                # Re-raise as ToolCallException to maintain consistent error flow
+                from janito.exceptions import ToolCallException
+                raise ToolCallException(
+                    name, 
+                    f"Loop protection triggered: {str(e)}", 
+                    arguments=kwargs
+                )
+            # Re-raise other RuntimeError exceptions as ToolCallException
+            from janito.exceptions import ToolCallException
+            raise ToolCallException(
+                name, 
+                f"Runtime error during tool execution: {str(e)}", 
+                arguments=kwargs
+            )
+
     # ------------------------------------------------------------------
     # Convenience methods
     # ------------------------------------------------------------------

janito/tools/adapters/local/ask_user.py

@@ -1,5 +1,6 @@
 from janito.tools.tool_base import ToolBase, ToolPermissions
 from janito.tools.adapters.local.adapter import register_local_tool
+from janito.tools.loop_protection_decorator import protect_against_loops
 
 from rich import print as rich_print
 from janito.i18n import tr
@@ -31,6 +32,7 @@ class AskUserTool(ToolBase):
     permissions = ToolPermissions(read=True)
     tool_name = "ask_user"
 
+    @protect_against_loops(max_calls=5, time_window=10.0)
     def run(self, question: str) -> str:
 
         print()  # Print an empty line before the question panel

janito/tools/adapters/local/fetch_url.py

@@ -9,6 +9,7 @@ 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
+from janito.tools.loop_protection_decorator import protect_against_loops
 
 
 @register_local_tool
@@ -16,6 +17,25 @@ class FetchUrlTool(ToolBase):
     """
     Fetch the content of a web page and extract its text.
 
+    This tool implements a **session-based caching mechanism** that provides
+    **in-memory caching** for the lifetime of the tool instance. URLs are cached
+    in RAM during the session, providing instant access to previously fetched
+    content without making additional HTTP requests.
+
+    **Session Cache Behavior:**
+    - **Lifetime**: Cache exists for the lifetime of the FetchUrlTool instance
+    - **Scope**: In-memory (RAM) cache, not persisted to disk
+    - **Storage**: Successful responses are cached as raw HTML content
+    - **Key**: Cache key is the exact URL string
+    - **Invalidation**: Cache is automatically cleared when the tool instance is destroyed
+    - **Performance**: Subsequent requests for the same URL return instantly
+
+    **Error Cache Behavior:**
+    - HTTP 403 errors: Cached for 24 hours (more permanent)
+    - HTTP 404 errors: Cached for 1 hour (temporary)
+    - Other 4xx errors: Cached for 30 minutes
+    - 5xx errors: Not cached (retried on each request)
+
     Args:
         url (str): The URL of the web page to fetch.
         search_strings (list[str], optional): Strings to search for in the page content.
@@ -23,6 +43,8 @@ class FetchUrlTool(ToolBase):
         max_lines (int, optional): Maximum number of lines to return. Defaults to 200.
         context_chars (int, optional): Characters of context around search matches. Defaults to 400.
         timeout (int, optional): Timeout in seconds for the HTTP request. Defaults to 10.
+        save_to_file (str, optional): File path to save the full resource content. If provided, 
+            the complete response will be saved to this file instead of being processed.
     Returns:
         str: Extracted text content from the web page, or a warning message. Example:
             - "<main text content...>"
@@ -38,6 +60,7 @@ class FetchUrlTool(ToolBase):
         self.cache_dir = Path.home() / ".janito" / "cache" / "fetch_url"
         self.cache_dir.mkdir(parents=True, exist_ok=True)
         self.cache_file = self.cache_dir / "error_cache.json"
+        self.session_cache = {}  # In-memory session cache - lifetime matches tool instance
         self._load_cache()
 
     def _load_cache(self):
@@ -99,8 +122,41 @@ class FetchUrlTool(ToolBase):
         self._save_cache()
 
     def _fetch_url_content(self, url: str, timeout: int = 10) -> str:
-        """Fetch URL content and handle HTTP errors."""
-        # Check cache first for known errors
+        """Fetch URL content and handle HTTP errors.
+        
+        Implements two-tier caching:
+        1. Session cache: In-memory cache for successful responses (lifetime = tool instance)
+        2. Error cache: Persistent disk cache for HTTP errors with different expiration times
+        
+        Also implements URL whitelist checking.
+        """
+        # Check URL whitelist
+        from janito.tools.url_whitelist import get_url_whitelist_manager
+        whitelist_manager = get_url_whitelist_manager()
+        
+        if not whitelist_manager.is_url_allowed(url):
+            error_message = tr(
+                "Warning: URL blocked by whitelist: {url}",
+                url=url,
+            )
+            self.report_error(
+                tr(
+                    "❗ URL blocked by whitelist: {url}",
+                    url=url,
+                ),
+                ReportAction.READ,
+            )
+            return error_message
+
+        # Check session cache first
+        if url in self.session_cache:
+            self.report_warning(
+                tr("ℹ️ Using session cache"),
+                ReportAction.READ,
+            )
+            return self.session_cache[url]
+
+        # Check persistent cache for known errors
         cached_error, is_cached = self._get_cached_error(url)
         if cached_error:
             self.report_warning(
@@ -115,7 +171,10 @@ class FetchUrlTool(ToolBase):
         try:
             response = requests.get(url, timeout=timeout)
             response.raise_for_status()
-            return response.text
+            content = response.text
+            # Cache successful responses in session cache
+            self.session_cache[url] = content
+            return content
         except requests.exceptions.HTTPError as http_err:
             status_code = http_err.response.status_code if http_err.response else None
             if status_code and 400 <= status_code < 500:
@@ -203,6 +262,7 @@ class FetchUrlTool(ToolBase):
 
         return text
 
+    @protect_against_loops(max_calls=5, time_window=10.0)
     def run(
         self,
         url: str,
@@ -211,6 +271,7 @@ class FetchUrlTool(ToolBase):
         max_lines: int = 200,
         context_chars: int = 400,
         timeout: int = 10,
+        save_to_file: str = None,
     ) -> str:
         if not url.strip():
             self.report_warning(tr("ℹ️ Empty URL provided."), ReportAction.READ)
@@ -218,7 +279,31 @@ class FetchUrlTool(ToolBase):
 
         self.report_action(tr("🌐 Fetch URL '{url}' ...", url=url), ReportAction.READ)
 
-        # Fetch URL content
+        # Check if we should save to file
+        if save_to_file:
+            html_content = self._fetch_url_content(url, timeout=timeout)
+            if html_content.startswith("Warning:"):
+                return html_content
+            
+            try:
+                with open(save_to_file, 'w', encoding='utf-8') as f:
+                    f.write(html_content)
+                file_size = len(html_content)
+                self.report_success(
+                    tr(
+                        "✅ Saved {size} bytes to {file}",
+                        size=file_size,
+                        file=save_to_file,
+                    ),
+                    ReportAction.READ,
+                )
+                return tr("Successfully saved content to: {file}", file=save_to_file)
+            except IOError as e:
+                error_msg = tr("Error saving to file: {error}", error=str(e))
+                self.report_error(error_msg, ReportAction.READ)
+                return error_msg
+
+        # Normal processing path
         html_content = self._fetch_url_content(url, timeout=timeout)
         if html_content.startswith("Warning:"):
             return html_content

janito/tools/adapters/local/find_files.py

@@ -6,6 +6,7 @@ from janito.dir_walk_utils import walk_dir_with_gitignore
 from janito.i18n import tr
 import fnmatch
 import os
+from janito.tools.loop_protection_decorator import protect_against_loops
 
 
 @register_local_tool
@@ -107,6 +108,7 @@ class FindFilesTool(ToolBase):
             }
         return sorted(dir_output)
 
+    @protect_against_loops(max_calls=5, time_window=10.0)
     def run(
         self,
         paths: str,

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

@@ -10,6 +10,7 @@ from janito.tools.tool_utils import display_path, pluralize
 from janito.i18n import tr
 
 from janito.tools.adapters.local.adapter import register_local_tool as register_tool
+from janito.tools.loop_protection_decorator import protect_against_loops
 
 
 @register_tool
@@ -24,6 +25,7 @@ class GetFileOutlineTool(ToolBase):
     permissions = ToolPermissions(read=True)
     tool_name = "get_file_outline"
 
+    @protect_against_loops(max_calls=5, time_window=10.0)
     def run(self, path: str) -> str:
         try:
             self.report_action(

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

@@ -1,5 +1,6 @@
 from janito.tools.tool_base import ToolBase, ToolPermissions
 from janito.report_events import ReportAction
+from janito.tools.loop_protection_decorator import protect_against_loops
 
 
 class SearchOutlineTool(ToolBase):
@@ -15,6 +16,7 @@ class SearchOutlineTool(ToolBase):
     permissions = ToolPermissions(read=True)
     tool_name = "search_outline"
 
+    @protect_against_loops(max_calls=5, time_window=10.0)
     def run(self, path: str) -> str:
         from janito.tools.tool_utils import display_path
         from janito.i18n import tr

janito/tools/adapters/local/open_html_in_browser.py

@@ -4,6 +4,7 @@ from janito.tools.adapters.local.adapter import register_local_tool
 from janito.tools.tool_base import ToolBase, ToolPermissions
 from janito.report_events import ReportAction
 from janito.i18n import tr
+from janito.tools.loop_protection_decorator import protect_against_loops
 
 
 @register_local_tool
@@ -20,6 +21,7 @@ class OpenHtmlInBrowserTool(ToolBase):
     permissions = ToolPermissions(read=True)
     tool_name = "open_html_in_browser"
 
+    @protect_against_loops(max_calls=5, time_window=10.0)
     def run(self, path: str) -> str:
         if not path.strip():
             self.report_warning(tr("ℹ️ Empty file path provided."))

janito/tools/adapters/local/open_url.py

@@ -3,6 +3,7 @@ from janito.tools.adapters.local.adapter import register_local_tool
 from janito.tools.tool_base import ToolBase, ToolPermissions
 from janito.report_events import ReportAction
 from janito.i18n import tr
+from janito.tools.loop_protection_decorator import protect_against_loops
 
 
 @register_local_tool
@@ -19,6 +20,7 @@ class OpenUrlTool(ToolBase):
     permissions = ToolPermissions(read=True)
     tool_name = "open_url"
 
+    @protect_against_loops(max_calls=5, time_window=10.0)
     def run(self, url: str) -> str:
         if not url.strip():
             self.report_warning(tr("ℹ️ Empty URL provided."))

janito/tools/adapters/local/python_code_run.py

@@ -17,6 +17,7 @@ class PythonCodeRunTool(ToolBase):
     Args:
         code (str): The Python code to execute as a string.
         timeout (int): Timeout in seconds for the command. Defaults to 60.
+        silent (bool): If True, suppresses progress and status messages. Defaults to False.
 
     Returns:
         str: Output and status message, or file paths/line counts if output is large.
@@ -25,15 +26,18 @@ class PythonCodeRunTool(ToolBase):
     permissions = ToolPermissions(execute=True)
     tool_name = "python_code_run"
 
-    def run(self, code: str, timeout: int = 60) -> str:
+    def run(self, code: str, timeout: int = 60, silent: bool = False) -> str:
         if not code.strip():
             self.report_warning(tr("ℹ️ Empty code provided."), ReportAction.EXECUTE)
             return tr("Warning: Empty code provided. Operation skipped.")
-        self.report_action(
-            tr("⚡ Running: python (stdin mode) ...\n{code}\n", code=code),
-            ReportAction.EXECUTE,
-        )
-        self.report_stdout("\n")
+        if not silent:
+            self.report_action(
+                tr("⚡ Running: python (stdin mode) ...\n{code}\n", code=code),
+                ReportAction.EXECUTE,
+            )
+            self.report_stdout("\n")
+        else:
+            self.report_action(tr("⚡ Executing..."), ReportAction.EXECUTE)
         try:
             with (
                 tempfile.NamedTemporaryFile(
@@ -70,10 +74,11 @@ class PythonCodeRunTool(ToolBase):
                     )
                 stdout_file.flush()
                 stderr_file.flush()
-                self.report_success(
-                    tr("✅ Return code {return_code}", return_code=return_code),
-                    ReportAction.EXECUTE,
-                )
+                if not silent:
+                    self.report_success(
+                        tr("✅ Return code {return_code}", return_code=return_code),
+                        ReportAction.EXECUTE,
+                    )
                 return self._format_result(
                     stdout_file.name, stderr_file.name, return_code
                 )

janito/tools/adapters/local/python_command_run.py

@@ -17,6 +17,7 @@ class PythonCommandRunTool(ToolBase):
     Args:
         code (str): The Python code to execute as a string.
         timeout (int): Timeout in seconds for the command. Defaults to 60.
+        silent (bool): If True, suppresses progress and status messages. Defaults to False.
 
     Returns:
         str: Output and status message, or file paths/line counts if output is large.
@@ -25,14 +26,17 @@ class PythonCommandRunTool(ToolBase):
     permissions = ToolPermissions(execute=True)
     tool_name = "python_command_run"
 
-    def run(self, code: str, timeout: int = 60) -> str:
+    def run(self, code: str, timeout: int = 60, silent: bool = False) -> str:
         if not code.strip():
             self.report_warning(tr("ℹ️ Empty code provided."), ReportAction.EXECUTE)
             return tr("Warning: Empty code provided. Operation skipped.")
-        self.report_action(
-            tr("🐍 Running: python -c ...\n{code}\n", code=code), ReportAction.EXECUTE
-        )
-        self.report_stdout("\n")
+        if not silent:
+            self.report_action(
+                tr("🐍 Running: python -c ...\n{code}\n", code=code), ReportAction.EXECUTE
+            )
+            self.report_stdout("\n")
+        else:
+            self.report_action(tr("⚡ Executing..."), ReportAction.EXECUTE)
         try:
             with (
                 tempfile.NamedTemporaryFile(
@@ -68,10 +72,11 @@ class PythonCommandRunTool(ToolBase):
                     )
                 stdout_file.flush()
                 stderr_file.flush()
-                self.report_success(
-                    tr("✅ Return code {return_code}", return_code=return_code),
-                    ReportAction.EXECUTE,
-                )
+                if not silent:
+                    self.report_success(
+                        tr("✅ Return code {return_code}", return_code=return_code),
+                        ReportAction.EXECUTE,
+                    )
                 return self._format_result(
                     stdout_file.name, stderr_file.name, return_code
                 )

janito/tools/adapters/local/python_file_run.py

@@ -17,6 +17,7 @@ class PythonFileRunTool(ToolBase):
     Args:
         path (str): Path to the Python script file to execute.
         timeout (int): Timeout in seconds for the command. Defaults to 60.
+        silent (bool): If True, suppresses progress and status messages. Defaults to False.
 
     Returns:
         str: Output and status message, or file paths/line counts if output is large.
@@ -25,12 +26,15 @@ class PythonFileRunTool(ToolBase):
     permissions = ToolPermissions(execute=True)
     tool_name = "python_file_run"
 
-    def run(self, path: str, timeout: int = 60) -> str:
-        self.report_action(
-            tr("🚀 Running: python {path}", path=path),
-            ReportAction.EXECUTE,
-        )
-        self.report_stdout("\n")
+    def run(self, path: str, timeout: int = 60, silent: bool = False) -> str:
+        if not silent:
+            self.report_action(
+                tr("🚀 Running: python {path}", path=path),
+                ReportAction.EXECUTE,
+            )
+            self.report_stdout("\n")
+        else:
+            self.report_action(tr("⚡ Executing..."), ReportAction.EXECUTE)
         try:
             with (
                 tempfile.NamedTemporaryFile(
@@ -66,10 +70,11 @@ class PythonFileRunTool(ToolBase):
                     )
                 stdout_file.flush()
                 stderr_file.flush()
-                self.report_success(
-                    tr("✅ Return code {return_code}", return_code=return_code),
-                    ReportAction.EXECUTE,
-                )
+                if not silent:
+                    self.report_success(
+                        tr("✅ Return code {return_code}", return_code=return_code),
+                        ReportAction.EXECUTE,
+                    )
                 return self._format_result(
                     stdout_file.name, stderr_file.name, return_code
                 )