hanzo-mcp 0.3.8__py3-none-any.whl → 0.5.0__py3-none-any.whl

hanzo_mcp/tools/agent/lmstudio_provider.py

@@ -1,219 +0,0 @@
-"""LM Studio provider for agent delegation.
-
-Enables the use of local LLMs via LM Studio's Python SDK.
-"""
-
-import logging
-import asyncio
-import functools
-from typing import Any, Dict, List, Optional, Tuple
-
-from hanzo_mcp.tools.agent.base_provider import BaseModelProvider
-
-logger = logging.getLogger(__name__)
-
-
-class LMStudioProvider(BaseModelProvider):
-    """Provider for local models via LM Studio Python SDK."""
-
-    def __init__(self):
-        """Initialize the LM Studio provider."""
-        self.models = {}
-        self.initialized = False
-        
-    async def initialize(self) -> None:
-        """Initialize the LM Studio provider.
-        
-        Import is done here to avoid dependency issues if LM Studio SDK is not installed.
-        """
-        if self.initialized:
-            return
-            
-        try:
-            # Dynamic import to avoid dependency issues if LM Studio is not installed
-            from importlib.util import find_spec
-            if find_spec("lmstudio") is None:
-                logger.warning("LM Studio Python SDK not installed. Install with 'pip install lmstudio'")
-                return
-                
-            # Import the LM Studio module
-            import lmstudio as lms
-            self.lms = lms
-            self.initialized = True
-            logger.info("LM Studio provider initialized successfully")
-        except ImportError as e:
-            logger.error(f"Failed to import LM Studio Python SDK: {str(e)}")
-            logger.error("Install LM Studio Python SDK with 'pip install lmstudio'")
-        except Exception as e:
-            logger.error(f"Failed to initialize LM Studio provider: {str(e)}")
-            
-    async def load_model(self, model_name: str, identifier: Optional[str] = None) -> str:
-        """Load a model from LM Studio.
-        
-        Args:
-            model_name: The name of the model to load
-            identifier: Optional identifier for the model instance
-            
-        Returns:
-            The identifier for the loaded model
-        """
-        if not self.initialized:
-            await self.initialize()
-            if not self.initialized:
-                raise RuntimeError("LM Studio provider failed to initialize")
-        
-        model_id = identifier or model_name
-        
-        try:
-            if model_id in self.models:
-                logger.info(f"Model {model_id} already loaded")
-                return model_id
-                
-            logger.info(f"Loading model {model_name}")
-            
-            # Use the thread pool to run the blocking operation
-            loop = asyncio.get_event_loop()
-            model = await loop.run_in_executor(
-                None, 
-                functools.partial(self.lms.llm, model_name)
-            )
-            
-            # Store the model with its identifier
-            self.models[model_id] = model
-            logger.info(f"Model {model_name} loaded successfully as {model_id}")
-            return model_id
-            
-        except Exception as e:
-            logger.error(f"Failed to load model {model_name}: {str(e)}")
-            raise RuntimeError(f"Failed to load model {model_name}: {str(e)}")
-    
-    async def generate(
-        self,
-        model_id: str,
-        prompt: str,
-        system_prompt: Optional[str] = None,
-        max_tokens: int = 4096,
-        temperature: float = 0.7,
-        top_p: float = 0.95,
-        stop_sequences: Optional[List[str]] = None,
-    ) -> Tuple[str, Dict[str, Any]]:
-        """Generate a response from the model.
-        
-        Args:
-            model_id: The identifier of the model to use
-            prompt: The prompt to send to the model
-            system_prompt: Optional system prompt to send to the model
-            max_tokens: Maximum number of tokens to generate
-            temperature: Sampling temperature
-            top_p: Top-p sampling parameter
-            stop_sequences: Optional list of strings that will stop generation
-            
-        Returns:
-            A tuple of (generated text, metadata)
-        """
-        if not self.initialized:
-            await self.initialize()
-            if not self.initialized:
-                raise RuntimeError("LM Studio provider failed to initialize")
-        
-        if model_id not in self.models:
-            raise ValueError(f"Model {model_id} not loaded")
-            
-        model = self.models[model_id]
-        
-        try:
-            logger.debug(f"Generating with model {model_id}")
-            
-            # Prepare generation parameters
-            params = {
-                "max_tokens": max_tokens,
-                "temperature": temperature,
-                "top_p": top_p
-            }
-            
-            if stop_sequences:
-                params["stop"] = stop_sequences
-                
-            # Generate response
-            loop = asyncio.get_event_loop()
-            
-            if system_prompt:
-                # For chat models with system prompt
-                response_future = loop.run_in_executor(
-                    None,
-                    functools.partial(
-                        model.chat,
-                        system=system_prompt, 
-                        message=prompt,
-                        **params
-                    )
-                )
-            else:
-                # For completion models without system prompt
-                response_future = loop.run_in_executor(
-                    None,
-                    functools.partial(
-                        model.respond,
-                        prompt,
-                        **params
-                    )
-                )
-                
-            response = await response_future
-            
-            # Extract the generated text
-            if isinstance(response, dict) and "text" in response:
-                generated_text = response["text"]
-            elif isinstance(response, str):
-                generated_text = response
-            else:
-                generated_text = str(response)
-                
-            # Metadata
-            metadata = {
-                "model": model_id,
-                "usage": {
-                    "prompt_tokens": -1,  # LM Studio Python SDK doesn't provide token counts
-                    "completion_tokens": -1,
-                    "total_tokens": -1
-                }
-            }
-            
-            logger.debug(f"Generated {len(generated_text)} chars with model {model_id}")
-            return generated_text, metadata
-        except Exception as e:
-            logger.error(f"Failed to generate with model {model_id}: {str(e)}")
-            raise RuntimeError(f"Failed to generate with model {model_id}: {str(e)}")
-            
-    async def unload_model(self, model_id: str) -> None:
-        """Unload a model from LM Studio.
-        
-        Args:
-            model_id: The identifier of the model to unload
-        """
-        if not self.initialized:
-            return
-            
-        if model_id not in self.models:
-            logger.warning(f"Model {model_id} not loaded")
-            return
-            
-        try:
-            # Just remove the model reference, Python garbage collection will handle it
-            del self.models[model_id]
-            logger.info(f"Model {model_id} unloaded")
-        except Exception as e:
-            logger.error(f"Failed to unload model {model_id}: {str(e)}")
-            
-    async def shutdown(self) -> None:
-        """Shutdown the LM Studio provider."""
-        if not self.initialized:
-            return
-            
-        try:
-            # Clear all model references
-            self.models = {}
-            self.initialized = False
-            logger.info("LM Studio provider shut down")
-        except Exception as e:
-            logger.error(f"Failed to shut down LM Studio provider: {str(e)}")

hanzo_mcp/tools/agent/provider_registry.py

@@ -1,120 +0,0 @@
-"""Provider registry for agent delegation.
-
-Manages different model providers for agent delegation.
-"""
-
-import logging
-from typing import Any, Dict, List, Optional, Tuple, Type
-
-from hanzo_mcp.tools.agent.base_provider import BaseModelProvider
-
-logger = logging.getLogger(__name__)
-
-
-class ProviderRegistry:
-    """Registry for model providers."""
-    
-    _instance = None
-    
-    def __new__(cls):
-        """Singleton pattern to ensure only one registry instance exists."""
-        if cls._instance is None:
-            cls._instance = super(ProviderRegistry, cls).__new__(cls)
-            cls._instance._initialized = False
-        return cls._instance
-        
-    def __init__(self):
-        """Initialize the provider registry."""
-        if self._initialized:
-            return
-            
-        self.providers = {}
-        self.provider_classes = {}
-        self._initialized = True
-        logger.info("Provider registry initialized")
-        
-    def register_provider_class(self, provider_type: str, provider_class: Type[BaseModelProvider]) -> None:
-        """Register a provider class with the registry.
-        
-        Args:
-            provider_type: The type identifier for the provider
-            provider_class: The provider class to register
-        """
-        self.provider_classes[provider_type] = provider_class
-        logger.info(f"Registered provider class: {provider_type}")
-        
-    async def get_provider(self, provider_type: str) -> BaseModelProvider:
-        """Get or create a provider instance for the given type.
-        
-        Args:
-            provider_type: The type identifier for the provider
-            
-        Returns:
-            A provider instance
-            
-        Raises:
-            ValueError: If the provider type is not registered
-        """
-        # Check if we already have an instance
-        if provider_type in self.providers:
-            return self.providers[provider_type]
-            
-        # Check if we have a class for this type
-        if provider_type not in self.provider_classes:
-            raise ValueError(f"Unknown provider type: {provider_type}")
-            
-        # Create a new instance
-        provider_class = self.provider_classes[provider_type]
-        provider = provider_class()
-        
-        # Initialize the provider
-        await provider.initialize()
-        
-        # Store and return the provider
-        self.providers[provider_type] = provider
-        logger.info(f"Created and initialized provider: {provider_type}")
-        return provider
-        
-    async def shutdown_all(self) -> None:
-        """Shutdown all providers."""
-        for provider_type, provider in self.providers.items():
-            try:
-                await provider.shutdown()
-                logger.info(f"Provider shut down: {provider_type}")
-            except Exception as e:
-                logger.error(f"Failed to shut down provider {provider_type}: {str(e)}")
-                
-        self.providers = {}
-        logger.info("All providers shut down")
-        
-    async def shutdown_provider(self, provider_type: str) -> None:
-        """Shutdown a specific provider.
-        
-        Args:
-            provider_type: The type identifier for the provider
-        """
-        if provider_type not in self.providers:
-            logger.warning(f"Provider not found: {provider_type}")
-            return
-            
-        try:
-            await self.providers[provider_type].shutdown()
-            del self.providers[provider_type]
-            logger.info(f"Provider shut down: {provider_type}")
-        except Exception as e:
-            logger.error(f"Failed to shut down provider {provider_type}: {str(e)}")
-
-
-# Create a singleton instance
-registry = ProviderRegistry()
-
-# Register LiteLLM provider
-from hanzo_mcp.tools.agent.litellm_provider import LiteLLMProvider
-registry.register_provider_class("litellm", LiteLLMProvider)
-
-# Try to register LM Studio provider if available
-try:
-    from hanzo_mcp.tools.agent.lmstudio_provider import LMStudioProvider
-    registry.register_provider_class("lmstudio", LMStudioProvider)
-except ImportError:
-    logger.warning("LM Studio provider not available. Install the package if needed.")

hanzo_mcp/tools/common/error_handling.py

@@ -1,86 +0,0 @@
-"""Error handling utilities for MCP tools.
-
-This module provides utility functions for better error handling in MCP tools.
-"""
-
-import logging
-import traceback
-from functools import wraps
-from typing import Any, Callable, TypeVar, Awaitable, cast
-
-from mcp.server.fastmcp import Context as MCPContext
-
-# Setup logger
-logger = logging.getLogger(__name__)
-
-# Type variables for generic function signatures
-T = TypeVar('T')
-F = TypeVar('F', bound=Callable[..., Awaitable[Any]])
-
-
-async def log_error(ctx: MCPContext, error: Exception, message: str) -> None:
-    """Log an error to both the logger and the MCP context.
-    
-    Args:
-        ctx: The MCP context
-        error: The exception that occurred
-        message: A descriptive message about the error
-    """
-    error_message = f"{message}: {str(error)}"
-    stack_trace = "".join(traceback.format_exception(type(error), error, error.__traceback__))
-    
-    # Log to system logger
-    logger.error(error_message)
-    logger.debug(stack_trace)
-    
-    # Log to MCP context if available
-    try:
-        await ctx.error(error_message)
-    except Exception as e:
-        logger.error(f"Failed to log error to MCP context: {str(e)}")
-
-
-def tool_error_handler(func: F) -> F:
-    """Decorator for handling errors in tool execution.
-    
-    This decorator wraps a tool function to catch and properly handle exceptions,
-    ensuring they are logged and proper error messages are returned.
-    
-    Args:
-        func: The async tool function to wrap
-        
-    Returns:
-        Wrapped function with error handling
-    """
-    @wraps(func)
-    async def wrapper(*args: Any, **kwargs: Any) -> Any:
-        try:
-            # Extract the MCP context from arguments
-            ctx = None
-            for arg in args:
-                if isinstance(arg, MCPContext):
-                    ctx = arg
-                    break
-            
-            if not ctx and 'ctx' in kwargs:
-                ctx = kwargs['ctx']
-                
-            if not ctx:
-                logger.warning("No MCP context found in tool arguments, error handling will be limited")
-            
-            # Call the original function
-            return await func(*args, **kwargs)
-        except Exception as e:
-            # Log the error
-            error_message = f"Error in tool execution: {func.__name__}"
-            if ctx:
-                await log_error(ctx, e, error_message)
-            else:
-                stack_trace = "".join(traceback.format_exception(type(e), e, e.__traceback__))
-                logger.error(f"{error_message}: {str(e)}")
-                logger.debug(stack_trace)
-            
-            # Return a friendly error message
-            return f"Error executing {func.__name__}: {str(e)}"
-    
-    return cast(F, wrapper)

hanzo_mcp/tools/common/logging_config.py

@@ -1,115 +0,0 @@
-"""Logging configuration for Hanzo MCP.
-
-This module sets up logging for the Hanzo MCP project.
-"""
-
-import logging
-import os
-import sys
-from datetime import datetime
-from pathlib import Path
-from typing import Optional
-
-
-def setup_logging(
-    log_level: str = "INFO", 
-    log_to_file: bool = True, 
-    log_to_console: bool = False,  # Changed default to False
-    transport: Optional[str] = None,
-    testing: bool = False
-) -> None:
-    """Set up logging configuration.
-    
-    Args:
-        log_level: The logging level ("DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL")
-        log_to_file: Whether to log to a file in addition to the console (default: True)
-        log_to_console: Whether to log to the console (default: False to avoid stdio transport conflicts)
-        transport: The transport mechanism being used ("stdio" or "sse")
-        testing: Set to True to disable file operations for testing
-    """
-    # Convert string log level to logging constant
-    numeric_level = getattr(logging, log_level.upper(), None)
-    if not isinstance(numeric_level, int):
-        raise ValueError(f"Invalid log level: {log_level}")
-    
-    # Create logs directory if needed
-    log_dir = Path.home() / ".hanzo" / "logs"
-    if log_to_file and not testing:
-        log_dir.mkdir(parents=True, exist_ok=True)
-    
-    # Generate log filename based on current date
-    current_time = datetime.now().strftime("%Y-%m-%d")
-    log_file = log_dir / f"hanzo-mcp-{current_time}.log"
-    
-    # Base configuration
-    handlers = []
-    
-    # Console handler - Always use stderr to avoid interfering with stdio transport
-    # Disable console logging when using stdio transport to avoid protocol corruption
-    if log_to_console and (transport != "stdio"):
-        console = logging.StreamHandler(sys.stderr)
-        console.setLevel(numeric_level)
-        console_formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
-        console.setFormatter(console_formatter)
-        handlers.append(console)
-    
-    # File handler (if enabled)
-    if log_to_file and not testing:
-        file_handler = logging.FileHandler(log_file)
-        file_handler.setLevel(numeric_level)
-        file_formatter = logging.Formatter(
-            '%(asctime)s - %(name)s - %(levelname)s - %(filename)s:%(lineno)d - %(message)s'
-        )
-        file_handler.setFormatter(file_formatter)
-        handlers.append(file_handler)
-    
-    # Configure root logger
-    logging.basicConfig(
-        level=numeric_level,
-        handlers=handlers,
-        force=True  # Overwrite any existing configuration
-    )
-    
-    # Set specific log levels for third-party libraries
-    logging.getLogger("urllib3").setLevel(logging.WARNING)
-    logging.getLogger("asyncio").setLevel(logging.WARNING)
-    
-    # Log startup message
-    root_logger = logging.getLogger()
-    root_logger.info(f"Logging initialized at level {log_level}")
-    if log_to_file and not testing:
-        root_logger.info(f"Log file: {log_file}")
-    if not log_to_console or transport == "stdio":
-        root_logger.info("Console logging disabled")
-
-
-def get_log_files() -> list[str]:
-    """Get a list of all log files.
-    
-    Returns:
-        List of log file paths
-    """
-    log_dir = Path.home() / ".hanzo" / "logs"
-    if not log_dir.exists():
-        return []
-    
-    log_files = [str(f) for f in log_dir.glob("hanzo-mcp-*.log")]
-    return sorted(log_files, reverse=True)
-
-
-def get_current_log_file() -> Optional[str]:
-    """Get the path to the current log file.
-    
-    Returns:
-        The path to the current log file, or None if no log file exists
-    """
-    log_dir = Path.home() / ".hanzo" / "logs"
-    if not log_dir.exists():
-        return None
-    
-    current_time = datetime.now().strftime("%Y-%m-%d")
-    log_file = log_dir / f"hanzo-mcp-{current_time}.log"
-    
-    if log_file.exists():
-        return str(log_file)
-    return None

hanzo_mcp/tools/common/session.py

@@ -1,91 +0,0 @@
-"""Session management for maintaining state across tool executions."""
-
-import os
-from pathlib import Path
-from typing import Dict, Optional, final
-
-
-@final
-class SessionManager:
-    """Manages session state across tool executions."""
-
-    _instances: Dict[str, "SessionManager"] = {}
-
-    @classmethod
-    def get_instance(cls, session_id: str) -> "SessionManager":
-        """Get or create a session manager instance for the given session ID.
-
-        Args:
-            session_id: The session ID
-
-        Returns:
-            The session manager instance
-        """
-        if session_id not in cls._instances:
-            cls._instances[session_id] = cls(session_id)
-        return cls._instances[session_id]
-
-    def __init__(self, session_id: str):
-        """Initialize the session manager.
-
-        Args:
-            session_id: The session ID
-        """
-        self.session_id = session_id
-        self._current_working_dir: Optional[Path] = None
-        self._initial_working_dir: Optional[Path] = None
-        self._environment_vars: Dict[str, str] = {}
-
-    @property
-    def current_working_dir(self) -> Path:
-        """Get the current working directory.
-
-        Returns:
-            The current working directory
-        """
-        if self._current_working_dir is None:
-            # Default to project directory if set, otherwise use current directory
-            self._current_working_dir = Path(os.getcwd())
-            self._initial_working_dir = self._current_working_dir
-        return self._current_working_dir
-
-    def set_working_dir(self, path: Path) -> None:
-        """Set the current working directory.
-
-        Args:
-            path: The path to set as the current working directory
-        """
-        self._current_working_dir = path
-
-    def reset_working_dir(self) -> None:
-        """Reset the working directory to the initial directory."""
-        if self._initial_working_dir is not None:
-            self._current_working_dir = self._initial_working_dir
-
-    def set_env_var(self, key: str, value: str) -> None:
-        """Set an environment variable.
-
-        Args:
-            key: The environment variable name
-            value: The environment variable value
-        """
-        self._environment_vars[key] = value
-
-    def get_env_var(self, key: str) -> Optional[str]:
-        """Get an environment variable.
-
-        Args:
-            key: The environment variable name
-
-        Returns:
-            The environment variable value, or None if not set
-        """
-        return self._environment_vars.get(key)
-
-    def get_env_vars(self) -> Dict[str, str]:
-        """Get all environment variables.
-
-        Returns:
-            A dictionary of environment variables
-        """
-        return self._environment_vars.copy()