ha-mcp-dev 8.6.0.dev2852__tar.gz → 8.6.0.dev2855__tar.gz

{ha_mcp_dev-8.6.0.dev2852 → ha_mcp_dev-8.6.0.dev2855}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ha-mcp-dev
-Version: 8.6.0.dev2852
+Version: 8.6.0.dev2855
 Summary: Home Assistant MCP Server - Complete control of Home Assistant through MCP
 Keywords: mcp,home-assistant,ai,automation,smart-home
 Author: Julien

{ha_mcp_dev-8.6.0.dev2852 → ha_mcp_dev-8.6.0.dev2855}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "uv_build"
 
 [project]
 name = "ha-mcp-dev"
-version = "8.6.0.dev2852"
+version = "8.6.0.dev2855"
 description = "Home Assistant MCP Server - Complete control of Home Assistant through MCP"
 readme = "README.md"
 requires-python = ">=3.13,<3.15"

{ha_mcp_dev-8.6.0.dev2852 → ha_mcp_dev-8.6.0.dev2855}/pyproject.toml.orig

@@ -4,7 +4,7 @@ build-backend = "uv_build"
 
 [project]
 name = "ha-mcp-dev"
-version = "8.6.0.dev2852"
+version = "8.6.0.dev2855"
 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.6.0.dev2852 → ha_mcp_dev-8.6.0.dev2855}/src/ha_mcp/policy/middleware.py

@@ -30,6 +30,7 @@ from .evaluator import (
 )
 from .events import emit_approval_requested
 from .model import Policy, Rule
+from .mrtr import ApprovalContinuation, supports_mrtr
 
 if TYPE_CHECKING:
     from ..client.rest_client import HomeAssistantClient
@@ -163,11 +164,29 @@ class PolicyMiddleware(Middleware):
         if _passes_ungated(name, args):
             return await call_next(context)
 
+        args_hash = compute_args_hash(args)
+        resumed = ApprovalContinuation.resume(
+            context, self._queue, name, args_hash, policy
+        )
         if evaluate(name, args, policy) != Verdict.REQUIRE_APPROVAL:
             return await call_next(context)
 
+        return await self._gate_approval(
+            context, call_next, policy, name, args, args_hash, resumed
+        )
+
+    async def _gate_approval(
+        self,
+        context: MiddlewareContext,
+        call_next: CallNext,
+        policy: Policy,
+        name: str,
+        args: dict[str, Any],
+        args_hash: str,
+        resumed: tuple[ApprovalContinuation, PendingApproval] | None,
+    ) -> Any:
+        """Wait on one approval, returning a continuation only while it is pending."""
         rule = find_matching_rule(name, args, policy)
-        args_hash = compute_args_hash(args)
         dynamic_targets = has_dynamic_selector_targets(name, args)
         remember_minutes = (
             0 if dynamic_targets else rule.remember_minutes if rule else 0
@@ -182,7 +201,11 @@ class PolicyMiddleware(Middleware):
             not dynamic_targets and policy.rule_effect == "require_approval"
         )
 
-        if reads_remembered and self._queue.is_remembered(name, args_hash):
+        if (
+            resumed is None
+            and reads_remembered
+            and self._queue.is_remembered(name, args_hash)
+        ):
             return await call_next(context)
 
         # A dynamic selector call must never consume an entry it did not
@@ -207,7 +230,7 @@ class PolicyMiddleware(Middleware):
         # The accepted cost is that a retry never silently rides an earlier
         # approval: each blocked call gets its own approval row, and only
         # approving the row for the CURRENTLY-blocked call has any effect.
-        if self._resolve_already_decided(
+        if resumed is None and self._resolve_already_decided(
             name,
             args_hash,
             dynamic_targets=dynamic_targets,
@@ -216,8 +239,19 @@ class PolicyMiddleware(Middleware):
         ):
             return await call_next(context)
 
-        pending = await self._new_pending(
-            name, args_hash, args, policy=policy, dynamic_targets=dynamic_targets
+        continuation, pending = (
+            resumed
+            if resumed is not None
+            else (
+                None,
+                await self._new_pending(
+                    name,
+                    args_hash,
+                    args,
+                    policy=policy,
+                    dynamic_targets=dynamic_targets,
+                ),
+            )
         )
         await self._announce(pending, rule, dynamic_targets=dynamic_targets)
 
@@ -226,14 +260,20 @@ class PolicyMiddleware(Middleware):
             if self._wait_override is not None
             else policy.wait_seconds
         )
-        await self._wait_for_decision(context, pending, wait)
+        if continuation is None and supports_mrtr(context) and wait > 0:
+            continuation = ApprovalContinuation.start(
+                pending, policy, wait, dynamic_targets=dynamic_targets
+            )
+        await self._wait_for_decision(
+            context, pending, continuation.wait_seconds() if continuation else wait
+        )
 
         if pending.decision == "approved":
             if self._claim_approval(
                 pending,
                 name,
                 args_hash,
-                reads_remembered=reads_remembered,
+                reads_remembered=reads_remembered and resumed is None,
                 remember_minutes=remember_minutes,
             ):
                 return await call_next(context)
@@ -252,6 +292,11 @@ class PolicyMiddleware(Middleware):
             self._queue.remove(pending.token)
             self._raise_denied_error()
 
+        if continuation is not None:
+            result = continuation.next_result(self._queue)
+            if result is not None:
+                return result
+
         pending = self._finalize_timed_out_pending(
             pending, dynamic_targets=dynamic_targets, policy=policy, name=name
         )
@@ -543,7 +588,7 @@ class PolicyMiddleware(Middleware):
         self,
         context: MiddlewareContext,
         pending: PendingApproval,
-        wait_seconds: int,
+        wait_seconds: float,
     ) -> None:
         deadline = anyio.current_time() + wait_seconds
         while anyio.current_time() < deadline and pending.decision == "pending":

ha_mcp_dev-8.6.0.dev2855/src/ha_mcp/policy/mrtr.py

@@ -0,0 +1,158 @@
+"""Bounded MRTR polling of the existing approval queue.
+
+FastMCP seals requestState and binds it to the wire call and principal. This
+module additionally binds the resolved leaf tool, policy and queue entry. The
+state is a reference to a decision, never an approval supplied by the client.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from datetime import UTC, datetime
+from time import time
+from typing import Literal, NoReturn
+
+from pydantic import BaseModel, ConfigDict, Field, ValidationError
+
+from ha_mcp._vendor.fastmcp.server.middleware.middleware import MiddlewareContext
+from ha_mcp._vendor.fastmcp.tools.base import InputRequiredToolResult
+from ha_mcp._vendor.mcp_types import InputRequiredResult
+from ha_mcp._vendor.mcp_types.version import MODERN_PROTOCOL_VERSIONS
+
+from ..errors import ErrorCode, create_error_response
+from ..renamed_tools import current_tool_name
+from ..tool_dispatch import CALL_PROXY_META_TOOLS
+from ..tools.helpers import raise_tool_error
+from .approval_queue import ApprovalQueue, PendingApproval, compute_args_hash
+from .model import Policy
+
+# Leave room below the SDK's default ten-round limit for a normal final error.
+MAX_CONTINUATIONS = 8
+ROUND_WAIT_SECONDS = 10
+
+
+def supports_mrtr(context: MiddlewareContext) -> bool:
+    """Use modern MRTR only where retrying resumes this single tool dispatch."""
+    ctx = context.fastmcp_context
+    request = getattr(ctx, "request_context", None)
+    if getattr(request, "protocol_version", None) not in MODERN_PROTOCOL_VERSIONS:
+        return False
+    params = getattr(getattr(request, "_srctx", None), "params", None)
+    if not isinstance(params, Mapping):
+        return False
+    name = current_tool_name(params.get("name", ""))
+    if name in CALL_PROXY_META_TOOLS:
+        args = params.get("arguments") or {}
+        name = current_tool_name(args.get("name", ""))
+    # Nested code-mode calls keep blocking approval: replaying their outer
+    # script could repeat effects that ran before it reached the gated tool.
+    return name == current_tool_name(context.message.name)
+
+
+def _policy_hash(policy: Policy) -> str:
+    return compute_args_hash(
+        {
+            "rule_effect": policy.rule_effect,
+            "rules": [r.model_dump() for r in policy.rules],
+        }
+    )
+
+
+def _cannot_resume() -> NoReturn:
+    raise_tool_error(
+        create_error_response(
+            ErrorCode.USER_APPROVAL_REQUIRED,
+            "This approval continuation is no longer valid. No tool was executed "
+            "by this retry. Check the original call's outcome before issuing a "
+            "fresh call; it may already have used the approval.",
+            suggestions=[
+                "Check the Tool Security Policies tab and the target's current state.",
+                "A fresh call may require a new approval.",
+            ],
+        )
+    )
+
+
+class ApprovalContinuation(BaseModel):
+    """Small, sealed reference retaining one logical call's deadline."""
+
+    model_config = ConfigDict(extra="forbid", strict=True, allow_inf_nan=False)
+
+    kind: Literal["ha_mcp_approval"] = "ha_mcp_approval"
+    token: str
+    tool_name: str
+    args_hash: str
+    policy_hash: str
+    deadline: float
+    rounds: int = Field(default=0, ge=0, le=MAX_CONTINUATIONS)
+
+    @classmethod
+    def resume(
+        cls,
+        context: MiddlewareContext,
+        queue: ApprovalQueue,
+        name: str,
+        args_hash: str,
+        policy: Policy,
+    ) -> tuple[ApprovalContinuation, PendingApproval] | None:
+        """Resolve only the original live entry, including on concurrent retries."""
+        ctx = context.fastmcp_context
+        if ctx is None or not supports_mrtr(context):
+            return None
+        state = ctx.request_state
+        if state is None:
+            return None
+        try:
+            continuation = cls.model_validate_json(state)
+        except ValidationError:
+            _cannot_resume()
+        pending = queue.get(continuation.token)
+        if (
+            pending is None
+            or continuation.tool_name != name
+            or continuation.args_hash != args_hash
+            or pending.tool_name != name
+            or pending.args_hash != args_hash
+            or continuation.policy_hash != _policy_hash(policy)
+            or continuation.deadline <= time()
+        ):
+            _cannot_resume()
+        return continuation, pending
+
+    @classmethod
+    def start(
+        cls,
+        pending: PendingApproval,
+        policy: Policy,
+        wait_seconds: int,
+        *,
+        dynamic_targets: bool,
+    ) -> ApprovalContinuation:
+        deadline = min(time() + wait_seconds, pending.expires_at.timestamp())
+        if dynamic_targets:
+            # A client that never resumes must not leave an approvable dynamic
+            # selector behind after its original invocation's wait window.
+            pending.expires_at = datetime.fromtimestamp(deadline, UTC)
+        return cls(
+            token=pending.token,
+            tool_name=pending.tool_name,
+            args_hash=pending.args_hash,
+            policy_hash=_policy_hash(policy),
+            deadline=deadline,
+        )
+
+    def wait_seconds(self) -> float:
+        return max(0, min(ROUND_WAIT_SECONDS, self.deadline - time()))
+
+    def next_result(self, queue: ApprovalQueue) -> InputRequiredToolResult | None:
+        """End a pending leg without granting, consuming or extending approval."""
+        if (
+            self.rounds >= MAX_CONTINUATIONS
+            or time() >= self.deadline
+            or queue.get(self.token) is None
+        ):
+            return None
+        state = self.model_copy(update={"rounds": self.rounds + 1})
+        return InputRequiredToolResult(
+            InputRequiredResult(request_state=state.model_dump_json())
+        )

{ha_mcp_dev-8.6.0.dev2852 → ha_mcp_dev-8.6.0.dev2855}/src/ha_mcp/tools/component_devices.py

@@ -8,7 +8,7 @@ device registry and filter for one entry (``ha_get_device`` single lookup,
 single in-process read: ``device_get`` returns one ``DeviceEntry.dict_repr`` by
 id, ``device_list`` returns them all — each byte-identical to a
 ``config/device_registry/list`` element by construction (see
-``custom_components/ha_mcp_tools/websocket_api.py``). Consumers keep their own
+``custom_components/ha_mcp_tools/websocket_api/lookups.py``). Consumers keep their own
 transforms over that raw shape.
 
 This module owns the caps-gated fetch so the routing discipline — probe caps,

{ha_mcp_dev-8.6.0.dev2852 → ha_mcp_dev-8.6.0.dev2855}/src/ha_mcp/tools/component_registries.py

@@ -11,7 +11,7 @@ capability, all of that becomes ONE in-process read: ``ha_mcp_tools/registries``
 returns exactly the requested registry kinds (``area`` / ``floor`` / ``label``
 / ``category``) as their FULL-FIELD ``config/<x>_registry/list``-shaped rows —
 byte-compatible with the legacy WS list responses the consumers already parse
-(see ``custom_components/ha_mcp_tools/websocket_api.py::_do_registries``).
+(see ``custom_components/ha_mcp_tools/websocket_api/registries.py::_do_registries``).
 
 This module owns the caps-gated fetch so the routing discipline — probe caps,
 send one frame, invalidate on ``unknown_command``, fall back to the legacy

{ha_mcp_dev-8.6.0.dev2852 → ha_mcp_dev-8.6.0.dev2855}/src/ha_mcp/tools/tools_config_dashboards.py

@@ -996,7 +996,7 @@ async def _component_dashboard_config(
 
 # --- Cross-dashboard search walk (component-less legacy path) -----------------
 # Byte-for-byte port of the component's ``_search_dashboard_docs`` walk
-# (custom_components/ha_mcp_tools/websocket_api.py) so a component-less install
+# (custom_components/ha_mcp_tools/websocket_api/dashboards.py) so a component-less install
 # gets the SAME cross-dashboard ``search`` matches, just at N+1 WS cost. The two
 # implementations are pinned equal by test_component_dashboards_contract.py.
 

{ha_mcp_dev-8.6.0.dev2852 → ha_mcp_dev-8.6.0.dev2855}/src/ha_mcp/tools/tools_search.py

@@ -1230,7 +1230,7 @@ def _merge_sort_key(record: dict[str, Any]) -> str:
 
     The component cuts its window with ``(-score, _sort_key)`` where
     ``_sort_key`` is ``str(entity_id or id or name or "")``
-    (``custom_components/ha_mcp_tools/websocket_api.py``); those fields ride
+    (``custom_components/ha_mcp_tools/websocket_api/search.py``); those fields ride
     the wire records unchanged, so the merge reproduces the exact order that
     decided window membership. Dashboard records are outside the component
     corpus, so any deterministic key places them consistently across pages —