hanzo-mcp 0.5.1__py3-none-any.whl → 0.6.1__py3-none-any.whl

hanzo_mcp/__init__.py

@@ -1,3 +1,3 @@
 """Hanzo MCP - Implementation of Hanzo capabilities using MCP."""
 
-__version__ = "0.5.1"
+__version__ = "0.6.0"

hanzo_mcp/cli.py

@@ -145,6 +145,12 @@ def main() -> None:
         help="Single project directory (alias for --project)",
     )
 
+    _ = parser.add_argument(
+        "--dev",
+        action="store_true",
+        help="Run in development mode with hot reload",
+    )
+    
     _ = parser.add_argument(
         "--install",
         action="store_true",
@@ -156,6 +162,7 @@ def main() -> None:
     # Cast args attributes to appropriate types to avoid 'Any' warnings
     name: str = cast(str, args.name)
     install: bool = cast(bool, args.install)
+    dev: bool = cast(bool, args.dev)
     transport: str = cast(str, args.transport)
     agent_model: str | None = cast(str | None, args.agent_model)
     agent_max_tokens: int | None = cast(int | None, args.agent_max_tokens)
@@ -200,6 +207,31 @@ def main() -> None:
     if not allowed_paths:
         allowed_paths = [os.getcwd()]
 
+    # Run in dev mode if requested
+    if dev:
+        from hanzo_mcp.dev_server import DevServer
+        
+        dev_server = DevServer(
+            name=name,
+            allowed_paths=allowed_paths,
+            project_paths=project_paths,
+            project_dir=project_dir,
+            agent_model=agent_model,
+            agent_max_tokens=agent_max_tokens,
+            agent_api_key=agent_api_key,
+            agent_base_url=agent_base_url,
+            agent_max_iterations=agent_max_iterations,
+            agent_max_tool_uses=agent_max_tool_uses,
+            enable_agent_tool=enable_agent_tool,
+            command_timeout=command_timeout,
+            disable_write_tools=disable_write_tools,
+            disable_search_tools=disable_search_tools,
+            host=host,
+            port=port,
+        )
+        dev_server.run(transport=transport)
+        return
+
     # Run the server
     server = HanzoMCPServer(
         name=name,

hanzo_mcp/dev_server.py

@@ -0,0 +1,246 @@
+"""Development server with hot reload for Hanzo MCP."""
+
+import asyncio
+import os
+import sys
+import time
+from pathlib import Path
+from typing import Optional, Set
+
+import watchdog.events
+import watchdog.observers
+from watchdog.events import FileSystemEventHandler
+
+from hanzo_mcp.server import HanzoMCPServer
+
+
+class MCPReloadHandler(FileSystemEventHandler):
+    """Handler for file system events that triggers MCP server reload."""
+    
+    def __init__(self, restart_callback, ignore_patterns: Optional[Set[str]] = None):
+        """Initialize the reload handler.
+        
+        Args:
+            restart_callback: Function to call when files change
+            ignore_patterns: Set of patterns to ignore
+        """
+        self.restart_callback = restart_callback
+        self.ignore_patterns = ignore_patterns or {
+            "__pycache__", ".pyc", ".pyo", ".git", ".pytest_cache",
+            ".mypy_cache", ".ruff_cache", ".coverage", "*.log",
+            ".env", ".venv", "venv", "node_modules"
+        }
+        self.last_reload = 0
+        self.reload_delay = 0.5  # Debounce delay in seconds
+    
+    def should_ignore(self, path: str) -> bool:
+        """Check if a path should be ignored."""
+        path_obj = Path(path)
+        
+        # Check against ignore patterns
+        for pattern in self.ignore_patterns:
+            if pattern in str(path_obj):
+                return True
+            if path_obj.name.endswith(pattern):
+                return True
+        
+        # Only watch Python files and config files
+        if path_obj.is_file():
+            allowed_extensions = {".py", ".json", ".yaml", ".yml", ".toml"}
+            if path_obj.suffix not in allowed_extensions:
+                return True
+        
+        return False
+    
+    def on_any_event(self, event):
+        """Handle any file system event."""
+        if event.is_directory:
+            return
+        
+        if self.should_ignore(event.src_path):
+            return
+        
+        # Debounce rapid changes
+        current_time = time.time()
+        if current_time - self.last_reload < self.reload_delay:
+            return
+        
+        self.last_reload = current_time
+        
+        print(f"\n🔄 File changed: {event.src_path}")
+        print("🔄 Reloading MCP server...")
+        
+        self.restart_callback()
+
+
+class DevServer:
+    """Development server with hot reload capability."""
+    
+    def __init__(
+        self,
+        name: str = "hanzo-dev",
+        allowed_paths: Optional[list[str]] = None,
+        project_paths: Optional[list[str]] = None,
+        project_dir: Optional[str] = None,
+        **kwargs
+    ):
+        """Initialize the development server.
+        
+        Args:
+            name: Server name
+            allowed_paths: Allowed paths for the server
+            project_paths: Project paths
+            project_dir: Project directory
+            **kwargs: Additional arguments for HanzoMCPServer
+        """
+        self.name = name
+        self.allowed_paths = allowed_paths or []
+        self.project_paths = project_paths
+        self.project_dir = project_dir
+        self.server_kwargs = kwargs
+        self.server_process = None
+        self.observer = None
+        self.running = False
+    
+    def create_server(self) -> HanzoMCPServer:
+        """Create a new MCP server instance."""
+        return HanzoMCPServer(
+            name=self.name,
+            allowed_paths=self.allowed_paths,
+            project_paths=self.project_paths,
+            project_dir=self.project_dir,
+            **self.server_kwargs
+        )
+    
+    def start_file_watcher(self):
+        """Start watching for file changes."""
+        # Watch the hanzo_mcp package directory
+        package_dir = Path(__file__).parent
+        
+        # Create observer and handler
+        self.observer = watchdog.observers.Observer()
+        handler = MCPReloadHandler(self.restart_server)
+        
+        # Watch the package directory
+        self.observer.schedule(handler, str(package_dir), recursive=True)
+        
+        # Also watch any project directories
+        if self.project_dir:
+            self.observer.schedule(handler, self.project_dir, recursive=True)
+        
+        for path in self.allowed_paths:
+            if Path(path).is_dir() and path not in [str(package_dir), self.project_dir]:
+                self.observer.schedule(handler, path, recursive=True)
+        
+        self.observer.start()
+        print(f"👀 Watching for changes in: {package_dir}")
+        if self.project_dir:
+            print(f"👀 Also watching: {self.project_dir}")
+    
+    def stop_file_watcher(self):
+        """Stop the file watcher."""
+        if self.observer and self.observer.is_alive():
+            self.observer.stop()
+            self.observer.join(timeout=2)
+    
+    def restart_server(self):
+        """Restart the MCP server."""
+        # Since MCP servers run in the same process, we need to handle this differently
+        # For now, we'll print a message indicating a restart is needed
+        print("\n⚠️  Server restart required. Please restart the MCP client to reload changes.")
+        print("💡 Tip: In development, consider using the MCP test client for easier reloading.")
+    
+    async def run_async(self, transport: str = "stdio"):
+        """Run the development server asynchronously."""
+        self.running = True
+        
+        print(f"\n🚀 Starting Hanzo MCP in development mode...")
+        print(f"🔧 Hot reload enabled - watching for file changes")
+        print(f"📁 Project: {self.project_dir or 'current directory'}")
+        print(f"🌐 Transport: {transport}\n")
+        
+        # Start file watcher
+        self.start_file_watcher()
+        
+        try:
+            # Create and run server
+            server = self.create_server()
+            
+            # Run the server (this will block)
+            server.run(transport=transport)
+            
+        except KeyboardInterrupt:
+            print("\n\n🛑 Shutting down development server...")
+        finally:
+            self.running = False
+            self.stop_file_watcher()
+            print("👋 Development server stopped")
+    
+    def run(self, transport: str = "stdio"):
+        """Run the development server."""
+        try:
+            # Run the async version
+            asyncio.run(self.run_async(transport))
+        except KeyboardInterrupt:
+            pass
+
+
+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.add_argument(
+        "--name",
+        type=str,
+        default="hanzo-dev",
+        help="Name of the MCP server"
+    )
+    parser.add_argument(
+        "--project-dir",
+        type=str,
+        help="Project directory to serve"
+    )
+    parser.add_argument(
+        "--allowed-path",
+        type=str,
+        action="append",
+        dest="allowed_paths",
+        help="Additional allowed paths (can be specified multiple times)"
+    )
+    parser.add_argument(
+        "--transport",
+        type=str,
+        default="stdio",
+        choices=["stdio", "sse"],
+        help="Transport type (default: stdio)"
+    )
+    parser.add_argument(
+        "--host",
+        type=str,
+        default="127.0.0.1",
+        help="Host for SSE transport"
+    )
+    parser.add_argument(
+        "--port",
+        type=int,
+        default=3000,
+        help="Port for SSE transport"
+    )
+    
+    args = parser.parse_args()
+    
+    # Create and run dev server
+    dev_server = DevServer(
+        name=args.name,
+        allowed_paths=args.allowed_paths,
+        project_dir=args.project_dir,
+        host=args.host,
+        port=args.port,
+    )
+    
+    dev_server.run(transport=args.transport)
+
+
+if __name__ == "__main__":
+    run_dev_server()

hanzo_mcp/prompts/__init__.py

@@ -1,6 +1,6 @@
 import os
 
-from fastmcp import FastMCP
+from mcp.server import FastMCP
 
 from hanzo_mcp.prompts.compact_conversation import COMPACT_CONVERSATION_PROMPT
 from hanzo_mcp.prompts.create_release import CREATE_RELEASE_PROMPT

hanzo_mcp/prompts/project_system.py

@@ -29,6 +29,42 @@ Recent commits:
 {recent_commits}
 </project_info>
 
+<available_tools>
+Hanzo MCP provides 65+ tools organized by category. Key tools include:
+
+# File Operations
+- read, write, edit, multi_edit: File manipulation
+- tree, find: Navigation and discovery
+
+# Search & Analysis  
+- grep: Fast text search
+- symbols: AST-aware symbol search
+- search: Multi-modal intelligent search
+- git_search: Git history search
+- vector_search: Semantic search
+
+# Shell & Process
+- run_command: Execute commands
+- processes, pkill: Process management
+- npx, uvx: Run packages directly
+
+# Development
+- jupyter: Notebook operations (read/edit actions)
+- todo: Task management (read/write actions)
+- agent: Delegate complex tasks
+- llm: Query LLMs (query/list/consensus actions)
+
+# Databases
+- sql: SQL operations (query/search/stats actions)
+- graph: Graph operations (add/remove/query/search/stats actions)
+
+# System
+- config: Configuration management
+- stats: Usage statistics
+- tool_enable/disable: Dynamic tool control
+
+Tools follow the principle of one tool per task with multiple actions where appropriate.
+</available_tools>
 
 <preferences>
 IMPORTANT: Always use the todo_write tool to plan and track tasks throughout the conversation.
@@ -63,21 +99,21 @@ When making changes to files, first understand the file's code conventions. Mimi
 
 <task_management>
 # Task Management
-You have access to the todo_write and todo_read tools to help you manage and plan tasks. Use these tools VERY frequently to ensure that you are tracking your tasks and giving me visibility into your progress.
-These tools are also EXTREMELY helpful for planning tasks, and for breaking down larger complex tasks into smaller steps. If you do not use this tool when planning, you may forget to do important tasks - and that is unacceptable.
+You have access to the todo tool (actions: read, write) to help you manage and plan tasks. Use this tool VERY frequently to ensure that you are tracking your tasks and giving me visibility into your progress.
+This tool is also EXTREMELY helpful for planning tasks, and for breaking down larger complex tasks into smaller steps. If you do not use this tool when planning, you may forget to do important tasks - and that is unacceptable.
 
 It is critical that you mark todos as completed as soon as you are done with a task. Do not batch up multiple tasks before marking them as completed.
 
 Examples:
 <example>
 user: Run the build and fix any type errors
-assistant: I'm going to use the todo_write tool to write the following items to the todo list:
+assistant: I'm going to use the todo tool with write action to add the following items to the todo list:
 - Run the build
 - Fix any type errors
 
 I'm now going to run the build using Bash.
 
-Looks like I found 10 type errors. I'm going to use the todo_write tool to write 10 items to the todo list.
+Looks like I found 10 type errors. I'm going to use the todo tool with write action to add 10 items to the todo list.
 
 marking the first todo as in_progress
 
@@ -91,7 +127,7 @@ In the above example, the assistant completes all the tasks, including the 10 er
 <example>
 user: Help me write a new feature that allows users to track their usage metrics and export them to various formats
 
-assistant: I'll help you implement a usage metrics tracking and export feature. Let me first use the todo_write tool to plan this task.
+assistant: I'll help you implement a usage metrics tracking and export feature. Let me first use the todo tool with write action to plan this task.
 Adding the following todos to the todo list:
 1. Research existing metrics tracking in the codebase
 2. Design the metrics collection system
@@ -109,8 +145,8 @@ I've found some existing telemetry code. Let me mark the first todo as in_progre
 
 # Doing tasks
 I will primarily request you perform software engineering tasks. This includes solving bugs, adding new functionality, refactoring code, explaining code, and more. For these tasks the following steps are recommended:
-- Use the todo_write tool to plan the task if required
-- Use the available search tools to understand the codebase and my query. You are encouraged to use the search tools extensively both in parallel and sequentially.
+- Use the todo tool with write action to plan the task if required
+- Use the available search tools (grep, symbols, search, git_search) to understand the codebase and my query. The 'search' tool intelligently combines multiple search strategies. You are encouraged to use search tools extensively both in parallel and sequentially.
 - Implement the solution using all tools available to you
 - Verify the solution if possible with tests. NEVER assume specific test framework or test script. Check the README or search codebase to determine the testing approach.
 - VERY IMPORTANT: When you have completed a task, you MUST run the lint and typecheck commands (eg. npm run lint, npm run typecheck, ruff, etc.) with Bash if they were provided to you to ensure your code is correct. If you are unable to find the correct command, ask me for the command to run and if they supply it, proactively suggest writing it to CLAUDE.md so that you will know to run it next time.

hanzo_mcp/server.py

@@ -6,7 +6,11 @@ import threading
 import time
 from typing import Literal, cast, final
 
-from fastmcp import FastMCP
+try:
+    from fastmcp import FastMCP
+except ImportError:
+    # Fallback for older MCP versions
+    from mcp.server import FastMCP
 
 from hanzo_mcp.prompts import register_all_prompts
 from hanzo_mcp.tools import register_all_tools

hanzo_mcp/tools/__init__.py

@@ -9,18 +9,27 @@ space for structured thinking. It also includes an "agent" tool that enables Cla
 to delegate tasks to sub-agents for concurrent execution and specialized processing.
 """
 
-from fastmcp import FastMCP
+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.base import BaseTool
-
 from hanzo_mcp.tools.common.permissions import PermissionManager
+from hanzo_mcp.tools.common.tool_enable import ToolEnableTool
+from hanzo_mcp.tools.common.tool_disable import ToolDisableTool
+from hanzo_mcp.tools.common.tool_list import ToolListTool
+from hanzo_mcp.tools.common.stats import StatsTool
 from hanzo_mcp.tools.filesystem import register_filesystem_tools
 from hanzo_mcp.tools.jupyter import register_jupyter_tools
 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.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
 
 
 def register_all_tools(
@@ -37,6 +46,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,
 ) -> None:
     """Register all Hanzo tools with the MCP server.
 
@@ -54,12 +65,23 @@ 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)
     """
     # Dictionary to store all registered tools
     all_tools: dict[str, BaseTool] = {}
     
-    # Use individual tool configuration if provided, otherwise fall back to category-level flags
-    tool_config = enabled_tools or {}
+    # Apply palette configuration if enabled
+    if use_palette:
+        tool_config = PaletteLoader.get_enabled_tools_from_palette(
+            base_enabled_tools=enabled_tools,
+            force_palette=force_palette
+        )
+        # Apply palette environment variables
+        PaletteLoader.apply_palette_environment()
+    else:
+        # Use individual tool configuration if provided, otherwise fall back to category-level flags
+        tool_config = enabled_tools or {}
     
     def is_tool_enabled(tool_name: str, category_enabled: bool = True) -> bool:
         """Check if a specific tool should be enabled."""
@@ -76,7 +98,10 @@ def register_all_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),
+        "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),
     }
     
@@ -87,8 +112,8 @@ def register_all_tools(
         "vector_search": is_tool_enabled("vector_search", False),
     }
     
-    # Create project manager if vector tools or unified search are enabled
-    if any(vector_enabled.values()) or filesystem_enabled.get("unified_search", False):
+    # 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 vector_config:
             from hanzo_mcp.tools.vector.project_manager import ProjectVectorManager
             search_paths = [str(path) for path in permission_manager.allowed_paths]
@@ -175,3 +200,140 @@ def register_all_tools(
     # Register batch tool if enabled (batch tool is typically always enabled)
     if is_tool_enabled("batch", True):
         register_batch_tool(mcp_server, all_tools)
+    
+    # Register database tools if enabled
+    db_manager = None
+    database_enabled = {
+        "sql_query": is_tool_enabled("sql_query", True),
+        "sql_search": is_tool_enabled("sql_search", True),
+        "sql_stats": is_tool_enabled("sql_stats", True),
+        "graph_add": is_tool_enabled("graph_add", True),
+        "graph_remove": is_tool_enabled("graph_remove", True),
+        "graph_query": is_tool_enabled("graph_query", True),
+        "graph_search": is_tool_enabled("graph_search", True),
+        "graph_stats": is_tool_enabled("graph_stats", True),
+    }
+    
+    if any(database_enabled.values()):
+        db_manager = DatabaseManager(permission_manager)
+        database_tools = register_database_tools(
+            mcp_server,
+            permission_manager,
+            db_manager=db_manager,
+        )
+        # Filter based on enabled state
+        for tool in database_tools:
+            if database_enabled.get(tool.name, True):
+                all_tools[tool.name] = tool
+    
+    # Register unified MCP tool if enabled
+    if is_tool_enabled("mcp", True):
+        tool = UnifiedMCPTool()
+        tool.register(mcp_server)
+        all_tools[tool.name] = tool
+    
+    # Register legacy MCP tools if explicitly enabled (disabled by default)
+    legacy_mcp_enabled = {
+        "mcp_add": is_tool_enabled("mcp_add", False),
+        "mcp_remove": is_tool_enabled("mcp_remove", False),
+        "mcp_stats": is_tool_enabled("mcp_stats", False),
+    }
+    
+    if legacy_mcp_enabled.get("mcp_add", False):
+        tool = McpAddTool()
+        tool.register(mcp_server)
+        all_tools[tool.name] = tool
+    
+    if legacy_mcp_enabled.get("mcp_remove", False):
+        tool = McpRemoveTool()
+        tool.register(mcp_server)
+        all_tools[tool.name] = tool
+    
+    if legacy_mcp_enabled.get("mcp_stats", False):
+        tool = McpStatsTool()
+        tool.register(mcp_server)
+        all_tools[tool.name] = tool
+    
+    # Register system tools (always enabled)
+    # Tool enable/disable tools
+    tool_enable = ToolEnableTool()
+    tool_enable.register(mcp_server)
+    all_tools[tool_enable.name] = tool_enable
+    
+    tool_disable = ToolDisableTool()
+    tool_disable.register(mcp_server)
+    all_tools[tool_disable.name] = tool_disable
+    
+    tool_list = ToolListTool()
+    tool_list.register(mcp_server)
+    all_tools[tool_list.name] = tool_list
+    
+    # Stats tool
+    stats_tool = StatsTool(db_manager=db_manager)
+    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
+    
+    # Register editor tools if enabled
+    editor_enabled = {
+        "neovim_edit": is_tool_enabled("neovim_edit", True),
+        "neovim_command": is_tool_enabled("neovim_command", True),
+        "neovim_session": is_tool_enabled("neovim_session", True),
+    }
+    
+    if editor_enabled.get("neovim_edit", True):
+        tool = NeovimEditTool(permission_manager)
+        tool.register(mcp_server)
+        all_tools[tool.name] = tool
+    
+    if editor_enabled.get("neovim_command", True):
+        tool = NeovimCommandTool(permission_manager)
+        tool.register(mcp_server)
+        all_tools[tool.name] = tool
+    
+    if editor_enabled.get("neovim_session", True):
+        tool = NeovimSessionTool()
+        tool.register(mcp_server)
+        all_tools[tool.name] = tool
+    
+    # Register unified LLM tool if enabled
+    if is_tool_enabled("llm", True):
+        tool = UnifiedLLMTool()
+        if tool.available_providers:  # Only register if API keys found
+            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),
+        "consensus": is_tool_enabled("consensus", False),
+        "llm_manage": is_tool_enabled("llm_manage", False),
+    }
+    
+    if legacy_llm_enabled.get("llm_legacy", False):
+        tool = LLMTool()
+        if tool.available_providers:
+            tool.register(mcp_server)
+            all_tools["llm_legacy"] = tool
+    
+    if legacy_llm_enabled.get("consensus", False):
+        tool = ConsensusTool()
+        if tool.llm_tool.available_providers:
+            tool.register(mcp_server)
+            all_tools[tool.name] = tool
+    
+    if legacy_llm_enabled.get("llm_manage", False):
+        tool = LLMManageTool()
+        tool.register(mcp_server)
+        all_tools[tool.name] = tool
+    
+    # Register provider-specific LLM tools (disabled by default)
+    if is_tool_enabled("provider_specific_llm", False):
+        provider_tools = create_provider_tools()
+        for tool in provider_tools:
+            if is_tool_enabled(tool.name, False):
+                tool.register(mcp_server)
+                all_tools[tool.name] = tool

hanzo_mcp/tools/agent/__init__.py

@@ -4,7 +4,7 @@ This module provides tools that allow Claude to delegate tasks to sub-agents,
 enabling concurrent execution of multiple operations and specialized processing.
 """
 
-from fastmcp import FastMCP
+from mcp.server import FastMCP
 
 from hanzo_mcp.tools.agent.agent_tool import AgentTool
 from hanzo_mcp.tools.common.base import BaseTool, ToolRegistry