hanzo-mcp 0.2.0__py3-none-any.whl → 0.3.1__py3-none-any.whl

hanzo_mcp/tools/agent/provider_registry.py

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

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

@@ -0,0 +1,84 @@
+"""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
+
+
+def setup_logging(log_level: str = "INFO", log_to_file: bool = True, 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
+        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
+    console = logging.StreamHandler(sys.stdout)
+    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}")
+
+
+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)

{hanzo_mcp-0.2.0.dist-info → hanzo_mcp-0.3.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hanzo-mcp
-Version: 0.2.0
+Version: 0.3.1
 Summary: MCP implementation of Hanzo capabilities
 Author-email: Hanzo Industries Inc <dev@hanzo.ai>
 License: MIT

{hanzo_mcp-0.2.0.dist-info → hanzo_mcp-0.3.1.dist-info}/RECORD

@@ -1,14 +1,21 @@
-hanzo_mcp/__init__.py,sha256=crlSOFdbUf7WY8A-esMOCLI-YKa7IwfxXTsOZvFswvg,89
-hanzo_mcp/cli.py,sha256=nfTY2lDvdxUR7KTk5j89CGpgLCj9YwAb2mqBzWlJBHI,8070
-hanzo_mcp/server.py,sha256=rZcu0JsOQlnnbBVV128qpXEl-ocWEVToBDeA8wmt068,5913
+hanzo_mcp/__init__.py,sha256=roRFuV1ugS6Zf28PtFGKzOnpJMDFncOz6fR3TlG-LF0,89
+hanzo_mcp/cli.py,sha256=ST428ys32fputErgrmLNJV9oYHbKGwkjrPBJfKh_K_Y,10820
+hanzo_mcp/server.py,sha256=bV4ywWOgm7BwZrbZwv1qoRKbAsMYT08aCGQwuFS8raM,6678
 hanzo_mcp/tools/__init__.py,sha256=9LbWAPfSntDwLaAex3dagsHO4BgZQHKj5E6UX-Gmyb4,3496
 hanzo_mcp/tools/agent/__init__.py,sha256=0eyQqqdAy7WCZEqUfV6xh66bDpQI9neB6iDjWf0_pJI,2189
 hanzo_mcp/tools/agent/agent_tool.py,sha256=qXu62ZRGM0o9mxOiRVFy-ABIZtEJ8z03DqAXshKAieI,19180
+hanzo_mcp/tools/agent/base_provider.py,sha256=dd1J75Q0wl_t_Gcuwc8Ft3PWxeDsmf0B3ybhRsUEgmA,2080
+hanzo_mcp/tools/agent/litellm_provider.py,sha256=6mVOLSNpfjAJKj6aBMflyYU6DRJpEqIxgu8wSzeRmxU,1334
+hanzo_mcp/tools/agent/lmstudio_agent.py,sha256=c4-VIDRXksv39HYpXzqwyF1PisoNd73R3Txa8Mkzibg,14510
+hanzo_mcp/tools/agent/lmstudio_provider.py,sha256=-gX8fxebyWaC7bqmZERR6QQc62Paj62IIDIu_rBu0wM,7876
 hanzo_mcp/tools/agent/prompt.py,sha256=jmYRI4Sm2D3LwEdC2qWakpqupgfGg8CT6grmx4NEDaA,4431
+hanzo_mcp/tools/agent/provider_registry.py,sha256=A-Wd5B5hLBznQV4wWbxE-yyvBPnbuUL2OtSJUz2K_H0,4236
 hanzo_mcp/tools/agent/tool_adapter.py,sha256=g9NKfIET0WOsm0r28xEXsibsprpI1C6ripcM6QwU-rI,2172
 hanzo_mcp/tools/common/__init__.py,sha256=felrGAEqLWOa8fuHjTCS7khqtlA-izz8k865ky7R-f8,797
 hanzo_mcp/tools/common/base.py,sha256=O7Lgft0XiC9Iyi3fYsmoWWrvKDK2Aa-FJLxPgnNJRJY,7341
 hanzo_mcp/tools/common/context.py,sha256=ReIfcm37j5qnLQ8G_-d88ad5uC1OKkjQZKG9HdJPybI,13145
+hanzo_mcp/tools/common/error_handling.py,sha256=rluaHpXV89pjcf8JxgYB6EdqVkcxihb3pyEO2gN-u7w,2789
+hanzo_mcp/tools/common/logging_config.py,sha256=b1swgWV3nuhpVT0TCcbxlOC0gmiRLmbey_t2LOWEMbU,2793
 hanzo_mcp/tools/common/permissions.py,sha256=4YCfA2PJUOl-z_47n5uaRXO8gAZ_shMaPhpi1dilgRE,7594
 hanzo_mcp/tools/common/session.py,sha256=csX5ZhgBjO2bdXXXPpsUPzOCc7Tib-apYe01AP8sh8k,2774
 hanzo_mcp/tools/common/think_tool.py,sha256=I-O6ipM-PUofkNoMMzv37Y_2Yfx9mh7F1upTTsfRN4M,4046
@@ -38,9 +45,9 @@ hanzo_mcp/tools/shell/command_executor.py,sha256=5GcJvg54uty9fl_tkGdWTBcHyjxuynQ
 hanzo_mcp/tools/shell/run_command.py,sha256=r7HBw0lqabgkGnVsDXmLnrTo0SU9g8gLvzpa-9n-cmM,6891
 hanzo_mcp/tools/shell/run_script.py,sha256=CLYnDc0Ze8plkXU6d98RgE4UrBg-fwaMVdcn9Fc6Ixw,7432
 hanzo_mcp/tools/shell/script_tool.py,sha256=s63tawIZBvwgm_kU9P7A3D4v2ulVw7j4l_rpsa_zGuc,8680
-hanzo_mcp-0.2.0.dist-info/licenses/LICENSE,sha256=mf1qZGFsPGskoPgytp9B-RsahfKvXsBpmaAbTLGTt8Y,1063
-hanzo_mcp-0.2.0.dist-info/METADATA,sha256=dAdJtsK8J9wl9dVksKcMPvaj7xcxtPjcyhbIekF_BX0,7550
-hanzo_mcp-0.2.0.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-hanzo_mcp-0.2.0.dist-info/entry_points.txt,sha256=aRKOKXtuQr-idSr-yH4efnRl2v8te94AcgN3ysqqSYs,49
-hanzo_mcp-0.2.0.dist-info/top_level.txt,sha256=eGFANatA0MHWiVlpS56fTYRIShtibrSom1uXI6XU0GU,10
-hanzo_mcp-0.2.0.dist-info/RECORD,,
+hanzo_mcp-0.3.1.dist-info/licenses/LICENSE,sha256=mf1qZGFsPGskoPgytp9B-RsahfKvXsBpmaAbTLGTt8Y,1063
+hanzo_mcp-0.3.1.dist-info/METADATA,sha256=ay2jJEkPi-ivKlvoCRyCNj57-M0tT36tL4w5nuK_SQ0,7550
+hanzo_mcp-0.3.1.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+hanzo_mcp-0.3.1.dist-info/entry_points.txt,sha256=aRKOKXtuQr-idSr-yH4efnRl2v8te94AcgN3ysqqSYs,49
+hanzo_mcp-0.3.1.dist-info/top_level.txt,sha256=eGFANatA0MHWiVlpS56fTYRIShtibrSom1uXI6XU0GU,10
+hanzo_mcp-0.3.1.dist-info/RECORD,,