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

janito/plugins/core_adapter.py

@@ -1,131 +0,0 @@
-"""
-Core plugin adapter for legacy plugin system.
-
-This module provides proper Plugin class implementations for core plugins
-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, ToolPermissions
-
-
-class CorePluginAdapter(Plugin):
-    """Adapter for core plugins using function-based tools."""
-
-    def __init__(self, plugin_name: str, description: str, tools_module):
-        super().__init__()
-        self._plugin_name = plugin_name
-        self._description = description
-        self._tools_module = tools_module
-        self._tool_classes = []
-
-        # Set the metadata attribute that Plugin expects
-        self.metadata = self.get_metadata()
-
-    def get_metadata(self) -> PluginMetadata:
-        return PluginMetadata(
-            name=self._plugin_name,
-            version="1.0.0",
-            description=self._description,
-            author="Janito",
-            license="MIT",
-        )
-
-    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
-        tools = getattr(self._tools_module, "__plugin_tools__", [])
-
-        self._tool_classes = []
-        for tool_func in tools:
-            if callable(tool_func):
-                tool_class = self._create_tool_class(tool_func)
-                self._tool_classes.append(tool_class)
-
-
-def create_core_plugin(
-    plugin_name: str, description: str, tools_module
-) -> CorePluginAdapter:
-    """Create a core plugin adapter."""
-    return CorePluginAdapter(plugin_name, description, tools_module)

janito/providers/together/__init__.py

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

janito/providers/together/model_info.py

@@ -1,69 +0,0 @@
-"""
-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

@@ -1,108 +0,0 @@
-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)
-