hanzo-mcp 0.8.11__py3-none-any.whl → 0.9.0__py3-none-any.whl

hanzo_mcp/tools/agent/iching_tool.py

@@ -423,17 +423,13 @@ class IChing:
                 lines += "1"
         return Hexagram(lines)
 
-    def select_principles(
-        self, hexagram: Hexagram, challenge: str
-    ) -> List[HanzoPrinciple]:
+    def select_principles(self, hexagram: Hexagram, challenge: str) -> List[HanzoPrinciple]:
         """Select relevant Hanzo principles based on hexagram and challenge."""
         # Use hexagram pattern to deterministically but creatively select principles
         selected = []
 
         # Primary principle based on hexagram pattern
-        primary_index = sum(
-            int(bit) * (2**i) for i, bit in enumerate(hexagram.lines)
-        ) % len(self.principles)
+        primary_index = sum(int(bit) * (2**i) for i, bit in enumerate(hexagram.lines)) % len(self.principles)
         selected.append(self.principles[primary_index])
 
         # Supporting principles based on challenge keywords
@@ -458,9 +454,7 @@ class IChing:
         # Add complementary principle based on changing lines
         changing_lines = hexagram.get_changing_lines()
         if changing_lines:
-            complement_index = (primary_index + sum(changing_lines)) % len(
-                self.principles
-            )
+            complement_index = (primary_index + sum(changing_lines)) % len(self.principles)
             selected.append(self.principles[complement_index])
 
         # Ensure uniqueness and limit to 3-5 principles
@@ -473,9 +467,7 @@ class IChing:
 
         return unique_selected[:5]
 
-    def generate_guidance(
-        self, hexagram: Hexagram, principles: List[HanzoPrinciple], challenge: str
-    ) -> str:
+    def generate_guidance(self, hexagram: Hexagram, principles: List[HanzoPrinciple], challenge: str) -> str:
         """Generate creative guidance combining I Ching wisdom and Hanzo principles."""
         guidance = f"☯️ I CHING GUIDANCE FOR ENGINEERING CHALLENGE ☯️\n\n"
         guidance += f"**Your Challenge:** {challenge}\n\n"
@@ -498,21 +490,15 @@ class IChing:
         if "Creative" in hexagram.title:
             guidance += "• This is a time for bold innovation. Don't hold back on ambitious ideas.\n"
         elif "Receptive" in hexagram.title:
-            guidance += (
-                "• Listen deeply to user needs and system constraints before acting.\n"
-            )
+            guidance += "• Listen deeply to user needs and system constraints before acting.\n"
         elif "Difficulty" in hexagram.title:
-            guidance += (
-                "• Challenges are teachers. Each obstacle reveals the path forward.\n"
-            )
+            guidance += "• Challenges are teachers. Each obstacle reveals the path forward.\n"
         elif "Waiting" in hexagram.title:
             guidance += "• Strategic patience required. Prepare thoroughly before implementation.\n"
         elif "Conflict" in hexagram.title:
             guidance += "• Technical disagreements? Seek data-driven resolution.\n"
         elif "Peace" in hexagram.title:
-            guidance += (
-                "• Harmony achieved. Now build sustainably on this foundation.\n"
-            )
+            guidance += "• Harmony achieved. Now build sustainably on this foundation.\n"
 
         # Principle-specific actionable advice
         principle_actions = {
@@ -534,9 +520,7 @@ class IChing:
         changing_lines = hexagram.get_changing_lines()
         if changing_lines:
             guidance += f"\n**Lines in Transition:** {', '.join(str(i + 1) for i in changing_lines)}\n"
-            guidance += (
-                "• Change is imminent in these areas. Prepare for transformation.\n"
-            )
+            guidance += "• Change is imminent in these areas. Prepare for transformation.\n"
 
         # Final synthesis
         guidance += "\n**The Way Forward:**\n"
@@ -547,9 +531,7 @@ class IChing:
 
         return guidance
 
-    def _synthesize_action_plan(
-        self, hexagram: Hexagram, principles: List[HanzoPrinciple], challenge: str
-    ) -> str:
+    def _synthesize_action_plan(self, hexagram: Hexagram, principles: List[HanzoPrinciple], challenge: str) -> str:
         """Create a specific action plan based on the reading."""
         plan = ""
 
@@ -558,21 +540,15 @@ class IChing:
             plan += "1. **Diagnose systematically** - Use empirical debugging, not guesswork\n"
             plan += "2. **Fix root cause** - Address the source, not just symptoms\n"
             plan += "3. **Prevent recurrence** - Add tests and monitoring\n"
-        elif any(
-            word in challenge.lower() for word in ["scale", "performance", "slow"]
-        ):
+        elif any(word in challenge.lower() for word in ["scale", "performance", "slow"]):
             plan += "1. **Measure first** - Profile to find actual bottlenecks\n"
             plan += "2. **Parallelize** - Use concurrency where possible\n"
             plan += "3. **Simplify** - Remove complexity before optimizing\n"
-        elif any(
-            word in challenge.lower() for word in ["design", "architect", "structure"]
-        ):
+        elif any(word in challenge.lower() for word in ["design", "architect", "structure"]):
             plan += "1. **Start simple** - MVP first, elaborate later\n"
             plan += "2. **Stay flexible** - Design for change\n"
             plan += "3. **Think holistically** - Consider entire system\n"
-        elif any(
-            word in challenge.lower() for word in ["team", "collaborate", "people"]
-        ):
+        elif any(word in challenge.lower() for word in ["team", "collaborate", "people"]):
             plan += "1. **Enable autonomy** - Trust your team\n"
             plan += "2. **Maintain balance** - Sustainable pace wins\n"
             plan += "3. **Share knowledge** - Elevate everyone\n"

hanzo_mcp/tools/agent/network_tool.py

@@ -77,9 +77,7 @@ class NetworkTool(BaseTool):
         """
         self.permission_manager = permission_manager
         self.default_mode = default_mode
-        self.cluster_endpoint = cluster_endpoint or os.environ.get(
-            "HANZO_CLUSTER_ENDPOINT", "http://localhost:8000"
-        )
+        self.cluster_endpoint = cluster_endpoint or os.environ.get("HANZO_CLUSTER_ENDPOINT", "http://localhost:8000")
         self._cluster = None
 
     async def _ensure_cluster(self):
@@ -160,9 +158,7 @@ class NetworkTool(BaseTool):
                         results["results"].append(
                             {
                                 "agent": "local-cluster",
-                                "response": local_result.get("choices", [{}])[0].get(
-                                    "text", ""
-                                ),
+                                "response": local_result.get("choices", [{}])[0].get("text", ""),
                                 "local": True,
                             }
                         )
@@ -180,6 +176,7 @@ class NetworkTool(BaseTool):
                 # Agent-based execution with concurrency
                 if not results["success"] or mode in ["distributed", "hybrid"]:
                     from hanzo_mcp.tools.agent.agent_tool import AgentTool
+
                     agent = AgentTool(permission_manager=self.permission_manager, model=model_pref)
                     concurrency = max(1, len(agents_list)) if agents_list else 5 if routing == "parallel" else 1
                     agent_params = {"prompts": task, "concurrency": concurrency}
@@ -206,25 +203,17 @@ class NetworkTool(BaseTool):
         async def network_handler(
             ctx: MCPContext,
             task: Annotated[str, Field(description="Task to execute on the network")],
-            agents: Annotated[
-                Optional[List[str]], Field(description="Specific agents to use")
-            ] = None,
+            agents: Annotated[Optional[List[str]], Field(description="Specific agents to use")] = None,
             mode: Annotated[
                 Optional[str],
                 Field(description="Execution mode: local, distributed, or hybrid"),
             ] = None,
-            model: Annotated[
-                Optional[str], Field(description="Model preference")
-            ] = None,
+            model: Annotated[Optional[str], Field(description="Model preference")] = None,
             routing: Annotated[
                 Optional[str],
-                Field(
-                    description="Routing strategy: sequential, parallel, or consensus"
-                ),
-            ] = None,
-            require_local: Annotated[
-                Optional[bool], Field(description="Require local-only execution")
+                Field(description="Routing strategy: sequential, parallel, or consensus"),
             ] = None,
+            require_local: Annotated[Optional[bool], Field(description="Require local-only execution")] = None,
         ) -> str:
             """Dispatch work to agent networks."""
             params = NetworkToolParams(

hanzo_mcp/tools/agent/prompt.py

@@ -139,11 +139,7 @@ def get_default_model(model_override: str | None = None) -> str:
     model = os.environ.get("AGENT_MODEL", "claude-3-5-sonnet-20241022")
 
     # Special cases for tests
-    if (
-        model.startswith("test-model")
-        or "TEST_MODE" in os.environ
-        and model == "claude-3-5-sonnet-20241022"
-    ):
+    if model.startswith("test-model") or "TEST_MODE" in os.environ and model == "claude-3-5-sonnet-20241022":
         return model
 
     provider = os.environ.get("AGENT_PROVIDER", "anthropic")

hanzo_mcp/tools/agent/review_tool.py

@@ -83,9 +83,7 @@ review(
             file_paths: Optional[List[str]] = None,
             context: Optional[str] = None,
         ) -> str:
-            return await tool_self.call(
-                ctx, focus, work_description, code_snippets, file_paths, context
-            )
+            return await tool_self.call(ctx, focus, work_description, code_snippets, file_paths, context)
 
 
 class BalancedReviewer:
@@ -210,23 +208,18 @@ class BalancedReviewer:
 
         if code_snippets:
             total_lines = sum(snippet.count("\n") + 1 for snippet in code_snippets)
-            avg_line_length = sum(
-                len(line) for snippet in code_snippets for line in snippet.split("\n")
-            ) / max(total_lines, 1)
+            avg_line_length = sum(len(line) for snippet in code_snippets for line in snippet.split("\n")) / max(
+                total_lines, 1
+            )
 
             if avg_line_length < 80:
                 response += "✓ Line lengths are reasonable\n"
             else:
-                response += (
-                    "• Some lines might be too long, consider breaking them up\n"
-                )
+                response += "• Some lines might be too long, consider breaking them up\n"
 
             # Check naming
             has_good_names = any(
-                any(
-                    word in snippet
-                    for word in ["Add", "Get", "Set", "Create", "Update", "Delete"]
-                )
+                any(word in snippet for word in ["Add", "Get", "Set", "Create", "Update", "Delete"])
                 for snippet in code_snippets
             )
             if has_good_names:
@@ -264,10 +257,7 @@ class BalancedReviewer:
         # Check for modularity in code
         if code_snippets:
             function_count = sum(
-                snippet.count("func ")
-                + snippet.count("def ")
-                + snippet.count("function ")
-                for snippet in code_snippets
+                snippet.count("func ") + snippet.count("def ") + snippet.count("function ") for snippet in code_snippets
             )
             if function_count > 0:
                 response += "✓ Code is broken into functions/methods\n"
@@ -334,8 +324,7 @@ class BalancedReviewer:
         has_comments = False
         if code_snippets:
             has_comments = any(
-                "//" in snippet or "/*" in snippet or "#" in snippet or '"""' in snippet
-                for snippet in code_snippets
+                "//" in snippet or "/*" in snippet or "#" in snippet or '"""' in snippet for snippet in code_snippets
             )
 
         if has_comments:
@@ -372,9 +361,7 @@ class BalancedReviewer:
         # Analyze file structure
         if file_paths:
             # Check for separation of concerns
-            has_separation = (
-                len(set(str(p).split("/")[-2] for p in file_paths if "/" in str(p))) > 1
-            )
+            has_separation = len(set(str(p).split("/")[-2] for p in file_paths if "/" in str(p))) > 1
             if has_separation:
                 response += "✓ Changes span multiple modules (good separation)\n"
             else:
@@ -426,9 +413,7 @@ class ReviewProtocol:
         except KeyError:
             focus_enum = ReviewFocus.GENERAL
 
-        review = self.reviewer.review(
-            focus_enum, work_description, code_snippets, file_paths, context
-        )
+        review = self.reviewer.review(focus_enum, work_description, code_snippets, file_paths, context)
 
         header = f"Review {self.review_count}/{self.max_reviews} (Focus: {focus_enum.value}):\n\n"
         footer = "\n\n💡 This is a balanced review - consider both strengths and suggestions."

hanzo_mcp/tools/agent/swarm_alias.py

@@ -61,9 +61,7 @@ For new code, prefer using 'network' directly."""
             **kwargs: Additional arguments passed to NetworkTool
         """
         # Just pass through to NetworkTool
-        super().__init__(
-            permission_manager=permission_manager, default_mode=default_mode, **kwargs
-        )
+        super().__init__(permission_manager=permission_manager, default_mode=default_mode, **kwargs)
 
     async def call(self, **kwargs) -> str:
         """Execute swarm via network tool.

hanzo_mcp/tools/agent/unified_cli_tools.py

@@ -21,10 +21,10 @@ from ...core.model_registry import registry
 
 class UnifiedCLITool(BaseTool, CLIAgent):
     """Unified CLI tool that combines BaseTool and CLIAgent functionality.
-    
+
     MRO: BaseTool first for proper method resolution order.
     """
-    
+
     def __init__(
         self,
         name: str,
@@ -34,7 +34,7 @@ class UnifiedCLITool(BaseTool, CLIAgent):
         permission_manager: Optional[PermissionManager] = None,
     ):
         """Initialize unified CLI tool.
-        
+
         Args:
             name: Tool name
             description: Tool description
@@ -45,47 +45,47 @@ class UnifiedCLITool(BaseTool, CLIAgent):
         # Initialize CLIAgent with config
         config = AgentConfig(model=default_model)
         CLIAgent.__init__(self, config)
-        
+
         # Store tool metadata
         self._name = name
         self._description = description
         self._cli_command = cli_command
         self.permission_manager = permission_manager
-    
+
     @property
     def name(self) -> str:
         return self._name
-    
+
     @property
     def description(self) -> str:
         return self._description
-    
+
     @property
     def cli_command(self) -> str:
         return self._cli_command
-    
+
     def build_command(self, prompt: str, **kwargs: Any) -> List[str]:
         """Build the CLI command with model-specific formatting.
-        
+
         Args:
             prompt: The prompt
             **kwargs: Additional parameters
-            
+
         Returns:
             Command arguments list
         """
         command = [self.cli_command]
-        
+
         # Get model config from registry
         model_config = registry.get(self.config.model)
-        
+
         # Handle different CLI tool formats
         if self.cli_command == "claude":
             if model_config:
                 command.extend(["--model", model_config.full_name])
             # Claude takes prompt via stdin
             return command
-            
+
         elif self.cli_command == "openai":
             # OpenAI CLI format
             command.extend(["api", "chat.completions.create"])
@@ -93,14 +93,14 @@ class UnifiedCLITool(BaseTool, CLIAgent):
                 command.extend(["-m", model_config.full_name])
             command.extend(["-g", "user", prompt])
             return command
-            
+
         elif self.cli_command in ["gemini", "grok"]:
             # Simple format: command --model MODEL prompt
             if model_config:
                 command.extend(["--model", model_config.full_name])
             command.append(prompt)
             return command
-            
+
         elif self.cli_command == "openhands":
             # OpenHands format
             command.extend(["run", prompt])
@@ -109,7 +109,7 @@ class UnifiedCLITool(BaseTool, CLIAgent):
             if self.config.working_dir:
                 command.extend(["--workspace", str(self.config.working_dir)])
             return command
-            
+
         elif self.cli_command == "hanzo":
             # Hanzo dev format
             command.append("dev")
@@ -117,13 +117,13 @@ class UnifiedCLITool(BaseTool, CLIAgent):
                 command.extend(["--model", model_config.full_name])
             command.extend(["--prompt", prompt])
             return command
-            
+
         elif self.cli_command == "cline":
             # Cline format
             command.append(prompt)
             command.append("--no-interactive")
             return command
-            
+
         elif self.cli_command == "aider":
             # Aider format
             if model_config:
@@ -131,24 +131,24 @@ class UnifiedCLITool(BaseTool, CLIAgent):
             command.extend(["--message", prompt])
             command.extend(["--yes", "--no-stream"])
             return command
-            
+
         elif self.cli_command == "ollama":
             # Ollama format for local models
             command.extend(["run", self.config.model.replace("ollama/", "")])
             command.append(prompt)
             return command
-        
+
         # Default format
         command.append(prompt)
         return command
-    
+
     async def call(self, ctx: Context[Any, Any, Any], **params: Any) -> str:
         """Execute the CLI tool via MCP interface.
-        
+
         Args:
             ctx: MCP context
             **params: Tool parameters
-            
+
         Returns:
             Execution result
         """
@@ -159,23 +159,23 @@ class UnifiedCLITool(BaseTool, CLIAgent):
             self.config.working_dir = Path(params["working_dir"])
         if params.get("timeout"):
             self.config.timeout = params["timeout"]
-        
+
         # Execute using base agent
         result = await self.execute(
             params.get("prompt", ""),
             context=ctx,
         )
-        
+
         return result.content
-    
+
     def register(self, mcp_server: FastMCP) -> None:
         """Register this tool with the MCP server.
-        
+
         Args:
             mcp_server: The FastMCP server instance
         """
         tool_self = self
-        
+
         @mcp_server.tool(name=self.name, description=self.description)
         async def tool_wrapper(
             prompt: str,
@@ -195,15 +195,15 @@ class UnifiedCLITool(BaseTool, CLIAgent):
 
 def create_cli_tools(permission_manager: Optional[PermissionManager] = None) -> Dict[str, UnifiedCLITool]:
     """Create all CLI tools with unified implementation.
-    
+
     Args:
         permission_manager: Permission manager for access control
-        
+
     Returns:
         Dictionary of tool name to tool instance
     """
     tools = {}
-    
+
     # Define all tools with their configurations
     tool_configs = [
         ("claude", "Execute Claude CLI for AI assistance", "claude", "claude"),
@@ -217,7 +217,7 @@ def create_cli_tools(permission_manager: Optional[PermissionManager] = None) ->
         ("cline", "Execute Cline for autonomous coding", "cline", "claude"),
         ("aider", "Execute Aider for AI pair programming", "aider", "gpt-4-turbo"),
     ]
-    
+
     for name, description, cli_command, default_model in tool_configs:
         tools[name] = UnifiedCLITool(
             name=name,
@@ -226,7 +226,7 @@ def create_cli_tools(permission_manager: Optional[PermissionManager] = None) ->
             default_model=default_model,
             permission_manager=permission_manager,
         )
-    
+
     return tools
 
 
@@ -235,20 +235,20 @@ def register_cli_tools(
     permission_manager: Optional[PermissionManager] = None,
 ) -> List[BaseTool]:
     """Register all CLI tools with the MCP server.
-    
+
     Args:
         mcp_server: The FastMCP server instance
         permission_manager: Permission manager for access control
-        
+
     Returns:
         List of registered CLI tools
     """
     tools = create_cli_tools(permission_manager)
-    
+
     # Register each tool
     for tool in tools.values():
         tool.register(mcp_server)
-    
+
     return list(tools.values())
 
 
@@ -256,4 +256,4 @@ __all__ = [
     "UnifiedCLITool",
     "create_cli_tools",
     "register_cli_tools",
-]
+]

hanzo_mcp/tools/common/batch_tool.py

@@ -177,30 +177,22 @@ Not available: think,write,edit,multi_edit,notebook_edit
 
         # Validate required parameters
         if not description:
-            await tool_ctx.error(
-                "Parameter 'description' is required but was None or empty"
-            )
+            await tool_ctx.error("Parameter 'description' is required but was None or empty")
             return "Error: Parameter 'description' is required but was None or empty"
 
         if not invocations:
-            await tool_ctx.error(
-                "Parameter 'invocations' is required but was None or empty"
-            )
+            await tool_ctx.error("Parameter 'invocations' is required but was None or empty")
             return "Error: Parameter 'invocations' is required but was None or empty"
 
         if not isinstance(invocations, list) or len(invocations) == 0:
             await tool_ctx.error("Parameter 'invocations' must be a non-empty list")
             return "Error: Parameter 'invocations' must be a non-empty list"
 
-        await tool_ctx.info(
-            f"Executing batch operation: {description} ({len(invocations)} invocations)"
-        )
+        await tool_ctx.info(f"Executing batch operation: {description} ({len(invocations)} invocations)")
 
         # Execute all tool invocations in parallel
         tasks: list[asyncio.Future[dict[str, Any]]] = []
-        invocation_map: dict[asyncio.Future[dict[str, Any]], dict[str, Any]] = (
-            {}
-        )  # Map task Future to invocation
+        invocation_map: dict[asyncio.Future[dict[str, Any]], dict[str, Any]] = {}  # Map task Future to invocation
 
         for i, invocation in enumerate(invocations):
             # Extract tool name and input from invocation
@@ -213,9 +205,7 @@ Not available: think,write,edit,multi_edit,notebook_edit
                 await tool_ctx.error(error_message)
                 # Add direct result for this invocation
                 tasks.append(asyncio.Future())
-                tasks[-1].set_result(
-                    {"invocation": invocation, "result": f"Error: {error_message}"}
-                )
+                tasks[-1].set_result({"invocation": invocation, "result": f"Error: {error_message}"})
                 invocation_map[tasks[-1]] = invocation
                 continue
 
@@ -225,9 +215,7 @@ Not available: think,write,edit,multi_edit,notebook_edit
                 await tool_ctx.error(error_message)
                 # Add direct result for this invocation
                 tasks.append(asyncio.Future())
-                tasks[-1].set_result(
-                    {"invocation": invocation, "result": f"Error: {error_message}"}
-                )
+                tasks[-1].set_result({"invocation": invocation, "result": f"Error: {error_message}"})
                 invocation_map[tasks[-1]] = invocation
                 continue
 
@@ -237,9 +225,7 @@ Not available: think,write,edit,multi_edit,notebook_edit
                 await tool_ctx.info(f"Creating task for tool: {tool_name}")
 
                 # Create coroutine for this tool execution
-                async def execute_tool(
-                    tool_obj: BaseTool, tool_name: str, tool_input: dict[str, Any]
-                ):
+                async def execute_tool(tool_obj: BaseTool, tool_name: str, tool_input: dict[str, Any]):
                     try:
                         await tool_ctx.info(f"Executing tool: {tool_name}")
                         result = await tool_obj.call(ctx, **tool_input)
@@ -265,9 +251,7 @@ Not available: think,write,edit,multi_edit,notebook_edit
                 await tool_ctx.error(error_message)
                 # Add direct result for this invocation
                 tasks.append(asyncio.Future())
-                tasks[-1].set_result(
-                    {"invocation": invocation, "result": f"Error: {error_message}"}
-                )
+                tasks[-1].set_result({"invocation": invocation, "result": f"Error: {error_message}"})
                 invocation_map[tasks[-1]] = invocation
 
         # Wait for all tasks to complete
@@ -284,9 +268,7 @@ Not available: think,write,edit,multi_edit,notebook_edit
                 tool_name: str = invocation.get("tool_name", "unknown")
                 error_message = f"Unexpected error in tool '{tool_name}': {str(e)}"
                 await tool_ctx.error(error_message)
-                results.append(
-                    {"invocation": invocation, "result": f"Error: {error_message}"}
-                )
+                results.append({"invocation": invocation, "result": f"Error: {error_message}"})
 
         # Extract cursor if provided
         cursor = params.get("cursor")
@@ -314,9 +296,7 @@ Not available: think,write,edit,multi_edit,notebook_edit
             )
 
         # Create paginated response with token awareness
-        paginated_response = create_paginated_response(
-            formatted_results, cursor=cursor, use_token_limit=True
-        )
+        paginated_response = create_paginated_response(formatted_results, cursor=cursor, use_token_limit=True)
 
         # Convert paginated response to string format for MCP
         if isinstance(paginated_response, dict) and "items" in paginated_response:
@@ -326,13 +306,9 @@ Not available: think,write,edit,multi_edit,notebook_edit
             # Add header
             result_parts.append(f"=== Batch operation: {description} ===")
             result_parts.append(f"Total invocations: {len(invocations)}")
-            result_parts.append(
-                f"Showing results: {len(paginated_response['items'])} of {len(results)}"
-            )
+            result_parts.append(f"Showing results: {len(paginated_response['items'])} of {len(results)}")
             if paginated_response.get("hasMore"):
-                result_parts.append(
-                    f"More results available - use cursor: {paginated_response.get('nextCursor')}"
-                )
+                result_parts.append(f"More results available - use cursor: {paginated_response.get('nextCursor')}")
             result_parts.append("")
 
             # Format each result
@@ -352,12 +328,8 @@ Not available: think,write,edit,multi_edit,notebook_edit
 
             # If there's a next cursor, we need to preserve it in the response
             # For now, append it as a note at the end
-            if paginated_response.get("hasMore") and paginated_response.get(
-                "nextCursor"
-            ):
-                formatted_output += (
-                    f"\n\n[To continue, use cursor: {paginated_response['nextCursor']}]"
-                )
+            if paginated_response.get("hasMore") and paginated_response.get("nextCursor"):
+                formatted_output += f"\n\n[To continue, use cursor: {paginated_response['nextCursor']}]"
 
             await tool_ctx.info(
                 f"Batch operation '{description}' completed with {len(paginated_response['items'])} results"
@@ -424,6 +396,4 @@ Not available: think,write,edit,multi_edit,notebook_edit
             cursor: Cursor,
             ctx: MCPContext,
         ) -> str:
-            return await tool_self.call(
-                ctx, description=description, invocations=invocations, cursor=cursor
-            )
+            return await tool_self.call(ctx, description=description, invocations=invocations, cursor=cursor)