janito 3.1.0__py3-none-any.whl → 3.2.0__py3-none-any.whl

janito/plugin_system/core_loader.py

@@ -12,8 +12,7 @@ from pathlib import Path
 from typing import Optional, List, Type
 
 from janito.plugin_system.base import Plugin, PluginMetadata
-from janito.tools.function_adapter import create_function_tool
-from janito.tools.tool_base import ToolBase
+from janito.tools.tool_base import ToolBase, ToolPermissions
 
 
 class CorePlugin(Plugin):
@@ -38,12 +37,86 @@ class CorePlugin(Plugin):
     def get_tools(self) -> List[Type[ToolBase]]:
         return self._tool_classes
 
+    def _create_tool_class(self, func):
+        """Create a ToolBase class from a function."""
+        resolved_tool_name = getattr(func, "tool_name", func.__name__)
+        
+        # Create a proper tool class with explicit parameters and documentation
+        import inspect
+        from typing import get_type_hints
+        
+        func_sig = inspect.signature(func)
+        type_hints = get_type_hints(func)
+        
+        # Build parameter definitions for the run method
+        param_defs = []
+        param_docs = []
+        for name, param in func_sig.parameters.items():
+            type_hint = type_hints.get(name, str)
+            if param.default == inspect.Parameter.empty:
+                param_defs.append(f"{name}: {type_hint.__name__}")
+            else:
+                param_defs.append(f"{name}: {type_hint.__name__} = {repr(param.default)}")
+            
+            # Add parameter documentation
+            param_docs.append(f"    {name}: {type_hint.__name__} - Parameter {name}")
+        
+        # Get function docstring or create one
+        func_doc = func.__doc__ or f"Execute {resolved_tool_name} tool"
+        
+        # Create the tool class with proper signature and documentation
+        exec_globals = {
+            'ToolBase': ToolBase,
+            'ToolPermissions': ToolPermissions,
+            'func': func,
+            'inspect': inspect,
+            'str': str,
+        }
+        
+        param_docs_str = '\n'.join(param_docs)
+        
+        class_def = f'''
+class DynamicTool(ToolBase):
+    """
+    {func_doc}
+    
+    Parameters:
+{param_docs_str}
+    
+    Returns:
+        str: Execution result
+    """
+    tool_name = "{resolved_tool_name}"
+    permissions = ToolPermissions(read=True, write=True, execute=True)
+    
+    def __init__(self):
+        super().__init__()
+    
+    def run(self, {', '.join(param_defs)}) -> str:
+        kwargs = locals()
+        sig = inspect.signature(func)
+        
+        # Filter kwargs to only include parameters the function accepts
+        filtered_kwargs = {{}}
+        for name, param in sig.parameters.items():
+            if name in kwargs and kwargs[name] is not None:
+                filtered_kwargs[name] = kwargs[name]
+        
+        result = func(**filtered_kwargs)
+        return str(result) if result is not None else ""
+'''
+        
+        exec(class_def, exec_globals)
+        return exec_globals['DynamicTool']
+        
+        return DynamicTool
+
     def initialize(self):
         """Initialize by creating tool classes."""
         self._tool_classes = []
         for tool_func in self._tools:
             if callable(tool_func):
-                tool_class = create_function_tool(tool_func)
+                tool_class = self._create_tool_class(tool_func)
                 self._tool_classes.append(tool_class)
 
 

janito/plugin_system/core_loader_fixed.py

@@ -11,8 +11,7 @@ from pathlib import Path
 from typing import Optional, List, Type
 
 from janito.plugin_system.base import Plugin, PluginMetadata
-from janito.tools.function_adapter import create_function_tool
-from janito.tools.tool_base import ToolBase
+from janito.tools.tool_base import ToolBase, ToolPermissions
 
 
 class CorePlugin(Plugin):
@@ -37,12 +36,89 @@ class CorePlugin(Plugin):
     def get_tools(self) -> List[Type[ToolBase]]:
         return self._tool_classes
 
+    def _create_tool_class(self, func):
+        """Create a ToolBase class from a function."""
+        resolved_tool_name = getattr(func, "tool_name", func.__name__)
+        
+        # Create a proper tool class with explicit parameters and documentation
+        import inspect
+        from typing import get_type_hints
+        
+        func_sig = inspect.signature(func)
+        type_hints = get_type_hints(func)
+        
+        # Build parameter definitions for the run method
+        param_defs = []
+        param_docs = []
+        for name, param in func_sig.parameters.items():
+            type_hint = type_hints.get(name, str)
+            if param.default == inspect.Parameter.empty:
+                param_defs.append(f"{name}: {type_hint.__name__}")
+            else:
+                param_defs.append(f"{name}: {type_hint.__name__} = {repr(param.default)}")
+            
+            # Add parameter documentation
+            param_docs.append(f"    {name}: {type_hint.__name__} - Parameter {name}")
+        
+        # Get function docstring or create one
+        func_doc = func.__doc__ or f"Execute {resolved_tool_name} tool"
+        
+        # Create the tool class with proper signature and documentation
+        exec_globals = {
+            'ToolBase': ToolBase,
+            'ToolPermissions': ToolPermissions,
+            'func': func,
+            'inspect': inspect,
+            'str': str,
+            'List': list,
+            'Dict': dict,
+            'Optional': type(None),
+        }
+        
+        param_docs_str = '\n'.join(param_docs)
+        
+        class_def = f'''
+class DynamicTool(ToolBase):
+    """
+    {func_doc}
+    
+    Parameters:
+{param_docs_str}
+    
+    Returns:
+        str: Execution result
+    """
+    tool_name = "{resolved_tool_name}"
+    permissions = ToolPermissions(read=True, write=True, execute=True)
+    
+    def __init__(self):
+        super().__init__()
+    
+    def run(self, {', '.join(param_defs)}) -> str:
+        kwargs = locals()
+        sig = inspect.signature(func)
+        
+        # Filter kwargs to only include parameters the function accepts
+        filtered_kwargs = {{}}
+        for name, param in sig.parameters.items():
+            if name in kwargs and kwargs[name] is not None:
+                filtered_kwargs[name] = kwargs[name]
+        
+        result = func(**filtered_kwargs)
+        return str(result) if result is not None else ""
+'''
+        
+        exec(class_def, exec_globals)
+        return exec_globals['DynamicTool']
+        
+        return DynamicTool
+
     def initialize(self):
         """Initialize by creating tool classes."""
         self._tool_classes = []
         for tool_func in self._tools:
             if callable(tool_func):
-                tool_class = create_function_tool(tool_func)
+                tool_class = self._create_tool_class(tool_func)
                 self._tool_classes.append(tool_class)
 
 

janito/plugins/auto_loader.py

@@ -13,7 +13,7 @@ from janito.plugins.discovery import list_available_plugins
 # List of core plugins that should be enabled by default
 CORE_PLUGINS = [
     "core.filemanager",
-    "core.codeanalyzer", 
+    "core.codeanalyzer",
     "core.system",
     "core.imagedisplay",
     "dev.pythondev",
@@ -26,23 +26,23 @@ CORE_PLUGINS = [
 def load_core_plugins(pm: PluginManager = None) -> List[str]:
     """
     Load all core plugins.
-    
+
     Args:
         pm: PluginManager instance. If None, creates a new one.
-        
+
     Returns:
         List of successfully loaded plugin names
     """
     if pm is None:
         pm = PluginManager()
-    
+
     # Ensure plugins directory is in search path
     plugins_dir = Path.cwd() / "plugins"
     if plugins_dir.exists():
         pm.add_plugin_path(str(plugins_dir))
-    
+
     loaded = []
-    
+
     # Load core plugins
     for plugin_name in CORE_PLUGINS:
         try:
@@ -50,14 +50,14 @@ def load_core_plugins(pm: PluginManager = None) -> List[str]:
                 loaded.append(plugin_name)
         except Exception as e:
             print(f"Warning: Failed to load core plugin {plugin_name}: {e}")
-    
+
     return loaded
 
 
 def get_loaded_core_plugins() -> List[str]:
     """
     Get list of currently loaded core plugins.
-    
+
     Returns:
         List of loaded core plugin names
     """
@@ -69,10 +69,10 @@ def get_loaded_core_plugins() -> List[str]:
 def is_core_plugin(plugin_name: str) -> bool:
     """
     Check if a plugin is a core plugin.
-    
+
     Args:
         plugin_name: Name of the plugin to check
-        
+
     Returns:
         True if it's a core plugin
     """
@@ -82,10 +82,11 @@ def is_core_plugin(plugin_name: str) -> bool:
 # Auto-load core plugins when module is imported
 _plugin_manager = None
 
+
 def get_plugin_manager() -> PluginManager:
     """Get the global plugin manager with core plugins loaded."""
     global _plugin_manager
     if _plugin_manager is None:
         _plugin_manager = PluginManager()
         load_core_plugins(_plugin_manager)
-    return _plugin_manager
+    return _plugin_manager

janito/plugins/core/filemanager/tools/create_file.py

@@ -27,13 +27,13 @@ class CreateFileTool(ToolBase):
     Note: Syntax validation is automatically performed after this operation.
 
     Security: This tool includes loop protection to prevent excessive file creation operations.
-    Maximum 5 calls per 10 seconds for the same file path.
+    Protection: Prevents repeated create calls for the same file path within a short window (1 allowed per 10 seconds).
     """
 
     permissions = ToolPermissions(write=True)
     tool_name = "create_file"
 
-    @protect_against_loops(max_calls=5, time_window=10.0, key_field="path")
+    @protect_against_loops(max_calls=1, time_window=10.0, key_field="path")
     def run(self, path: str, content: str, overwrite: bool = False) -> str:
         path = expand_path(path)
         disp_path = display_path(path)

janito/plugins/core_adapter.py

@@ -7,8 +7,7 @@ that use the function-based approach instead of class-based.
 
 from janito.plugin_system.base import Plugin, PluginMetadata
 from typing import List, Type
-from janito.tools.tool_base import ToolBase
-from janito.tools.function_adapter import create_function_tool
+from janito.tools.tool_base import ToolBase, ToolPermissions
 
 
 class CorePluginAdapter(Plugin):
@@ -36,6 +35,83 @@ class CorePluginAdapter(Plugin):
     def get_tools(self) -> List[Type[ToolBase]]:
         return self._tool_classes
 
+    def _create_tool_class(self, func):
+        """Create a ToolBase class from a function."""
+        resolved_tool_name = getattr(func, "tool_name", func.__name__)
+        
+        # Create a proper tool class with explicit parameters and documentation
+        import inspect
+        from typing import get_type_hints
+        
+        func_sig = inspect.signature(func)
+        type_hints = get_type_hints(func)
+        
+        # Build parameter definitions for the run method
+        param_defs = []
+        param_docs = []
+        for name, param in func_sig.parameters.items():
+            type_hint = type_hints.get(name, str)
+            if param.default == inspect.Parameter.empty:
+                param_defs.append(f"{name}: {type_hint.__name__}")
+            else:
+                param_defs.append(f"{name}: {type_hint.__name__} = {repr(param.default)}")
+            
+            # Add parameter documentation
+            param_docs.append(f"    {name}: {type_hint.__name__} - Parameter {name}")
+        
+        # Get function docstring or create one
+        func_doc = func.__doc__ or f"Execute {resolved_tool_name} tool"
+        
+        # Create the tool class with proper signature and documentation
+        exec_globals = {
+            'ToolBase': ToolBase,
+            'ToolPermissions': ToolPermissions,
+            'func': func,
+            'inspect': inspect,
+            'str': str,
+            'List': list,
+            'Dict': dict,
+            'Optional': type(None),
+        }
+        
+        param_docs_str = '\n'.join(param_docs)
+        
+        class_def = f'''
+class DynamicTool(ToolBase):
+    """
+    {func_doc}
+    
+    Parameters:
+{param_docs_str}
+    
+    Returns:
+        str: Execution result
+    """
+    tool_name = "{resolved_tool_name}"
+    permissions = ToolPermissions(read=True, write=True, execute=True)
+    
+    def __init__(self):
+        super().__init__()
+    
+    def run(self, {', '.join(param_defs)}) -> str:
+        kwargs = locals()
+        sig = inspect.signature(func)
+        
+        # Filter kwargs to only include parameters the function accepts
+        filtered_kwargs = {{}}
+        for name, param in sig.parameters.items():
+            if name in kwargs and kwargs[name] is not None:
+                filtered_kwargs[name] = kwargs[name]
+        
+        result = func(**filtered_kwargs)
+        return str(result) if result is not None else ""
+'''
+        
+        exec(class_def, exec_globals)
+        return exec_globals['DynamicTool']
+        
+        return DynamicTool
+
     def initialize(self):
         """Initialize the plugin by creating tool classes."""
         # Get tools from the module
@@ -44,7 +120,7 @@ class CorePluginAdapter(Plugin):
         self._tool_classes = []
         for tool_func in tools:
             if callable(tool_func):
-                tool_class = create_function_tool(tool_func)
+                tool_class = self._create_tool_class(tool_func)
                 self._tool_classes.append(tool_class)
 
 

janito/plugins/discovery_core.py

@@ -17,11 +17,11 @@ from .core_adapter import CorePluginAdapter
 def _load_core_plugin(package_path: Path, plugin_name: str) -> Optional[Plugin]:
     """
     Load a core plugin from a package directory.
-    
+
     Args:
         package_path: Path to the __init__.py file
         plugin_name: Full plugin name (e.g., core.filemanager)
-        
+
     Returns:
         Plugin instance if loaded successfully
     """
@@ -30,20 +30,25 @@ def _load_core_plugin(package_path: Path, plugin_name: str) -> Optional[Plugin]:
         spec = importlib.util.spec_from_file_location(plugin_name, package_path)
         if spec is None or spec.loader is None:
             return None
-            
+
         module = importlib.util.module_from_spec(spec)
         spec.loader.exec_module(module)
-        
+
         # Get plugin metadata
         plugin_name_attr = getattr(module, "__plugin_name__", plugin_name)
-        description = getattr(module, "__plugin_description__", f"Core plugin: {plugin_name}")
-        
+        description = getattr(
+            module, "__plugin_description__", f"Core plugin: {plugin_name}"
+        )
+
         # Create and return the core plugin adapter
         plugin = CorePluginAdapter(plugin_name_attr, description, module)
         plugin.initialize()  # Initialize to set up tools
         return plugin
-        
+
     except Exception as e:
         import logging
-        logging.getLogger(__name__).error(f"Failed to load core plugin {plugin_name}: {e}")
-        return None
+
+        logging.getLogger(__name__).error(
+            f"Failed to load core plugin {plugin_name}: {e}"
+        )
+        return None

janito/plugins/tools/core_tools_plugin.py

@@ -6,16 +6,6 @@ from functools import wraps
 from typing import Type
 from janito.plugin_system.base import Plugin, PluginMetadata
 
-# Registry for core tools
-_core_tools_registry = []
-
-
-def register_core_tool(cls: Type):
-    """Decorator to register a core tool."""
-    _core_tools_registry.append(cls)
-    return cls
-
-
 from .ask_user import AskUser
 from .copy_file import CopyFile
 from .create_directory import CreateDirectory
@@ -44,6 +34,15 @@ from .get_file_outline.core import GetFileOutline
 from .search_text.core import SearchText
 from .decorators import get_core_tools
 
+# Registry for core tools
+_core_tools_registry = []
+
+
+def register_core_tool(cls: Type):
+    """Decorator to register a core tool."""
+    _core_tools_registry.append(cls)
+    return cls
+
 
 class CoreToolsPlugin(Plugin):
     """Core tools plugin providing essential janito functionality."""

janito/plugins/tools/create_file.py

@@ -55,7 +55,7 @@ class CreateFile(ToolBase):
         or file exists (when overwrite=False).
 
     Security Features:
-        - Loop protection: Maximum 5 calls per 10 seconds for the same file path
+        - Loop protection: Prevents repeated create calls for the same file path within a short window (1 allowed per 10 seconds)
         - Path traversal prevention: Validates and sanitizes file paths
         - Permission checking: Respects file system permissions
         - Atomic writes: Prevents partial file creation on errors
@@ -84,7 +84,7 @@ class CreateFile(ToolBase):
     permissions = ToolPermissions(write=True)
     tool_name = "create_file"
 
-    @protect_against_loops(max_calls=5, time_window=10.0, key_field="path")
+    @protect_against_loops(max_calls=1, time_window=10.0, key_field="path")
     def run(self, path: str, content: str, overwrite: bool = False) -> str:
         path = expand_path(path)
         disp_path = display_path(path)

janito/providers/__init__.py

@@ -10,3 +10,4 @@ import janito.providers.zai.provider
 import janito.providers.cerebras.provider
 import janito.providers.mistral.provider
 import janito.providers.ibm.provider
+import janito.providers.together.provider

janito/providers/together/__init__.py

@@ -0,0 +1 @@
+# Together AI provider for Janito

janito/providers/together/model_info.py

@@ -0,0 +1,69 @@
+"""
+Model specifications for Together AI provider.
+"""
+
+MODEL_SPECS = {
+    "allenai/OLMo-2-0325-32B-Instruct": {
+        "max_tokens": 32768,
+        "max_input_tokens": 32768,
+        "max_output_tokens": 32768,
+        "description": "OLMo 2 32B Instruct - Fully open language model from AllenAI",
+        "supports_tools": True,
+        "supports_system_prompt": True,
+        "supports_streaming": True,
+    },
+    "allenai/OLMo-2-1124-7B-Instruct": {
+        "max_tokens": 32768,
+        "max_input_tokens": 32768,
+        "max_output_tokens": 32768,
+        "description": "OLMo 2 7B Instruct - Fully open language model from AllenAI",
+        "supports_tools": True,
+        "supports_system_prompt": True,
+        "supports_streaming": True,
+    },
+    "allenai/OLMo-2-0425-1B": {
+        "max_tokens": 32768,
+        "max_input_tokens": 32768,
+        "max_output_tokens": 32768,
+        "description": "OLMo 2 1B - Fully open language model from AllenAI",
+        "supports_tools": True,
+        "supports_system_prompt": True,
+        "supports_streaming": True,
+    },
+    "meta-llama/Meta-Llama-3.1-8B-Instruct-Turbo": {
+        "max_tokens": 8192,
+        "max_input_tokens": 128000,
+        "max_output_tokens": 8192,
+        "description": "Llama 3.1 8B Instruct Turbo",
+        "supports_tools": True,
+        "supports_system_prompt": True,
+        "supports_streaming": True,
+    },
+    "meta-llama/Meta-Llama-3.1-70B-Instruct-Turbo": {
+        "max_tokens": 8192,
+        "max_input_tokens": 128000,
+        "max_output_tokens": 8192,
+        "description": "Llama 3.1 70B Instruct Turbo",
+        "supports_tools": True,
+        "supports_system_prompt": True,
+        "supports_streaming": True,
+    },
+    "mistralai/Mixtral-8x7B-Instruct-v0.1": {
+        "max_tokens": 32768,
+        "max_input_tokens": 32768,
+        "max_output_tokens": 32768,
+        "description": "Mixtral 8x7B Instruct",
+        "supports_tools": True,
+        "supports_system_prompt": True,
+        "supports_streaming": True,
+    },
+    "deepseek-ai/deepseek-llm-67b-chat": {
+        "max_tokens": 4096,
+        "max_input_tokens": 4096,
+        "max_output_tokens": 4096,
+        "description": "DeepSeek LLM 67B Chat",
+        "supports_tools": True,
+        "supports_system_prompt": True,
+        "supports_streaming": True,
+    },
+}

janito/providers/together/provider.py

@@ -0,0 +1,108 @@
+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 TogetherProvider(LLMProvider):
+    name = 'together'
+    NAME = 'together'
+    MAINTAINER = 'Janito Team'
+    MODEL_SPECS = MODEL_SPECS
+    DEFAULT_MODEL = 'allenai/OLMo-2-0325-32B-Instruct'
+
+    def __init__(
+        self, auth_manager: LLMAuthManager = None, config: LLMDriverConfig = None
+    ):
+        self._tools_adapter = get_local_tools_adapter()
+        self._driver = None
+
+        if not self.available:
+            return
+
+        self._initialize_config(auth_manager, config)
+        self._setup_model_config()
+
+    def _initialize_config(self, auth_manager, config):
+        self.auth_manager = auth_manager or LLMAuthManager()
+        self._api_key = self.auth_manager.get_credentials(type(self).NAME)
+        if not self._api_key:
+            from janito.llm.auth_utils import handle_missing_api_key
+            handle_missing_api_key(self.name, 'TOGETHER_API_KEY')
+
+        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
+
+        self._driver_config.base_url = 'https://api.together.xyz/v1'
+
+    def _setup_model_config(self):
+        model_name = self._driver_config.model
+        model_spec = self.MODEL_SPECS.get(model_name)
+
+        if hasattr(self._driver_config, 'max_tokens'):
+            self._driver_config.max_tokens = None
+        if hasattr(self._driver_config, 'max_completion_tokens'):
+            self._driver_config.max_completion_tokens = None
+
+        if model_spec:
+            max_tokens = getattr(model_spec, 'max_tokens', None)
+            if max_tokens and max_tokens != 'N/A':
+                self._driver_config.max_tokens = int(max_tokens)
+
+        self.fill_missing_device_info(self._driver_config)
+
+    @property
+    def driver(self) -> OpenAIModelDriver:
+        if not self.available:
+            raise ImportError(f'TogetherProvider 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):
+        driver = OpenAIModelDriver(
+            tools_adapter=self._tools_adapter, provider_name=self.NAME
+        )
+        driver.config = self._driver_config
+        return driver
+
+    def create_agent(self, tools_adapter=None, agent_name: str = None, **kwargs):
+        from janito.llm.agent import LLMAgent
+        if tools_adapter is None:
+            tools_adapter = get_local_tools_adapter()
+        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):
+        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(TogetherProvider.NAME, TogetherProvider)
+