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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hanzo-mcp
-Version: 0.3.8
+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"
@@ -96,6 +97,37 @@ 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](./docs/USEFUL_PROMPTS.md) for some inspiration on how to use hanzo-mcp.

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.8.dist-info → hanzo_mcp-0.5.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (79.0.1)
+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)