hanzo-mcp 0.8.2__py3-none-any.whl → 0.8.3__py3-none-any.whl

hanzo_mcp/compute_nodes.py

@@ -8,33 +8,39 @@ from typing import Any, Dict, List
 
 class ComputeNodeDetector:
     """Detect available compute nodes (GPUs, WebGPU, CPUs) for distributed work."""
-    
+
     @staticmethod
     def detect_local_gpus() -> List[Dict[str, Any]]:
         """Detect local GPU devices."""
         gpus = []
-        
+
         # Try NVIDIA GPUs
         try:
             result = subprocess.run(
-                ["nvidia-smi", "--query-gpu=name,memory.total", "--format=csv,noheader"],
+                [
+                    "nvidia-smi",
+                    "--query-gpu=name,memory.total",
+                    "--format=csv,noheader",
+                ],
                 capture_output=True,
                 text=True,
-                timeout=2
+                timeout=2,
             )
             if result.returncode == 0:
-                for line in result.stdout.strip().split('\n'):
+                for line in result.stdout.strip().split("\n"):
                     if line:
-                        name, memory = line.split(', ')
-                        gpus.append({
-                            "type": "cuda",
-                            "name": name,
-                            "memory": memory,
-                            "id": f"cuda:{len(gpus)}"
-                        })
+                        name, memory = line.split(", ")
+                        gpus.append(
+                            {
+                                "type": "cuda",
+                                "name": name,
+                                "memory": memory,
+                                "id": f"cuda:{len(gpus)}",
+                            }
+                        )
         except (FileNotFoundError, subprocess.TimeoutExpired):
             pass
-        
+
         # Try Metal GPUs (macOS)
         if platform.system() == "Darwin":
             try:
@@ -43,96 +49,103 @@ class ComputeNodeDetector:
                     ["system_profiler", "SPDisplaysDataType"],
                     capture_output=True,
                     text=True,
-                    timeout=2
+                    timeout=2,
                 )
                 if result.returncode == 0 and "Metal" in result.stdout:
                     # Parse GPU info from system_profiler
-                    lines = result.stdout.split('\n')
+                    lines = result.stdout.split("\n")
                     for i, line in enumerate(lines):
-                        if 'Chipset Model:' in line:
-                            gpu_name = line.split(':')[1].strip()
-                            gpus.append({
-                                "type": "metal",
-                                "name": gpu_name,
-                                "memory": "Shared",
-                                "id": f"metal:{len(gpus)}"
-                            })
+                        if "Chipset Model:" in line:
+                            gpu_name = line.split(":")[1].strip()
+                            gpus.append(
+                                {
+                                    "type": "metal",
+                                    "name": gpu_name,
+                                    "memory": "Shared",
+                                    "id": f"metal:{len(gpus)}",
+                                }
+                            )
             except (FileNotFoundError, subprocess.TimeoutExpired):
                 pass
-        
+
         return gpus
-    
+
     @staticmethod
     def detect_webgpu_nodes() -> List[Dict[str, Any]]:
         """Detect connected WebGPU nodes (from browsers)."""
         webgpu_nodes = []
-        
+
         # Check for WebGPU connections (would need actual WebSocket/server to track)
         # For now, check if a WebGPU server is running
         webgpu_port = os.environ.get("HANZO_WEBGPU_PORT", "8765")
         try:
             import socket
+
             sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-            result = sock.connect_ex(('localhost', int(webgpu_port)))
+            result = sock.connect_ex(("localhost", int(webgpu_port)))
             sock.close()
             if result == 0:
-                webgpu_nodes.append({
-                    "type": "webgpu",
-                    "name": "Chrome WebGPU",
-                    "memory": "Browser",
-                    "id": "webgpu:0"
-                })
+                webgpu_nodes.append(
+                    {
+                        "type": "webgpu",
+                        "name": "Chrome WebGPU",
+                        "memory": "Browser",
+                        "id": "webgpu:0",
+                    }
+                )
         except Exception:
             pass
-        
+
         return webgpu_nodes
-    
+
     @staticmethod
     def detect_cpu_nodes() -> List[Dict[str, Any]]:
         """Detect CPU compute nodes."""
         import multiprocessing
-        
-        return [{
-            "type": "cpu",
-            "name": f"{platform.processor() or 'CPU'}",
-            "cores": multiprocessing.cpu_count(),
-            "id": "cpu:0"
-        }]
-    
+
+        return [
+            {
+                "type": "cpu",
+                "name": f"{platform.processor() or 'CPU'}",
+                "cores": multiprocessing.cpu_count(),
+                "id": "cpu:0",
+            }
+        ]
+
     @classmethod
     def get_all_nodes(cls) -> List[Dict[str, Any]]:
         """Get all available compute nodes."""
         nodes = []
-        
+
         # Detect GPUs
         gpus = cls.detect_local_gpus()
         nodes.extend(gpus)
-        
+
         # Detect WebGPU connections
         webgpu = cls.detect_webgpu_nodes()
         nodes.extend(webgpu)
-        
+
         # If no GPUs/WebGPU, add CPU as compute node
         if not nodes:
             nodes.extend(cls.detect_cpu_nodes())
-        
+
         return nodes
-    
+
     @classmethod
     def get_node_count(cls) -> int:
         """Get total number of available compute nodes."""
         return len(cls.get_all_nodes())
-    
+
     @classmethod
     def get_node_summary(cls) -> str:
         """Get a summary string of available nodes."""
         nodes = cls.get_all_nodes()
         if not nodes:
             return "No compute nodes available"
-        
+
         count = len(nodes)
         node_word = "node" if count == 1 else "nodes"
-        
+
         # Group by type
         types = {}
         for node in nodes:
@@ -140,7 +153,7 @@ class ComputeNodeDetector:
             if node_type not in types:
                 types[node_type] = 0
             types[node_type] += 1
-        
+
         # Build summary
         parts = []
         for node_type, type_count in types.items():
@@ -152,7 +165,7 @@ class ComputeNodeDetector:
                 parts.append(f"{type_count} WebGPU")
             elif node_type == "cpu":
                 parts.append(f"{type_count} CPU")
-        
+
         type_str = ", ".join(parts)
         return f"{count} {node_word} available ({type_str})"
 
@@ -161,7 +174,7 @@ def print_node_status():
     """Print current node status."""
     detector = ComputeNodeDetector()
     nodes = detector.get_all_nodes()
-    
+
     print(f"\n🖥️  Compute Nodes: {len(nodes)}")
     for node in nodes:
         if node["type"] in ["cuda", "metal"]:
@@ -176,4 +189,4 @@ def print_node_status():
 if __name__ == "__main__":
     # Test the detector
     print_node_status()
-    print(ComputeNodeDetector.get_node_summary())
+    print(ComputeNodeDetector.get_node_summary())

hanzo_mcp/config/settings.py

@@ -514,6 +514,17 @@ def _merge_config(
 
     merged = deep_merge(base_dict, config_dict)
 
+    # Backwards/forwards compatibility: support a structured "tools" section
+    # where each tool can define { enabled: bool, ...options } and map it to
+    # the existing enabled_tools/disabled_tools layout.
+    tools_cfg = merged.get("tools", {})
+    if isinstance(tools_cfg, dict):
+        enabled_tools = dict(merged.get("enabled_tools", {}))
+        for tool_name, tool_data in tools_cfg.items():
+            if isinstance(tool_data, dict) and "enabled" in tool_data:
+                enabled_tools[tool_name] = bool(tool_data.get("enabled"))
+        merged["enabled_tools"] = enabled_tools
+
     # Reconstruct the settings object
     mcp_servers = {}
     for name, server_data in merged.get("mcp_servers", {}).items():