janito 2.21.0__py3-none-any.whl → 2.24.0__py3-none-any.whl

janito/plugins/manager.py

@@ -0,0 +1,185 @@
+"""
+Plugin manager for loading and managing plugins.
+"""
+
+import os
+import sys
+import importlib
+import importlib.util
+from pathlib import Path
+from typing import Dict, List, Optional, Any
+import logging
+
+from .base import Plugin, PluginMetadata
+from .discovery import discover_plugins
+from janito.tools.adapters.local import LocalToolsAdapter
+
+logger = logging.getLogger(__name__)
+
+
+class PluginManager:
+    """
+    Manages plugin loading, registration, and lifecycle.
+    """
+    
+    def __init__(self, tools_adapter: Optional[LocalToolsAdapter] = None):
+        self.tools_adapter = tools_adapter or LocalToolsAdapter()
+        self.plugins: Dict[str, Plugin] = {}
+        self.plugin_configs: Dict[str, Dict[str, Any]] = {}
+        self.plugin_paths: List[Path] = []
+        
+    def add_plugin_path(self, path: str) -> None:
+        """Add a directory to search for plugins."""
+        plugin_path = Path(path)
+        if plugin_path.exists() and plugin_path.is_dir():
+            self.plugin_paths.append(plugin_path)
+            if str(plugin_path) not in sys.path:
+                sys.path.insert(0, str(plugin_path))
+    
+    def load_plugin(self, plugin_name: str, config: Optional[Dict[str, Any]] = None) -> bool:
+        """
+        Load a plugin by name.
+        
+        Args:
+            plugin_name: Name of the plugin to load
+            config: Optional configuration for the plugin
+            
+        Returns:
+            True if plugin loaded successfully
+        """
+        try:
+            if plugin_name in self.plugins:
+                logger.warning(f"Plugin {plugin_name} already loaded")
+                return True
+                
+            plugin = discover_plugins(plugin_name, self.plugin_paths)
+            if not plugin:
+                logger.error(f"Plugin {plugin_name} not found")
+                return False
+            
+            # Store config
+            if config:
+                self.plugin_configs[plugin_name] = config
+            
+            # Validate config if provided
+            if config and hasattr(plugin, 'validate_config'):
+                if not plugin.validate_config(config):
+                    logger.error(f"Invalid configuration for plugin {plugin_name}")
+                    return False
+            
+            # Initialize plugin
+            plugin.initialize()
+            
+            # Register tools
+            tools = plugin.get_tools()
+            for tool_class in tools:
+                self.tools_adapter.register_tool(tool_class)
+            
+            # Store plugin
+            self.plugins[plugin_name] = plugin
+            
+            logger.info(f"Successfully loaded plugin: {plugin_name}")
+            return True
+            
+        except Exception as e:
+            logger.error(f"Failed to load plugin {plugin_name}: {e}")
+            return False
+    
+    def unload_plugin(self, plugin_name: str) -> bool:
+        """
+        Unload a plugin.
+        
+        Args:
+            plugin_name: Name of the plugin to unload
+            
+        Returns:
+            True if plugin unloaded successfully
+        """
+        try:
+            if plugin_name not in self.plugins:
+                logger.warning(f"Plugin {plugin_name} not loaded")
+                return False
+            
+            plugin = self.plugins[plugin_name]
+            
+            # Unregister tools
+            tools = plugin.get_tools()
+            for tool_class in tools:
+                tool_name = getattr(tool_class(), 'tool_name', None)
+                if tool_name:
+                    self.tools_adapter.unregister_tool(tool_name)
+            
+            # Cleanup plugin
+            plugin.cleanup()
+            
+            # Remove from registry
+            del self.plugins[plugin_name]
+            if plugin_name in self.plugin_configs:
+                del self.plugin_configs[plugin_name]
+            
+            logger.info(f"Successfully unloaded plugin: {plugin_name}")
+            return True
+            
+        except Exception as e:
+            logger.error(f"Failed to unload plugin {plugin_name}: {e}")
+            return False
+    
+    def list_plugins(self) -> List[str]:
+        """Return list of loaded plugin names."""
+        return list(self.plugins.keys())
+    
+    def get_plugin(self, plugin_name: str) -> Optional[Plugin]:
+        """Get a loaded plugin by name."""
+        return self.plugins.get(plugin_name)
+    
+    def get_plugin_metadata(self, plugin_name: str) -> Optional[PluginMetadata]:
+        """Get metadata for a loaded plugin."""
+        plugin = self.plugins.get(plugin_name)
+        return plugin.metadata if plugin else None
+    
+    def load_plugins_from_config(self, config: Dict[str, Any]) -> None:
+        """
+        Load plugins from configuration.
+        
+        Args:
+            config: Configuration dict with plugin settings
+        """
+        plugins_config = config.get('plugins', {})
+        
+        # Add plugin paths
+        for path in plugins_config.get('paths', []):
+            self.add_plugin_path(path)
+        
+        # Load plugins
+        for plugin_name, plugin_config in plugins_config.get('load', {}).items():
+            if isinstance(plugin_config, bool):
+                if plugin_config:
+                    self.load_plugin(plugin_name)
+            else:
+                self.load_plugin(plugin_name, plugin_config)
+    
+    def reload_plugin(self, plugin_name: str) -> bool:
+        """
+        Reload a plugin.
+        
+        Args:
+            plugin_name: Name of the plugin to reload
+            
+        Returns:
+            True if plugin reloaded successfully
+        """
+        config = self.plugin_configs.get(plugin_name)
+        self.unload_plugin(plugin_name)
+        return self.load_plugin(plugin_name, config)
+    
+    def get_loaded_plugins_info(self) -> Dict[str, Dict[str, Any]]:
+        """Get information about all loaded plugins."""
+        info = {}
+        for name, plugin in self.plugins.items():
+            info[name] = {
+                'metadata': plugin.metadata,
+                'tools': [tool.__name__ for tool in plugin.get_tools()],
+                'commands': list(plugin.get_commands().keys()),
+                'config': self.plugin_configs.get(name, {})
+            }
+        return info

janito/providers/ibm/model_info.py

@@ -3,6 +3,15 @@
 from janito.llm.model import LLMModelInfo
 
 MODEL_SPECS = {
+    "openai/gpt-oss-120b": LLMModelInfo(
+        name="openai/gpt-oss-120b",
+        context=128000,
+        max_input=128000,
+        max_response=4096,
+        max_cot=4096,
+        thinking_supported=True,
+        category="IBM WatsonX",
+    ),
     "ibm/granite-3-8b-instruct": LLMModelInfo(
         name="ibm/granite-3-8b-instruct",
         context=128000,

janito/tools/adapters/local/__init__.py

@@ -23,6 +23,7 @@ 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
+from .read_chart import ReadChartTool
 
 from janito.tools.tool_base import ToolPermissions
 import os
@@ -61,6 +62,7 @@ for tool_class in [
     SearchOutlineTool,
     SearchTextTool,
     ValidateFileSyntaxTool,
+    ReadChartTool,
 ]:
     local_tools_adapter.register_tool(tool_class)
 

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

@@ -1,10 +1,15 @@
 import requests
+import time
+import os
+import json
+from pathlib import Path
 from bs4 import BeautifulSoup
 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.tool_utils import pluralize
+from janito.tools.loop_protection_decorator import protect_against_loops
 
 
 @register_local_tool
@@ -12,12 +17,34 @@ 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.
         max_length (int, optional): Maximum number of characters to return. Defaults to 5000.
         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...>"
@@ -28,15 +55,138 @@ class FetchUrlTool(ToolBase):
     permissions = ToolPermissions(read=True)
     tool_name = "fetch_url"
 
-    def _fetch_url_content(self, url: str) -> str:
-        """Fetch URL content and handle HTTP errors."""
+    def __init__(self):
+        super().__init__()
+        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):
+        """Load error cache from disk."""
+        if self.cache_file.exists():
+            try:
+                with open(self.cache_file, 'r', encoding='utf-8') as f:
+                    self.error_cache = json.load(f)
+            except (json.JSONDecodeError, IOError):
+                self.error_cache = {}
+        else:
+            self.error_cache = {}
+
+    def _save_cache(self):
+        """Save error cache to disk."""
+        try:
+            with open(self.cache_file, 'w', encoding='utf-8') as f:
+                json.dump(self.error_cache, f, indent=2)
+        except IOError:
+            pass  # Silently fail if we can't write cache
+
+    def _get_cached_error(self, url: str) -> tuple[str, bool]:
+        """
+        Check if we have a cached error for this URL.
+        Returns (error_message, is_cached) tuple.
+        """
+        if url not in self.error_cache:
+            return None, False
+        
+        entry = self.error_cache[url]
+        current_time = time.time()
+        
+        # Different expiration times for different status codes
+        if entry['status_code'] == 403:
+            # Cache 403 errors for 24 hours (more permanent)
+            expiration_time = 24 * 3600
+        elif entry['status_code'] == 404:
+            # Cache 404 errors for 1 hour (more temporary)
+            expiration_time = 3600
+        else:
+            # Cache other 4xx errors for 30 minutes
+            expiration_time = 1800
+            
+        if current_time - entry['timestamp'] > expiration_time:
+            # Cache expired, remove it
+            del self.error_cache[url]
+            self._save_cache()
+            return None, False
+            
+        return entry['message'], True
+
+    def _cache_error(self, url: str, status_code: int, message: str):
+        """Cache an HTTP error response."""
+        self.error_cache[url] = {
+            'status_code': status_code,
+            'message': message,
+            'timestamp': time.time()
+        }
+        self._save_cache()
+
+    def _fetch_url_content(self, url: str, timeout: int = 10) -> str:
+        """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(
+                tr(
+                    "ℹ️ Using cached HTTP error for URL: {url}",
+                    url=url,
+                ),
+                ReportAction.READ,
+            )
+            return cached_error
+
         try:
-            response = requests.get(url, timeout=10)
+            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:
+                error_message = tr(
+                    "Warning: HTTP {status_code} error for URL: {url}",
+                    status_code=status_code,
+                    url=url,
+                )
+                # Cache 403 and 404 errors
+                if status_code in [403, 404]:
+                    self._cache_error(url, status_code, error_message)
+                
                 self.report_error(
                     tr(
                         "❗ HTTP {status_code} error for URL: {url}",
@@ -45,11 +195,7 @@ class FetchUrlTool(ToolBase):
                     ),
                     ReportAction.READ,
                 )
-                return tr(
-                    "Warning: HTTP {status_code} error for URL: {url}",
-                    status_code=status_code,
-                    url=url,
-                )
+                return error_message
             else:
                 self.report_error(
                     tr(
@@ -116,6 +262,7 @@ class FetchUrlTool(ToolBase):
 
         return text
 
+    @protect_against_loops(max_calls=5, time_window=10.0)
     def run(
         self,
         url: str,
@@ -123,6 +270,8 @@ class FetchUrlTool(ToolBase):
         max_length: int = 5000,
         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)
@@ -130,8 +279,32 @@ class FetchUrlTool(ToolBase):
 
         self.report_action(tr("🌐 Fetch URL '{url}' ...", url=url), ReportAction.READ)
 
-        # Fetch URL content
-        html_content = self._fetch_url_content(url)
+        # 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."))