hanzo-mcp 0.7.7__py3-none-any.whl → 0.8.0__py3-none-any.whl

hanzo_mcp/tools/agent/agent_tool_v1_deprecated.py

@@ -4,49 +4,50 @@ This module implements the AgentTool that allows Claude to delegate tasks to sub
 enabling concurrent execution of multiple operations and specialized processing.
 """
 
-import asyncio
-import json
 import re
+import json
 import time
-from collections.abc import Iterable
-from typing import Annotated, TypedDict, Unpack, final, override
+import asyncio
 
 # Import litellm with warnings suppressed
 import warnings
+from typing import Unpack, Annotated, TypedDict, final, override
+from collections.abc import Iterable
+
 with warnings.catch_warnings():
     warnings.simplefilter("ignore", DeprecationWarning)
     import litellm
-from mcp.server.fastmcp import Context as MCPContext
-from mcp.server import FastMCP
-from openai.types.chat import ChatCompletionMessageParam, ChatCompletionToolParam
 from pydantic import Field
+from mcp.server import FastMCP
+from openai.types.chat import ChatCompletionToolParam, ChatCompletionMessageParam
+from mcp.server.fastmcp import Context as MCPContext
 
+from hanzo_mcp.tools.jupyter import get_read_only_jupyter_tools
+from hanzo_mcp.tools.filesystem import Edit, MultiEdit, get_read_only_filesystem_tools
+from hanzo_mcp.tools.common.base import BaseTool
 from hanzo_mcp.tools.agent.prompt import (
-    get_allowed_agent_tools,
     get_default_model,
-    get_model_parameters,
     get_system_prompt,
+    get_model_parameters,
+    get_allowed_agent_tools,
 )
-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.common.context import (
+    ToolContext,
+    create_tool_context,
 )
-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.agent.review_tool import ReviewTool, ReviewProtocol
 from hanzo_mcp.tools.common.batch_tool import BatchTool
-from hanzo_mcp.tools.common.context import (
-    ToolContext,
-    create_tool_context,
+from hanzo_mcp.tools.agent.tool_adapter import (
+    convert_tools_to_openai_functions,
 )
 from hanzo_mcp.tools.common.permissions import PermissionManager
-from hanzo_mcp.tools.filesystem import get_read_only_filesystem_tools, Edit, MultiEdit
-from hanzo_mcp.tools.jupyter import get_read_only_jupyter_tools
+from hanzo_mcp.tools.agent.clarification_tool import ClarificationTool
+from hanzo_mcp.tools.agent.clarification_protocol import (
+    ClarificationType,
+    AgentClarificationMixin,
+)
 
 Prompt = Annotated[
     str,
@@ -73,7 +74,7 @@ class AgentTool(AgentClarificationMixin, BaseTool):
 
     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.
     """
 
@@ -156,27 +157,27 @@ 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()
@@ -204,7 +205,7 @@ Usage notes:
 
         # Extract and validate parameters
         prompts = params.get("prompts")
-        
+
         if prompts is None:
             await tool_ctx.error("No prompts provided")
             return """Error: At least one prompt must be provided.
@@ -238,7 +239,9 @@ Example of correct usage:
         absolute_path_pattern = r"/(?:[^/\s]+/)*[^/\s]+"
         for prompt in prompt_list:
             if not re.search(absolute_path_pattern, prompt):
-                await tool_ctx.error(f"Prompt does not contain absolute path: {prompt[:50]}...")
+                await tool_ctx.error(
+                    f"Prompt does not contain absolute path: {prompt[:50]}..."
+                )
                 return """Error: All prompts must contain at least one absolute path.
 
 IMPORTANT REMINDER FOR CLAUDE:
@@ -268,7 +271,9 @@ AGENT RESPONSE:
 
 AGENT RESPONSES:
 {result}"""
-            await tool_ctx.info(f"Multi-agent execution completed in {execution_time:.2f}s")
+            await tool_ctx.info(
+                f"Multi-agent execution completed in {execution_time:.2f}s"
+            )
             return formatted_result
 
     async def _execute_agent(self, prompt: str, tool_ctx: ToolContext) -> str:
@@ -316,7 +321,9 @@ AGENT RESPONSES:
 
         return result if result else "No results returned from agent"
 
-    async def _execute_multiple_agents(self, prompts: list[str], tool_ctx: ToolContext) -> str:
+    async def _execute_multiple_agents(
+        self, prompts: list[str], tool_ctx: ToolContext
+    ) -> str:
         """Execute multiple agents concurrently.
 
         Args:
@@ -344,7 +351,7 @@ AGENT RESPONSES:
         # Create tasks for parallel execution
         tasks = []
         for i, prompt in enumerate(prompts):
-            await tool_ctx.info(f"Creating agent task {i+1}: {prompt[:50]}...")
+            await tool_ctx.info(f"Creating agent task {i + 1}: {prompt[:50]}...")
             task = self._execute_agent_with_tools(
                 system_prompt, prompt, agent_tools, openai_tools, tool_ctx
             )
@@ -365,10 +372,10 @@ AGENT RESPONSES:
         formatted_results = []
         for i, result in enumerate(results):
             if isinstance(result, Exception):
-                formatted_results.append(f"Agent {i+1} Error:\n{str(result)}")
-                await tool_ctx.error(f"Agent {i+1} failed: {str(result)}")
+                formatted_results.append(f"Agent {i + 1} Error:\n{str(result)}")
+                await tool_ctx.error(f"Agent {i + 1} failed: {str(result)}")
             else:
-                formatted_results.append(f"Agent {i+1} Result:\n{result}")
+                formatted_results.append(f"Agent {i + 1} Result:\n{result}")
 
         return "\n\n---\n\n".join(formatted_results)
 
@@ -438,9 +445,7 @@ AGENT RESPONSES:
                     completion_params["base_url"] = self.base_url_override
 
                 # Make the model call
-                response = litellm.completion(
-                    **completion_params  # pyright: ignore
-                )
+                response = litellm.completion(**completion_params)  # pyright: ignore
 
                 if len(response.choices) == 0:  # pyright: ignore
                     raise ValueError("No response choices returned")
@@ -487,20 +492,22 @@ AGENT RESPONSES:
                             request_type = function_args.get("type", "ADDITIONAL_INFO")
                             question = function_args.get("question", "")
                             context = function_args.get("context", {})
-                            options = function_args.get("options", None)
-                            
+                            options = function_args.get("options")
+
                             # 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
+                                options=options,
+                            )
+
+                            tool_result = self.format_clarification_in_output(
+                                question, answer
                             )
-                            
-                            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
@@ -509,17 +516,17 @@ AGENT RESPONSES:
                             # 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)
-                            
+                            code_snippets = function_args.get("code_snippets")
+                            file_paths = function_args.get("file_paths")
+                            specific_concerns = function_args.get("specific_concerns")
+
                             # 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
+                                specific_concerns=specific_concerns,
                             )
                         except Exception as e:
                             tool_result = f"Error processing critic review: {str(e)}"
@@ -529,17 +536,17 @@ AGENT RESPONSES:
                             # 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)
-                            
+                            code_snippets = function_args.get("code_snippets")
+                            file_paths = function_args.get("file_paths")
+                            context = function_args.get("context")
+
                             # 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
+                                context=context,
                             )
                         except Exception as e:
                             tool_result = f"Error processing review: {str(e)}"
@@ -634,8 +641,5 @@ AGENT RESPONSE:
         tool_self = self  # Create a reference to self for use in the closure
 
         @mcp_server.tool(name=self.name, description=self.description)
-        async def dispatch_agent(
-            prompts: str | list[str],
-            ctx: MCPContext
-        ) -> str:
+        async def dispatch_agent(prompts: str | list[str], ctx: MCPContext) -> str:
             return await tool_self.call(ctx, prompts=prompts)

hanzo_mcp/tools/agent/clarification_protocol.py

@@ -5,13 +5,14 @@ from the main loop without human intervention.
 """
 
 import json
-from dataclasses import dataclass
-from typing import Any, Dict, List, Optional
 from enum import Enum
+from typing import Any, Dict, List, Optional
+from dataclasses import dataclass
 
 
 class ClarificationType(Enum):
     """Types of clarification requests."""
+
     AMBIGUOUS_INSTRUCTION = "ambiguous_instruction"
     MISSING_CONTEXT = "missing_context"
     MULTIPLE_OPTIONS = "multiple_options"
@@ -22,23 +23,25 @@ class ClarificationType(Enum):
 @dataclass
 class ClarificationRequest:
     """A request for clarification from an agent."""
-    
+
     agent_id: str
     request_type: ClarificationType
     question: str
     context: Dict[str, Any]
     options: Optional[List[str]] = None
-    
+
     def to_json(self) -> str:
         """Convert to JSON for transport."""
-        return json.dumps({
-            "agent_id": self.agent_id,
-            "request_type": self.request_type.value,
-            "question": self.question,
-            "context": self.context,
-            "options": self.options
-        })
-    
+        return json.dumps(
+            {
+                "agent_id": self.agent_id,
+                "request_type": self.request_type.value,
+                "question": self.question,
+                "context": self.context,
+                "options": self.options,
+            }
+        )
+
     @classmethod
     def from_json(cls, data: str) -> "ClarificationRequest":
         """Create from JSON string."""
@@ -48,44 +51,46 @@ class ClarificationRequest:
             request_type=ClarificationType(obj["request_type"]),
             question=obj["question"],
             context=obj["context"],
-            options=obj.get("options")
+            options=obj.get("options"),
         )
 
 
 @dataclass
 class ClarificationResponse:
     """A response to a clarification request."""
-    
+
     request_id: str
     answer: str
     additional_context: Optional[Dict[str, Any]] = None
-    
+
     def to_json(self) -> str:
         """Convert to JSON for transport."""
-        return json.dumps({
-            "request_id": self.request_id,
-            "answer": self.answer,
-            "additional_context": self.additional_context
-        })
+        return json.dumps(
+            {
+                "request_id": self.request_id,
+                "answer": self.answer,
+                "additional_context": self.additional_context,
+            }
+        )
 
 
 class ClarificationHandler:
     """Handles clarification requests from agents."""
-    
+
     def __init__(self):
         self.pending_requests: Dict[str, ClarificationRequest] = {}
         self.request_counter = 0
-    
+
     def create_request(
         self,
         agent_id: str,
         request_type: ClarificationType,
         question: str,
         context: Dict[str, Any],
-        options: Optional[List[str]] = None
+        options: Optional[List[str]] = None,
     ) -> str:
         """Create a new clarification request.
-        
+
         Returns:
             Request ID for tracking
         """
@@ -94,23 +99,23 @@ class ClarificationHandler:
             request_type=request_type,
             question=question,
             context=context,
-            options=options
+            options=options,
         )
-        
+
         request_id = f"clarify_{self.request_counter}"
         self.request_counter += 1
         self.pending_requests[request_id] = request
-        
+
         return request_id
-    
+
     def handle_request(self, request: ClarificationRequest) -> ClarificationResponse:
         """Handle a clarification request automatically.
-        
+
         This method implements automatic clarification resolution
         based on context and common patterns.
         """
         request_id = f"clarify_{len(self.pending_requests)}"
-        
+
         # Handle different types of clarification
         if request.request_type == ClarificationType.AMBIGUOUS_INSTRUCTION:
             # Try to clarify based on context
@@ -123,7 +128,7 @@ class ClarificationHandler:
                     answer = "Add imports according to the language's conventions."
             else:
                 answer = "Proceed with the most reasonable interpretation based on the context."
-        
+
         elif request.request_type == ClarificationType.MISSING_CONTEXT:
             # Provide additional context based on what's missing
             if "import_path" in request.question.lower():
@@ -132,7 +137,7 @@ class ClarificationHandler:
                 answer = "Match the existing code style in the file. Use the same indentation and formatting patterns."
             else:
                 answer = "Analyze the surrounding code and project structure to infer the missing information."
-        
+
         elif request.request_type == ClarificationType.MULTIPLE_OPTIONS:
             # Choose the best option based on context
             if request.options:
@@ -145,7 +150,7 @@ class ClarificationHandler:
                     answer = f"Choose option: {request.options[0]}"
             else:
                 answer = "Choose the most conventional approach based on the codebase patterns."
-        
+
         elif request.request_type == ClarificationType.CONFIRMATION_NEEDED:
             # Auto-confirm safe operations
             if "add import" in request.question.lower():
@@ -154,67 +159,67 @@ class ClarificationHandler:
                 answer = "Yes, use multi_edit for efficiency."
             else:
                 answer = "Proceed if the operation is safe and reversible."
-        
+
         else:  # ADDITIONAL_INFO
             answer = "Continue with available information and make reasonable assumptions based on context."
-        
+
         return ClarificationResponse(
             request_id=request_id,
             answer=answer,
-            additional_context={"auto_resolved": True}
+            additional_context={"auto_resolved": True},
         )
 
 
 class AgentClarificationMixin:
     """Mixin for agents to request clarification."""
-    
+
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
         self.clarification_handler = ClarificationHandler()
         self.clarification_count = 0
         self.max_clarifications = 1  # Allow up to 1 clarification per task
-    
+
     async def request_clarification(
         self,
         request_type: ClarificationType,
         question: str,
         context: Dict[str, Any],
-        options: Optional[List[str]] = None
+        options: Optional[List[str]] = None,
     ) -> str:
         """Request clarification from the main loop.
-        
+
         Args:
             request_type: Type of clarification needed
             question: The question to ask
             context: Relevant context for the question
             options: Optional list of choices
-            
+
         Returns:
             The clarification response
-            
+
         Raises:
             RuntimeError: If clarification limit exceeded
         """
         if self.clarification_count >= self.max_clarifications:
             raise RuntimeError("Clarification limit exceeded")
-        
+
         self.clarification_count += 1
-        
+
         # Create request
         request = ClarificationRequest(
-            agent_id=getattr(self, 'agent_id', 'unknown'),
+            agent_id=getattr(self, "agent_id", "unknown"),
             request_type=request_type,
             question=question,
             context=context,
-            options=options
+            options=options,
         )
-        
+
         # In real implementation, this would communicate with main loop
         # For now, use the automatic handler
         response = self.clarification_handler.handle_request(request)
-        
+
         return response.answer
-    
+
     def format_clarification_in_output(self, question: str, answer: str) -> str:
         """Format clarification exchange for output."""
-        return f"\n🤔 Clarification needed: {question}\n✅ Resolved: {answer}\n"
+        return f"\n🤔 Clarification needed: {question}\n✅ Resolved: {answer}\n"

hanzo_mcp/tools/agent/clarification_tool.py

@@ -2,16 +2,17 @@
 
 from typing import Any, Dict, List, Optional, override
 
-from hanzo_mcp.tools.common.base import BaseTool
-from mcp.server.fastmcp import Context as MCPContext
 from mcp.server import FastMCP
+from mcp.server.fastmcp import Context as MCPContext
+
+from hanzo_mcp.tools.common.base import BaseTool
 
 
 class ClarificationTool(BaseTool):
     """Tool for agents to request clarification from the main loop."""
-    
+
     name = "request_clarification"
-    
+
     @property
     @override
     def description(self) -> str:
@@ -40,29 +41,29 @@ request_clarification(
     context={"file_path": "/path/to/file.go", "undefined_symbol": "common"},
     options=["github.com/luxfi/node/common", "github.com/project/common"]
 )"""
-    
+
     async def call(
         self,
         ctx: MCPContext,
         type: str,
         question: str,
         context: Dict[str, Any],
-        options: Optional[List[str]] = None
+        options: Optional[List[str]] = None,
     ) -> str:
         """This is a placeholder - actual implementation happens in AgentTool."""
         # This tool is handled specially in the agent execution
         return f"Clarification request: {question}"
-    
+
     def register(self, server: FastMCP) -> None:
         """Register the tool with the MCP server."""
         tool_self = self
-        
+
         @server.tool(name=self.name, description=self.description)
         async def request_clarification(
             ctx: MCPContext,
             type: str,
             question: str,
             context: Dict[str, Any],
-            options: Optional[List[str]] = None
+            options: Optional[List[str]] = None,
         ) -> str:
-            return await tool_self.call(ctx, type, question, context, options)
+            return await tool_self.call(ctx, type, question, context, options)