janito 3.4.0__py3-none-any.whl → 3.5.1__py3-none-any.whl

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)
+

janito/tools/__init__.py

@@ -1,6 +1,6 @@
-from janito.tools.adapters.local import (
-    local_tools_adapter as _internal_local_tools_adapter,
-    LocalToolsAdapter,
+from janito.tools.adapters.local import LocalToolsAdapter
+from janito.tools.adapters.local.adapter import (
+    LocalToolsAdapter as _internal_local_tools_adapter,
 )
 
 
@@ -11,8 +11,10 @@ def get_local_tools_adapter(workdir=None, allowed_permissions=None):
     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
+    # Create and initialize adapter
+    from janito.tools.initialize import initialize_tools
+
+    registry = initialize_tools(LocalToolsAdapter(workdir=workdir))
     # Change workdir if requested
     if workdir is not None:
         try:
@@ -27,10 +29,32 @@ def get_local_tools_adapter(workdir=None, allowed_permissions=None):
     return registry
 
 
-local_tools_adapter = _internal_local_tools_adapter
+# Initialize the global adapter - defer import to avoid circular dependencies
+local_tools_adapter = None
+
+
+def get_local_tools_adapter(workdir=None, allowed_permissions=None):
+    """Get the global tools adapter, initializing on first use."""
+    global local_tools_adapter
+    if local_tools_adapter is None:
+        from janito.tools.initialize import initialize_tools
+
+        adapter = LocalToolsAdapter(workdir=workdir)
+        local_tools_adapter = initialize_tools(adapter)
+
+    # Handle workdir if provided
+    if workdir is not None and local_tools_adapter is not None:
+        import os
+
+        if not os.path.exists(workdir):
+            os.makedirs(workdir, exist_ok=True)
+        os.chdir(workdir)
+        local_tools_adapter.workdir = workdir
+
+    return local_tools_adapter
+
 
 __all__ = [
     "LocalToolsAdapter",
     "get_local_tools_adapter",
-    "local_tools_adapter",
 ]

janito/tools/adapters/__init__.py

@@ -1 +1,6 @@
-# Tools providers package: for plug-and-play tool collections, integrations, and adapters.
+"""
+Tools providers package: for plug-and-play tool collections, integrations, and adapters.
+
+This package contains the core adapter infrastructure for managing tools,
+while the actual tool implementations have been moved to the plugins system.
+"""

janito/tools/adapters/local/__init__.py

@@ -1,73 +1,10 @@
-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 .read_files import ReadFilesTool
-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
-from .read_chart import ReadChartTool
-from .show_image import ShowImageTool
-from .show_image_grid import ShowImageGridTool
-
-from janito.tools.tool_base import ToolPermissions
-import os
-from janito.tools.permissions import get_global_allowed_permissions
-
-# Singleton tools adapter with all standard tools registered
-local_tools_adapter = LocalToolsAdapter(workdir=os.getcwd())
+"""
+Local tools adapter for janito.
 
+This package provides the LocalToolsAdapter class which manages tool registration
+and execution for local, in-process tools.
+"""
 
-def get_local_tools_adapter(workdir=None):
-    return LocalToolsAdapter(workdir=workdir or os.getcwd())
-
-
-# Register tools
-for tool_class in [
-    AskUserTool,
-    CopyFileTool,
-    CreateDirectoryTool,
-    CreateFileTool,
-    FetchUrlTool,
-    FindFilesTool,
-    ViewFileTool,
-    ReadFilesTool,
-    MoveFileTool,
-    OpenUrlTool,
-    OpenHtmlInBrowserTool,
-    PythonCodeRunTool,
-    PythonCommandRunTool,
-    PythonFileRunTool,
-    RemoveDirectoryTool,
-    RemoveFileTool,
-    ReplaceTextInFileTool,
-    RunBashCommandTool,
-    RunPowershellCommandTool,
-    GetFileOutlineTool,
-    SearchOutlineTool,
-    SearchTextTool,
-    ValidateFileSyntaxTool,
-    ReadChartTool,
-    ShowImageTool,
-    ShowImageGridTool,
-]:
-    local_tools_adapter.register_tool(tool_class)
+from .adapter import LocalToolsAdapter
 
-# DEBUG: Print registered tools at startup
+__all__ = ["LocalToolsAdapter"]

janito/tools/cli_initializer.py

@@ -0,0 +1,88 @@
+"""
+CLI-specific tool initialization for janito.
+
+This module provides functions to initialize tools specifically for CLI usage,
+handling circular imports and ensuring proper registration.
+"""
+
+import sys
+from pathlib import Path
+from typing import List, Optional
+
+# Ensure current directory is in path
+sys.path.insert(0, str(Path.cwd()))
+
+
+def initialize_cli_tools():
+    """Initialize tools for CLI usage, avoiding circular imports."""
+    try:
+        from janito.tools.adapters.local.adapter import LocalToolsAdapter
+        from janito.plugin_system.core_loader_fixed import load_core_plugin
+        from janito.tools.permissions import set_global_allowed_permissions
+        from janito.tools.tool_base import ToolPermissions
+
+        # Create adapter
+        adapter = LocalToolsAdapter()
+
+        # Set permissions for CLI
+        set_global_allowed_permissions(
+            ToolPermissions(read=True, write=True, execute=True)
+        )
+
+        # Core plugins to load
+        core_plugins = [
+            "core.filemanager",
+            "core.codeanalyzer",
+            "core.system",
+            "core.imagedisplay",
+            "dev.pythondev",
+            "dev.visualization",
+        ]
+
+        loaded_count = 0
+        for plugin_name in core_plugins:
+            plugin = load_core_plugin(plugin_name)
+            if plugin:
+                tools = plugin.get_tools()
+                for tool_class in tools:
+                    try:
+                        adapter.register_tool(tool_class)
+                        loaded_count += 1
+                    except ValueError:
+                        # Tool already registered, skip
+                        pass
+
+        return adapter, loaded_count
+
+    except Exception as e:
+        print(f"Error initializing CLI tools: {e}", file=sys.stderr)
+        return None, 0
+
+
+def get_cli_tools_adapter():
+    """Get a CLI-initialized tools adapter."""
+    adapter, count = initialize_cli_tools()
+    if adapter and count > 0:
+        return adapter
+    return None
+
+
+def list_cli_tools():
+    """List all available CLI tools."""
+    adapter = get_cli_tools_adapter()
+    if not adapter:
+        return []
+
+    return adapter.list_tools()
+
+
+if __name__ == "__main__":
+    adapter, count = initialize_cli_tools()
+    if adapter:
+        tools = adapter.list_tools()
+        print(f"CLI initialized {count} tools")
+        print(f"Available tools: {len(tools)}")
+        for tool in sorted(tools):
+            print(f"  - {tool}")
+    else:
+        print("Failed to initialize CLI tools")

janito/tools/initialize.py

@@ -0,0 +1,70 @@
+"""
+Initialize janito tools for CLI and programmatic usage.
+
+This module provides functions to load core plugins and register their tools
+with the local tools adapter.
+"""
+
+import sys
+from pathlib import Path
+from typing import List, Optional
+
+from janito.plugin_system.core_loader_fixed import load_core_plugin
+from janito.tools.adapters.local.adapter import LocalToolsAdapter
+
+
+def initialize_tools(adapter: Optional[LocalToolsAdapter] = None) -> LocalToolsAdapter:
+    """
+    Initialize all janito tools by loading core plugins and registering tools.
+
+    Args:
+        adapter: LocalToolsAdapter instance to register tools with.
+                If None, creates a new instance.
+
+    Returns:
+        LocalToolsAdapter with all tools registered.
+    """
+    if adapter is None:
+        adapter = LocalToolsAdapter()
+
+    # Core plugins to load
+    core_plugins = [
+        "core.filemanager",
+        "core.codeanalyzer",
+        "core.system",
+        "core.imagedisplay",
+        "dev.pythondev",
+        "dev.visualization",
+    ]
+
+    loaded_count = 0
+    for plugin_name in core_plugins:
+        plugin = load_core_plugin(plugin_name)
+        if plugin:
+            tools = plugin.get_tools()
+            for tool_class in tools:
+                adapter.register_tool(tool_class)
+                loaded_count += 1
+
+    return adapter
+
+
+def get_initialized_adapter() -> LocalToolsAdapter:
+    """Get a pre-initialized LocalToolsAdapter with all tools registered."""
+    return initialize_tools()
+
+
+def list_available_tools() -> List[str]:
+    """Get a list of all available tool names."""
+    adapter = get_initialized_adapter()
+    return sorted(list(adapter._tools.keys()))
+
+
+if __name__ == "__main__":
+    adapter = initialize_tools()
+    tools = sorted(list(adapter._tools.keys()))
+
+    print(f"Initialized {len(tools)} tools")
+    print("Available tools:")
+    for tool_name in tools:
+        print(f"  - {tool_name}")