unifi-network-mcp 0.3.0__py3-none-any.whl → 0.3.2__py3-none-any.whl

src/config/config.yaml

@@ -12,13 +12,43 @@ server:
   port: 3000
   log_level: INFO
 
-  # Tool registration mode (New in v0.2.0)
+  # Tool registration mode
   # Options: eager, lazy, meta_only
-  # - eager: Register all 67 tools immediately (~5,000 tokens) - Best for dev console, automation
-  # - lazy: Register 3 meta-tools, load others on-demand (~225 tokens) - RECOMMENDED for LLMs
-  # - meta_only: Register only 3 meta-tools, manual discovery (~225 tokens) - Maximum control
+  # - eager: Register all tools immediately - Best for dev console, automation
+  # - lazy: Register meta-tools, load others on-demand - RECOMMENDED for LLMs
+  # - meta_only: Register only meta-tools, manual discovery - Maximum context savings
   tool_registration_mode: ${oc.env:UNIFI_TOOL_REGISTRATION_MODE,lazy}
 
+  # Tool filtering (optional, for eager mode)
+  # Use these to limit which tools are registered for automation/n8n workflows
+  #
+  # enabled_categories: Only load tools from these categories (module names in src/tools/)
+  #   Valid values:
+  #     - clients        # Client listing, blocking, guest auth
+  #     - config         # Configuration management
+  #     - devices        # Device listing, reboot, locate, upgrade
+  #     - events         # Events and alarms
+  #     - firewall       # Firewall rules and groups
+  #     - hotspot        # Vouchers for guest network
+  #     - network        # Network/VLAN management
+  #     - port_forwards  # Port forwarding rules
+  #     - qos            # QoS/traffic shaping rules
+  #     - routing        # Static routes (V1 API)
+  #     - stats          # Statistics and metrics
+  #     - system         # System info, health, settings
+  #     - traffic_routes # Policy-based routing (V2 API)
+  #     - usergroups     # Bandwidth profiles/user groups
+  #     - vpn            # VPN servers and clients
+  #   Example: "clients,devices,system" or ["clients", "devices", "system"]
+  #
+  # enabled_tools: Only register these specific tools (use with enabled_categories or alone)
+  #   Example: "unifi_list_clients,unifi_list_devices" or ["unifi_list_clients", "unifi_list_devices"]
+  #
+  # Note: Tools may also be filtered by the permissions section below (e.g., update: false)
+  # If neither is set, all tools are registered (default behavior)
+  enabled_categories: ${oc.env:UNIFI_ENABLED_CATEGORIES,null}
+  enabled_tools: ${oc.env:UNIFI_ENABLED_TOOLS,null}
+
   http:
     enabled: ${oc.env:UNIFI_MCP_HTTP_ENABLED,false}
   diagnostics:

src/main.py

@@ -28,7 +28,7 @@ from src.runtime import (
 from src.tool_index import register_tool, tool_index_handler
 from src.utils.diagnostics import diagnostics_enabled, wrap_tool
 from src.utils.lazy_tool_loader import setup_lazy_loading
-from src.utils.meta_tools import register_meta_tools
+from src.utils.meta_tools import register_load_tools, register_meta_tools
 from src.utils.permissions import parse_permission  # noqa: E402
 from src.utils.tool_loader import auto_load_tools
 
@@ -77,17 +77,21 @@ def permissioned_tool(*d_args, **d_kwargs):  # acts like @server.tool
                     param_type = "string"  # default
                     if param.annotation != inspect.Parameter.empty:
                         ann = param.annotation
-                        # Basic type mapping
-                        if ann in (int, "int"):
+                        # Handle generic types like Dict[str, Any], List[str]
+                        from typing import get_origin
+
+                        origin = get_origin(ann)
+                        # Basic type mapping (check origin first for generics)
+                        if origin is dict or ann in (dict, "dict"):
+                            param_type = "object"
+                        elif origin is list or ann in (list, "list"):
+                            param_type = "array"
+                        elif ann in (int, "int"):
                             param_type = "integer"
                         elif ann in (bool, "bool"):
                             param_type = "boolean"
                         elif ann in (float, "float"):
                             param_type = "number"
-                        elif ann in (list, "list"):
-                            param_type = "array"
-                        elif ann in (dict, "dict"):
-                            param_type = "object"
 
                     properties[param_name] = {"type": param_type}
 
@@ -242,28 +246,58 @@ async def main_async():
     # Load full tool set based on registration mode
     if UNIFI_TOOL_REGISTRATION_MODE == "meta_only":
         logger.info("🔍 Tool registration mode: meta_only")
-        logger.info("   Only meta-tools registered (unifi_tool_index, unifi_async_*)")
-        logger.info("   Use unifi_tool_index to discover all 64+ available UniFi tools")
-        logger.info("   💡 This saves ~4,800 tokens vs. eager mode!")
-        logger.info("   To load all tools: set UNIFI_TOOL_REGISTRATION_MODE=eager")
+        logger.info("   Meta-tools: unifi_tool_index, unifi_execute, unifi_batch, unifi_batch_status")
+        logger.info("   Use unifi_execute to run any tool discovered via unifi_tool_index")
+        logger.info("   To load all tools directly: set UNIFI_TOOL_REGISTRATION_MODE=eager")
     elif UNIFI_TOOL_REGISTRATION_MODE == "lazy":
-        logger.info("⚡ Tool registration mode: lazy (NEW in v0.2.0!)")
-        logger.info("   Meta-tools registered now")
-        logger.info("   Other tools loaded on-demand when first called")
-        logger.info("   💡 Saves tokens AND provides seamless access to all tools!")
+        logger.info("⚡ Tool registration mode: lazy")
+        logger.info("   Meta-tools: unifi_tool_index, unifi_execute, unifi_batch, unifi_batch_status, unifi_load_tools")
+        logger.info("   Use unifi_execute to run any tool - works with all clients")
 
         # Setup lazy loading interceptor
-        setup_lazy_loading(server, _original_tool_decorator)
+        lazy_loader = setup_lazy_loading(server, _original_tool_decorator)
+
+        # Register unifi_load_tools meta-tool (requires lazy_loader)
+        register_load_tools(
+            server=server,
+            tool_decorator=_original_tool_decorator,
+            lazy_loader=lazy_loader,
+            register_tool=register_tool,
+        )
 
-        # All tools remain in the registry (for tool_index), but not registered with MCP yet
-        # They'll be registered on first use
         from src.utils.lazy_tool_loader import TOOL_MODULE_MAP
 
         logger.info(f"   Lazy loader ready - {len(TOOL_MODULE_MAP)} tools available on-demand")
     else:  # eager (default)
         logger.info("📚 Tool registration mode: eager")
-        logger.info("   All 64+ UniFi tools registered immediately")
-        auto_load_tools()
+
+        # Check for tool filtering config
+        enabled_categories = config.server.get("enabled_categories")
+        enabled_tools = config.server.get("enabled_tools")
+
+        # Parse from comma-separated string if from env var
+        if isinstance(enabled_categories, str) and enabled_categories not in ("null", ""):
+            enabled_categories = [c.strip() for c in enabled_categories.split(",")]
+        elif enabled_categories in (None, "null", ""):
+            enabled_categories = None
+
+        if isinstance(enabled_tools, str) and enabled_tools not in ("null", ""):
+            enabled_tools = [t.strip() for t in enabled_tools.split(",")]
+        elif enabled_tools in (None, "null", ""):
+            enabled_tools = None
+
+        if enabled_categories:
+            logger.info(f"   Filtering by categories: {enabled_categories}")
+        elif enabled_tools:
+            logger.info(f"   Filtering to {len(enabled_tools)} specific tools")
+        else:
+            logger.info("   All tools registered (no filtering)")
+
+        auto_load_tools(
+            enabled_categories=enabled_categories,
+            enabled_tools=enabled_tools,
+            server=server,
+        )
 
     # List all registered tools for debugging
     try:

src/managers/connection_manager.py

@@ -13,11 +13,68 @@ from aiounifi.models.configuration import Configuration
 logger = logging.getLogger("unifi-network-mcp")
 
 
+async def detect_unifi_os_pre_login(
+    session: aiohttp.ClientSession,
+    base_url: str,
+    timeout: int = 5,
+) -> Optional[bool]:
+    """
+    Detect UniFi OS BEFORE authentication using unauthenticated probes.
+
+    This detection determines which auth endpoint to use:
+    - UniFi OS: /api/auth/login
+    - Standalone: /api/login
+
+    Strategy:
+    1. GET base URL - UniFi OS returns 200 with HTML, standalone redirects or errors
+    2. Check for UniFi OS specific headers/behavior
+
+    Args:
+        session: Active aiohttp.ClientSession
+        base_url: Base URL of controller (e.g., 'https://192.168.1.1:443')
+        timeout: Detection timeout in seconds (default: 5)
+
+    Returns:
+        True: UniFi OS detected (use /api/auth/login)
+        False: Standalone controller (use /api/login)
+        None: Detection inconclusive
+    """
+    client_timeout = aiohttp.ClientTimeout(total=timeout)
+
+    try:
+        # Probe 1: GET base URL without following redirects
+        # UniFi OS typically returns 200 OK with the web UI
+        # Standalone controllers often redirect to /manage or return different status
+        async with session.get(base_url, timeout=client_timeout, ssl=False, allow_redirects=False) as response:
+            logger.debug(f"Pre-login probe {base_url}: status={response.status}")
+
+            if response.status == 200:
+                # UniFi OS returns 200 at base URL
+                logger.debug("Pre-login detection: UniFi OS (200 at base URL)")
+                return True
+            elif response.status in (301, 302, 303, 307, 308):
+                # Redirect typically indicates standalone controller
+                location = response.headers.get("Location", "")
+                logger.debug(f"Pre-login detection: redirect to {location}")
+                # Could be standalone redirecting to /manage
+                return False
+
+    except asyncio.TimeoutError:
+        logger.debug("Pre-login detection: timeout")
+    except aiohttp.ClientError as e:
+        logger.debug(f"Pre-login detection failed: {e}")
+    except Exception as e:
+        logger.debug(f"Pre-login detection unexpected error: {e}")
+
+    return None
+
+
 async def detect_with_retry(
     session: aiohttp.ClientSession,
     base_url: str,
     max_retries: int = 3,
     timeout: int = 5,
+    pre_login: bool = False,
 ) -> Optional[bool]:
     """
     Detect UniFi OS with exponential backoff retry.
@@ -27,6 +84,8 @@ async def detect_with_retry(
         base_url: Base URL of controller
         max_retries: Maximum retry attempts (default: 3)
         timeout: Detection timeout per attempt in seconds (default: 5)
+        pre_login: If True, use unauthenticated detection for auth endpoint selection.
+                   If False, use authenticated detection for API path verification.
 
     Returns:
         True: UniFi OS detected
@@ -39,9 +98,11 @@ async def detect_with_retry(
         - Logs retry attempts at debug level
         - Returns None if all attempts fail
     """
+    detect_func = detect_unifi_os_pre_login if pre_login else detect_unifi_os_proactively
+
     for attempt in range(max_retries):
         try:
-            result = await detect_unifi_os_proactively(session, base_url, timeout)
+            result = await detect_func(session, base_url, timeout)
             if result is not None:
                 return result
         except Exception as e:
@@ -55,22 +116,6 @@ async def detect_with_retry(
     return None
 
 
-def _generate_detection_failure_message(base_url: str, port: int) -> str:
-    """Generate user-friendly troubleshooting message for detection failures."""
-    return f"""
-UniFi controller path detection failed.
-
-Troubleshooting Steps:
-1. Verify network connectivity to {base_url}
-2. Check controller is accessible on port {port}
-3. Manually set controller type using environment variable:
-   - For UniFi OS (Cloud Gateway, UDM-Pro): export UNIFI_CONTROLLER_TYPE=proxy
-   - For standalone controllers: export UNIFI_CONTROLLER_TYPE=direct
-
-For more help, see: https://github.com/sirkirby/unifi-network-mcp/issues/19
-"""
-
-
 async def _probe_endpoint(
     session: aiohttp.ClientSession,
     url: str,
@@ -233,7 +278,11 @@ class ConnectionManager:
                     )
                     session_created = True
 
-                    # Manual override configuration (FR-004: runs before login, no auth needed)
+                    # Controller type detection/override configuration
+                    # Two-phase detection:
+                    # 1. Pre-login: Determines auth endpoint (/api/auth/login vs /api/login)
+                    # 2. Post-login: Verifies API path prefix (/proxy/network/api vs /api)
+                    # See: https://github.com/sirkirby/unifi-network-mcp/issues/33
                     from src.bootstrap import UNIFI_CONTROLLER_TYPE
 
                     if UNIFI_CONTROLLER_TYPE == "proxy":
@@ -242,6 +291,30 @@ class ConnectionManager:
                     elif UNIFI_CONTROLLER_TYPE == "direct":
                         self._unifi_os_override = False
                         logger.info("Controller type forced to standard (direct) via config")
+                    elif UNIFI_CONTROLLER_TYPE == "auto":
+                        # Phase 1: Pre-login detection (unauthenticated)
+                        # Determines which auth endpoint to use
+                        if self._unifi_os_override is None:
+                            detected = await detect_with_retry(
+                                self._aiohttp_session,
+                                self.url_base,
+                                max_retries=3,
+                                timeout=5,
+                                pre_login=True,  # Use unauthenticated detection
+                            )
+                            if detected is not None:
+                                self._unifi_os_override = detected
+                                mode = "UniFi OS (proxy)" if detected else "standard (direct)"
+                                logger.info(f"Pre-login auto-detected controller type: {mode}")
+                            else:
+                                # Pre-login detection inconclusive - aiounifi will try its own detection
+                                # Show helpful message for troubleshooting
+                                logger.warning(
+                                    "Pre-login detection inconclusive, deferring to aiounifi. "
+                                    "If login fails, try setting UNIFI_CONTROLLER_TYPE=proxy for UniFi OS devices."
+                                )
+                        else:
+                            logger.debug(f"Using cached detection result: {self._unifi_os_override}")
 
                     config = Configuration(
                         session=self._aiohttp_session,
@@ -254,30 +327,34 @@ class ConnectionManager:
 
                     self.controller = Controller(config=config)
 
+                    # Apply pre-login detection result BEFORE login to ensure correct auth endpoint
+                    # aiounifi uses /api/auth/login for UniFi OS, /api/login for standalone
+                    if self._unifi_os_override is not None:
+                        self.controller.connectivity.is_unifi_os = self._unifi_os_override
+                        logger.debug(f"Pre-login is_unifi_os set to: {self._unifi_os_override}")
+
                     await self.controller.login()
 
-                    # Auto-detection (FR-002: runs after login for authenticated probes)
-                    if UNIFI_CONTROLLER_TYPE == "auto":
-                        # Check if already detected (session cache - FR-011)
-                        if self._unifi_os_override is None:
-                            # Proactive detection with retry (FR-001, FR-005, FR-008)
-                            detected = await detect_with_retry(
-                                self._aiohttp_session,
-                                self.url_base,
-                                max_retries=3,
-                                timeout=5,
+                    # Phase 2: Post-login verification (authenticated)
+                    # Verify API path prefix works correctly after successful login
+                    if UNIFI_CONTROLLER_TYPE == "auto" and self._unifi_os_override is not None:
+                        post_login_detected = await detect_with_retry(
+                            self._aiohttp_session,
+                            self.url_base,
+                            max_retries=2,
+                            timeout=5,
+                            pre_login=False,  # Use authenticated detection
+                        )
+                        if post_login_detected is not None and post_login_detected != self._unifi_os_override:
+                            # Post-login detection differs - update override
+                            logger.warning(
+                                f"Post-login detection differs from pre-login: "
+                                f"pre={self._unifi_os_override}, post={post_login_detected}. "
+                                f"Using post-login result."
                             )
-                            if detected is not None:
-                                self._unifi_os_override = detected
-                                mode = "UniFi OS (proxy)" if detected else "standard (direct)"
-                                logger.info(f"Auto-detected controller type: {mode}")
-                            else:
-                                # Show clear error message (FR-009)
-                                error_msg = _generate_detection_failure_message(self.url_base, self.port)
-                                logger.warning(error_msg)
-                                logger.warning("Falling back to aiounifi's check_unifi_os()")
-                        else:
-                            logger.debug(f"Using cached detection result: {self._unifi_os_override}")
+                            self._unifi_os_override = post_login_detected
+                        elif post_login_detected is not None:
+                            logger.debug("Post-login detection confirmed pre-login result")
 
                     self._initialized = True
                     logger.info(f"Successfully connected to Unifi controller at {self.host} for site '{self.site}'")

src/tools_manifest.json

@@ -119,7 +119,7 @@
               "type": "boolean"
             },
             "policy_data": {
-              "type": "string"
+              "type": "object"
             }
           },
           "required": [
@@ -139,7 +139,7 @@
               "type": "boolean"
             },
             "network_data": {
-              "type": "string"
+              "type": "object"
             }
           },
           "required": [
@@ -156,7 +156,7 @@
         "input": {
           "properties": {
             "port_forward_data": {
-              "type": "string"
+              "type": "object"
             }
           },
           "required": [
@@ -176,7 +176,7 @@
               "type": "boolean"
             },
             "qos_data": {
-              "type": "string"
+              "type": "object"
             }
           },
           "required": [
@@ -230,7 +230,7 @@
               "type": "boolean"
             },
             "policy": {
-              "type": "string"
+              "type": "object"
             }
           },
           "required": [
@@ -250,7 +250,7 @@
               "type": "boolean"
             },
             "rule": {
-              "type": "string"
+              "type": "object"
             }
           },
           "required": [
@@ -270,7 +270,7 @@
               "type": "boolean"
             },
             "rule": {
-              "type": "string"
+              "type": "object"
             }
           },
           "required": [
@@ -351,7 +351,7 @@
               "type": "boolean"
             },
             "wlan_data": {
-              "type": "string"
+              "type": "object"
             }
           },
           "required": [
@@ -1227,7 +1227,7 @@
               "type": "string"
             },
             "update_data": {
-              "type": "string"
+              "type": "object"
             }
           },
           "required": [
@@ -1251,7 +1251,7 @@
               "type": "string"
             },
             "update_data": {
-              "type": "string"
+              "type": "object"
             }
           },
           "required": [
@@ -1275,7 +1275,7 @@
               "type": "string"
             },
             "update_data": {
-              "type": "string"
+              "type": "object"
             }
           },
           "required": [
@@ -1299,7 +1299,7 @@
               "type": "string"
             },
             "update_data": {
-              "type": "string"
+              "type": "object"
             }
           },
           "required": [
@@ -1452,7 +1452,7 @@
               "type": "boolean"
             },
             "update_data": {
-              "type": "string"
+              "type": "object"
             },
             "wlan_id": {
               "type": "string"

src/utils/diagnostics.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import inspect
 import json
 import logging
 import os
@@ -142,6 +143,12 @@ def log_tool_call(
 
 
 def wrap_tool(func, tool_name: str):
+    """Wrap a tool function with diagnostics logging.
+
+    IMPORTANT: Preserves the original function's signature so that FastMCP
+    can correctly generate the JSON schema for tool parameters.
+    """
+
     @wraps(func)
     async def _wrapper(*args, **kwargs):
         if not diagnostics_enabled():
@@ -163,6 +170,8 @@ def wrap_tool(func, tool_name: str):
                 # Never let diagnostics break the tool
                 pass
 
+    # Preserve the original function's signature for FastMCP schema generation
+    _wrapper.__signature__ = inspect.signature(func)
     return _wrapper
 
 

src/utils/lazy_tool_loader.py

@@ -7,12 +7,63 @@ when first called by an LLM. This dramatically reduces initial context usage.
 import importlib
 import logging
 from functools import wraps
+from pathlib import Path
 from typing import Any, Callable, Dict, Set
 
 logger = logging.getLogger("unifi-network-mcp")
 
-# Tool module mapping: tool_name -> module_path
-TOOL_MODULE_MAP: Dict[str, str] = {
+
+def _build_tool_module_map() -> Dict[str, str]:
+    """Build tool-to-module mapping by scanning tool files.
+
+    This dynamically discovers all tools and their modules, eliminating the need
+    for a manually-maintained static mapping that can get out of sync.
+    """
+    tool_map: Dict[str, str] = {}
+
+    # Find the tools directory
+    # Try relative to this file first, then fall back to cwd
+    this_dir = Path(__file__).parent
+    tools_dir = this_dir.parent / "tools"
+
+    if not tools_dir.exists():
+        tools_dir = Path("src/tools")
+
+    if not tools_dir.exists():
+        logger.warning("Tools directory not found, falling back to static map")
+        return _STATIC_TOOL_MODULE_MAP
+
+    # Scan each .py file in tools directory
+    for tool_file in tools_dir.glob("*.py"):
+        if tool_file.name.startswith("_"):
+            continue
+
+        module_name = f"src.tools.{tool_file.stem}"
+
+        try:
+            # Read file and look for @server.tool or @permissioned_tool decorators
+            content = tool_file.read_text()
+
+            # Find tool names using simple pattern matching
+            # Looking for: name="unifi_xxx" or name='unifi_xxx'
+            import re
+
+            pattern = r'name\s*=\s*["\']([unifi_][a-z_]+)["\']'
+            matches = re.findall(pattern, content)
+
+            for tool_name in matches:
+                if tool_name.startswith("unifi_"):
+                    tool_map[tool_name] = module_name
+
+        except Exception as e:
+            logger.debug(f"Error scanning {tool_file}: {e}")
+
+    logger.debug(f"Built dynamic tool map with {len(tool_map)} tools")
+    return tool_map
+
+
+# Static fallback map (used if dynamic discovery fails)
+_STATIC_TOOL_MODULE_MAP: Dict[str, str] = {
     # Client tools
     "unifi_list_clients": "src.tools.clients",
     "unifi_get_client_details": "src.tools.clients",
@@ -61,15 +112,21 @@ TOOL_MODULE_MAP: Dict[str, str] = {
     "unifi_update_vpn_client_state": "src.tools.vpn",
     # QoS tools
     "unifi_list_qos_rules": "src.tools.qos",
+    "unifi_get_qos_rule_details": "src.tools.qos",
     "unifi_create_qos_rule": "src.tools.qos",
+    "unifi_create_simple_qos_rule": "src.tools.qos",
     "unifi_update_qos_rule": "src.tools.qos",
     "unifi_delete_qos_rule": "src.tools.qos",
+    "unifi_toggle_qos_rule_enabled": "src.tools.qos",
     # Statistics tools
     "unifi_get_client_stats": "src.tools.stats",
     "unifi_get_device_stats": "src.tools.stats",
     "unifi_get_network_stats": "src.tools.stats",
     "unifi_get_wireless_stats": "src.tools.stats",
     "unifi_get_system_stats": "src.tools.stats",
+    "unifi_get_top_clients": "src.tools.stats",
+    "unifi_get_dpi_stats": "src.tools.stats",
+    "unifi_get_alerts": "src.tools.stats",
     # System tools
     "unifi_get_system_info": "src.tools.system",
     "unifi_get_network_health": "src.tools.system",
@@ -101,8 +158,35 @@ TOOL_MODULE_MAP: Dict[str, str] = {
     "unifi_get_traffic_route_details": "src.tools.traffic_routes",
     "unifi_update_traffic_route": "src.tools.traffic_routes",
     "unifi_toggle_traffic_route": "src.tools.traffic_routes",
+    # Port Forward tools
+    "unifi_list_port_forwards": "src.tools.port_forwards",
+    "unifi_get_port_forward": "src.tools.port_forwards",
+    "unifi_create_port_forward": "src.tools.port_forwards",
+    "unifi_create_simple_port_forward": "src.tools.port_forwards",
+    "unifi_update_port_forward": "src.tools.port_forwards",
+    "unifi_toggle_port_forward": "src.tools.port_forwards",
+    # Firewall Policy tools (zone-based)
+    "unifi_list_firewall_policies": "src.tools.firewall",
+    "unifi_list_firewall_zones": "src.tools.firewall",
+    "unifi_list_ip_groups": "src.tools.firewall",
+    "unifi_get_firewall_policy_details": "src.tools.firewall",
+    "unifi_create_firewall_policy": "src.tools.firewall",
+    "unifi_create_simple_firewall_policy": "src.tools.firewall",
+    "unifi_update_firewall_policy": "src.tools.firewall",
+    "unifi_toggle_firewall_policy": "src.tools.firewall",
+    # WLAN tools
+    "unifi_list_wlans": "src.tools.network",
+    "unifi_get_wlan_details": "src.tools.network",
+    "unifi_create_wlan": "src.tools.network",
+    "unifi_update_wlan": "src.tools.network",
+    # Device tools (additional)
+    "unifi_rename_device": "src.tools.devices",
 }
 
+# Build the tool map dynamically at module load time
+# Falls back to static map if dynamic discovery fails
+TOOL_MODULE_MAP: Dict[str, str] = _build_tool_module_map()
+
 
 class LazyToolLoader:
     """Manages lazy/on-demand tool loading."""