hanzo-mcp 0.8.2__py3-none-any.whl → 0.8.3__py3-none-any.whl

hanzo_mcp/core/model_registry.py

@@ -0,0 +1,436 @@
+"""Unified Model Registry - Single source of truth for all AI model mappings.
+
+This module provides a centralized registry for AI model configurations,
+eliminating duplication and ensuring consistency across the codebase.
+Thread-safe singleton implementation.
+"""
+
+from __future__ import annotations
+
+import threading
+from dataclasses import dataclass, field
+from typing import Dict, List, Optional, Set, Any
+from enum import Enum
+
+
+class ModelProvider(Enum):
+    """Enumeration of AI model providers."""
+    
+    ANTHROPIC = "anthropic"
+    OPENAI = "openai"
+    GOOGLE = "google"
+    XAI = "xai"
+    OLLAMA = "ollama"
+    DEEPSEEK = "deepseek"
+    MISTRAL = "mistral"
+    META = "meta"
+    HANZO = "hanzo"
+
+
+@dataclass(frozen=True)
+class ModelConfig:
+    """Configuration for a single AI model."""
+    
+    full_name: str
+    provider: ModelProvider
+    aliases: Set[str] = field(default_factory=set)
+    default_params: Dict[str, Any] = field(default_factory=dict)
+    supports_vision: bool = False
+    supports_tools: bool = False
+    supports_streaming: bool = True
+    context_window: int = 8192
+    max_output: int = 4096
+    api_key_env: Optional[str] = None
+    cli_command: Optional[str] = None
+
+
+class ModelRegistry:
+    """Centralized registry for all AI models.
+    
+    Thread-safe singleton implementation ensuring single source of truth
+    for model configurations across the codebase.
+    """
+    
+    _instance: Optional[ModelRegistry] = None
+    _lock = threading.Lock()
+    _models: Dict[str, ModelConfig] = {}
+    _initialized = False
+    
+    def __new__(cls) -> ModelRegistry:
+        """Thread-safe singleton pattern."""
+        if cls._instance is None:
+            with cls._lock:
+                if cls._instance is None:
+                    cls._instance = super().__new__(cls)
+        return cls._instance
+    
+    def __init__(self) -> None:
+        """Initialize model registry once."""
+        if not self._initialized:
+            with self._lock:
+                if not self._initialized:
+                    self._initialize_models()
+                    self._initialized = True
+    
+    def _initialize_models(self) -> None:
+        """Initialize all model configurations."""
+        # Claude models
+        self._register(ModelConfig(
+            full_name="claude-3-5-sonnet-20241022",
+            provider=ModelProvider.ANTHROPIC,
+            aliases={"claude", "cc", "claude-code", "sonnet", "sonnet-4.1"},
+            supports_vision=True,
+            supports_tools=True,
+            context_window=200000,
+            max_output=8192,
+            api_key_env="ANTHROPIC_API_KEY",
+            cli_command="claude",
+        ))
+        
+        self._register(ModelConfig(
+            full_name="claude-opus-4-1-20250805",
+            provider=ModelProvider.ANTHROPIC,
+            aliases={"opus", "opus-4.1", "claude-opus"},
+            supports_vision=True,
+            supports_tools=True,
+            context_window=200000,
+            max_output=8192,
+            api_key_env="ANTHROPIC_API_KEY",
+            cli_command="claude",
+        ))
+        
+        self._register(ModelConfig(
+            full_name="claude-3-haiku-20240307",
+            provider=ModelProvider.ANTHROPIC,
+            aliases={"haiku", "claude-haiku"},
+            supports_vision=True,
+            supports_tools=True,
+            context_window=200000,
+            max_output=4096,
+            api_key_env="ANTHROPIC_API_KEY",
+            cli_command="claude",
+        ))
+        
+        # OpenAI models
+        self._register(ModelConfig(
+            full_name="gpt-4-turbo",
+            provider=ModelProvider.OPENAI,
+            aliases={"gpt4", "gpt-4", "codex"},
+            supports_vision=True,
+            supports_tools=True,
+            context_window=128000,
+            max_output=4096,
+            api_key_env="OPENAI_API_KEY",
+            cli_command="openai",
+        ))
+        
+        self._register(ModelConfig(
+            full_name="gpt-5-turbo",
+            provider=ModelProvider.OPENAI,
+            aliases={"gpt5", "gpt-5"},
+            supports_vision=True,
+            supports_tools=True,
+            context_window=256000,
+            max_output=16384,
+            api_key_env="OPENAI_API_KEY",
+            cli_command="openai",
+        ))
+        
+        self._register(ModelConfig(
+            full_name="o1-preview",
+            provider=ModelProvider.OPENAI,
+            aliases={"o1", "openai-o1"},
+            supports_vision=False,
+            supports_tools=False,
+            context_window=128000,
+            max_output=32768,
+            api_key_env="OPENAI_API_KEY",
+            cli_command="openai",
+        ))
+        
+        # Google models
+        self._register(ModelConfig(
+            full_name="gemini-2.0-flash-exp",
+            provider=ModelProvider.GOOGLE,
+            aliases={"gemini-2", "gemini-2.0", "gemini2"},
+            supports_vision=True,
+            supports_tools=True,
+            context_window=1000000,
+            max_output=8192,
+            api_key_env="GEMINI_API_KEY",
+            cli_command="gemini",
+        ))
+        
+        self._register(ModelConfig(
+            full_name="gemini-exp-1206",
+            provider=ModelProvider.GOOGLE,
+            aliases={"gemini-2.5", "gemini-2.5-pro", "gemini-pro-2.5"},
+            supports_vision=True,
+            supports_tools=True,
+            context_window=2000000,
+            max_output=8192,
+            api_key_env="GEMINI_API_KEY",
+            cli_command="gemini",
+        ))
+        
+        self._register(ModelConfig(
+            full_name="gemini-1.5-pro",
+            provider=ModelProvider.GOOGLE,
+            aliases={"gemini", "gemini-pro", "gemini-1.5"},
+            supports_vision=True,
+            supports_tools=True,
+            context_window=2000000,
+            max_output=8192,
+            api_key_env="GEMINI_API_KEY",
+            cli_command="gemini",
+        ))
+        
+        self._register(ModelConfig(
+            full_name="gemini-1.5-flash",
+            provider=ModelProvider.GOOGLE,
+            aliases={"gemini-flash", "flash"},
+            supports_vision=True,
+            supports_tools=True,
+            context_window=1000000,
+            max_output=8192,
+            api_key_env="GEMINI_API_KEY",
+            cli_command="gemini",
+        ))
+        
+        # xAI models
+        self._register(ModelConfig(
+            full_name="grok-4",
+            provider=ModelProvider.XAI,
+            aliases={"grok", "xai-grok", "grok-2"},  # grok-2 for backward compat
+            supports_vision=True,  # Grok-4 supports multimodal
+            supports_tools=True,
+            context_window=128000,
+            max_output=8192,
+            api_key_env="XAI_API_KEY",
+            cli_command="grok",
+        ))
+        
+        # Ollama models
+        self._register(ModelConfig(
+            full_name="ollama/llama-3.2-3b",
+            provider=ModelProvider.OLLAMA,
+            aliases={"llama", "llama-3.2", "llama3"},
+            supports_vision=False,
+            supports_tools=False,
+            context_window=128000,
+            max_output=4096,
+            api_key_env=None,  # Local model
+            cli_command="ollama",
+        ))
+        
+        self._register(ModelConfig(
+            full_name="ollama/mistral:7b",
+            provider=ModelProvider.MISTRAL,
+            aliases={"mistral", "mistral-7b"},
+            supports_vision=False,
+            supports_tools=False,
+            context_window=32000,
+            max_output=4096,
+            api_key_env=None,  # Local model
+            cli_command="ollama",
+        ))
+        
+        # DeepSeek models
+        self._register(ModelConfig(
+            full_name="deepseek-coder-v2",
+            provider=ModelProvider.DEEPSEEK,
+            aliases={"deepseek", "deepseek-coder"},
+            supports_vision=False,
+            supports_tools=True,
+            context_window=128000,
+            max_output=8192,
+            api_key_env="DEEPSEEK_API_KEY",
+            cli_command="deepseek",
+        ))
+    
+    def _register(self, config: ModelConfig) -> None:
+        """Register a model configuration.
+        
+        Args:
+            config: Model configuration to register
+        """
+        # Register by full name
+        self._models[config.full_name] = config
+        
+        # Register all aliases
+        for alias in config.aliases:
+            self._models[alias.lower()] = config
+    
+    def get(self, model_name: str) -> Optional[ModelConfig]:
+        """Get model configuration by name or alias.
+        
+        Args:
+            model_name: Model name or alias
+            
+        Returns:
+            Model configuration or None if not found
+        """
+        return self._models.get(model_name.lower())
+    
+    def resolve(self, model_name: str) -> str:
+        """Resolve model name or alias to full model name.
+        
+        Args:
+            model_name: Model name or alias
+            
+        Returns:
+            Full model name, or original if not found
+        """
+        config = self.get(model_name)
+        return config.full_name if config else model_name
+    
+    def get_by_provider(self, provider: ModelProvider) -> List[ModelConfig]:
+        """Get all unique models for a specific provider.
+        
+        Args:
+            provider: Model provider
+            
+        Returns:
+            List of unique model configurations
+        """
+        seen_names = set()
+        results = []
+        for config in self._models.values():
+            if config.provider == provider and config.full_name not in seen_names:
+                seen_names.add(config.full_name)
+                results.append(config)
+        return results
+    
+    def get_models_supporting(
+        self,
+        vision: Optional[bool] = None,
+        tools: Optional[bool] = None,
+        streaming: Optional[bool] = None,
+    ) -> List[ModelConfig]:
+        """Get unique models supporting specific features.
+        
+        Args:
+            vision: Filter by vision support
+            tools: Filter by tool support
+            streaming: Filter by streaming support
+            
+        Returns:
+            List of unique matching model configurations
+        """
+        seen_names = set()
+        results = []
+        
+        for config in self._models.values():
+            if config.full_name in seen_names:
+                continue
+                
+            if vision is not None and config.supports_vision != vision:
+                continue
+            if tools is not None and config.supports_tools != tools:
+                continue
+            if streaming is not None and config.supports_streaming != streaming:
+                continue
+            
+            seen_names.add(config.full_name)
+            results.append(config)
+        
+        return results
+    
+    def get_api_key_env(self, model_name: str) -> Optional[str]:
+        """Get the API key environment variable for a model.
+        
+        Args:
+            model_name: Model name or alias
+            
+        Returns:
+            Environment variable name or None
+        """
+        config = self.get(model_name)
+        return config.api_key_env if config else None
+    
+    def get_cli_command(self, model_name: str) -> Optional[str]:
+        """Get the CLI command for a model.
+        
+        Args:
+            model_name: Model name or alias
+            
+        Returns:
+            CLI command or None
+        """
+        config = self.get(model_name)
+        return config.cli_command if config else None
+    
+    def list_all_models(self) -> List[str]:
+        """List all unique model full names.
+        
+        Returns:
+            Sorted list of unique full model names
+        """
+        seen_names = set()
+        for config in self._models.values():
+            seen_names.add(config.full_name)
+        return sorted(list(seen_names))
+    
+    def list_all_aliases(self) -> Dict[str, str]:
+        """List all aliases and their full names.
+        
+        Returns:
+            Dictionary mapping aliases to full names
+        """
+        result = {}
+        for key, config in self._models.items():
+            if key != config.full_name:
+                result[key] = config.full_name
+        return result
+
+
+# Global singleton instance
+registry = ModelRegistry()
+
+
+# Convenience functions
+def resolve_model(model_name: str) -> str:
+    """Resolve model name or alias to full model name.
+    
+    Args:
+        model_name: Model name or alias
+        
+    Returns:
+        Full model name
+    """
+    return registry.resolve(model_name)
+
+
+def get_model_config(model_name: str) -> Optional[ModelConfig]:
+    """Get model configuration.
+    
+    Args:
+        model_name: Model name or alias
+        
+    Returns:
+        Model configuration or None
+    """
+    return registry.get(model_name)
+
+
+def get_api_key_env(model_name: str) -> Optional[str]:
+    """Get API key environment variable for model.
+    
+    Args:
+        model_name: Model name or alias
+        
+    Returns:
+        Environment variable name or None
+    """
+    return registry.get_api_key_env(model_name)
+
+
+__all__ = [
+    "ModelProvider",
+    "ModelConfig",
+    "ModelRegistry",
+    "registry",
+    "resolve_model",
+    "get_model_config",
+    "get_api_key_env",
+]

hanzo_mcp/dev_server.py

@@ -172,17 +172,18 @@ class DevServer:
 
         logger = logging.getLogger(__name__)
         logger.info(f"\n🚀 Starting Hanzo AI in development mode...")
-        
+
         # Show compute nodes
         try:
             from hanzo_mcp.compute_nodes import ComputeNodeDetector
+
             detector = ComputeNodeDetector()
             summary = detector.get_node_summary()
             logger.info(f"🖥️  {summary}")
         except Exception:
             # Silently ignore if compute node detection fails
             pass
-        
+
         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")

hanzo_mcp/server.py

@@ -9,7 +9,9 @@ import threading
 from typing import Literal, cast, final
 
 # Suppress litellm deprecation warnings about event loop
-warnings.filterwarnings("ignore", message="There is no current event loop", category=DeprecationWarning)
+warnings.filterwarnings(
+    "ignore", message="There is no current event loop", category=DeprecationWarning
+)
 
 try:
     from fastmcp import FastMCP
@@ -224,6 +226,7 @@ class HanzoMCPServer:
         if transport != "stdio" and not os.environ.get("HANZO_QUIET"):
             try:
                 from hanzo_mcp.compute_nodes import ComputeNodeDetector
+
                 detector = ComputeNodeDetector()
                 summary = detector.get_node_summary()
                 logger = logging.getLogger(__name__)

hanzo_mcp/tools/__init__.py

@@ -1,55 +1,70 @@
 """Tools package for Hanzo AI.
 
-This package contains all the tools for the Hanzo AI server.
-It provides a interface for registering all tools with an MCP server.
+This package contains all tools for the Hanzo MCP server. To keep imports
+robust across environments (e.g., older Python during CI), heavy imports are
+guarded. Submodules can still be imported directly, e.g.:
 
-This includes a "think" tool implementation based on Anthropic's research showing
-improved performance for complex tool-based interactions when Claude has a dedicated
-space for structured thinking. It also includes an "agent" tool that enables Claude
-to delegate tasks to sub-agents for concurrent execution and specialized processing.
+from hanzo_mcp.tools.llm.llm_tool import LLMTool
 """
 
-from mcp.server import FastMCP
-
-from hanzo_mcp.tools.todo import register_todo_tools
-from hanzo_mcp.tools.agent import register_agent_tools
-from hanzo_mcp.tools.shell import register_shell_tools
-from hanzo_mcp.tools.common import (
-    register_batch_tool,
-    register_critic_tool,
-    register_thinking_tool,
-)
-from hanzo_mcp.tools.vector import register_vector_tools
-from hanzo_mcp.tools.jupyter import register_jupyter_tools
-from hanzo_mcp.tools.database import DatabaseManager, register_database_tools
-from hanzo_mcp.tools.filesystem import register_filesystem_tools
-from hanzo_mcp.tools.common.base import BaseTool
-from hanzo_mcp.tools.common.stats import StatsTool
-from hanzo_mcp.tools.common.tool_list import ToolListTool
-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
-
-# Try to import memory tools, but don't fail if hanzo-memory is not installed
-try:
-    from hanzo_mcp.tools.memory import register_memory_tools
+# Defer annotation evaluation to avoid import-time NameErrors in constrained envs
+from __future__ import annotations
 
-    MEMORY_TOOLS_AVAILABLE = True
-except ImportError:
-    MEMORY_TOOLS_AVAILABLE = False
-    register_memory_tools = None
-from hanzo_mcp.tools.llm import (
-    LLMTool,
-    ConsensusTool,
-    LLMManageTool,
-    create_provider_tools,
-)
-from hanzo_mcp.tools.mcp import MCPTool, McpAddTool, McpStatsTool, McpRemoveTool
-from hanzo_mcp.tools.editor import NeovimEditTool, NeovimCommandTool, NeovimSessionTool
-from hanzo_mcp.tools.common.mode import activate_mode_from_env
-from hanzo_mcp.tools.config.mode_tool import mode_tool
-from hanzo_mcp.tools.common.mode_loader import ModeLoader
-from hanzo_mcp.tools.common.plugin_loader import load_user_plugins
+# NOTE: Keep top-level imports resilient for environments without optional deps
+try:  # pragma: no cover - import guards for CI environments
+    from mcp.server import FastMCP  # type: ignore
+except Exception:  # pragma: no cover
+
+    class FastMCP:  # type: ignore
+        pass
+
+
+try:  # pragma: no cover
+    from hanzo_mcp.tools.llm import (
+        LLMTool,
+        ConsensusTool,
+        LLMManageTool,
+        create_provider_tools,
+    )
+    from hanzo_mcp.tools.mcp import (
+        MCPTool,
+        McpAddTool,
+        McpStatsTool,
+        McpRemoveTool,
+    )
+    from hanzo_mcp.tools.todo import register_todo_tools
+    from hanzo_mcp.tools.agent import register_agent_tools
+    from hanzo_mcp.tools.shell import register_shell_tools
+    from hanzo_mcp.tools.editor import (
+        NeovimEditTool,
+        NeovimCommandTool,
+        NeovimSessionTool,
+    )
+    from hanzo_mcp.tools.vector import register_vector_tools
+    from hanzo_mcp.tools.jupyter import register_jupyter_tools
+    from hanzo_mcp.tools.database import DatabaseManager, register_database_tools
+    from hanzo_mcp.tools.filesystem import register_filesystem_tools
+    from hanzo_mcp.tools.common.base import BaseTool
+    from hanzo_mcp.tools.common.mode import activate_mode_from_env
+    from hanzo_mcp.tools.common.stats import StatsTool
+    from hanzo_mcp.tools.common.tool_list import ToolListTool
+    from hanzo_mcp.tools.config.mode_tool import mode_tool
+    from hanzo_mcp.tools.common.mode_loader import ModeLoader
+    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
+
+    # Try memory tools
+    try:
+        from hanzo_mcp.tools.memory import register_memory_tools
+
+        MEMORY_TOOLS_AVAILABLE = True
+    except Exception:
+        MEMORY_TOOLS_AVAILABLE = False
+        register_memory_tools = None  # type: ignore
+except Exception:
+    # Minimal surface to allow submodule imports elsewhere
+    pass
 
 # Try to import LSP tool
 try:

hanzo_mcp/tools/agent/__init__.py

@@ -13,11 +13,21 @@ from hanzo_mcp.tools.agent.agent_tool import AgentTool
 from hanzo_mcp.tools.agent.swarm_tool import SwarmTool
 from hanzo_mcp.tools.agent.network_tool import NetworkTool
 from hanzo_mcp.tools.common.permissions import PermissionManager
-from hanzo_mcp.tools.agent.grok_cli_tool import GrokCLITool
+# Import unified CLI tools (single source of truth)
+from hanzo_mcp.tools.agent.cli_tools import (
+    ClaudeCLITool,
+    ClaudeCodeCLITool,  # cc alias
+    CodexCLITool,
+    GeminiCLITool,
+    GrokCLITool,
+    OpenHandsCLITool,
+    OpenHandsShortCLITool,  # oh alias
+    HanzoDevCLITool,
+    ClineCLITool,
+    AiderCLITool,
+    register_cli_tools,
+)
 from hanzo_mcp.tools.agent.code_auth_tool import CodeAuthTool
-from hanzo_mcp.tools.agent.codex_cli_tool import CodexCLITool
-from hanzo_mcp.tools.agent.claude_cli_tool import ClaudeCLITool
-from hanzo_mcp.tools.agent.gemini_cli_tool import GeminiCLITool
 
 
 def register_agent_tools(
@@ -68,27 +78,6 @@ def register_agent_tools(
         agent_max_tool_uses=agent_max_tool_uses,
     )
 
-    # Create CLI agent tools
-    claude_cli_tool = ClaudeCLITool(
-        permission_manager=permission_manager,
-        model=agent_model,  # Can override default Sonnet
-    )
-
-    codex_cli_tool = CodexCLITool(
-        permission_manager=permission_manager,
-        model=agent_model if agent_model and "gpt" in agent_model else None,
-    )
-
-    gemini_cli_tool = GeminiCLITool(
-        permission_manager=permission_manager,
-        model=agent_model if agent_model and "gemini" in agent_model else None,
-    )
-
-    grok_cli_tool = GrokCLITool(
-        permission_manager=permission_manager,
-        model=agent_model if agent_model and "grok" in agent_model else None,
-    )
-
     # Create auth management tool
     code_auth_tool = CodeAuthTool()
 
@@ -98,24 +87,19 @@ def register_agent_tools(
         default_mode="hybrid",  # Prefer local, fallback to cloud
     )
 
-    # Register tools
+    # Register core agent tools
     ToolRegistry.register_tool(mcp_server, agent_tool)
     ToolRegistry.register_tool(mcp_server, swarm_tool)
     ToolRegistry.register_tool(mcp_server, network_tool)
-    ToolRegistry.register_tool(mcp_server, claude_cli_tool)
-    ToolRegistry.register_tool(mcp_server, codex_cli_tool)
-    ToolRegistry.register_tool(mcp_server, gemini_cli_tool)
-    ToolRegistry.register_tool(mcp_server, grok_cli_tool)
     ToolRegistry.register_tool(mcp_server, code_auth_tool)
 
+    # Register all CLI tools (includes claude, codex, gemini, grok, etc.)
+    cli_tools = register_cli_tools(mcp_server, permission_manager)
+    
     # Return list of registered tools
     return [
         agent_tool,
         swarm_tool,
         network_tool,
-        claude_cli_tool,
-        codex_cli_tool,
-        gemini_cli_tool,
-        grok_cli_tool,
         code_auth_tool,
-    ]
+    ] + cli_tools