hanzo-mcp 0.6.12__py3-none-any.whl → 0.6.13__py3-none-any.whl

hanzo_mcp/__init__.py

@@ -1,4 +1,4 @@
-"""Hanzo MCP - Implementation of Hanzo capabilities using MCP."""
+"""Hanzo AI - Implementation of Hanzo capabilities using MCP."""
 
 # Configure FastMCP logging globally for stdio transport
 import os
@@ -9,4 +9,4 @@ if os.environ.get("HANZO_MCP_TRANSPORT") == "stdio":
     except ImportError:
         pass
 
-__version__ = "0.6.12"
+__version__ = "0.6.13"

hanzo_mcp/cli.py

@@ -1,4 +1,4 @@
-"""Command-line interface for the Hanzo MCP server."""
+"""Command-line interface for the Hanzo AI server."""
 
 import argparse
 import json
@@ -13,7 +13,7 @@ from hanzo_mcp.server import HanzoMCPServer
 
 
 def main() -> None:
-    """Run the CLI for the Hanzo MCP server."""
+    """Run the CLI for the Hanzo AI server."""
     
     # Pre-parse arguments to check transport type early
     import sys

hanzo_mcp/cli_enhanced.py

@@ -1,4 +1,4 @@
-"""Enhanced command-line interface for the Hanzo MCP server with full tool configuration."""
+"""Enhanced command-line interface for the Hanzo AI server with full tool configuration."""
 
 import argparse
 import json
@@ -15,7 +15,7 @@ from hanzo_mcp.server import HanzoMCPServer
 def create_parser() -> argparse.ArgumentParser:
     """Create the argument parser with all tool configuration options."""
     parser = argparse.ArgumentParser(
-        description="Hanzo MCP server with comprehensive tool configuration",
+        description="Hanzo AI server with comprehensive tool configuration",
         formatter_class=argparse.RawDescriptionHelpFormatter,
         epilog="""
 Tool Configuration:
@@ -346,7 +346,7 @@ def apply_cli_overrides(args: argparse.Namespace) -> Dict[str, Any]:
 def list_tools(settings: HanzoMCPSettings) -> None:
     """List all tools and their current status."""
     logger = logging.getLogger(__name__)
-    logger.info("Hanzo MCP Tools Status:")
+    logger.info("Hanzo AI Tools Status:")
     logger.info("=" * 50)
     
     categories = {}
@@ -371,7 +371,7 @@ def list_tools(settings: HanzoMCPSettings) -> None:
 
 
 def main() -> None:
-    """Run the enhanced CLI for the Hanzo MCP server."""
+    """Run the enhanced CLI for the Hanzo AI server."""
     parser = create_parser()
     args = parser.parse_args()
 

hanzo_mcp/cli_plugin.py

@@ -0,0 +1,91 @@
+#!/usr/bin/env python3
+"""CLI for managing Hanzo MCP plugins."""
+
+import argparse
+import sys
+from pathlib import Path
+
+from hanzo_mcp.tools.common.plugin_loader import create_plugin_template, list_plugin_tools
+
+
+def main():
+    """Main CLI entry point."""
+    parser = argparse.ArgumentParser(
+        description="Hanzo MCP Plugin Manager",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  # Create a new plugin template
+  hanzo-plugin create mytool
+  
+  # List installed plugins
+  hanzo-plugin list
+  
+  # Create plugin in specific directory
+  hanzo-plugin create mytool --output /path/to/plugins
+"""
+    )
+    
+    subparsers = parser.add_subparsers(dest="command", help="Command to run")
+    
+    # Create command
+    create_parser = subparsers.add_parser("create", help="Create a new plugin template")
+    create_parser.add_argument("name", help="Name of the tool (e.g., 'mytool')")
+    create_parser.add_argument(
+        "--output", "-o",
+        type=Path,
+        default=Path.home() / ".hanzo" / "plugins",
+        help="Output directory for the plugin (default: ~/.hanzo/plugins)"
+    )
+    
+    # List command
+    list_parser = subparsers.add_parser("list", help="List installed plugins")
+    
+    args = parser.parse_args()
+    
+    if args.command == "create":
+        # Create plugin template
+        output_dir = args.output / args.name
+        try:
+            create_plugin_template(output_dir, args.name)
+            print(f"\n✅ Plugin template created successfully!")
+            print(f"\nTo use your plugin:")
+            print(f"1. Edit the tool implementation in {output_dir / f'{args.name}_tool.py'}")
+            print(f"2. Restart Hanzo MCP to load the plugin")
+            print(f"3. Add '{args.name}' to your mode's tool list")
+        except Exception as e:
+            print(f"❌ Error creating plugin: {e}", file=sys.stderr)
+            sys.exit(1)
+    
+    elif args.command == "list":
+        # List installed plugins
+        try:
+            from hanzo_mcp.tools.common.plugin_loader import load_user_plugins
+            plugins = load_user_plugins()
+            
+            if not plugins:
+                print("No plugins installed.")
+                print("\nPlugin directories:")
+                print("  ~/.hanzo/plugins/")
+                print("  ./.hanzo/plugins/")
+                print("  $HANZO_PLUGIN_PATH")
+            else:
+                print(f"Installed plugins ({len(plugins)}):")
+                for name, plugin in plugins.items():
+                    print(f"\n  {name}:")
+                    print(f"    Source: {plugin.source_path}")
+                    if plugin.metadata:
+                        print(f"    Version: {plugin.metadata.get('version', 'unknown')}")
+                        print(f"    Author: {plugin.metadata.get('author', 'unknown')}")
+                        print(f"    Description: {plugin.metadata.get('description', '')}")
+        except Exception as e:
+            print(f"❌ Error listing plugins: {e}", file=sys.stderr)
+            sys.exit(1)
+    
+    else:
+        parser.print_help()
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

hanzo_mcp/config/__init__.py

@@ -1,4 +1,4 @@
-"""Configuration management for Hanzo MCP.
+"""Configuration management for Hanzo AI.
 
 This module provides a comprehensive configuration system that supports:
 - CLI arguments for individual tool control

hanzo_mcp/config/settings.py

@@ -1,4 +1,4 @@
-"""Settings management for Hanzo MCP.
+"""Settings management for Hanzo AI.
 
 Handles loading and saving configuration from multiple sources:
 1. Default settings
@@ -59,6 +59,7 @@ class AgentConfig:
     enabled: bool = False
     model: Optional[str] = None
     api_key: Optional[str] = None
+    hanzo_api_key: Optional[str] = None  # HANZO_API_KEY support
     base_url: Optional[str] = None
     max_tokens: Optional[int] = None
     max_iterations: int = 10
@@ -78,7 +79,7 @@ class ServerConfig:
 
 @dataclass
 class HanzoMCPSettings:
-    """Complete configuration for Hanzo MCP."""
+    """Complete configuration for Hanzo AI."""
     # Server settings
     server: ServerConfig = field(default_factory=ServerConfig)
     
@@ -106,6 +107,9 @@ class HanzoMCPSettings:
     projects: Dict[str, ProjectConfig] = field(default_factory=dict)
     current_project: Optional[str] = None
     
+    # Mode configuration
+    active_mode: Optional[str] = None
+    
     def __post_init__(self):
         """Initialize default tool states if not specified."""
         if not self.enabled_tools:
@@ -250,7 +254,7 @@ class HanzoMCPSettings:
 
 
 def get_config_dir() -> Path:
-    """Get the configuration directory for Hanzo MCP."""
+    """Get the configuration directory for Hanzo AI."""
     if os.name == "nt":  # Windows
         config_dir = Path(os.environ.get("APPDATA", "")) / "hanzo"
     else:  # Unix/macOS
@@ -341,6 +345,59 @@ def detect_project_from_path(file_path: str) -> Optional[Dict[str, str]]:
     return None
 
 
+def _load_from_env() -> Dict[str, Any]:
+    """Load configuration from environment variables."""
+    config = {}
+    
+    # Check for agent API keys
+    has_api_keys = False
+    
+    # HANZO_API_KEY
+    if hanzo_key := os.environ.get("HANZO_API_KEY"):
+        config.setdefault("agent", {})["hanzo_api_key"] = hanzo_key
+        config["agent"]["enabled"] = True
+        has_api_keys = True
+    
+    # Check for other API keys
+    api_key_env_vars = [
+        ("OPENAI_API_KEY", "openai"),
+        ("ANTHROPIC_API_KEY", "anthropic"), 
+        ("GOOGLE_API_KEY", "google"),
+        ("GROQ_API_KEY", "groq"),
+        ("TOGETHER_API_KEY", "together"),
+        ("MISTRAL_API_KEY", "mistral"),
+        ("PERPLEXITY_API_KEY", "perplexity"),
+    ]
+    
+    for env_var, provider in api_key_env_vars:
+        if os.environ.get(env_var):
+            has_api_keys = True
+            break
+    
+    # Auto-enable agent and consensus tools if API keys present
+    if has_api_keys:
+        config.setdefault("enabled_tools", {})
+        config["enabled_tools"]["agent"] = True
+        config["enabled_tools"]["consensus"] = True
+        config.setdefault("agent", {})["enabled"] = True
+    
+    # Check for MODE/PERSONALITY/HANZO_MODE
+    if mode := os.environ.get("HANZO_MODE") or os.environ.get("PERSONALITY") or os.environ.get("MODE"):
+        config["active_mode"] = mode
+    
+    # Check for other environment overrides
+    if project_dir := os.environ.get("HANZO_PROJECT_DIR"):
+        config["project_dir"] = project_dir
+    
+    if log_level := os.environ.get("HANZO_LOG_LEVEL"):
+        config.setdefault("server", {})["log_level"] = log_level
+    
+    if allowed_paths := os.environ.get("HANZO_ALLOWED_PATHS"):
+        config["allowed_paths"] = allowed_paths.split(":")
+    
+    return config
+
+
 def load_settings(
     project_dir: Optional[str] = None,
     config_overrides: Optional[Dict[str, Any]] = None
@@ -349,9 +406,10 @@ def load_settings(
     
     Priority (highest to lowest):
     1. config_overrides (usually from CLI)
-    2. Project-specific config file
-    3. Global config file
-    4. Defaults
+    2. Environment variables
+    3. Project-specific config file
+    4. Global config file
+    5. Defaults
     """
     # Start with defaults
     settings = HanzoMCPSettings()
@@ -380,6 +438,11 @@ def load_settings(
             logger = logging.getLogger(__name__)
             logger.warning(f"Failed to load project config: {e}")
     
+    # Apply environment variables
+    env_config = _load_from_env()
+    if env_config:
+        settings = _merge_config(settings, env_config)
+    
     # Apply CLI overrides
     if config_overrides:
         settings = _merge_config(settings, config_overrides)

hanzo_mcp/config/tool_config.py

@@ -1,4 +1,4 @@
-"""Tool configuration definitions for Hanzo MCP."""
+"""Tool configuration definitions for Hanzo AI."""
 
 from enum import Enum
 from typing import Dict, List, Optional
@@ -6,7 +6,7 @@ from dataclasses import dataclass
 
 
 class ToolCategory(str, Enum):
-    """Categories of tools available in Hanzo MCP."""
+    """Categories of tools available in Hanzo AI."""
     FILESYSTEM = "filesystem"
     SHELL = "shell"
     JUPYTER = "jupyter"

hanzo_mcp/dev_server.py

@@ -1,4 +1,4 @@
-"""Development server with hot reload for Hanzo MCP."""
+"""Development server with hot reload for Hanzo AI."""
 
 import asyncio
 import logging
@@ -159,7 +159,7 @@ class DevServer:
         self.running = True
         
         logger = logging.getLogger(__name__)
-        logger.info(f"\n🚀 Starting Hanzo MCP in development mode...")
+        logger.info(f"\n🚀 Starting Hanzo AI in development mode...")
         logger.info(f"🔧 Hot reload enabled - watching for file changes")
         logger.info(f"📁 Project: {self.project_dir or 'current directory'}")
         logger.info(f"🌐 Transport: {transport}\n")
@@ -194,7 +194,7 @@ def run_dev_server():
     """Entry point for development server."""
     import argparse
     
-    parser = argparse.ArgumentParser(description="Run Hanzo MCP in development mode with hot reload")
+    parser = argparse.ArgumentParser(description="Run Hanzo AI in development mode with hot reload")
     parser.add_argument(
         "--name",
         type=str,

hanzo_mcp/prompts/project_system.py

@@ -30,7 +30,7 @@ Recent commits:
 </project_info>
 
 <available_tools>
-Hanzo MCP provides 65+ tools organized by category. Key tools include:
+Hanzo AI provides 65+ tools organized by category. Key tools include:
 
 # File Operations
 - read, write, edit, multi_edit: File manipulation

hanzo_mcp/server.py

@@ -16,6 +16,9 @@ except ImportError:
     # Fallback for older MCP versions
     from mcp.server import FastMCP
 
+# Import our enhanced server
+from hanzo_mcp.server_enhanced import EnhancedFastMCP
+
 from hanzo_mcp.prompts import register_all_prompts
 from hanzo_mcp.tools import register_all_tools
 
@@ -49,7 +52,7 @@ class HanzoMCPServer:
         enabled_tools: dict[str, bool] | None = None,
         disabled_tools: list[str] | None = None,
     ):
-        """Initialize the Hanzo MCP server.
+        """Initialize the Hanzo AI server.
 
         Args:
             name: The name of the server
@@ -72,7 +75,8 @@ class HanzoMCPServer:
             enabled_tools: Dictionary of individual tool enable states (default: None)
             disabled_tools: List of tool names to disable (default: None)
         """
-        self.mcp = mcp_instance if mcp_instance is not None else FastMCP(name)
+        # Use enhanced server for automatic context normalization
+        self.mcp = mcp_instance if mcp_instance is not None else EnhancedFastMCP(name)
 
         # Initialize permissions and command executor
         self.permission_manager = PermissionManager()

hanzo_mcp/server_enhanced.py

@@ -0,0 +1,69 @@
+"""Enhanced MCP server with automatic context normalization.
+
+This module provides an enhanced FastMCP server that automatically
+applies context normalization to all registered tools.
+"""
+
+from typing import Any, Callable
+from functools import wraps
+
+from mcp.server import FastMCP
+
+from hanzo_mcp.tools.common.decorators import with_context_normalization
+
+
+class EnhancedFastMCP(FastMCP):
+    """Enhanced FastMCP server with automatic context normalization.
+    
+    This server automatically wraps all tool registrations with context
+    normalization, ensuring that tools work properly when called externally
+    with serialized context parameters.
+    """
+    
+    def tool(
+        self,
+        name: str | None = None,
+        description: str | None = None
+    ) -> Callable:
+        """Enhanced tool decorator that includes automatic context normalization.
+        
+        Args:
+            name: Tool name (defaults to function name)
+            description: Tool description
+            
+        Returns:
+            Decorator function that registers the tool with context normalization
+        """
+        # Get the original decorator from parent class
+        original_decorator = super().tool(
+            name=name,
+            description=description
+        )
+        
+        # Create our enhanced decorator
+        def enhanced_decorator(func: Callable) -> Callable:
+            # Apply context normalization first
+            # Check if function has ctx parameter
+            import inspect
+            sig = inspect.signature(func)
+            if 'ctx' in sig.parameters:
+                normalized_func = with_context_normalization(func)
+            else:
+                normalized_func = func
+            
+            # Then apply the original decorator
+            return original_decorator(normalized_func)
+        
+        return enhanced_decorator
+
+
+def create_enhanced_server(name: str = "hanzo") -> EnhancedFastMCP:
+    """Create an enhanced MCP server with automatic context normalization.
+    
+    Args:
+        name: Server name
+        
+    Returns:
+        Enhanced FastMCP server instance
+    """
+    return EnhancedFastMCP(name)

hanzo_mcp/tools/__init__.py

@@ -1,7 +1,7 @@
-"""Tools package for Hanzo MCP.
+"""Tools package for Hanzo AI.
 
-This package contains all the tools for the Hanzo MCP server.
-It provides a unified interface for registering all tools with an MCP server.
+This package contains all the tools for the Hanzo AI server.
+It provides a interface for registering all tools with an MCP server.
 
 This includes a "think" tool implementation based on Anthropic's research showing
 improved performance for complex tool-based interactions when Claude has a dedicated
@@ -12,7 +12,7 @@ to delegate tasks to sub-agents for concurrent execution and specialized process
 from mcp.server import FastMCP
 
 from hanzo_mcp.tools.agent import register_agent_tools
-from hanzo_mcp.tools.common import register_batch_tool, register_thinking_tool
+from hanzo_mcp.tools.common import register_batch_tool, register_thinking_tool, register_critic_tool
 from hanzo_mcp.tools.common.base import BaseTool
 from hanzo_mcp.tools.common.permissions import PermissionManager
 from hanzo_mcp.tools.common.tool_enable import ToolEnableTool
@@ -25,11 +25,13 @@ from hanzo_mcp.tools.shell import register_shell_tools
 from hanzo_mcp.tools.todo import register_todo_tools
 from hanzo_mcp.tools.vector import register_vector_tools
 from hanzo_mcp.tools.database import register_database_tools, DatabaseManager
-from hanzo_mcp.tools.mcp import UnifiedMCPTool, McpAddTool, McpRemoveTool, McpStatsTool
+from hanzo_mcp.tools.mcp import MCPTool, McpAddTool, McpRemoveTool, McpStatsTool
 from hanzo_mcp.tools.editor import NeovimEditTool, NeovimCommandTool, NeovimSessionTool
-from hanzo_mcp.tools.llm import UnifiedLLMTool, LLMTool, ConsensusTool, LLMManageTool, create_provider_tools
-from hanzo_mcp.tools.config.palette_tool import palette_tool
-from hanzo_mcp.tools.common.palette_loader import PaletteLoader
+from hanzo_mcp.tools.llm import LLMTool, LLMTool, ConsensusTool, LLMManageTool, create_provider_tools
+from hanzo_mcp.tools.config.mode_tool import mode_tool
+from hanzo_mcp.tools.common.mode_loader import ModeLoader
+from hanzo_mcp.tools.common.mode import activate_mode_from_env
+from hanzo_mcp.tools.common.plugin_loader import load_user_plugins
 
 
 def register_all_tools(
@@ -46,8 +48,8 @@ def register_all_tools(
     disable_search_tools: bool = False,
     enabled_tools: dict[str, bool] | None = None,
     vector_config: dict | None = None,
-    use_palette: bool = True,
-    force_palette: str | None = None,
+    use_mode: bool = True,
+    force_mode: str | None = None,
 ) -> None:
     """Register all Hanzo tools with the MCP server.
 
@@ -65,20 +67,36 @@ def register_all_tools(
         disable_search_tools: Whether to disable search tools (default: False)
         enabled_tools: Dictionary of individual tool enable/disable states (default: None)
         vector_config: Vector store configuration (default: None)
-        use_palette: Whether to use palette system for tool configuration (default: True)
-        force_palette: Force a specific palette to be active (default: None)
+        use_mode: Whether to use mode system for tool configuration (default: True)
+        force_mode: Force a specific mode to be active (default: None)
     """
     # Dictionary to store all registered tools
     all_tools: dict[str, BaseTool] = {}
     
-    # Apply palette configuration if enabled
-    if use_palette:
-        tool_config = PaletteLoader.get_enabled_tools_from_palette(
+    # Load user plugins early
+    try:
+        plugins = load_user_plugins()
+        import logging
+        logger = logging.getLogger(__name__)
+        if plugins:
+            logger.info(f"Loaded {len(plugins)} user plugin tools: {', '.join(plugins.keys())}")
+    except Exception as e:
+        import logging
+        logger = logging.getLogger(__name__)
+        logger.warning(f"Failed to load user plugins: {e}")
+        plugins = {}
+    
+    # Apply mode configuration if enabled
+    if use_mode:
+        # First check for mode activation from environment
+        activate_mode_from_env()
+        
+        tool_config = ModeLoader.get_enabled_tools_from_mode(
             base_enabled_tools=enabled_tools,
-            force_palette=force_palette
+            force_mode=force_mode
         )
-        # Apply palette environment variables
-        PaletteLoader.apply_palette_environment()
+        # Apply mode environment variables
+        ModeLoader.apply_environment_from_mode()
     else:
         # Use individual tool configuration if provided, otherwise fall back to category-level flags
         tool_config = enabled_tools or {}
@@ -97,15 +115,16 @@ def register_all_tools(
         "multi_edit": is_tool_enabled("multi_edit", not disable_write_tools),
         "directory_tree": is_tool_enabled("directory_tree", True),
         "grep": is_tool_enabled("grep", not disable_search_tools),
-        "grep_ast": is_tool_enabled("grep_ast", not disable_search_tools),
+        "symbols": is_tool_enabled("symbols", not disable_search_tools),
         "git_search": is_tool_enabled("git_search", not disable_search_tools),
         "content_replace": is_tool_enabled("content_replace", not disable_write_tools),
         "batch_search": is_tool_enabled("batch_search", not disable_search_tools),
         "find_files": is_tool_enabled("find_files", True),
-        "unified_search": is_tool_enabled("unified_search", not disable_search_tools),
+        "rules": is_tool_enabled("rules", True),
+        "search": is_tool_enabled("search", not disable_search_tools),
     }
     
-    # Vector tools setup (needed for unified search)
+    # Vector tools setup (needed for search)
     project_manager = None
     vector_enabled = {
         "vector_index": is_tool_enabled("vector_index", False),
@@ -113,7 +132,7 @@ def register_all_tools(
     }
     
     # Create project manager if vector tools, batch_search, or unified_search are enabled
-    if any(vector_enabled.values()) or filesystem_enabled.get("batch_search", False) or filesystem_enabled.get("unified_search", False):
+    if any(vector_enabled.values()) or filesystem_enabled.get("batch_search", False) or filesystem_enabled.get("search", False):
         if vector_config:
             from hanzo_mcp.tools.vector.project_manager import ProjectVectorManager
             search_paths = [str(path) for path in permission_manager.allowed_paths]
@@ -155,7 +174,7 @@ def register_all_tools(
             all_tools[tool.name] = tool
 
     # Register agent tools if enabled
-    agent_enabled = enable_agent_tool or is_tool_enabled("dispatch_agent", False)
+    agent_enabled = enable_agent_tool or is_tool_enabled("agent", False) or is_tool_enabled("dispatch_agent", False)
     if agent_enabled:
         agent_tools = register_agent_tools(
             mcp_server,
@@ -172,12 +191,15 @@ def register_all_tools(
 
     # Register todo tools if enabled
     todo_enabled = {
+        "todo": is_tool_enabled("todo", True),
+        # Backward compatibility - if old names are used, enable the unified tool
         "todo_read": is_tool_enabled("todo_read", True),
         "todo_write": is_tool_enabled("todo_write", True),
     }
     
+    # Enable unified todo if any of the todo tools are enabled
     if any(todo_enabled.values()):
-        todo_tools = register_todo_tools(mcp_server, enabled_tools=todo_enabled)
+        todo_tools = register_todo_tools(mcp_server, enabled_tools={"todo": True})
         for tool in todo_tools:
             all_tools[tool.name] = tool
 
@@ -186,6 +208,12 @@ def register_all_tools(
         thinking_tool = register_thinking_tool(mcp_server)
         for tool in thinking_tool:
             all_tools[tool.name] = tool
+    
+    # Register critic tool if enabled
+    if is_tool_enabled("critic", True):
+        critic_tools = register_critic_tool(mcp_server)
+        for tool in critic_tools:
+            all_tools[tool.name] = tool
 
     # Register vector tools if enabled (reuse project_manager if available)
     if any(vector_enabled.values()) and project_manager:
@@ -230,7 +258,7 @@ def register_all_tools(
     
     # Register unified MCP tool if enabled
     if is_tool_enabled("mcp", True):
-        tool = UnifiedMCPTool()
+        tool = MCPTool()
         tool.register(mcp_server)
         all_tools[tool.name] = tool
     
@@ -275,9 +303,9 @@ def register_all_tools(
     stats_tool.register(mcp_server)
     all_tools[stats_tool.name] = stats_tool
     
-    # Palette tool (always enabled for managing tool sets)
-    palette_tool.register(mcp_server)
-    all_tools[palette_tool.name] = palette_tool
+    # Mode tool (always enabled for managing tool sets)
+    mode_tool.register(mcp_server)
+    all_tools[mode_tool.name] = mode_tool
     
     # Register editor tools if enabled
     editor_enabled = {
@@ -303,11 +331,18 @@ def register_all_tools(
     
     # Register unified LLM tool if enabled
     if is_tool_enabled("llm", True):
-        tool = UnifiedLLMTool()
+        tool = LLMTool()
         if tool.available_providers:  # Only register if API keys found
             tool.register(mcp_server)
             all_tools[tool.name] = tool
     
+    # Register consensus tool if enabled (enabled by default)
+    if is_tool_enabled("consensus", True):
+        tool = ConsensusTool()
+        if tool.llm_tool.available_providers:
+            tool.register(mcp_server)
+            all_tools[tool.name] = tool
+
     # Register legacy LLM tools if explicitly enabled (disabled by default)
     legacy_llm_enabled = {
         "llm_legacy": is_tool_enabled("llm_legacy", False),
@@ -339,3 +374,14 @@ def register_all_tools(
             if is_tool_enabled(tool.name, False):
                 tool.register(mcp_server)
                 all_tools[tool.name] = tool
+    
+    # Register user plugins last (so they can override built-in tools)
+    for plugin_name, plugin in plugins.items():
+        if is_tool_enabled(plugin_name, True):
+            try:
+                tool = plugin.tool_class()
+                tool.register(mcp_server)
+                all_tools[tool.name] = tool
+                logger.info(f"Registered plugin tool: {plugin_name}")
+            except Exception as e:
+                logger.error(f"Failed to register plugin tool {plugin_name}: {e}")

hanzo_mcp/tools/agent/__init__.py

@@ -1,4 +1,4 @@
-"""Agent tools for Hanzo MCP.
+"""Agent tools for Hanzo AI.
 
 This module provides tools that allow Claude to delegate tasks to sub-agents,
 enabling concurrent execution of multiple operations and specialized processing.

hanzo_mcp/tools/agent/agent_tool.py

@@ -1,4 +1,4 @@
-"""Agent tool implementation for Hanzo MCP.
+"""Agent tool implementation for Hanzo AI.
 
 This module implements the AgentTool that allows Claude to delegate tasks to sub-agents,
 enabling concurrent execution of multiple operations and specialized processing.
@@ -75,7 +75,7 @@ class AgentTool(BaseTool):
         Returns:
             Tool name
         """
-        return "dispatch_agent"
+        return "agent"
 
     @property
     @override