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

hanzo_mcp/tools/agent/prompt.py

@@ -26,7 +26,7 @@ def get_allowed_agent_tools(
     """
     # Get all tools except for the agent tool itself (avoid recursion)
     filtered_tools = [tool for tool in tools if tool.name != "agent"]
-    
+
     return filtered_tools
 
 
@@ -44,9 +44,7 @@ def get_system_prompt(
         System prompt for the sub-agent
     """
     # Get filtered tools
-    filtered_tools = get_allowed_agent_tools(
-        tools, permission_manager
-    )
+    filtered_tools = get_allowed_agent_tools(tools, permission_manager)
 
     # Extract tool names for display
     tool_names = ", ".join(f"`{tool.name}`" for tool in filtered_tools)
@@ -61,6 +59,7 @@ GUIDELINES:
 4. Be concise and focus on the specific task assigned
 5. When relevant, share file names and code snippets relevant to the query
 6. Any file paths you return in your final response MUST be absolute. DO NOT use relative paths.
+7. CRITICAL: You can only work with the absolute paths provided in your task prompt. You cannot infer or guess other locations.
 
 RESPONSE FORMAT:
 - Begin with a summary of findings
@@ -86,24 +85,28 @@ def get_default_model(model_override: str | None = None) -> str:
         # If in testing mode and using a test model, return as-is
         if model_override.startswith("test-model") or "TEST_MODE" in os.environ:
             return model_override
-        
+
         # If the model already has a provider prefix, return as-is
         if "/" in model_override:
             return model_override
-        
+
         # Otherwise, add the default provider prefix
         provider = os.environ.get("AGENT_PROVIDER", "openai")
         return f"{provider}/{model_override}"
-    
+
     # Fall back to environment variables
     model = os.environ.get("AGENT_MODEL", "gpt-4o")
-    
+
     # Special cases for tests
-    if model.startswith("test-model") or model == "gpt-4o" and "TEST_MODE" in os.environ:
+    if (
+        model.startswith("test-model")
+        or model == "gpt-4o"
+        and "TEST_MODE" in os.environ
+    ):
         return model
-        
+
     provider = os.environ.get("AGENT_PROVIDER", "openai")
-    
+
     # Only add provider prefix if it's not already in the model name
     if "/" not in model and provider != "openai":
         return f"{provider}/{model}"
@@ -127,11 +130,11 @@ def get_model_parameters(max_tokens: int | None = None) -> dict[str, Any]:
         "temperature": float(os.environ.get("AGENT_TEMPERATURE", "0.7")),
         "timeout": int(os.environ.get("AGENT_API_TIMEOUT", "60")),
     }
-    
+
     # Add max_tokens if provided or if set in environment variable
     if max_tokens is not None:
         params["max_tokens"] = max_tokens
     elif os.environ.get("AGENT_MAX_TOKENS"):
         params["max_tokens"] = int(os.environ.get("AGENT_MAX_TOKENS", "1000"))
-    
+
     return params

hanzo_mcp/tools/agent/tool_adapter.py

@@ -5,7 +5,6 @@ formats, making MCP tools available to the OpenAI API, and processing tool input
 and outputs for agent execution.
 """
 
-
 from openai.types import FunctionParameters
 from openai.types.chat import ChatCompletionToolParam
 import litellm
@@ -13,7 +12,9 @@ import litellm
 from hanzo_mcp.tools.common.base import BaseTool
 
 
-def convert_tools_to_openai_functions(tools: list[BaseTool]) -> list[ChatCompletionToolParam]:
+def convert_tools_to_openai_functions(
+    tools: list[BaseTool],
+) -> list[ChatCompletionToolParam]:
     """Convert MCP tools to OpenAI function format.
 
     Args:
@@ -22,9 +23,9 @@ def convert_tools_to_openai_functions(tools: list[BaseTool]) -> list[ChatComplet
     Returns:
         List of tools formatted for OpenAI API
     """
-    openai_tools:list[ChatCompletionToolParam] = []
+    openai_tools: list[ChatCompletionToolParam] = []
     for tool in tools:
-        openai_tool:ChatCompletionToolParam = {
+        openai_tool: ChatCompletionToolParam = {
             "type": "function",
             "function": {
                 "name": tool.name,
@@ -47,19 +48,18 @@ def convert_tool_parameters(tool: BaseTool) -> FunctionParameters:
     """
     # Start with a copy of the parameters
     params = tool.parameters.copy()
-    
+
     # Ensure the schema has the right format for OpenAI
     if "properties" not in params:
         params["properties"] = {}
-        
+
     if "type" not in params:
         params["type"] = "object"
-        
+
     if "required" not in params:
         params["required"] = tool.required
-        
-    return params
 
+    return params
 
 
 def supports_parallel_function_calling(model: str) -> bool:

hanzo_mcp/tools/common/__init__.py

@@ -1,30 +1,31 @@
 """Common utilities for Hanzo MCP tools."""
 
-from mcp.server.fastmcp import FastMCP
+from fastmcp import FastMCP
 
-from hanzo_mcp.tools.common.base import ToolRegistry
-from hanzo_mcp.tools.common.think_tool import ThinkingTool
-from hanzo_mcp.tools.common.version_tool import VersionTool
+from hanzo_mcp.tools.common.base import BaseTool, ToolRegistry
+from hanzo_mcp.tools.common.batch_tool import BatchTool
+from hanzo_mcp.tools.common.thinking_tool import ThinkingTool
 
 
-def register_think_tool(
+def register_thinking_tool(
     mcp_server: FastMCP,
-) -> None:
-    """Register all thinking tools with the MCP server. 
-    
+) -> list[BaseTool]:
+    """Register thinking tools with the MCP server.
+
     Args:
         mcp_server: The FastMCP server instance
     """
-    think_tool = ThinkingTool()
-    ToolRegistry.register_tool(mcp_server, think_tool)
+    thinking_tool = ThinkingTool()
+    ToolRegistry.register_tool(mcp_server, thinking_tool)
+    return [thinking_tool]
 
 
-def register_version_tool(
-    mcp_server: FastMCP,
-) -> None:
-    """Register the version tool with the MCP server.
-    
+def register_batch_tool(mcp_server: FastMCP, tools: dict[str, BaseTool]) -> None:
+    """Register batch tool with the MCP server.
+
     Args:
         mcp_server: The FastMCP server instance
+        tools: Dictionary mapping tool names to tool instances
     """
-    _ = VersionTool(mcp_server)  # Tool registers itself in constructor
+    batch_tool = BatchTool(tools)
+    ToolRegistry.register_tool(mcp_server, batch_tool)

hanzo_mcp/tools/common/base.py

@@ -5,180 +5,149 @@ for all tools used in Hanzo MCP. These abstractions help ensure consistent tool
 behavior and provide a foundation for tool registration and management.
 """
 
+import functools
 from abc import ABC, abstractmethod
-from typing import Any, final
+from collections.abc import Awaitable
+from typing import Any, Callable, final
+
+from fastmcp import FastMCP
+from fastmcp import Context as MCPContext
 
-from mcp.server.fastmcp import Context as MCPContext
-from mcp.server.fastmcp import FastMCP
 
-from hanzo_mcp.tools.common.context import DocumentContext 
 from hanzo_mcp.tools.common.permissions import PermissionManager
-from hanzo_mcp.tools.common.validation import ValidationResult, validate_path_parameter
+from hanzo_mcp.tools.common.validation import (
+    ValidationResult,
+    validate_path_parameter,
+)
+
+
+def handle_connection_errors(
+    func: Callable[..., Awaitable[str]],
+) -> Callable[..., Awaitable[str]]:
+    """Decorator to handle connection errors in MCP tool functions.
+
+    This decorator wraps tool functions to catch ClosedResourceError and other
+    connection-related exceptions that occur when the client disconnects.
+
+    Args:
+        func: The async tool function to wrap
+
+    Returns:
+        Wrapped function that handles connection errors gracefully
+    """
+
+    @functools.wraps(func)
+    async def wrapper(*args: Any, **kwargs: Any) -> str:
+        try:
+            return await func(*args, **kwargs)
+        except Exception as e:
+            # Check if this is a connection-related error
+            error_name = type(e).__name__
+            if any(
+                name in error_name
+                for name in [
+                    "ClosedResourceError",
+                    "ConnectionError",
+                    "BrokenPipeError",
+                ]
+            ):
+                # Client has disconnected - log the error but don't crash
+                # Return a simple error message (though it likely won't be received)
+                return f"Client disconnected during operation: {error_name}"
+            else:
+                # Re-raise non-connection errors
+                raise
+
+    return wrapper
 
 
 class BaseTool(ABC):
     """Abstract base class for all Hanzo MCP tools.
-    
+
     This class defines the core interface that all tools must implement, ensuring
     consistency in how tools are registered, documented, and called.
     """
-    
+
     @property
     @abstractmethod
     def name(self) -> str:
         """Get the tool name.
-        
+
         Returns:
             The tool name as it will appear in the MCP server
         """
         pass
-        
+
     @property
     @abstractmethod
     def description(self) -> str:
         """Get the tool description.
-        
+
         Returns:
             Detailed description of the tool's purpose and usage
         """
         pass
-        
-    @property
-    def mcp_description(self) -> str:
-        """Get the complete tool description for MCP.
-        
-        This method combines the tool description with parameter descriptions.
-        
-        Returns:
-            Complete tool description including parameter details
-        """
-        # Start with the base description
-        desc = self.description.strip()
-        
-        # Add parameter descriptions section if there are parameters
-        if self.parameters and "properties" in self.parameters:
-            # Add Args section header
-            desc += "\n\nArgs:"
-            
-            # Get the properties dictionary
-            properties = self.parameters["properties"]
-            
-            # Add each parameter description
-            for param_name, param_info in properties.items():
-                # Get the title if available, otherwise use the parameter name and capitalize it
-                if "title" in param_info:
-                    title = param_info["title"]
-                else:
-                    # Convert snake_case to Title Case
-                    title = " ".join(word.capitalize() for word in param_name.split("_"))
-                
-                # Check if the parameter is required
-                required = param_name in self.required
-                required_text = "" if required else " (optional)"
-                
-                # Add the parameter description line
-                desc += f"\n    {param_name}: {title}{required_text}"
-        
-        # Add Returns section
-        desc += "\n\nReturns:\n    "
-        
-        # Add a generic return description based on the tool's purpose
-        # This could be enhanced with more specific return descriptions
-        if "read" in self.name or "get" in self.name or "search" in self.name:
-            desc += f"{self.name.replace('_', ' ').capitalize()} results"
-        elif "write" in self.name or "edit" in self.name or "create" in self.name:
-            desc += "Result of the operation"
-        else:
-            desc += "Tool execution results"
-            
-        return desc
-        
-    @property
-    @abstractmethod
-    def parameters(self) -> dict[str, Any]:
-        """Get the parameter specifications for the tool.
-        
-        Returns:
-            Dictionary containing parameter specifications in JSON Schema format
-        """
-        pass
-        
-    @property
-    @abstractmethod
-    def required(self) -> list[str]:
-        """Get the list of required parameter names.
-        
-        Returns:
-            List of parameter names that are required for the tool
-        """
-        pass
-        
+
     @abstractmethod
-    async def call(self, ctx: MCPContext, **params: Any) -> str:
+    async def call(self, ctx: MCPContext, **params: Any) -> Any:
         """Execute the tool with the given parameters.
-        
+
         Args:
             ctx: MCP context for the tool call
             **params: Tool parameters provided by the caller
-            
+
         Returns:
             Tool execution result as a string
         """
         pass
-        
+
     @abstractmethod
     def register(self, mcp_server: FastMCP) -> None:
         """Register this tool with the MCP server.
-        
+
         This method must be implemented by each tool class to create a wrapper function
         with explicitly defined parameters that calls this tool's call method.
         The wrapper function is then registered with the MCP server.
-        
+
         Args:
             mcp_server: The FastMCP server instance
         """
         pass
 
 
-class FileSystemTool(BaseTool,ABC):
+class FileSystemTool(BaseTool, ABC):
     """Base class for filesystem-related tools.
-    
+
     Provides common functionality for working with files and directories,
     including permission checking and path validation.
     """
-    
-    def __init__(
-        self, 
-        document_context: DocumentContext, 
-        permission_manager: PermissionManager
-    ) -> None:
+
+    def __init__(self, permission_manager: PermissionManager) -> None:
         """Initialize filesystem tool.
-        
+
         Args:
-            document_context: Document context for tracking file contents
             permission_manager: Permission manager for access control
         """
-        self.document_context:DocumentContext = document_context
-        self.permission_manager:PermissionManager = permission_manager
-        
+        self.permission_manager: PermissionManager = permission_manager
+
     def validate_path(self, path: str, param_name: str = "path") -> ValidationResult:
         """Validate a path parameter.
-        
+
         Args:
             path: Path to validate
             param_name: Name of the parameter (for error messages)
-            
+
         Returns:
             Validation result containing validation status and error message if any
         """
         return validate_path_parameter(path, param_name)
-        
+
     def is_path_allowed(self, path: str) -> bool:
         """Check if a path is allowed according to permission settings.
-        
+
         Args:
             path: Path to check
-            
+
         Returns:
             True if the path is allowed, False otherwise
         """
@@ -188,26 +157,26 @@ class FileSystemTool(BaseTool,ABC):
 @final
 class ToolRegistry:
     """Registry for Hanzo MCP tools.
-    
+
     Provides functionality for registering tool implementations with an MCP server,
     handling the conversion between tool classes and MCP tool functions.
     """
-    
+
     @staticmethod
     def register_tool(mcp_server: FastMCP, tool: BaseTool) -> None:
         """Register a tool with the MCP server.
-        
+
         Args:
             mcp_server: The FastMCP server instance
             tool: The tool to register
         """
         # Use the tool's register method which handles all the details
         tool.register(mcp_server)
-            
+
     @staticmethod
     def register_tools(mcp_server: FastMCP, tools: list[BaseTool]) -> None:
         """Register multiple tools with the MCP server.
-        
+
         Args:
             mcp_server: The FastMCP server instance
             tools: List of tools to register