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

{hanzo_mcp-0.3.4.dist-info → hanzo_mcp-0.5.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hanzo-mcp
-Version: 0.3.4
+Version: 0.5.0
 Summary: MCP implementation of Hanzo capabilities
 Author-email: Hanzo Industries Inc <dev@hanzo.ai>
 License: MIT
@@ -20,6 +20,7 @@ Requires-Dist: uvicorn>=0.23.1
 Requires-Dist: openai>=1.50.0
 Requires-Dist: python-dotenv>=1.0.0
 Requires-Dist: litellm>=1.40.14
+Requires-Dist: grep-ast>=0.8.1
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0.0; extra == "dev"
 Requires-Dist: pytest-cov>=4.1.0; extra == "dev"
@@ -50,7 +51,7 @@ An implementation of Hanzo capabilities using the Model Context Protocol (MCP).
 
 This project provides an MCP server that implements Hanzo-like functionality, allowing Claude to directly execute instructions for modifying and improving project files. By leveraging the Model Context Protocol, this implementation enables seamless integration with various MCP clients including Claude Desktop.
 
-![example](./doc/example.gif)
+![example](./docs/example.gif)
 
 ## Features
 
@@ -96,9 +97,40 @@ uv pip install hanzo-mcp
 pip install hanzo-mcp
 ```
 
+### Claude Desktop Integration
+
+To install and configure hanzo-mcp for use with Claude Desktop:
+
+```bash
+# Install the package globally
+uv pip install hanzo-mcp
+
+# Install configuration to Claude Desktop with default settings
+hanzo-mcp --install
+```
+
+For development, if you want to install your local version to Claude Desktop:
+
+```bash
+# Clone and navigate to the repository
+git clone https://github.com/hanzoai/mcp.git
+cd mcp
+
+# Install and configure for Claude Desktop
+make install-desktop
+
+# With custom paths and server name
+make install-desktop ALLOWED_PATHS="/path/to/projects,/another/path" SERVER_NAME="hanzo-dev"
+
+# Disable write tools (useful if you prefer using your IDE for edits)
+make install-desktop DISABLE_WRITE=1
+```
+
+After installation, restart Claude Desktop. You'll see "hanzo" (or your custom server name) available in the MCP server dropdown.
+
 For detailed installation and configuration instructions, please refer to the [documentation](./docs/).
 
-Of course, you can also read [USEFUL_PROMPTS](./doc/USEFUL_PROMPTS.md) for some inspiration on how to use hanzo-mcp.
+Of course, you can also read [USEFUL_PROMPTS](./docs/USEFUL_PROMPTS.md) for some inspiration on how to use hanzo-mcp.
 
 ## Security
 

hanzo_mcp-0.5.0.dist-info/RECORD

@@ -0,0 +1,63 @@
+hanzo_mcp/__init__.py,sha256=_HhgLXRNztyXYLjqCEuPOeVQ7tZ0pRxqkZziKkpSUrE,89
+hanzo_mcp/cli.py,sha256=fX8HtsD44elZhYre7Dn6RmH5lUt2AFRWz6ehGeoCkUY,9784
+hanzo_mcp/cli_enhanced.py,sha256=rqh9gqyjMuUznIlPTC5pcIGYZTKAScacMsDb1e68ReE,15819
+hanzo_mcp/server.py,sha256=mYiIcsAtQO2c_MGExYbzk5tj2U-MjcDWfTU5T22KuwQ,8107
+hanzo_mcp/config/__init__.py,sha256=iZYGSJMsC1c97gRFqgyowfP4XW480BBVRAQq1r-Dp7g,506
+hanzo_mcp/config/settings.py,sha256=ibMmec9Zm5wHu-Y8e3o1F0_rgzP9V7pVOZjcW35l3KI,14058
+hanzo_mcp/config/tool_config.py,sha256=AT5eJRZAL8VTLu5DCdoC_MkDxtufVE_QOj7Yp_Fyi8k,6317
+hanzo_mcp/prompts/__init__.py,sha256=L3eolRTyTohIp5JA0xv50TSFU4YSf_ycEEaODta7Ve0,3989
+hanzo_mcp/prompts/compact_conversation.py,sha256=nvD068KEesiMcevxxMBeIJh6AqT7YHOqyH6RepRFFfA,4206
+hanzo_mcp/prompts/create_release.py,sha256=1Z8xSTtz5vAm0rWFnERpFu7wIYExT4iXhM6nGmQaM-s,1374
+hanzo_mcp/prompts/project_system.py,sha256=fQhOM6AGb6VIZQE_fSPDeS9slBGVkz_f_UbNNhxPRdw,7031
+hanzo_mcp/prompts/project_todo_reminder.py,sha256=otiBdmzxssBSb3MZZSQsjYDGLBqi1bM0HgraELP_Nf4,3645
+hanzo_mcp/prompts/utils.py,sha256=IwxIhzZfYJ2anToPulbrpcc07u4Dozo9ok6VE3BC_4A,9963
+hanzo_mcp/tools/__init__.py,sha256=q8bVRv11mHTRSZL9PPHlTl3kr4GUAygPk78QjCYavT4,6728
+hanzo_mcp/tools/agent/__init__.py,sha256=MZ-LMIYptodQn1JpAEyNMbqRlioS4R8scgzNgsU189E,1897
+hanzo_mcp/tools/agent/agent_tool.py,sha256=w-Oy2wPPTz79SCzmi7NsI8RU4eLbFKMTXDi-sFKrrbo,21268
+hanzo_mcp/tools/agent/prompt.py,sha256=Wi9Z45hmQ92eUNZbOWzj9ZVCCr-fM1K9iyaRvTCAgrQ,4529
+hanzo_mcp/tools/agent/tool_adapter.py,sha256=Od7VtD9qqDbgxhDHj0L-rohX4wOSMtYjZnU2BRuWSqI,2151
+hanzo_mcp/tools/common/__init__.py,sha256=6LOEE9anSTsiPofgGNcD8CVHdU4SiaHjoQcRzNT2xos,921
+hanzo_mcp/tools/common/base.py,sha256=HB7glx3O9eq2B8nHQu1FbRjtlQZM77CKB1lwMGb-CuE,5631
+hanzo_mcp/tools/common/batch_tool.py,sha256=-FaZtH1cqd3xSHUrMaIvB664WEK0rKtTvzpUeEl0DhY,12073
+hanzo_mcp/tools/common/context.py,sha256=XrgzJwPQP8ooKoReveezVgRyOSJe-zfD5-knhusBgbg,5175
+hanzo_mcp/tools/common/permissions.py,sha256=LR1tuQAPMoaKvqNtHPRaiB0ZUb0Tbsg3e9L6vvd4FLU,7562
+hanzo_mcp/tools/common/thinking_tool.py,sha256=pEBSymlJZJIS2X0pc-2VX2dUAPi4ho2un-wa69yYTD8,5142
+hanzo_mcp/tools/common/validation.py,sha256=VV3VbDvYlAYl2Bi98xE7gFo0xnmqHHUGJGNPswm97qo,1694
+hanzo_mcp/tools/filesystem/__init__.py,sha256=M_Q8Z-w8UyXCKUXLUwPYMrKsOPybZoUs888THA6xqPY,4561
+hanzo_mcp/tools/filesystem/base.py,sha256=qwxer1jHgPIfyaUeC4QLzR9pjGWJCLP2L3qggUAulFY,3807
+hanzo_mcp/tools/filesystem/content_replace.py,sha256=hCiw9oQXS2_b6CjgC7XHOrRo5NH6H8zOFaSDS6Uwfgw,10015
+hanzo_mcp/tools/filesystem/directory_tree.py,sha256=LZTJRmrDdSFpq9EpcTmVytimCp_glpCVKDxf7UCyq20,10755
+hanzo_mcp/tools/filesystem/edit.py,sha256=PIlFsMjBG9WQw9IWC6dzLZly6UIBUcAUrohRkqyKFZY,10699
+hanzo_mcp/tools/filesystem/grep.py,sha256=-JKrBUk04tmObvwPh8UvBpLOc27NNndNt6eR5qSkCLs,16818
+hanzo_mcp/tools/filesystem/grep_ast_tool.py,sha256=F-HacdAISZI_jDGJrxIcZ-dyj3OG919JUVimpvgAZNA,8142
+hanzo_mcp/tools/filesystem/multi_edit.py,sha256=j8ytsFVsdQqJ9AWCJMQa8kWHyH4UpbBdHRIc7XepEJc,14313
+hanzo_mcp/tools/filesystem/read.py,sha256=uF1KdIAsKL8-oQiwOfL9-dkTzKOqQK0nKLVe6hW-5KE,8892
+hanzo_mcp/tools/filesystem/write.py,sha256=dkbZ61kYGRTzKPVtMG8ETYw8YHyo6YXb1cLI70ePYcQ,4833
+hanzo_mcp/tools/jupyter/__init__.py,sha256=IJnkx6vwxP2ZJOGvUxG25fhstlny-uFnNBLjGlUt5hs,2515
+hanzo_mcp/tools/jupyter/base.py,sha256=oxTz_exSsYni2cQJvL4gHZtC4EG5EU_1-nWyEdc-ZQ8,10090
+hanzo_mcp/tools/jupyter/notebook_edit.py,sha256=wKEEQJ36pfgB0JHQi2nV_X7ApXqy6HXZY9XO4lZ9Efg,11848
+hanzo_mcp/tools/jupyter/notebook_read.py,sha256=t2fkP5wAp8SBBaWHrty-uWsnn6l5WO2zIqISVSHnQus,5293
+hanzo_mcp/tools/shell/__init__.py,sha256=CcVnsAqSd8FLtVpkuHQK4cbKHWrac6o9enEIqNlxz4k,1951
+hanzo_mcp/tools/shell/base.py,sha256=twbz3EuX64cwvNlcHraZ5CcEhDpUvMI5mLTZvMADtbQ,5821
+hanzo_mcp/tools/shell/bash_session.py,sha256=YPtdtC0pc6Q04RJqKUy0u0RPTbiT2IGtsvFqejK5Hu4,27271
+hanzo_mcp/tools/shell/bash_session_executor.py,sha256=zRnrzj4sdQOxO22XXBENT6k2dXt3LDk5fxjWjUYyU_Q,10723
+hanzo_mcp/tools/shell/command_executor.py,sha256=IuoRY48PMmpKHL5CFIExebjoiRRS5ZEl73UDzYTR3kU,36406
+hanzo_mcp/tools/shell/run_command.py,sha256=Io6LyLm8XWZKZ-Zjhx3L-H5vmdNGoqbkU9jJzwL7zLs,16137
+hanzo_mcp/tools/shell/run_command_windows.py,sha256=MGXC76b0uYKhxg1-d9CijPP36ufRusgyq9Zurpo1vSc,15363
+hanzo_mcp/tools/shell/session_manager.py,sha256=o8iS4PFCnq28vPqYtdtH9M8lfGyzyhtNL0hmNI13Uuc,6509
+hanzo_mcp/tools/shell/session_storage.py,sha256=elnyFgn0FwsmVvoWAoJFAqiEeNaK4_yByT8-zXa6r-o,10141
+hanzo_mcp/tools/todo/__init__.py,sha256=Ai-rlVWcy-CkJf1H2zIsbyx0wkxzWNLR3WAbGszbXKg,1720
+hanzo_mcp/tools/todo/base.py,sha256=8sYZYAsFE5SjHRqynZCmCIKEobWB3aZwwSApg26keDo,10655
+hanzo_mcp/tools/todo/todo_read.py,sha256=zXI9jn-kWXGSj88tI63yoAv-EWPDpkX1E6m0QfMUQHE,4759
+hanzo_mcp/tools/todo/todo_write.py,sha256=fTAvrxrzkpdYwi7nYcJky2wjukChYsdXu5axqIUJg_c,15465
+hanzo_mcp/tools/vector/__init__.py,sha256=vNz7GM1P98TW-v6Y3KTwvaW7cO5P80mXAf6uKS0Y29M,3390
+hanzo_mcp/tools/vector/infinity_store.py,sha256=hYaSuRxqukwVDMgzrxs_Qdia7Gx-FFEGuHE-4KIACo0,12002
+hanzo_mcp/tools/vector/project_manager.py,sha256=JZ6c0m4RWKbV4JjkxAI6ZgyOy2Ymk8-o4ficTLZrIo0,12500
+hanzo_mcp/tools/vector/vector_index.py,sha256=FePsCTeVkA3Uth3PFIZykXprCPfef7cqCCV_vH7z0Eo,4316
+hanzo_mcp/tools/vector/vector_search.py,sha256=3dWS_jueMt07DSTZOKtz9El4uSwU9KgHUjRAiF14CxQ,9182
+hanzo_mcp-0.5.0.dist-info/licenses/LICENSE,sha256=mf1qZGFsPGskoPgytp9B-RsahfKvXsBpmaAbTLGTt8Y,1063
+hanzo_mcp-0.5.0.dist-info/METADATA,sha256=RRh07Zv5iMZRJZb2-nv92groJ5ql1VG2tS51Rj-fzhE,8930
+hanzo_mcp-0.5.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+hanzo_mcp-0.5.0.dist-info/entry_points.txt,sha256=aRKOKXtuQr-idSr-yH4efnRl2v8te94AcgN3ysqqSYs,49
+hanzo_mcp-0.5.0.dist-info/top_level.txt,sha256=eGFANatA0MHWiVlpS56fTYRIShtibrSom1uXI6XU0GU,10
+hanzo_mcp-0.5.0.dist-info/RECORD,,

{hanzo_mcp-0.3.4.dist-info → hanzo_mcp-0.5.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (78.1.0)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

hanzo_mcp/tools/agent/base_provider.py

@@ -1,73 +0,0 @@
-"""Base model provider for agent delegation.
-
-Defines the interface for model providers.
-"""
-
-import logging
-from abc import ABC, abstractmethod
-from typing import Any, Dict, List, Optional, Tuple
-
-logger = logging.getLogger(__name__)
-
-
-class BaseModelProvider(ABC):
-    """Base class for model providers."""
-    
-    @abstractmethod
-    async def initialize(self) -> None:
-        """Initialize the provider."""
-        pass
-        
-    @abstractmethod
-    async def load_model(self, model_name: str, identifier: Optional[str] = None) -> str:
-        """Load a model.
-        
-        Args:
-            model_name: The name of the model to load
-            identifier: Optional identifier for the model instance
-            
-        Returns:
-            The identifier for the loaded model
-        """
-        pass
-        
-    @abstractmethod
-    async def generate(
-        self,
-        model_id: str,
-        prompt: str,
-        system_prompt: Optional[str] = None,
-        max_tokens: int = 4096,
-        temperature: float = 0.7,
-        top_p: float = 0.95,
-        stop_sequences: Optional[List[str]] = None,
-    ) -> Tuple[str, Dict[str, Any]]:
-        """Generate a response from the model.
-        
-        Args:
-            model_id: The identifier of the model to use
-            prompt: The prompt to send to the model
-            system_prompt: Optional system prompt to send to the model
-            max_tokens: Maximum number of tokens to generate
-            temperature: Sampling temperature
-            top_p: Top-p sampling parameter
-            stop_sequences: Optional list of strings that will stop generation
-            
-        Returns:
-            A tuple of (generated text, metadata)
-        """
-        pass
-        
-    @abstractmethod
-    async def unload_model(self, model_id: str) -> None:
-        """Unload a model.
-        
-        Args:
-            model_id: The identifier of the model to unload
-        """
-        pass
-        
-    @abstractmethod
-    async def shutdown(self) -> None:
-        """Shutdown the provider."""
-        pass

hanzo_mcp/tools/agent/litellm_provider.py

@@ -1,45 +0,0 @@
-"""LiteLLM provider for agent delegation.
-
-Enables the use of various cloud LLM providers via LiteLLM.
-"""
-
-import asyncio
-import logging
-import json
-from typing import Any, Dict, List, Optional, Tuple
-
-from hanzo_mcp.tools.agent.base_provider import BaseModelProvider
-
-logger = logging.getLogger(__name__)
-
-# Define model capabilities
-DEFAULT_MAX_TOKENS = 4096
-DEFAULT_CONTEXT_WINDOW = 8192
-
-
-class LiteLLMProvider(BaseModelProvider):
-    """Provider for cloud models via LiteLLM."""
-
-    def __init__(self):
-        """Initialize the LiteLLM provider."""
-        self.models = {}
-        self.initialized = False
-        
-    async def initialize(self) -> None:
-        """Initialize the LiteLLM provider."""
-        if self.initialized:
-            return
-            
-        try:
-            # Import LiteLLM
-            import litellm
-            self.litellm = litellm
-            self.initialized = True
-            logger.info("LiteLLM provider initialized successfully")
-        except ImportError:
-            logger.error("Failed to import LiteLLM")
-            logger.error("Install LiteLLM with 'pip install litellm'")
-        except Exception as e:
-            logger.error(f"Failed to initialize LiteLLM provider: {str(e)}")
-            
-    async def load_model(self, model_name: str, identifier: Optional[str] = None

hanzo_mcp/tools/agent/lmstudio_agent.py

@@ -1,385 +0,0 @@
-"""LM Studio agent tool for parallel model execution.
-
-This module provides a tool for running tasks in parallel across multiple LM Studio models.
-"""
-
-import asyncio
-import json
-import logging
-import time
-from typing import Any, Dict, List, Optional, final, override
-
-from mcp.server.fastmcp import Context as MCPContext
-from mcp.server.fastmcp import FastMCP
-
-from hanzo_mcp.tools.common.base import BaseTool
-from hanzo_mcp.tools.common.context import DocumentContext, create_tool_context
-from hanzo_mcp.tools.common.permissions import PermissionManager
-from hanzo_mcp.tools.agent.lmstudio_provider import LMStudioProvider
-
-logger = logging.getLogger(__name__)
-
-
-@final
-class LMStudioAgentTool(BaseTool):
-    """Tool for parallel execution of tasks across multiple LM Studio models."""
-
-    @property
-    @override
-    def name(self) -> str:
-        """Get the tool name.
-        
-        Returns:
-            Tool name
-        """
-        return "lmstudio_dispatch"
-        
-    @property
-    @override
-    def description(self) -> str:
-        """Get the tool description.
-        
-        Returns:
-            Tool description
-        """
-        return """Run tasks in parallel across multiple LM Studio models.
-
-This tool allows you to dispatch the same task or different tasks to multiple locally available
-LM Studio models and execute them in parallel. This is useful for comparing model responses,
-leveraging different model strengths, or simply speeding up processing by distributing tasks.
-
-The task prompts can be the same for all models or different per model.
-
-Args:
-    model_tasks: A list of configurations, each with a 'model' name, and a 'prompt'.
-                Optionally can include 'system_prompt', 'temperature', 'max_tokens' and 'top_p'
-
-Returns:
-    Combined results from all model executions with performance metrics
-"""
-
-    @property
-    @override
-    def parameters(self) -> dict[str, Any]:
-        """Get the parameter specifications for the tool.
-        
-        Returns:
-            Parameter specifications
-        """
-        return {
-            "properties": {
-                "model_tasks": {
-                    "type": "array",
-                    "items": {
-                        "type": "object",
-                        "properties": {
-                            "model": {
-                                "type": "string",
-                                "description": "Name of the LM Studio model to use"
-                            },
-                            "identifier": {
-                                "type": "string",
-                                "description": "Optional identifier for the model instance"
-                            },
-                            "prompt": {
-                                "type": "string",
-                                "description": "Task prompt for the model"
-                            },
-                            "system_prompt": {
-                                "type": "string",
-                                "description": "Optional system prompt for the model"
-                            },
-                            "temperature": {
-                                "type": "number",
-                                "description": "Sampling temperature (defaults to 0.7)"
-                            },
-                            "max_tokens": {
-                                "type": "integer",
-                                "description": "Maximum tokens to generate (defaults to 2048)"
-                            },
-                            "top_p": {
-                                "type": "number",
-                                "description": "Top-p sampling parameter (defaults to 0.95)"
-                            }
-                        },
-                        "required": ["model", "prompt"]
-                    },
-                    "description": "List of model task configurations to execute in parallel"
-                }
-            },
-            "required": ["model_tasks"],
-            "type": "object"
-        }
-        
-    @property
-    @override
-    def required(self) -> list[str]:
-        """Get the list of required parameter names.
-        
-        Returns:
-            List of required parameter names
-        """
-        return ["model_tasks"]
-        
-    def __init__(self, document_context: DocumentContext, permission_manager: PermissionManager) -> None:
-        """Initialize the LM Studio agent tool.
-        
-        Args:
-            document_context: Document context for tracking file contents
-            permission_manager: Permission manager for access control
-        """
-        self.document_context = document_context
-        self.permission_manager = permission_manager
-        self.provider = LMStudioProvider()
-        
-    @override
-    async def call(self, ctx: MCPContext, **params: Any) -> str:
-        """Execute the tool with the given parameters.
-        
-        Args:
-            ctx: MCP context
-            **params: Tool parameters
-            
-        Returns:
-            Tool execution result
-        """
-        start_time = time.time()
-        
-        # Create tool context
-        tool_ctx = create_tool_context(ctx)
-        tool_ctx.set_tool_info(self.name)
-        
-        # Extract parameters
-        model_tasks = params.get("model_tasks")
-        if not model_tasks:
-            await tool_ctx.error("Parameter 'model_tasks' is required but was not provided")
-            return "Error: Parameter 'model_tasks' is required but was not provided"
-            
-        if not isinstance(model_tasks, list):
-            await tool_ctx.error("Parameter 'model_tasks' must be an array")
-            return "Error: Parameter 'model_tasks' must be an array"
-            
-        if not model_tasks:
-            await tool_ctx.error("At least one model task must be provided")
-            return "Error: At least one model task must be provided"
-            
-        # Validate each model task
-        for i, task in enumerate(model_tasks):
-            if not isinstance(task, dict):
-                await tool_ctx.error(f"Model task at index {i} must be an object")
-                return f"Error: Model task at index {i} must be an object"
-                
-            if "model" not in task:
-                await tool_ctx.error(f"Model task at index {i} must have a 'model' property")
-                return f"Error: Model task at index {i} must have a 'model' property"
-                
-            if "prompt" not in task:
-                await tool_ctx.error(f"Model task at index {i} must have a 'prompt' property")
-                return f"Error: Model task at index {i} must have a 'prompt' property"
-        
-        # Initialize the provider if needed
-        await self.provider.initialize()
-        
-        # Execute the tasks in parallel
-        await tool_ctx.info(f"Executing {len(model_tasks)} tasks across LM Studio models")
-        result = await self._execute_parallel_tasks(model_tasks, tool_ctx)
-        
-        # Calculate execution time
-        execution_time = time.time() - start_time
-        
-        # Format the result
-        formatted_result = self._format_result(result, execution_time)
-        
-        # Log completion
-        await tool_ctx.info(f"LM Studio model execution completed in {execution_time:.2f}s")
-        
-        return formatted_result
-    
-    async def _execute_parallel_tasks(self, model_tasks: List[Dict[str, Any]], tool_ctx: Any) -> List[Dict[str, Any]]:
-        """Execute multiple model tasks in parallel.
-        
-        Args:
-            model_tasks: List of model task configurations
-            tool_ctx: Tool context for logging
-            
-        Returns:
-            List of task results
-        """
-        # Create tasks for loading models
-        load_tasks = []
-        
-        for task in model_tasks:
-            model_name = task["model"]
-            identifier = task.get("identifier")
-            
-            await tool_ctx.info(f"Loading model: {model_name}" + (f" as {identifier}" if identifier else ""))
-            load_tasks.append(self.provider.load_model(model_name, identifier))
-            
-        # Wait for all models to load
-        try:
-            model_ids = await asyncio.gather(*load_tasks)
-        except Exception as e:
-            await tool_ctx.error(f"Failed to load models: {str(e)}")
-            return [{"error": f"Failed to load models: {str(e)}"}]
-            
-        # Create tasks for generating responses
-        generation_tasks = []
-        
-        for i, (task, model_id) in enumerate(zip(model_tasks, model_ids)):
-            prompt = task["prompt"]
-            system_prompt = task.get("system_prompt")
-            max_tokens = task.get("max_tokens", 2048)
-            temperature = task.get("temperature", 0.7)
-            top_p = task.get("top_p", 0.95)
-            
-            await tool_ctx.info(f"Generating with model {model_id}")
-            generation_tasks.append(
-                self._execute_single_task(
-                    model_id=model_id,
-                    prompt=prompt,
-                    system_prompt=system_prompt,
-                    max_tokens=max_tokens,
-                    temperature=temperature,
-                    top_p=top_p,
-                    task_index=i,
-                    tool_ctx=tool_ctx,
-                    original_task=task
-                )
-            )
-            
-        # Wait for all generation tasks to complete
-        results = await asyncio.gather(*generation_tasks, return_exceptions=True)
-        
-        # Process results, handling any exceptions
-        processed_results = []
-        for i, result in enumerate(results):
-            if isinstance(result, Exception):
-                processed_results.append({
-                    "model": model_tasks[i]["model"],
-                    "error": str(result),
-                    "success": False
-                })
-            else:
-                processed_results.append(result)
-                
-        return processed_results
-    
-    async def _execute_single_task(
-        self,
-        model_id: str,
-        prompt: str,
-        system_prompt: Optional[str],
-        max_tokens: int,
-        temperature: float,
-        top_p: float,
-        task_index: int,
-        tool_ctx: Any,
-        original_task: Dict[str, Any]
-    ) -> Dict[str, Any]:
-        """Execute a single model task.
-        
-        Args:
-            model_id: Model identifier
-            prompt: Prompt for the model
-            system_prompt: Optional system prompt
-            max_tokens: Maximum tokens to generate
-            temperature: Sampling temperature
-            top_p: Top-p sampling parameter
-            task_index: Index of the task
-            tool_ctx: Tool context for logging
-            original_task: Original task configuration
-            
-        Returns:
-            Task result
-        """
-        task_start_time = time.time()
-        
-        try:
-            # Generate response
-            generated_text, metadata = await self.provider.generate(
-                model_id=model_id,
-                prompt=prompt,
-                system_prompt=system_prompt,
-                max_tokens=max_tokens,
-                temperature=temperature,
-                top_p=top_p
-            )
-            
-            # Calculate execution time
-            task_execution_time = time.time() - task_start_time
-            
-            await tool_ctx.info(f"Task {task_index} completed in {task_execution_time:.2f}s")
-            
-            # Return result
-            return {
-                "model": original_task["model"],
-                "identifier": model_id,
-                "result": generated_text,
-                "execution_time": task_execution_time,
-                "success": True,
-                "metadata": metadata
-            }
-        except Exception as e:
-            await tool_ctx.error(f"Error executing task {task_index}: {str(e)}")
-            return {
-                "model": original_task["model"],
-                "identifier": model_id,
-                "error": str(e),
-                "execution_time": time.time() - task_start_time,
-                "success": False
-            }
-    
-    def _format_result(self, results: List[Dict[str, Any]], total_execution_time: float) -> str:
-        """Format the task results.
-        
-        Args:
-            results: List of task results
-            total_execution_time: Total execution time
-            
-        Returns:
-            Formatted results
-        """
-        # Calculate summary statistics
-        successful = [r for r in results if r.get("success", False)]
-        failed = [r for r in results if not r.get("success", False)]
-        
-        # Create the result string
-        output = [f"### LM Studio Dispatch Results\n"]
-        output.append(f"**Total execution time:** {total_execution_time:.2f}s")
-        output.append(f"**Models used:** {len(results)}")
-        output.append(f"**Successful:** {len(successful)}")
-        output.append(f"**Failed:** {len(failed)}\n")
-        
-        # Add the results for each model
-        for i, result in enumerate(results):
-            model_name = result.get("model", "Unknown model")
-            model_id = result.get("identifier", model_name)
-            
-            output.append(f"## Model {i+1}: {model_name}")
-            
-            if result.get("success", False):
-                exec_time = result.get("execution_time", 0)
-                output.append(f"**Execution time:** {exec_time:.2f}s")
-                
-                # Add the result
-                output.append("\n**Result:**\n")
-                output.append(result.get("result", "No result"))
-            else:
-                output.append(f"**Error:** {result.get('error', 'Unknown error')}")
-                
-            output.append("\n" + "-" * 40 + "\n")
-            
-        return "\n".join(output)
-    
-    @override
-    def register(self, mcp_server: FastMCP) -> None:
-        """Register this tool with the MCP server.
-        
-        Args:
-            mcp_server: The FastMCP server instance
-        """
-        tool_self = self  # Create a reference to self for use in the closure
-        
-        @mcp_server.tool(name=self.name, description=self.mcp_description)
-        async def lmstudio_dispatch(ctx: MCPContext, model_tasks: List[Dict[str, Any]]) -> str:
-            return await tool_self.call(ctx, model_tasks=model_tasks)