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

hanzo_mcp/tools/agent/__init__.py

@@ -1,12 +1,35 @@
-"""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.
 """
 
+import os
 from mcp.server import FastMCP
 
-from hanzo_mcp.tools.agent.agent_tool import AgentTool
+# Try to use hanzo-agents SDK versions if available
+USE_HANZO_AGENTS = os.environ.get("USE_HANZO_AGENTS", "true").lower() == "true"
+
+try:
+    if USE_HANZO_AGENTS:
+        from hanzo_mcp.tools.agent.agent_tool_v2 import AgentTool
+        from hanzo_mcp.tools.agent.swarm_tool_v2 import SwarmTool
+        print("[MCP] Using hanzo-agents SDK for agent and swarm tools")
+    else:
+        raise ImportError("USE_HANZO_AGENTS=false")
+except ImportError:
+    # Fall back to original implementations
+    from hanzo_mcp.tools.agent.agent_tool import AgentTool
+    from hanzo_mcp.tools.agent.swarm_tool import SwarmTool
+    if USE_HANZO_AGENTS:
+        print("[MCP] hanzo-agents SDK not available, using original agent implementations")
+
+from hanzo_mcp.tools.agent.claude_cli_tool import ClaudeCLITool
+from hanzo_mcp.tools.agent.codex_cli_tool import CodexCLITool
+from hanzo_mcp.tools.agent.gemini_cli_tool import GeminiCLITool
+from hanzo_mcp.tools.agent.grok_cli_tool import GrokCLITool
+from hanzo_mcp.tools.agent.code_auth_tool import CodeAuthTool
+from hanzo_mcp.tools.agent.network_tool import NetworkTool, LocalSwarmTool
 from hanzo_mcp.tools.common.base import BaseTool, ToolRegistry
 
 from hanzo_mcp.tools.common.permissions import PermissionManager
@@ -48,9 +71,67 @@ def register_agent_tools(
         max_iterations=agent_max_iterations,
         max_tool_uses=agent_max_tool_uses,
     )
+    
+    # Create swarm tool
+    swarm_tool = SwarmTool(
+        permission_manager=permission_manager,
+        model=agent_model,
+        api_key=agent_api_key,
+        base_url=agent_base_url,
+        max_tokens=agent_max_tokens,
+        agent_max_iterations=agent_max_iterations,
+        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()
+    
+    # Create network tool
+    network_tool = NetworkTool(
+        permission_manager=permission_manager,
+        default_mode="hybrid"  # Prefer local, fallback to cloud
+    )
 
-    # Register agent tool
+    # Register 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)
 
     # Return list of registered tools
-    return [agent_tool]
+    return [
+        agent_tool, 
+        swarm_tool,
+        network_tool,
+        claude_cli_tool,
+        codex_cli_tool,
+        gemini_cli_tool,
+        grok_cli_tool,
+        code_auth_tool,
+    ]

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.
@@ -30,6 +30,14 @@ from hanzo_mcp.tools.agent.prompt import (
 from hanzo_mcp.tools.agent.tool_adapter import (
     convert_tools_to_openai_functions,
 )
+from hanzo_mcp.tools.agent.clarification_protocol import (
+    AgentClarificationMixin,
+    ClarificationType,
+)
+from hanzo_mcp.tools.agent.clarification_tool import ClarificationTool
+from hanzo_mcp.tools.agent.critic_tool import CriticTool, CriticProtocol
+from hanzo_mcp.tools.agent.review_tool import ReviewTool, ReviewProtocol
+from hanzo_mcp.tools.agent.iching_tool import IChingTool
 from hanzo_mcp.tools.common.base import BaseTool
 from hanzo_mcp.tools.common.batch_tool import BatchTool
 from hanzo_mcp.tools.common.context import (
@@ -37,7 +45,7 @@ from hanzo_mcp.tools.common.context import (
     create_tool_context,
 )
 from hanzo_mcp.tools.common.permissions import PermissionManager
-from hanzo_mcp.tools.filesystem import get_read_only_filesystem_tools
+from hanzo_mcp.tools.filesystem import get_read_only_filesystem_tools, Edit, MultiEdit
 from hanzo_mcp.tools.jupyter import get_read_only_jupyter_tools
 
 Prompt = Annotated[
@@ -60,11 +68,13 @@ class AgentToolParams(TypedDict, total=False):
 
 
 @final
-class AgentTool(BaseTool):
+class AgentTool(AgentClarificationMixin, BaseTool):
     """Tool for delegating tasks to sub-agents.
 
     The AgentTool allows Claude to create and manage sub-agents for performing
     specialized tasks concurrently, such as code search, analysis, and more.
+    
+    Agents can request clarification from the main loop up to once per task.
     """
 
     @property
@@ -75,7 +85,7 @@ class AgentTool(BaseTool):
         Returns:
             Tool name
         """
-        return "dispatch_agent"
+        return "agent"
 
     @property
     @override
@@ -88,22 +98,26 @@ class AgentTool(BaseTool):
         # TODO: Add glob when it is implemented
         at = [t.name for t in self.available_tools]
 
-        return f"""Launch a new agent that has access to the following tools: {at} When you are searching for a keyword or file and are not confident that you will find the right match in the first few tries, use the Agent tool to perform the search for you.
+        return f"""Launch a new agent that has access to the following tools: {at}. When you are searching for a keyword or file and are not confident that you will find the right match in the first few tries, use the Agent tool to perform the search for you.
 
 When to use the Agent tool:
 - If you are searching for a keyword like \"config\" or \"logger\", or for questions like \"which file does X?\", the Agent tool is strongly recommended
+- When you need to perform edits across multiple files based on search results
+- When you need to delegate complex file modification tasks
 
 When NOT to use the Agent tool:
 - If you want to read a specific file path, use the read or glob tool instead of the Agent tool, to find the match more quickly
 - If you are searching for a specific class definition like \"class Foo\", use the glob tool instead, to find the match more quickly
 - If you are searching for code within a specific file or set of 2-3 files, use the read tool instead of the Agent tool, to find the match more quickly
+- Writing code and running bash commands (use other tools for that)
+- Other tasks that are not related to searching for a keyword or file
 
 Usage notes:
 1. Launch multiple agents concurrently whenever possible, to maximize performance; to do that, use a single message with multiple tool uses
 2. When the agent is done, it will return a single message back to you. The result returned by the agent is not visible to the user. To show the user the result, you should send a text message back to the user with a concise summary of the result.
 3. Each agent invocation is stateless. You will not be able to send additional messages to the agent, nor will the agent be able to communicate with you outside of its final report. Therefore, your prompt should contain a highly detailed task description for the agent to perform autonomously and you should specify exactly what information the agent should return back to you in its final and only message to you.
 4. The agent's outputs should generally be trusted
-5.IMPORTANT: The Agent has no awareness of your context, so you must explicitly specify absolute project/file/directory paths and detailed background information about the current task. """
+5. Clearly tell the agent whether you expect it to write code or just to do research (search, file reads, web fetches, etc.), since it is not aware of the user's intent"""
 
     def __init__(
         self,
@@ -142,9 +156,30 @@ Usage notes:
         self.available_tools.extend(
             get_read_only_jupyter_tools(self.permission_manager)
         )
+        
+        # Always add edit tools - agents should have edit access
+        self.available_tools.append(Edit(self.permission_manager))
+        self.available_tools.append(MultiEdit(self.permission_manager))
+        
+        # Add clarification tool for agents
+        self.available_tools.append(ClarificationTool())
+        
+        # Add critic tool for agents (devil's advocate)
+        self.available_tools.append(CriticTool())
+        
+        # Add review tool for agents (balanced review)
+        self.available_tools.append(ReviewTool())
+        
+        # Add I Ching tool for creative guidance
+        self.available_tools.append(IChingTool())
+        
         self.available_tools.append(
             BatchTool({t.name: t for t in self.available_tools})
         )
+        
+        # Initialize protocols
+        self.critic_protocol = CriticProtocol()
+        self.review_protocol = ReviewProtocol()
 
     @override
     async def call(
@@ -445,6 +480,69 @@ AGENT RESPONSES:
                     )
                     if not tool:
                         tool_result = f"Error: Tool '{function_name}' not found"
+                    # Special handling for clarification requests
+                    elif function_name == "request_clarification":
+                        try:
+                            # Extract clarification parameters
+                            request_type = function_args.get("type", "ADDITIONAL_INFO")
+                            question = function_args.get("question", "")
+                            context = function_args.get("context", {})
+                            options = function_args.get("options", None)
+                            
+                            # Convert string type to enum
+                            clarification_type = ClarificationType[request_type]
+                            
+                            # Request clarification
+                            answer = await self.request_clarification(
+                                request_type=clarification_type,
+                                question=question,
+                                context=context,
+                                options=options
+                            )
+                            
+                            tool_result = self.format_clarification_in_output(question, answer)
+                        except Exception as e:
+                            tool_result = f"Error processing clarification: {str(e)}"
+                    # Special handling for critic requests
+                    elif function_name == "critic":
+                        try:
+                            # Extract critic parameters
+                            review_type = function_args.get("review_type", "GENERAL")
+                            work_description = function_args.get("work_description", "")
+                            code_snippets = function_args.get("code_snippets", None)
+                            file_paths = function_args.get("file_paths", None)
+                            specific_concerns = function_args.get("specific_concerns", None)
+                            
+                            # Request critical review
+                            tool_result = self.critic_protocol.request_review(
+                                review_type=review_type,
+                                work_description=work_description,
+                                code_snippets=code_snippets,
+                                file_paths=file_paths,
+                                specific_concerns=specific_concerns
+                            )
+                        except Exception as e:
+                            tool_result = f"Error processing critic review: {str(e)}"
+                    # Special handling for review requests
+                    elif function_name == "review":
+                        try:
+                            # Extract review parameters
+                            focus = function_args.get("focus", "GENERAL")
+                            work_description = function_args.get("work_description", "")
+                            code_snippets = function_args.get("code_snippets", None)
+                            file_paths = function_args.get("file_paths", None)
+                            context = function_args.get("context", None)
+                            
+                            # Request balanced review
+                            tool_result = self.review_protocol.request_review(
+                                focus=focus,
+                                work_description=work_description,
+                                code_snippets=code_snippets,
+                                file_paths=file_paths,
+                                context=context
+                            )
+                        except Exception as e:
+                            tool_result = f"Error processing review: {str(e)}"
                     else:
                         try:
                             tool_result = await tool.call(