ha-mcp-dev 8.4.3.dev2563__tar.gz → 8.4.3.dev2564__tar.gz

{ha_mcp_dev-8.4.3.dev2563/src/ha_mcp_dev.egg-info → ha_mcp_dev-8.4.3.dev2564}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ha-mcp-dev
-Version: 8.4.3.dev2563
+Version: 8.4.3.dev2564
 Summary: Home Assistant MCP Server - Complete control of Home Assistant through MCP
 Author-email: Julien <github@qc-h.net>
 License: MIT

{ha_mcp_dev-8.4.3.dev2563 → ha_mcp_dev-8.4.3.dev2564}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ha-mcp-dev"
-version = "8.4.3.dev2563"
+version = "8.4.3.dev2564"
 description = "Home Assistant MCP Server - Complete control of Home Assistant through MCP"
 readme = "README.md"
 # Upper bound widened to <3.15 so the package installs on Home Assistant's

{ha_mcp_dev-8.4.3.dev2563 → ha_mcp_dev-8.4.3.dev2564}/src/ha_mcp/config.py

@@ -62,6 +62,10 @@ class Settings(BaseSettings):
     # Tool configuration
     fuzzy_threshold: int = Field(60, alias="FUZZY_THRESHOLD")
 
+    # Optional process-wide outer tool-call concurrency. Zero preserves the
+    # existing unlimited behavior; constrained installs can opt into queuing.
+    ha_tool_concurrency: int = Field(0, ge=0, le=32, alias="HA_TOOL_CONCURRENCY")
+
     # Smart-search config-fetch time budgets (seconds). Bound how long
     # ha_search spends fetching automation/script/scene
     # definitions during the per-id fallback before reporting a partial
@@ -890,6 +894,9 @@ ADVANCED_SETTINGS_FIELDS: tuple[AdvancedField, ...] = (
         True,
     ),
     # Operations.
+    AdvancedField(
+        "ha_tool_concurrency", "HA_TOOL_CONCURRENCY", int, "operations", True
+    ),
     AdvancedField("backup_hint", "BACKUP_HINT", str, "operations", True),
     AdvancedField("enable_websocket", "ENABLE_WEBSOCKET", bool, "operations", True),
     # Dashboard-screenshot engine URL (#1538): docker/.env users could set
@@ -1000,6 +1007,7 @@ _ADVANCED_SETTINGS_BOUNDS: dict[str, tuple[float, float]] = {
     "scene_config_time_budget": (1.0, 600.0),
     "individual_config_timeout": (1.0, 600.0),
     "individual_fetch_batch_size": (1, 100),
+    "ha_tool_concurrency": (1, 32),
     "code_mode_max_duration": (1.0, 300.0),
     "code_mode_max_memory": (1_048_576, 268_435_456),
     "code_mode_max_recursion": (1, 10_000),
@@ -1015,6 +1023,7 @@ _ADVANCED_SETTINGS_BOUNDS: dict[str, tuple[float, float]] = {
 # emits min=sentinel so the number input can still express "off"; the
 # override-apply and UI-POST paths accept the sentinel OR the bounded range.
 _ADVANCED_SETTINGS_SENTINELS: dict[str, int] = {
+    "ha_tool_concurrency": 0,
     "sidecar_pin_port": 0,
 }
 
@@ -1036,6 +1045,7 @@ _ADVANCED_SETTINGS_CHOICES: dict[str, tuple[str, ...]] = {
 # batches addon-origin writes and POSTs them via Supervisor.
 ADDON_SYNCED_ADVANCED_FIELDS: tuple[str, ...] = (
     "backup_hint",
+    "ha_tool_concurrency",
     "verify_ssl",
 )
 

ha_mcp_dev-8.4.3.dev2564/src/ha_mcp/ha_request_queue.py

@@ -0,0 +1,145 @@
+"""Cross-session concurrency control for Home Assistant tool calls."""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+from contextvars import ContextVar
+from typing import Any
+
+from fastmcp.server.middleware.middleware import CallNext, Middleware, MiddlewareContext
+
+from .errors import create_timeout_error
+from .tool_dispatch import (
+    CALL_PROXY_META_TOOLS,
+    LOCAL_ONLY_TOOLS,
+    OUTER_QUEUE_ORCHESTRATORS,
+    is_approval_management_call,
+)
+from .tools.helpers import raise_tool_error, safe_progress
+
+logger = logging.getLogger(__name__)
+
+_QUEUE_WAIT_TIMEOUT_SECONDS = 60.0
+_QUEUE_WAIT_HEARTBEAT_SECONDS = 15.0
+_QUEUE_WAIT_WARNING_SECONDS = 15.0
+
+
+def _bypasses_outer_queue(name: str, args: dict[str, Any]) -> bool:
+    """Return whether an outer envelope must run without a queue slot.
+
+    Proxy and orchestration envelopes leave admission to their nested dispatches.
+    Local search does not contact Home Assistant. Approval-management actions
+    must remain available while all configured slots are occupied.
+    """
+    return (
+        name in CALL_PROXY_META_TOOLS
+        or name in LOCAL_ONLY_TOOLS
+        or name in OUTER_QUEUE_ORCHESTRATORS
+        or is_approval_management_call(name, args)
+    )
+
+
+class HomeAssistantRequestQueueMiddleware(Middleware):
+    """Bound concurrent outer tool calls while allowing nested redispatch."""
+
+    def __init__(self, max_concurrency: int = 1) -> None:
+        if not 1 <= max_concurrency <= 32:
+            raise ValueError(
+                "ha_tool_concurrency middleware requires a value between 1 and 32; "
+                "0 is handled by not registering the middleware"
+            )
+        self._semaphore = asyncio.Semaphore(max_concurrency)
+        self._depth: ContextVar[int] = ContextVar(
+            f"ha_request_queue_depth_{id(self)}", default=0
+        )
+
+    async def _acquire_slot(self, context: MiddlewareContext, name: str) -> None:
+        """Acquire an outer-call slot with progress and a bounded wait."""
+        loop = asyncio.get_running_loop()
+        started = loop.time()
+        warned = False
+
+        if not self._semaphore.locked():
+            await self._semaphore.acquire()
+            logger.debug("HA tool queue: acquired slot tool=%s wait=0.000s", name)
+            return
+
+        logger.debug("HA tool queue: waiting for slot tool=%s", name)
+
+        while True:
+            elapsed = loop.time() - started
+            remaining = _QUEUE_WAIT_TIMEOUT_SECONDS - elapsed
+            if remaining <= 0:
+                logger.warning(
+                    "HA tool queue: timed out waiting for slot tool=%s wait=%.1fs",
+                    name,
+                    elapsed,
+                )
+                raise_tool_error(
+                    create_timeout_error(
+                        "Home Assistant tool queue admission",
+                        _QUEUE_WAIT_TIMEOUT_SECONDS,
+                        details=(
+                            f"Tool '{name}' did not start because all configured "
+                            "Home Assistant tool slots remained busy."
+                        ),
+                        context={"tool": name, "phase": "queue_wait"},
+                    )
+                )
+
+            ctx = getattr(context, "fastmcp_context", None)
+            await safe_progress(
+                ctx,
+                progress=0,
+                total=0,
+                message=f"Waiting for Home Assistant tool capacity: {name}",
+            )
+            try:
+                await asyncio.wait_for(
+                    self._semaphore.acquire(),
+                    timeout=min(_QUEUE_WAIT_HEARTBEAT_SECONDS, remaining),
+                )
+            except TimeoutError:
+                elapsed = loop.time() - started
+                if not warned and elapsed >= _QUEUE_WAIT_WARNING_SECONDS:
+                    warned = True
+                    logger.warning(
+                        "HA tool queue: still waiting for slot tool=%s wait=%.1fs",
+                        name,
+                        elapsed,
+                    )
+                continue
+
+            logger.debug(
+                "HA tool queue: acquired slot tool=%s wait=%.3fs",
+                name,
+                loop.time() - started,
+            )
+            return
+
+    async def on_call_tool(
+        self, context: MiddlewareContext, call_next: CallNext
+    ) -> Any:
+        if _bypasses_outer_queue(context.message.name, context.message.arguments or {}):
+            return await call_next(context)
+
+        depth = self._depth.get()
+        if depth:
+            token = self._depth.set(depth + 1)
+            try:
+                return await call_next(context)
+            finally:
+                self._depth.reset(token)
+
+        name = context.message.name
+        await self._acquire_slot(context, name)
+        try:
+            token = self._depth.set(1)
+            try:
+                return await call_next(context)
+            finally:
+                self._depth.reset(token)
+        finally:
+            self._semaphore.release()
+            logger.debug("HA tool queue: released slot tool=%s", name)

{ha_mcp_dev-8.4.3.dev2563 → ha_mcp_dev-8.4.3.dev2564}/src/ha_mcp/policy/middleware.py

@@ -13,6 +13,7 @@ from fastmcp.server.middleware.middleware import CallNext, Middleware, Middlewar
 
 from ..errors import ErrorCode, create_error_response
 from ..renamed_tools import current_tool_name
+from ..tool_dispatch import CALL_PROXY_META_TOOLS, is_approval_management_call
 from ..tools.helpers import raise_tool_error, safe_progress
 from .approval_queue import ApprovalQueue, PendingApproval, compute_args_hash
 from .evaluator import (
@@ -26,48 +27,12 @@ from .model import Policy, Rule
 
 logger = logging.getLogger(__name__)
 
-# Dispatching call proxies are a strict subset of the ungated tool-search
-# meta-tools. Only these three execute their envelope's ``name``; search merely
-# returns catalog metadata and must not be unwrapped by other middleware.
-# Gating a call proxy directly would be wrong: rule predicates target the real
-# tool's args (for example args.domain), while the proxy receives a wrapped
-# {"name": "...", "arguments": {...}} envelope. Its dispatch re-enters the
-# middleware chain with the real name and args, so the inner call is gated there.
-CALL_PROXY_META_TOOLS = frozenset(
-    {
-        "ha_call_read_tool",
-        "ha_call_write_tool",
-        "ha_call_delete_tool",
-    }
-)
-# Policy itself also leaves catalog search ungated; unlike the call proxies it
-# never dispatches a tool named in client-supplied arguments.
 PROXY_META_TOOLS = CALL_PROXY_META_TOOLS | {"ha_search_tools"}
 
-# ha_dev_manage_server actions that MANAGE the approval queue itself.
-# Gating these deadlocks by construction: with a wildcard (or
-# ha_dev_manage_server) rule in place, an MCP-only "approve" call would
-# itself require approval — creating a second pending entry instead of
-# deciding the first, so nothing can ever be approved through the tool.
-# Only the queue-management actions are exempt; update_source / restart
-# remain gateable like any other high-stakes action. The exemption is not
-# a free self-approval: approve/deny separately require the
-# dev_tools_security_policy_access setting (off by default, issue #2141).
-_APPROVAL_MANAGEMENT_TOOL = "ha_dev_manage_server"
-_APPROVAL_MANAGEMENT_ACTIONS = frozenset({"list_pending", "approve", "deny"})
-
-
-def _is_approval_management(name: str, args: dict[str, Any]) -> bool:
-    """True for dev-tool calls that manage the approval queue itself."""
-    return (
-        name == _APPROVAL_MANAGEMENT_TOOL
-        and args.get("action") in _APPROVAL_MANAGEMENT_ACTIONS
-    )
-
 
 def _passes_ungated(name: str, args: dict[str, Any]) -> bool:
     """Calls that must bypass gating: proxy meta-tools + queue management."""
-    return name in PROXY_META_TOOLS or _is_approval_management(name, args)
+    return name in PROXY_META_TOOLS or is_approval_management_call(name, args)
 
 
 class PolicyMiddleware(Middleware):

{ha_mcp_dev-8.4.3.dev2563 → ha_mcp_dev-8.4.3.dev2564}/src/ha_mcp/read_only.py

@@ -39,8 +39,8 @@ from fastmcp.tools import Tool
 
 from .config import get_global_settings
 from .errors import ErrorCode, create_error_response
-from .policy.middleware import CALL_PROXY_META_TOOLS
 from .renamed_tools import current_tool_name
+from .tool_dispatch import CALL_PROXY_META_TOOLS
 from .tools.helpers import raise_tool_error
 
 if TYPE_CHECKING:

{ha_mcp_dev-8.4.3.dev2563 → ha_mcp_dev-8.4.3.dev2564}/src/ha_mcp/server.py

@@ -289,6 +289,15 @@ class HomeAssistantSmartMCPServer:
         # wraps the final tool surface (including the search proxies).
         self._apply_tool_security_policies()
 
+        # Constrained installs can opt into cross-session tool queuing. This
+        # sits after approval gates so a call awaiting approval holds no slot.
+        if self.settings.ha_tool_concurrency:
+            from .ha_request_queue import HomeAssistantRequestQueueMiddleware
+
+            self.mcp.add_middleware(
+                HomeAssistantRequestQueueMiddleware(self.settings.ha_tool_concurrency)
+            )
+
         # Known-secret-value scrub (#2157) — registered just before the
         # visibility outbound half so that half stays innermost (its scan
         # must see truly raw output; a secret value could embed a hidden

{ha_mcp_dev-8.4.3.dev2563 → ha_mcp_dev-8.4.3.dev2564}/src/ha_mcp/settings_ui/_handlers_advanced.py

@@ -3,7 +3,8 @@
 Factory returning the ``get_advanced_settings`` / ``save_advanced_settings``
 handlers over the ``ADVANCED_SETTINGS_FIELDS`` registry. Most advanced
 fields write to the shared ``feature_flags.json`` override file;
-``ADDON_SYNCED_ADVANCED_FIELDS`` (``backup_hint``, ``verify_ssl``) route
+``ADDON_SYNCED_ADVANCED_FIELDS`` (``backup_hint``, ``ha_tool_concurrency``,
+``verify_ssl``) route
 through the Supervisor add-on options in add-on mode instead.
 
 Handlers are module-level (own C901 budget); ``build_advanced_handlers``
@@ -131,10 +132,10 @@ async def _get_advanced_settings(
     Mirrors ``_get_feature_flags`` / ``_get_backup_config`` but for the
     ``ADVANCED_SETTINGS_FIELDS`` registry. Most advanced fields write to
     ``feature_flags.json`` via the shared override file in either deployment
-    mode. ``ADDON_SYNCED_ADVANCED_FIELDS`` (``backup_hint``, ``verify_ssl``)
-    are an exception: in addon mode they have ``origin="addon"`` (editable)
-    and saves route through Supervisor so the add-on Configuration tab and
-    the web UI share state.
+    mode. ``ADDON_SYNCED_ADVANCED_FIELDS`` (``backup_hint``,
+    ``ha_tool_concurrency``, ``verify_ssl``) are an exception: in addon mode
+    they have ``origin="addon"`` (editable) and saves route through Supervisor
+    so the add-on Configuration tab and the web UI share state.
     """
     from ha_mcp.settings_ui import is_http_settings_mounted
 
@@ -327,7 +328,7 @@ def _validate_one_advanced_field(
                 status_code=409,
             ),
         )
-    # Addon-synced fields (e.g. backup_hint, verify_ssl) are editable in
+    # Addon-synced fields (backup_hint, ha_tool_concurrency, verify_ssl) are editable in
     # addon mode even though their env vars are set — start.py rewrites them
     # from /data/options.json on every boot, so route the write through
     # Supervisor instead of the override file.
@@ -525,11 +526,11 @@ async def _save_advanced_settings(
 ) -> JSONResponse:
     """Persist UI-edited advanced settings.
 
-    Addon-synced fields (``backup_hint``, ``verify_ssl``) in add-on mode
-    route through Supervisor; everything else atomically merges into the
-    shared ``feature_flags.json`` override file. Either sink responds with
-    ``restart_required=True`` (most advanced fields gate one-time startup
-    paths).
+    Addon-synced fields (``backup_hint``, ``ha_tool_concurrency``,
+    ``verify_ssl``) in add-on mode route through Supervisor; everything else
+    atomically merges into the shared ``feature_flags.json`` override file.
+    Either sink responds with ``restart_required=True`` (most advanced fields
+    gate one-time startup paths).
     """
     from ..config import ADVANCED_SETTINGS_FIELDS
 

{ha_mcp_dev-8.4.3.dev2563 → ha_mcp_dev-8.4.3.dev2564}/src/ha_mcp/settings_ui/locales/en.json

@@ -404,6 +404,8 @@
     "advanced.individual_config_timeout.help": "Timeout for each automation/script/scene config fetch. Range 1–600. Restart required.",
     "advanced.individual_fetch_batch_size.label": "Config fetch batch size",
     "advanced.individual_fetch_batch_size.help": "Concurrent per-ID config fetches. Lower toward 1 on serial HA servers. Range 1–100. Restart required.",
+    "advanced.ha_tool_concurrency.label": "Home Assistant tool concurrency",
+    "advanced.ha_tool_concurrency.help": "Optional limit on outer Home Assistant tool calls across all sessions. Internal REST, WebSocket, and per-tool fan-out concurrency is unchanged. 0 keeps unlimited behavior. A call waiting for capacity fails after 60 seconds. Range 0–32. Restart required.",
     "advanced.backup_hint.label": "Backup-hint level",
     "advanced.backup_hint.help": "Controls how strongly the LLM is prompted to take a full HA snapshot before risky writes.",
     "advanced.backup_hint.choices.strong": "Strong",
@@ -468,6 +470,8 @@
     "addon.pinned_tools.description": "Tools listed here are locked pinned — they appear at the top of the Tools tab and cannot be unpinned from the web Settings UI without unsetting this option first. Useful in combination with Tool Search. Comma-separated tool names.",
     "addon.verify_ssl.name": "Verify TLS certificate",
     "addon.verify_ssl.description": "Verify the Home Assistant server's TLS certificate. The app (add-on) connects via the Supervisor proxy, so this normally has no effect and should stay enabled. Disable only if you've reconfigured the app (add-on) to talk to HA over a public HTTPS hostname with a self-signed certificate or hostname mismatch. Disabling weakens transport security — leave on unless you know you need it. Requires restart to take effect.",
+    "addon.ha_tool_concurrency.name": "Home Assistant tool concurrency",
+    "addon.ha_tool_concurrency.description": "Optional limit on outer Home Assistant tool calls across all sessions. Internal REST, WebSocket, and per-tool fan-out concurrency is unchanged. 0 keeps unlimited behavior. A call waiting for capacity fails after 60 seconds.",
     "addon_stable.enable_tool_search.description": "Replace the full tool catalog with search-based discovery. Reduces idle context by roughly 90%, to about 5K tokens. ⚠️ Do NOT enable this in clients with their own built-in tool search / deferred tools (claude.ai, Claude Desktop, Claude Code) — the two search layers conflict, and the client's built-in tool search is the better choice there; leave this off. Whether tools are deferred depends on your client and model combination: use this when your setup loads the full catalog up front — models without native deferred tools (e.g. Gemini, OpenAI-compatible local models, Claude Haiku), clients that inline all tool schemas regardless of model (e.g. GitHub Copilot CLI), or smaller context windows. Some Codex models and ChatGPT include deferred tools too — check your client/model directly to confirm its features so you don't leave this enabled unnecessarily. Tools are found via ha_search_tools and executed via categorized proxies (read/write/delete). Requires an app (add-on) restart to take effect — then reconnect or refresh the MCP server in your AI client so it reloads the tool list. Restarting the app (add-on) alone does NOT refresh a client's cached tool list; this applies after changing any setting here."
   },
   "tool_groups": {},

{ha_mcp_dev-8.4.3.dev2563 → ha_mcp_dev-8.4.3.dev2564}/src/ha_mcp/settings_ui/settings.js

@@ -3868,6 +3868,7 @@ const ADVANCED_FIELD_META = {
   timeout:             { label: "HA request timeout (s)",      help: "Per-request HTTP timeout. Range 1–600. Restart required." },
   max_retries:         { label: "HA request max retries",      help: "Retry budget per failed REST call. Range 0–20. Restart required." },
   verify_ssl:          { label: "Verify SSL certificates",     help: "Skip TLS verification only on trusted networks (self-signed certs, hostname mismatch). Restart required." },
+  ha_tool_concurrency: { label: "Home Assistant tool concurrency", help: "Optional limit on outer Home Assistant tool calls across all MCP sessions. Internal REST, WebSocket, and per-tool fan-out concurrency is unchanged. 0 keeps unlimited behavior. A call waiting for capacity fails after 60 seconds. Range 0–32. Restart required." },
   fuzzy_threshold:     { label: "Fuzzy-search threshold",      help: "Lower = looser entity match. Range 0–100." },
   automation_config_time_budget: { label: "Automation config time budget (s)", help: "Max seconds deep search spends fetching automation configs before returning a partial result. Raise on instances with many automations. Range 1–600. Restart required." },
   script_config_time_budget:     { label: "Script config time budget (s)",     help: "Max seconds deep search spends fetching script configs before returning a partial result. Range 1–600. Restart required." },
@@ -3902,6 +3903,7 @@ const ADVANCED_FIELD_META = {
 // is per-request.
 const ADVANCED_RESTART_REQUIRED = new Set([
   "timeout", "max_retries", "verify_ssl",
+  "ha_tool_concurrency",
   "enabled_tool_modules", "enable_websocket",
   "log_level", "debug",
   "mcp_server_name", "mcp_server_version", "environment",

ha_mcp_dev-8.4.3.dev2564/src/ha_mcp/tool_dispatch.py

@@ -0,0 +1,39 @@
+"""Shared classifications for tool dispatch middleware."""
+
+from __future__ import annotations
+
+from typing import Any
+
+# Call proxies dispatch the envelope's ``name`` back through middleware. Policy
+# rules and read-only checks must apply to the real tool name and arguments, not
+# the proxy envelope, so these outer calls bypass those checks.
+CALL_PROXY_META_TOOLS = frozenset(
+    {
+        "ha_call_read_tool",
+        "ha_call_write_tool",
+        "ha_call_delete_tool",
+    }
+)
+
+LOCAL_ONLY_TOOLS = frozenset({"ha_search_tools"})
+
+# Code mode is local orchestration that can issue many nested HA calls. Its
+# outer envelope must not hold one slot while nested calls reuse that admission;
+# each nested HA dispatch instead acquires an outer-call slot normally.
+OUTER_QUEUE_ORCHESTRATORS = frozenset({"ha_manage_custom_tool"})
+
+_APPROVAL_MANAGEMENT_TOOL = "ha_dev_manage_server"
+_APPROVAL_MANAGEMENT_ACTIONS = frozenset({"list_pending", "approve", "deny"})
+
+
+def is_approval_management_call(name: str, args: dict[str, Any]) -> bool:
+    """Return whether a dispatch manages the policy approval queue.
+
+    Gating or queueing these actions can deadlock approval by making the action
+    that decides a pending request wait behind that same blocked workload.
+    Update and restart actions remain subject to normal middleware behavior.
+    """
+    return (
+        name == _APPROVAL_MANAGEMENT_TOOL
+        and args.get("action") in _APPROVAL_MANAGEMENT_ACTIONS
+    )

{ha_mcp_dev-8.4.3.dev2563 → ha_mcp_dev-8.4.3.dev2564}/src/ha_mcp/visibility/enforcement.py

@@ -62,8 +62,8 @@ from fastmcp.exceptions import ToolError
 from fastmcp.server.middleware.middleware import CallNext, Middleware, MiddlewareContext
 
 from ..errors import ErrorCode, create_entity_not_found_error, create_error_response
-from ..policy.middleware import CALL_PROXY_META_TOOLS
 from ..renamed_tools import current_tool_name
+from ..tool_dispatch import CALL_PROXY_META_TOOLS
 from ..tools.helpers import raise_tool_error
 from . import resolver
 from .model import VisibilityConfig

{ha_mcp_dev-8.4.3.dev2563 → ha_mcp_dev-8.4.3.dev2564/src/ha_mcp_dev.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ha-mcp-dev
-Version: 8.4.3.dev2563
+Version: 8.4.3.dev2564
 Summary: Home Assistant MCP Server - Complete control of Home Assistant through MCP
 Author-email: Julien <github@qc-h.net>
 License: MIT

{ha_mcp_dev-8.4.3.dev2563 → ha_mcp_dev-8.4.3.dev2564}/src/ha_mcp_dev.egg-info/SOURCES.txt

@@ -11,6 +11,7 @@ src/ha_mcp/backup_manager.py
 src/ha_mcp/browser_landing.py
 src/ha_mcp/config.py
 src/ha_mcp/errors.py
+src/ha_mcp/ha_request_queue.py
 src/ha_mcp/hacs_auto_refresh.py
 src/ha_mcp/llm_exposure.py
 src/ha_mcp/log_filters.py
@@ -22,6 +23,7 @@ src/ha_mcp/server.py
 src/ha_mcp/smoke_test.py
 src/ha_mcp/stdio_settings_sidecar.py
 src/ha_mcp/strict_bps.py
+src/ha_mcp/tool_dispatch.py
 src/ha_mcp/transport_security.py
 src/ha_mcp/update_check.py
 src/ha_mcp/_vendor/__init__.py