ha-mcp-dev 9.1.0.dev3271__tar.gz → 9.1.0.dev3275__tar.gz

{ha_mcp_dev-9.1.0.dev3271 → ha_mcp_dev-9.1.0.dev3275}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ha-mcp-dev
-Version: 9.1.0.dev3271
+Version: 9.1.0.dev3275
 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.1.0.dev3271 → ha_mcp_dev-9.1.0.dev3275}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "uv_build"
 
 [project]
 name = "ha-mcp-dev"
-version = "9.1.0.dev3271"
+version = "9.1.0.dev3275"
 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.1.0.dev3271 → ha_mcp_dev-9.1.0.dev3275}/pyproject.toml.orig

@@ -4,7 +4,7 @@ build-backend = "uv_build"
 
 [project]
 name = "ha-mcp-dev"
-version = "9.1.0.dev3271"
+version = "9.1.0.dev3275"
 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.1.0.dev3271 → ha_mcp_dev-9.1.0.dev3275}/src/ha_mcp/client/rest_client.py

@@ -1959,8 +1959,8 @@ class HomeAssistantClient:
         for attempt in range(max_retries):
             # Whether the failure happened before a usable connection existed.
             # Failing to obtain one is transport death whatever class the
-            # manager raises, and it raises a bare ``Exception`` when
-            # ``connect()`` returns False, so this cannot be decided by type.
+            # manager raises; an auth failure or the pool-lock guard's bare
+            # ``Exception`` is not a connection error; type cannot decide this.
             acquiring = True
             try:
                 # Use per-client WebSocket keyed to this client's credentials
@@ -1999,10 +1999,10 @@ class HomeAssistantClient:
                     continue
 
                 # Phase first, type second. Failing before a client exists is
-                # evidence about the transport whatever class was raised, and
-                # the pooled manager raises a bare ``Exception`` when
-                # ``connect()`` returns False, so that case cannot be decided
-                # by type. Past acquisition only the no-answer classes count:
+                # evidence about the transport whatever class was raised; an
+                # auth failure or the pool-lock guard's bare ``Exception`` is not
+                # a no-answer class, so that case cannot be decided by type.
+                # Past acquisition only the no-answer classes count:
                 # ``send_command`` deliberately re-raises the original
                 # ``ConnectionClosed`` / ``ConnectionResetError`` from the send
                 # rather than wrapping it, to keep at-most-once semantics for

{ha_mcp_dev-9.1.0.dev3271 → ha_mcp_dev-9.1.0.dev3275}/src/ha_mcp/tools/blueprint_sources.py

@@ -219,7 +219,7 @@ async def _via_component(client: Any, domain: str, path: str) -> _ComponentBody:
             )
         return _NO_COMPONENT_BODY
     except Exception as exc:  # noqa: BLE001
-        # HomeAssistantConnectionError / plain establish Exception → metadata-only
+        # HomeAssistantConnectionError or any other error → metadata-only
         # (no full-body legacy fetch exists; the base metadata is already served).
         logger.warning(
             "ha_mcp_tools/blueprint_get connection error; served metadata-only: %r",

{ha_mcp_dev-9.1.0.dev3271 → ha_mcp_dev-9.1.0.dev3275}/src/ha_mcp/tools/component_config_reads.py

@@ -27,11 +27,11 @@ returns its payload (an entity_lookup with an EMPTY ``matches`` list is
 authoritative — "no registry entry with that unique_id" — kept distinct from the
 ``None`` miss).
 
-Both helpers apply the uniform transport-fallback taxonomy: a
-``HomeAssistantConnectionError`` off ``send_command`` — and the plain
-``Exception`` ``get_websocket_client()`` raises when ``WebSocketManager`` cannot
-(re)build the pooled socket — are caught and mapped to ``None`` so the legacy
-path runs, NEVER propagated out of the read. Neither consumer's legacy path dies
+Both helpers apply the uniform transport-fallback taxonomy: a transport failure
+— ``HomeAssistantConnectionError`` off ``send_command`` or from a failed (re)build
+of the pooled socket in ``get_websocket_client()``, or ``HomeAssistantAuthError``
+when HA rejects the token — is caught and mapped to ``None`` so the legacy path
+runs, NEVER propagated out of the read. Neither consumer's legacy path dies
 identically on a pooled-WS drop, so propagating would abort work the legacy path
 still completes:
 
@@ -120,8 +120,8 @@ async def fetch_entity_lookup_via_component(
             logger.warning("%s failed; fell back to legacy: %r", WS_ENTITY_LOOKUP, exc)
         return None
     except Exception as exc:  # noqa: BLE001
-        # HomeAssistantConnectionError: a pooled-WS drop or a failed
-        # (re)connect.
+        # HomeAssistantConnectionError (a pooled-WS drop or a failed
+        # (re)connect) or any other error.
         # The resolvers' legacy paths do NOT die identically (see module docstring),
         # so route to legacy rather than escape.
         logger.warning(

{ha_mcp_dev-9.1.0.dev3271 → ha_mcp_dev-9.1.0.dev3275}/src/ha_mcp/tools/component_devices.py

@@ -193,7 +193,7 @@ async def fetch_device_list_via_component(client: Any) -> dict[str, Any] | None:
             logger.warning("%s failed; fell back to legacy: %r", WS_DEVICE_LIST, exc)
         return None
     except Exception as exc:  # noqa: BLE001
-        # HomeAssistantConnectionError / plain establish Exception → legacy (the
+        # HomeAssistantConnectionError or any other error → legacy (the
         # legacy device list rides the send_websocket_message bridge).
         logger.warning(
             "%s connection error; falling back to legacy: %r", WS_DEVICE_LIST, exc

{ha_mcp_dev-9.1.0.dev3271 → ha_mcp_dev-9.1.0.dev3275}/src/ha_mcp/tools/component_registry_lookup.py

@@ -104,7 +104,7 @@ async def fetch_entities_for_config_entry_via_component(
             )
         return None
     except Exception as exc:  # noqa: BLE001
-        # HomeAssistantConnectionError / plain establish Exception → legacy (the
+        # HomeAssistantConnectionError or any other error → legacy (the
         # legacy entity_registry/list dump rides the bridge; see module
         # docstring). Never propagate a transport failure out of the read.
         logger.warning(
@@ -159,7 +159,7 @@ async def resolve_entities_via_component(
             )
         return None
     except Exception as exc:  # noqa: BLE001
-        # HomeAssistantConnectionError / plain establish Exception → legacy. The
+        # HomeAssistantConnectionError or any other error → legacy. The
         # simple-delete consumer's legacy per-id retry loop only runs when this
         # returns None, so an escaping transport failure would skip it entirely.
         logger.warning(

{ha_mcp_dev-9.1.0.dev3271 → ha_mcp_dev-9.1.0.dev3275}/src/ha_mcp/tools/log_sources_logbook.py

@@ -602,12 +602,9 @@ class LogbookLogSourceMixin:
                     order,
                 )
 
-            wrapped = await add_timezone_metadata(self._client, logbook_data)
             if transport_warnings:
-                # Top-level, alongside the other tool warnings: nesting these
-                # under ``data`` would hide them from the warning merger.
-                wrapped["warnings"] = transport_warnings + wrapped.get("warnings", [])
-            return wrapped
+                logbook_data["warnings"] = transport_warnings
+            return await add_timezone_metadata(self._client, logbook_data)
 
         except ToolError:
             raise

{ha_mcp_dev-9.1.0.dev3271 → ha_mcp_dev-9.1.0.dev3275}/src/ha_mcp/tools/response_helpers.py

@@ -416,10 +416,27 @@ async def add_timezone_metadata(
     - Naive strings (no offset) are assumed to be UTC before conversion.
     - ``ZoneInfoNotFoundError`` (tzdata not installed) falls back to UTC.
     - Any config-fetch failure also falls back to UTC without conversion.
+
+    A top-level ``warnings`` list in *data* is returned beside ``data`` instead
+    of inside it, ahead of any timezone warning the wrapper adds, and omitted
+    when empty; *data* itself is left unchanged.
     """
     if not include_metadata:
         return data
 
+    result = await _wrap_with_timezone(client, data, convert_timestamps)
+    inner = result["data"]
+    if isinstance(inner, dict) and isinstance(inner.get("warnings"), list):
+        result["data"] = {k: v for k, v in inner.items() if k != "warnings"}
+        if warnings := inner["warnings"] + result.get("warnings", []):
+            result["warnings"] = warnings
+    return result
+
+
+async def _wrap_with_timezone(
+    client: Any, data: dict[str, Any], convert_timestamps: bool
+) -> dict[str, Any]:
+    """Fetch the timezone, convert *data* and wrap it; may add top-level ``warnings``."""
     ha_timezone, fetch_failed = await fetch_ha_timezone(client)
 
     if not convert_timestamps:

{ha_mcp_dev-9.1.0.dev3271 → ha_mcp_dev-9.1.0.dev3275}/src/ha_mcp/tools/search/component.py

@@ -767,7 +767,9 @@ class ComponentSearchMixin(LegacySearchMixin):
           ``send_websocket_message`` bridge, so a component-side fault degrades
           to partial results rather than escaping. The bridge shares this
           pooled connection, so a dead transport raises there too (#1947) and
-          the registry-unavailable warning names what was skipped.
+          the registry-unavailable warning names what was skipped. When no
+          legacy surface answers either, the legacy search raises its
+          structured error instead.
         """
         if isinstance(exc, (HomeAssistantCommandError, HomeAssistantCommandTimeout)):
             if is_unknown_command(exc):

{ha_mcp_dev-9.1.0.dev3271 → ha_mcp_dev-9.1.0.dev3275}/src/ha_mcp/tools/search/legacy.py

@@ -135,6 +135,14 @@ class LegacySearchMixin(EntityModesMixin):
                 continue
             _apply_search_outcome(response, label, outcome)
 
+        if outcomes and len(errors) == len(outcomes):
+            # No surface answered, so empty buckets would read as "nothing
+            # matched": report the first surface's error instead.
+            first = cast(Exception, outcomes[0])
+            if isinstance(first, ToolError):
+                raise first
+            exception_to_structured_error(first)
+
         # ``count`` mirrors the previous ha_search_entities semantics: items
         # returned in this response (post-pagination), not total matches across
         # the corpus. Total matches live in entity_total_matches +
@@ -347,17 +355,9 @@ class LegacySearchMixin(EntityModesMixin):
                 # carry area_result's warnings; forward them here in one place so a
                 # visibility/registry degradation on the area path is not silently
                 # dropped (mirrors the non-area path's merge_visibility_warnings).
-                # The builders now return the search dict directly (no
-                # add_timezone_metadata wrapper), so warnings merge into that dict;
-                # the ``["data"]`` unwrap is a defensive holdover for a hypothetical
-                # future wrapped payload.
-                warn_target = (
-                    area_search["data"]
-                    if isinstance(area_search, dict) and "data" in area_search
-                    else area_search
+                return merge_visibility_warnings(
+                    area_search, area_result.get("warnings", [])
                 )
-                merge_visibility_warnings(warn_target, area_result.get("warnings", []))
-                return area_search
 
             if domain_filter and (not query or not query.strip()):
                 return await self._search_domain_only(

{ha_mcp_dev-9.1.0.dev3271 → ha_mcp_dev-9.1.0.dev3275}/src/ha_mcp/tools/search/modes.py

@@ -167,8 +167,7 @@ class EntityModesMixin(EntityEnrichmentMixin):
         merge_visibility_warnings(search_data, enrich_warnings)
 
         # No add_timezone_metadata: entity records carry no timestamp fields, so
-        # the enrichment converted nothing and its /api/config fetch was pure
-        # waste (the orchestrator discards its metadata wrapper anyway).
+        # the enrichment converted nothing and its /api/config fetch was pure waste.
         return search_data
 
     async def _search_area_only_populated(

{ha_mcp_dev-9.1.0.dev3271 → ha_mcp_dev-9.1.0.dev3275}/src/ha_mcp/tools/search/overview.py

@@ -468,13 +468,14 @@ class OverviewMixin(SearchToolsBase):
           non-empty ``slice_errors`` — ``_build_overview_slices`` returns
           ``None``): treated like the command-error branch (legacy + warning +
           log), so a partial snapshot never serves a silently-degraded overview.
-        - ``HomeAssistantConnectionError`` (pooled-WS drop) or the plain
-          ``Exception`` ``get_websocket_client()`` raises on a failed (re)connect:
-          served the same way — the legacy overview reads ``/api/states`` +
-          ``/api/services`` over REST and the registries through the swallowing
-          ``send_websocket_message`` bridge, so it degrades to a partial overview
-          rather than dying identically on a pooled-WS drop; a transport failure
-          must not escape.
+        - ``HomeAssistantConnectionError`` (pooled-WS drop or a failed (re)connect
+          in ``get_websocket_client()``): served the same way — the legacy
+          overview reads ``/api/states`` + ``/api/services`` over REST and the
+          registries through the ``send_websocket_message`` bridge, so it
+          degrades to a partial overview rather than dying identically on a
+          pooled-WS drop; a transport failure must not escape. A token HA
+          rejects (``HomeAssistantAuthError``) takes this branch too, but the
+          legacy reads use the same token and fail with it.
         """
         try:
             raw = await self._send_component_overview(inputs)

{ha_mcp_dev-9.1.0.dev3271 → ha_mcp_dev-9.1.0.dev3275}/src/ha_mcp/tools/search/response.py

@@ -189,6 +189,17 @@ def _mirror_partial_to_warnings(response: dict[str, Any]) -> None:
         warnings.append(warning_text)
 
 
+def _omit_empty_warnings(response: dict[str, Any]) -> dict[str, Any]:
+    """Drop an empty ``warnings`` list: the response contract omits it.
+
+    The builders seed ``warnings`` as ``[]`` so they can extend it; this runs
+    once on the finished response of every ``ha_search`` path.
+    """
+    if response.get("warnings") == []:
+        del response["warnings"]
+    return response
+
+
 def _project_response_fields(
     response: dict[str, Any], parsed_fields: list[str] | None
 ) -> dict[str, Any]:
@@ -500,20 +511,9 @@ def _build_hidden_ids(registry_result: Any) -> set[str]:
 def _apply_search_outcome(
     response: dict[str, Any],
     label: str,
-    outcome: dict[str, Any],
+    payload: dict[str, Any],
 ) -> None:
-    """Apply one gather outcome (entities or configs) to the response dict in-place.
-
-    Both ``_ha_search_entities`` and ``_ha_deep_search`` return their search dict
-    directly. The entity builders no longer wrap it via ``add_timezone_metadata``:
-    entity-search records carry none of the timestamp fields that enrichment
-    converts, so it was a discarded ``/api/config`` fetch. The ``{"data": ...}``
-    unwrap is kept as a defensive no-op so a future wrapped payload still reads
-    correctly.
-    """
-    payload = (
-        outcome["data"] if isinstance(outcome, dict) and "data" in outcome else outcome
-    )
+    """Apply one gather outcome (entities or configs) to the response dict in-place."""
     if label == "entities":
         response["entities"] = payload.get("results", [])
         response["entity_total_matches"] = payload.get("total_matches", 0)

{ha_mcp_dev-9.1.0.dev3271 → ha_mcp_dev-9.1.0.dev3275}/src/ha_mcp/tools/search/state.py

@@ -13,7 +13,6 @@ from ...client.rest_client import (
     HomeAssistantAPIError,
     HomeAssistantCommandError,
     HomeAssistantCommandTimeout,
-    HomeAssistantConnectionError,
 )
 from ...client.websocket_client import get_websocket_client
 from ...errors import create_validation_error
@@ -297,11 +296,11 @@ class StateMixin(SearchToolsBase):
         Returns the component's ``{states, missing}`` payload (found ids mapped to
         their ``State.as_dict()`` body) or ``None`` when the component lacks the
         ``states`` capability, was downgraded (``unknown_command`` → invalidate the
-        cached caps), or errored (logged). Falls back **silently** — unlike
-        ``ha_search`` / ``ha_get_zone`` which append a ``warnings[]`` entry —
-        because ``ha_get_state``'s single- and bulk-mode responses do not share one
-        warnings channel; the ``log.warning`` preserves operator visibility and the
-        legacy REST path returns the byte-identical correct data either way.
+        cached caps), errored, or returned a malformed payload (both logged).
+        Falls back **silently** — unlike ``ha_search`` / ``ha_get_zone``, which
+        append a ``warnings[]`` entry — because the legacy REST path returns the
+        byte-identical correct data either way, so the caller has nothing to act
+        on; the ``log.warning`` preserves operator visibility.
         ``ha_get_state``'s legacy path is a REST ``get_entity_state`` read on a
         SEPARATE transport, so a WS transport/connect failure
         (``HomeAssistantConnectionError``, covering both a pooled-WS drop and a
@@ -316,11 +315,7 @@ class StateMixin(SearchToolsBase):
             return None
         try:
             raw = await self._send_component_states(entity_ids)
-        except (
-            HomeAssistantCommandError,
-            HomeAssistantCommandTimeout,
-            HomeAssistantConnectionError,
-        ) as exc:
+        except (HomeAssistantCommandError, HomeAssistantCommandTimeout) as exc:
             if is_unknown_command(exc):
                 invalidate_caps(self._client)
             else:
@@ -329,14 +324,19 @@ class StateMixin(SearchToolsBase):
                 )
             return None
         except Exception as exc:  # noqa: BLE001
-            # Anything the tuple above doesn't cover → legacy REST, so an
-            # install whose REST API still works keeps answering.
+            # Mostly HomeAssistantConnectionError (a pooled-WS drop or a failed
+            # (re)connect); a WS auth failure or a raw socket error lands here
+            # too. Legacy REST rides a separate transport, so an install whose
+            # REST API still works keeps answering.
             logger.warning(
                 "ha_mcp_tools/states connection error; fell back to legacy: %r", exc
             )
             return None
-        result = raw.get("result") or {}
-        if not isinstance(result.get("states"), dict):
+        result = raw.get("result")
+        if not isinstance(result, dict) or not isinstance(result.get("states"), dict):
+            logger.warning(
+                "ha_mcp_tools/states returned a malformed payload; fell back to legacy"
+            )
             return None
         return result
 

{ha_mcp_dev-9.1.0.dev3271 → ha_mcp_dev-9.1.0.dev3275}/src/ha_mcp/tools/tools_config_helpers.py

@@ -212,25 +212,27 @@ class HelperConfigTools:
         # silent empty). Storage/collection types keep the legacy fallback.
         is_flow = helper_type not in SIMPLE_HELPER_TYPES
 
-        # Prefer the custom component's in-process listing when it advertises
-        # the capability: one WS round-trip that joins the entity registry, so
-        # each record carries the current entity_id + display name (the #1794
-        # stale-id fix, shipped additively) instead of only the storage id.
-        # Fall back cleanly for storage types when the component is absent,
-        # downlevel, or errors — the taxonomy lives in
-        # ``_list_helpers_via_component``. The legacy body below is untouched.
-        caps = await get_component_caps(self._client)
-        if component_supports(caps, "helpers_list"):
-            component_response = await self._list_helpers_via_component(
-                helper_type, is_flow=is_flow
-            )
-            if component_response is not None:
-                return _paginate_helpers_response(component_response, offset, limit)
-        if is_flow:
-            # No usable component path and the legacy body cannot serve flow
-            # helpers: hard error rather than an empty or misleading list.
-            _raise_flow_requires_component(helper_type)
         try:
+            # Prefer the custom component's in-process listing when it advertises
+            # the capability: one WS round-trip that joins the entity registry, so
+            # each record carries the current entity_id + display name (the #1794
+            # stale-id fix, shipped additively) instead of only the storage id.
+            # Fall back cleanly for storage types when the component is absent,
+            # downlevel, or errors — the taxonomy lives in
+            # ``_list_helpers_via_component``.
+            # Inside the ``try`` so an error the fallback re-raises reaches the
+            # structured-error handler below.
+            caps = await get_component_caps(self._client)
+            if component_supports(caps, "helpers_list"):
+                component_response = await self._list_helpers_via_component(
+                    helper_type, is_flow=is_flow
+                )
+                if component_response is not None:
+                    return _paginate_helpers_response(component_response, offset, limit)
+            if is_flow:
+                # No usable component path and the legacy body cannot serve flow
+                # helpers: hard error rather than an empty or misleading list.
+                _raise_flow_requires_component(helper_type)
             result = await self._client.send_websocket_message(
                 {"type": f"{helper_type}/list"}
             )
@@ -297,8 +299,8 @@ class HelperConfigTools:
           for a storage type, serve the correct result from the legacy WS list,
           append a ``warnings[]`` entry, and ``log.warning``. For a flow type,
           raise the component-required error — no legacy fallback exists.
-        - ``HomeAssistantConnectionError`` (pooled-WS drop) or the plain
-          ``Exception`` ``get_websocket_client()`` raises on a failed (re)connect:
+        - ``HomeAssistantConnectionError`` (pooled-WS drop or a failed (re)connect
+          in ``get_websocket_client()``) or ``HomeAssistantAuthError`` (token rejected):
           for a storage type, the legacy ``{helper_type}/list`` body is attempted,
           with a ``warnings[]`` entry + ``log.warning``. It rides the
           ``send_websocket_message`` bridge over the SAME pooled connection
@@ -339,8 +341,9 @@ class HelperConfigTools:
             return legacy
         except Exception as exc:
             # Transport/establishment failure — a pooled-WS drop or a failed
-            # (re)connect, both HomeAssistantConnectionError. A storage type
-            # still attempts the legacy
+            # (re)connect (HomeAssistantConnectionError), a rejected token
+            # (HomeAssistantAuthError) or any other error. A storage type still
+            # attempts the legacy
             # `{helper_type}/list` body: it rides the same pooled connection, so it
             # recovers a component-side fault but not a dead socket, where the
             # bridge raises in turn (#1947). A flow type has NO legacy body, so its

{ha_mcp_dev-9.1.0.dev3271 → ha_mcp_dev-9.1.0.dev3275}/src/ha_mcp/tools/tools_dev.py

@@ -318,7 +318,7 @@ async def _fetch_server_entry_via_component(client: Any) -> dict[str, Any] | Non
             logger.warning("%s failed; fell back to legacy: %r", WS_SERVER_ENTRY, exc)
         return None
     except Exception as exc:  # noqa: BLE001
-        # HomeAssistantConnectionError / plain establish Exception → legacy probe
+        # HomeAssistantConnectionError or any other error → legacy probe
         # (which rides the send_websocket_message bridge).
         logger.warning(
             "%s connection error; falling back to legacy: %r", WS_SERVER_ENTRY, exc

{ha_mcp_dev-9.1.0.dev3271 → ha_mcp_dev-9.1.0.dev3275}/src/ha_mcp/tools/tools_entities.py

@@ -174,7 +174,7 @@ async def fetch_entity_enrichment_via_component(
             logger.warning("%s failed; skipped enrichment: %r", WS_ENTITY_ENRICH, exc)
         return None
     except Exception as exc:  # noqa: BLE001
-        # HomeAssistantConnectionError / plain establish Exception → skip
+        # HomeAssistantConnectionError or any other error → skip
         # enrichment (strictly additive; no legacy fetch dies here).
         logger.warning(
             "%s connection error; skipped enrichment: %r", WS_ENTITY_ENRICH, exc

{ha_mcp_dev-9.1.0.dev3271 → ha_mcp_dev-9.1.0.dev3275}/src/ha_mcp/tools/tools_history.py

@@ -502,8 +502,8 @@ class HistoryTools:
                 message="recorder query complete",
             )
             # Wrap first so the outer {"data": ..., "metadata": ...} shape
-            # is always present; then project the inner data dict in-place
-            # when caller requested field projection.
+            # is always present; then project the inner data dict and lift
+            # the typo warning project_fields may add to it.
             _r = await add_timezone_metadata(
                 self._client, inner, convert_timestamps=False
             )
@@ -980,7 +980,7 @@ async def _fetch_history(
             "summary": summary_until is not None,
         },
     }
-    if summary_until is not None:  # ha_get_history drops an empty list
+    if summary_until is not None:  # add_timezone_metadata drops an empty list
         history_data["warnings"] = summary_warnings(result_data, summaries, start_ts)
 
     return history_data

{ha_mcp_dev-9.1.0.dev3271 → ha_mcp_dev-9.1.0.dev3275}/src/ha_mcp/tools/tools_integrations.py

@@ -354,9 +354,9 @@ async def _fetch_entries_via_component(
         return None
     except Exception as exc:  # noqa: BLE001
         # DEVIATION (see docstring): the legacy path is pure REST / the REST-client
-        # WS bridge, NOT the shared pooled WS. A pooled-WS drop
-        # (HomeAssistantConnectionError) OR get_websocket_client() raising a plain
-        # Exception when WebSocketManager can't (re)connect must fall back to legacy
+        # WS bridge, NOT the shared pooled WS. A pooled-WS drop or a failed
+        # (re)connect (HomeAssistantConnectionError), a rejected token
+        # (HomeAssistantAuthError) or any other error must fall back to legacy
         # rather than kill the tool.
         logger.warning(
             "%s connection error; falling back to legacy: %r",

{ha_mcp_dev-9.1.0.dev3271 → ha_mcp_dev-9.1.0.dev3275}/src/ha_mcp/tools/tools_search.py

@@ -37,6 +37,7 @@ from .search.overview import (
 )
 from .search.response import (
     _compute_eligibility,
+    _omit_empty_warnings,
     _ResolvedSearch,
     _validate_search_types,
 )
@@ -417,9 +418,9 @@ class SearchTools(ComponentSearchMixin, OverviewMixin, StateMixin):
                         req, ctx, visibility=visibility, caps=caps
                     )
                     if component_response is not None:
-                        return component_response
+                        return _omit_empty_warnings(component_response)
 
-        return await self._legacy_ha_search(req, ctx)
+        return _omit_empty_warnings(await self._legacy_ha_search(req, ctx))
 
     @tool(
         name="ha_get_overview",
@@ -759,10 +760,9 @@ class SearchTools(ComponentSearchMixin, OverviewMixin, StateMixin):
         preserved. `attribute_keys=` further narrows the `attributes` sub-dict
         and is only applied when `"attributes"` is in `fields=` (or
         `fields=None`); otherwise it is a no-op and a `warnings` list is emitted
-        outside the projected record(s) — at the response wrapper level in bulk
-        mode, at the top-level result (sibling of `data`/`metadata`) in
-        single-entity mode — so `fields=["state"]` still returns a record with
-        only `state`.
+        at the top level of the result (sibling of `data`/`metadata`), outside
+        the projected record(s), so `fields=["state"]` still returns a record
+        with only `state`.
 
         EXAMPLES:
         - Single: ha_get_state("light.kitchen")

{ha_mcp_dev-9.1.0.dev3271 → ha_mcp_dev-9.1.0.dev3275}/src/ha_mcp/tools/tools_voice_assistant.py

@@ -114,7 +114,7 @@ class VoiceAssistantTools:
                 logger.warning("%s failed; fell back to legacy: %r", WS_EXPOSURE, exc)
             return None
         except Exception as exc:  # noqa: BLE001
-            # HomeAssistantConnectionError / plain establish Exception → legacy (the
+            # HomeAssistantConnectionError or any other error → legacy (the
             # legacy expose_entity/list read rides the bridge).
             logger.warning(
                 "%s connection error; falling back to legacy: %r", WS_EXPOSURE, exc

{ha_mcp_dev-9.1.0.dev3271 → ha_mcp_dev-9.1.0.dev3275}/src/ha_mcp/tools/tools_zones.py

@@ -237,12 +237,13 @@ class ZoneTools:
           entry, and ``log.warning``.
         - a response that does not authoritatively enumerate ``zone`` (an older
           component with no ``covered_types``): fall back to legacy silently.
-        - ``HomeAssistantConnectionError`` (pooled-WS drop) or the plain
-          ``Exception`` ``get_websocket_client()`` raises on a failed (re)connect:
-          served from the legacy listing (its reads ride the swallowing
-          ``send_websocket_message`` bridge, so a transport failure surfaces
-          there as a structured error or a listing gap rather than dying
-          identically), with a ``warnings[]`` entry + ``log.warning``.
+        - ``HomeAssistantConnectionError`` (pooled-WS drop or a failed (re)connect
+          in ``get_websocket_client()``): served from the legacy listing (its
+          reads ride the ``send_websocket_message`` bridge, so a transport
+          failure surfaces there as a structured error or a listing gap rather
+          than dying identically), with a ``warnings[]`` entry + ``log.warning``.
+          A token HA rejects (``HomeAssistantAuthError``) takes this branch too,
+          but the legacy reads use the same token and fail with it.
         """
         try:
             raw = await self._send_component_zone_list()