ha-mcp-dev 9.0.0.dev3224__tar.gz → 9.0.1.dev3231__tar.gz

{ha_mcp_dev-9.0.0.dev3224 → ha_mcp_dev-9.0.1.dev3231}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ha-mcp-dev
-Version: 9.0.0.dev3224
+Version: 9.0.1.dev3231
 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-9.0.0.dev3224 → ha_mcp_dev-9.0.1.dev3231}/pyproject.toml

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

{ha_mcp_dev-9.0.0.dev3224 → ha_mcp_dev-9.0.1.dev3231}/pyproject.toml.orig

@@ -4,7 +4,7 @@ build-backend = "uv_build"
 
 [project]
 name = "ha-mcp-dev"
-version = "9.0.0.dev3224"
+version = "9.0.1.dev3231"
 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-9.0.1.dev3231/src/ha_mcp/mcp_client_context.py

@@ -0,0 +1,164 @@
+"""What the connected MCP client said about itself on the current request.
+
+Handshake-era clients (through 2025-11-25) send their client info and
+capabilities once, in ``initialize``. On 2026-07-28 there is no handshake:
+every request carries its protocol version, client info and capabilities in
+``_meta``, and the SDK exposes them on that request's session. Either way the
+values are read per request, so they describe the request being served.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+from ha_mcp._vendor.fastmcp.server.dependencies import get_http_headers
+from ha_mcp._vendor.fastmcp.server.middleware.middleware import (
+    CallNext,
+    Middleware,
+    MiddlewareContext,
+)
+from ha_mcp._vendor.mcp_types import ClientCapabilities
+
+logger = logging.getLogger(__name__)
+
+
+def protocol_version(ctx: Any) -> str | None:
+    """The MCP protocol version this request was served on."""
+    version = getattr(getattr(ctx, "request_context", None), "protocol_version", None)
+    return version if isinstance(version, str) else None
+
+
+def client_capabilities(ctx: Any) -> ClientCapabilities | None:
+    """The capabilities the client declared for this request, if any."""
+    session = getattr(getattr(ctx, "request_context", None), "session", None)
+    caps = getattr(session, "client_capabilities", None)
+    return caps if isinstance(caps, ClientCapabilities) else None
+
+
+def declares_form_elicitation(caps: ClientCapabilities | None) -> bool:
+    """True when the client can show a form-mode elicitation to its user.
+
+    An empty ``elicitation`` object predates the form/url split and means
+    form mode only.
+    """
+    elicitation = caps.elicitation if caps is not None else None
+    if elicitation is None:
+        return False
+    return elicitation.form is not None or elicitation.url is None
+
+
+def capability_names(caps: ClientCapabilities | None) -> list[str] | None:
+    """Flatten declared capabilities into stable, readable names.
+
+    ``None`` means the request carried none to read, which is not the same as
+    declaring none: a handshake-era client over stateless HTTP sends them only
+    in ``initialize``, never on a later call.
+    """
+    if caps is None:
+        return None
+    names: list[str] = []
+    if caps.elicitation is not None:
+        if declares_form_elicitation(caps):
+            names.append("elicitation.form")
+        if caps.elicitation.url is not None:
+            names.append("elicitation.url")
+    names.extend(
+        field
+        for field in ("sampling", "roots", "tasks")
+        if getattr(caps, field) is not None
+    )
+    names.extend(f"extension:{key}" for key in sorted(caps.extensions or {}))
+    names.extend(f"experimental:{key}" for key in sorted(caps.experimental or {}))
+    return names
+
+
+def extract_client_info(ctx: Any) -> dict[str, str]:
+    """Pull the connecting MCP client's self-identification off the request context.
+
+    The MCP ``initialize`` handshake carries a ``clientInfo`` Implementation
+    object (``name``/``version``/optional ``title``). FastMCP exposes the
+    underlying server session as ``ctx.session``; the MCP SDK's
+    ``ServerSession`` keeps the parsed initialize params on ``client_params``;
+    on the 2026-07-28 protocol the SDK synthesizes them from the request's
+    ``_meta`` when it carries both client info and capabilities. An
+    older-protocol client over stateless HTTP sends client info only in
+    ``initialize``, so the request's ``User-Agent`` is the fallback there,
+    marked as such in ``title``.
+
+    Returns ``{"name": ..., "version": ..., "title": ...}``. ``name`` and
+    ``version`` fall back to ``"unknown"`` when the client didn't send them;
+    ``title`` falls back to the empty string so callers can distinguish "not
+    sent" from a real title without false-positive aside rendering.
+
+    Returns an empty dict when there is no context, or no client info and no
+    ``User-Agent`` (e.g. stdio), so its callers (bug report, overview, debug
+    log) never fail on it. The log level is intentionally INFO, not DEBUG:
+    this catch is the only signal we'd get if FastMCP/MCP SDK shape drifts in
+    a future release, and silent drift would hide a regression for months.
+    """
+    if ctx is None:
+        return {}
+    try:
+        params = getattr(getattr(ctx, "session", None), "client_params", None)
+        client = getattr(params, "client_info", None) or getattr(
+            params, "clientInfo", None
+        )
+        if client is None:
+            return _client_info_from_user_agent()
+        return {
+            "name": getattr(client, "name", None) or "unknown",
+            "version": getattr(client, "version", None) or "unknown",
+            "title": getattr(client, "title", None) or "",
+        }
+    except Exception as e:  # noqa: BLE001
+        logger.info(
+            "Failed to read MCP client info from context: %s (%s)",
+            e,
+            type(e).__name__,
+        )
+        return {}
+
+
+def _client_info_from_user_agent() -> dict[str, str]:
+    """``{"name", "version", "title"}`` from the HTTP ``User-Agent``, or ``{}``."""
+    user_agent = get_http_headers(include={"user-agent"}).get("user-agent", "").strip()
+    if not user_agent:
+        return {}
+    product = user_agent.split()[0]
+    name, _, version = product.partition("/")
+    logger.debug("No MCP client info on the request; using User-Agent %r", product)
+    return {
+        "name": name or "unknown",
+        "version": version or "unknown",
+        "title": "from HTTP User-Agent",
+    }
+
+
+def describe_mcp_client(ctx: Any) -> dict[str, Any]:
+    """Protocol version, client info and declared capabilities of this request."""
+    return {
+        "protocol_version": protocol_version(ctx) or "unknown",
+        "client_info": extract_client_info(ctx),
+        "capabilities": capability_names(client_capabilities(ctx)),
+    }
+
+
+class McpClientDebugLogMiddleware(Middleware):
+    """Log, at DEBUG, which protocol and capabilities each tool call arrived with.
+
+    The modern protocol is stateless, so there is no connection to log once
+    per client; the line is per call and costs one level check when DEBUG is
+    off.
+    """
+
+    async def on_call_tool(
+        self, context: MiddlewareContext, call_next: CallNext
+    ) -> Any:
+        if logger.isEnabledFor(logging.DEBUG):
+            logger.debug(
+                "tools/call %s: %s",
+                context.message.name,
+                describe_mcp_client(context.fastmcp_context),
+            )
+        return await call_next(context)

{ha_mcp_dev-9.0.0.dev3224 → ha_mcp_dev-9.0.1.dev3231}/src/ha_mcp/policy/middleware.py

@@ -15,6 +15,7 @@ from ha_mcp._vendor.fastmcp.server.middleware.middleware import (
     Middleware,
     MiddlewareContext,
 )
+from ha_mcp._vendor.fastmcp.tools.base import InputRequiredToolResult
 
 from ..errors import ErrorCode, create_error_response
 from ..renamed_tools import current_tool_name
@@ -30,7 +31,12 @@ from .evaluator import (
 )
 from .events import emit_approval_requested
 from .model import Policy, Rule
-from .mrtr import ApprovalContinuation, supports_mrtr
+from .mrtr import (
+    ApprovalAnswer,
+    ApprovalContinuation,
+    approval_answer,
+    supports_mrtr,
+)
 
 if TYPE_CHECKING:
     from ..client.rest_client import HomeAssistantClient
@@ -264,8 +270,22 @@ class PolicyMiddleware(Middleware):
             continuation = ApprovalContinuation.start(
                 pending, policy, wait, dynamic_targets=dynamic_targets
             )
+        if resumed is not None and (answer := approval_answer(context)) != "accept":
+            return await self._end_unconfirmed_resume(
+                pending,
+                rule,
+                resumed[0],
+                answer,
+                dynamic_targets=dynamic_targets,
+                policy=policy,
+                name=name,
+            )
         await self._wait_for_decision(
-            context, pending, continuation.wait_seconds() if continuation else wait
+            context,
+            pending,
+            continuation.wait_seconds(confirmed=resumed is not None)
+            if continuation
+            else wait,
         )
 
         if pending.decision == "approved":
@@ -292,17 +312,87 @@ class PolicyMiddleware(Middleware):
             self._queue.remove(pending.token)
             self._raise_denied_error()
 
-        if continuation is not None:
+        # Only the first leg asks; an accepted form already waited out the window.
+        if continuation is not None and resumed is None:
             result = continuation.next_result(self._queue)
             if result is not None:
                 return result
 
+        await self._raise_unresolved(
+            pending, rule, dynamic_targets=dynamic_targets, policy=policy, name=name
+        )
+        return None  # py/mixed-returns: explicit terminal; error handlers above always raise (NoReturn), unreachable
+
+    async def _end_unconfirmed_resume(
+        self,
+        pending: PendingApproval,
+        rule: Rule | None,
+        continuation: ApprovalContinuation,
+        answer: ApprovalAnswer | None,
+        *,
+        dynamic_targets: bool,
+        policy: Policy,
+        name: str,
+    ) -> InputRequiredToolResult | None:
+        """Handle a resumed call whose form was not accepted. Never dispatches.
+
+        Only an accepted form continues a resumed call, even once the row is
+        approved. The answer is client-supplied, so it may stop or deny the
+        call but never approve it: decline denies or removes the row (for
+        every call waiting on a shared static row, as a Deny click would),
+        cancel ends with the approval error, and a retry with no answer is
+        asked again.
+        """
+        if answer is not None:
+            # Logged because a client answer can end a row a human approved.
+            logger.info(
+                "policy middleware: token %s for tool=%s ended by the client's "
+                "form answer=%s (decision was %s)",
+                pending.token,
+                name,
+                answer,
+                pending.decision,
+            )
+        if answer == "decline" or pending.decision == "denied":
+            self._queue.deny(pending.token)
+            self._queue.remove(pending.token)
+            self._raise_denied_error()
+        if answer is None:
+            ask = continuation.next_result(self._queue)
+            if ask is not None:
+                return ask
+        await self._raise_unresolved(
+            pending,
+            rule,
+            dynamic_targets=dynamic_targets,
+            policy=policy,
+            name=name,
+            dismissed=answer == "cancel",
+        )
+        return None  # py/mixed-returns: explicit terminal; error handlers above always raise (NoReturn), unreachable
+
+    async def _raise_unresolved(
+        self,
+        pending: PendingApproval,
+        rule: Rule | None,
+        *,
+        dynamic_targets: bool,
+        policy: Policy,
+        name: str,
+        dismissed: bool = False,
+    ) -> NoReturn:
+        """End a call that has no decision: finalize the row, re-announce, raise."""
         pending = self._finalize_timed_out_pending(
-            pending, dynamic_targets=dynamic_targets, policy=policy, name=name
+            pending,
+            dynamic_targets=dynamic_targets,
+            policy=policy,
+            name=name,
+            dismissed=dismissed,
         )
         await self._announce_reissued(pending, rule, dynamic_targets=dynamic_targets)
-        self._raise_pending_error(pending, rule, dynamic_targets=dynamic_targets)
-        return None  # py/mixed-returns: explicit terminal; error handlers above always raise (NoReturn), unreachable
+        self._raise_pending_error(
+            pending, rule, dynamic_targets=dynamic_targets, dismissed=dismissed
+        )
 
     async def _announce_reissued(
         self,
@@ -526,8 +616,12 @@ class PolicyMiddleware(Middleware):
         dynamic_targets: bool,
         policy: Policy,
         name: str,
+        dismissed: bool = False,
     ) -> PendingApproval:
-        """Resolve a pending entry that timed out without a decision.
+        """Resolve a pending entry that ended without a decision.
+
+        ``dismissed`` means the user dismissed the approval form rather than
+        the wait running out; it only changes what is logged.
 
         Two mutually exclusive outcomes, split by ``dynamic_targets`` for
         the same reason the entry was never shared or looked up in the
@@ -561,9 +655,12 @@ class PolicyMiddleware(Middleware):
             # an operator tell those apart.
             logger.info(
                 "policy middleware: dynamic pending token %s removed after "
-                "its single-use wait window closed for tool=%s; a late "
-                "Approve click on it will log as an unknown token",
+                "%s for tool=%s; a late Approve click on it will log as an "
+                "unknown token",
                 pending.token,
+                "the approval form was dismissed"
+                if dismissed
+                else "its single-use wait window closed",
                 name,
             )
             return pending
@@ -627,6 +724,7 @@ class PolicyMiddleware(Middleware):
         rule: Rule | None = None,
         *,
         dynamic_targets: bool = False,
+        dismissed: bool = False,
     ) -> NoReturn:
         """Raise the structured USER_APPROVAL_REQUIRED error for one pending entry.
 
@@ -638,9 +736,9 @@ class PolicyMiddleware(Middleware):
         picked up by a later re-call -- so its wording must not promise the
         normal "re-call after the user approves" recovery path the
         non-dynamic case uses, and must not describe a still-open approval
-        window: this is the ONLY call site, reached after
-        ``_wait_for_decision`` returns with no decision, so the wait window
-        has already closed by the time this message is built.
+        window. It ends either after ``_wait_for_decision`` returned with no
+        decision (the window closed) or, with ``dismissed``, when the user
+        dismissed the approval form, and the message says which.
         """
         context: dict[str, Any] = {"token": pending.token}
         # Surface the matched rule so users (and the LLM) can tell at a
@@ -657,10 +755,15 @@ class PolicyMiddleware(Middleware):
             # countdown left to report -- a number here would read as
             # "there's still time", exactly the false impression this
             # message must not give.
+            ended = (
+                "the approval form for this call was dismissed"
+                if dismissed
+                else "this call's wait window has now closed"
+            )
             message = (
                 "User approval required, and this specific request has "
-                "already expired: it was single-use, bound to this one "
-                "call only, and this call's wait window has now closed. "
+                "already ended: it was single-use, bound to this one "
+                f"call only, and {ended}. "
                 "The token above has already been removed and no longer "
                 "exists -- there is nothing left to approve for this call. "
                 "Re-call this tool to create a brand-new, independent "

{ha_mcp_dev-9.0.0.dev3224 → ha_mcp_dev-9.0.1.dev3231}/src/ha_mcp/policy/mrtr.py

@@ -1,42 +1,69 @@
-"""Bounded MRTR polling of the existing approval queue.
+"""Ask the user, through MRTR elicitation, to decide a held tool call.
+
+A result carrying only ``requestState`` gives the client nothing to show its
+user, and the spec lets a client stop there instead of retrying. The only
+in-band way to reach the user is an ``inputRequests`` entry, and a server may
+send one only for a capability the client declared. So a client that declares
+form elicitation is told, after a short first wait, to decide the call in the
+ha-mcp settings; every other client keeps the blocking wait and its
+approval-required error.
 
 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.
+state is a reference to a decision, never an approval supplied by the client:
+the elicitation answer can stop or deny a call, never approve it.
 """
 
 from __future__ import annotations
 
+import logging
 from collections.abc import Mapping
 from datetime import UTC, datetime
 from time import time
-from typing import Literal, NoReturn
+from typing import Literal, NoReturn, cast, get_args
 
 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 import (
+    ElicitRequest,
+    ElicitRequestFormParams,
+    InputRequiredResult,
+)
 from ha_mcp._vendor.mcp_types.version import MODERN_PROTOCOL_VERSIONS
 
 from ..errors import ErrorCode, create_error_response
+from ..mcp_client_context import (
+    client_capabilities,
+    declares_form_elicitation,
+    protocol_version,
+)
 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
 
+logger = logging.getLogger(__name__)
+
 # Leave room below the SDK's default ten-round limit for a normal final error.
 MAX_CONTINUATIONS = 8
+# How long a call waits before asking; a quick approval never prompts.
 ROUND_WAIT_SECONDS = 10
+APPROVAL_INPUT_KEY = "ha_mcp_approval"
+
+ApprovalAnswer = Literal["accept", "decline", "cancel"]
 
 
 def supports_mrtr(context: MiddlewareContext) -> bool:
-    """Use modern MRTR only where retrying resumes this single tool dispatch."""
+    """Use MRTR only where the client can show the ask and a retry resumes this dispatch."""
     ctx = context.fastmcp_context
-    request = getattr(ctx, "request_context", None)
-    if getattr(request, "protocol_version", None) not in MODERN_PROTOCOL_VERSIONS:
+    if protocol_version(ctx) not in MODERN_PROTOCOL_VERSIONS:
+        return False
+    if not declares_form_elicitation(client_capabilities(ctx)):
         return False
+    request = getattr(ctx, "request_context", None)
     params = getattr(getattr(request, "_srctx", None), "params", None)
     if not isinstance(params, Mapping):
         return False
@@ -49,6 +76,48 @@ def supports_mrtr(context: MiddlewareContext) -> bool:
     return name == current_tool_name(context.message.name)
 
 
+def approval_answer(context: MiddlewareContext) -> ApprovalAnswer | None:
+    """The user's answer to the approval elicitation, if this retry carries one."""
+    responses = getattr(context.fastmcp_context, "input_responses", None)
+    if not responses:
+        return None
+    answer = responses.get(APPROVAL_INPUT_KEY)
+    action = getattr(answer, "action", None)
+    if action not in get_args(ApprovalAnswer):
+        logger.warning(
+            "approval elicitation: unreadable answer (keys %s, value %r); asking again",
+            sorted(responses),
+            answer,
+        )
+        return None
+    return cast("ApprovalAnswer", action)
+
+
+def _approval_request(tool_name: str, wait_seconds: int) -> ElicitRequest:
+    return ElicitRequest(
+        params=ElicitRequestFormParams(
+            # Clients may render this on one truncated line: keep it short.
+            message=(
+                f"Approve {tool_name} in ha-mcp > Tool Security Policies and "
+                f"Accept here (either order, within {wait_seconds} s of the call)."
+            ),
+            # A bool field rather than an empty schema: FastMCP notes some
+            # clients render an empty schema as a blank, non-functional form.
+            requested_schema={
+                "type": "object",
+                "properties": {
+                    "decided": {
+                        "type": "boolean",
+                        "title": "Continue once approved in the ha-mcp settings",
+                        "default": True,
+                    }
+                },
+                "required": ["decided"],
+            },
+        )
+    )
+
+
 def _policy_hash(policy: Policy) -> str:
     return compute_args_hash(
         {
@@ -73,8 +142,23 @@ def _cannot_resume() -> NoReturn:
     )
 
 
+def _window_ended() -> NoReturn:
+    raise_tool_error(
+        create_error_response(
+            ErrorCode.USER_APPROVAL_REQUIRED,
+            "The approval window for this call has ended. This retry executed "
+            "nothing, but an earlier attempt of this call may already have run: "
+            "check its outcome before calling the tool again.",
+            suggestions=[
+                "Check the target's current state before re-calling.",
+                "A fresh call needs a new approval in the Tool Security Policies tab.",
+            ],
+        )
+    )
+
+
 class ApprovalContinuation(BaseModel):
-    """Small, sealed reference retaining one logical call's deadline."""
+    """Small, sealed reference retaining one logical call's deadline and window."""
 
     model_config = ConfigDict(extra="forbid", strict=True, allow_inf_nan=False)
 
@@ -84,6 +168,7 @@ class ApprovalContinuation(BaseModel):
     args_hash: str
     policy_hash: str
     deadline: float
+    window_seconds: int
     rounds: int = Field(default=0, ge=0, le=MAX_CONTINUATIONS)
 
     @classmethod
@@ -107,6 +192,11 @@ class ApprovalContinuation(BaseModel):
         except ValidationError:
             _cannot_resume()
         pending = queue.get(continuation.token)
+        # A late answer is ordinary user latency, not a stale or reused
+        # state: past the deadline the gate waits no longer and ends with
+        # the normal approval outcome, so the deadline is not checked here.
+        if pending is None and continuation.deadline <= time():
+            _window_ended()
         if (
             pending is None
             or continuation.tool_name != name
@@ -114,7 +204,6 @@ class ApprovalContinuation(BaseModel):
             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
@@ -139,13 +228,18 @@ class ApprovalContinuation(BaseModel):
             args_hash=pending.args_hash,
             policy_hash=_policy_hash(policy),
             deadline=deadline,
+            window_seconds=wait_seconds,
         )
 
-    def wait_seconds(self) -> float:
-        return max(0, min(ROUND_WAIT_SECONDS, self.deadline - time()))
+    def wait_seconds(self, *, confirmed: bool) -> float:
+        """Wait briefly before asking; once the user confirmed, use the whole window."""
+        remaining = self.deadline - time()
+        if confirmed:
+            return max(0, remaining)
+        return max(0, min(ROUND_WAIT_SECONDS, remaining))
 
     def next_result(self, queue: ApprovalQueue) -> InputRequiredToolResult | None:
-        """End a pending leg without granting, consuming or extending approval."""
+        """Ask the user to decide, without granting, consuming or extending approval."""
         if (
             self.rounds >= MAX_CONTINUATIONS
             or time() >= self.deadline
@@ -154,5 +248,12 @@ class ApprovalContinuation(BaseModel):
             return None
         state = self.model_copy(update={"rounds": self.rounds + 1})
         return InputRequiredToolResult(
-            InputRequiredResult(request_state=state.model_dump_json())
+            InputRequiredResult(
+                input_requests={
+                    APPROVAL_INPUT_KEY: _approval_request(
+                        self.tool_name, self.window_seconds
+                    )
+                },
+                request_state=state.model_dump_json(),
+            )
         )

{ha_mcp_dev-9.0.0.dev3224 → ha_mcp_dev-9.0.1.dev3231}/src/ha_mcp/server.py

@@ -41,6 +41,7 @@ from .utils.skill_loader import (
     BEST_PRACTICES_SKILL_NAME,
     best_practices_skill,
     list_skill_files,
+    log_skill_registration_summary,
     parse_skill_frontmatter,
 )
 
@@ -216,9 +217,12 @@ class HomeAssistantSmartMCPServer:
         # Keep the pre-rename tool names callable for clients that still hold
         # an older catalog. First in the chain, so everything after it sees the
         # current name it is keyed on.
+        from .mcp_client_context import McpClientDebugLogMiddleware
         from .tools.renamed_tool_middleware import RenamedToolAliasMiddleware
 
         self.mcp.add_middleware(RenamedToolAliasMiddleware())
+        # After the alias, so the DEBUG line logs the current tool name.
+        self.mcp.add_middleware(McpClientDebugLogMiddleware())
 
         # Convert Pydantic type-validation errors to structured ToolErrors so
         # models get actionable guidance instead of raw Pydantic messages.
@@ -882,31 +886,7 @@ class HomeAssistantSmartMCPServer:
             )
             status["tool"] = "failed"
 
-        self._log_skill_registration_summary(status)
-
-    @staticmethod
-    def _log_skill_registration_summary(status: dict[str, str | int]) -> None:
-        """Emit one-line summary of skill registration outcome.
-
-        ``info`` when both provider and tool registered AND at least one
-        skill bundle parsed; ``warning`` otherwise. The guidance>0 gate
-        catches the "tool registered but exposes nothing" case (skills
-        directory missing, empty, or every SKILL.md fails to parse) —
-        the tool stays present so the failure is reachable via a tool
-        call, but operators should grep for this warning when a user
-        reports missing skill features.
-        """
-        provider = status.get("provider")
-        tool = status.get("tool")
-        raw_guidance = status.get("guidance_count", 0)
-        guidance = raw_guidance if isinstance(raw_guidance, int) else 0
-
-        message = "Skill system summary: provider=%s, tool=%s, guidance_count=%d"
-        args = (provider, tool, guidance)
-        if provider == "ok" and tool == "ok" and guidance > 0:
-            logger.info(message, *args)
-        else:
-            logger.warning(message, *args)
+        log_skill_registration_summary(status)
 
     def _register_skill_guide_tool(self, skills_dir: Path | None) -> int:
         """Register the ``ha_get_skill_guide`` tool unconditionally.