ha-mcp-dev 7.13.0.dev2029__tar.gz → 7.13.0.dev2033__tar.gz

{ha_mcp_dev-7.13.0.dev2029/src/ha_mcp_dev.egg-info → ha_mcp_dev-7.13.0.dev2033}/PKG-INFO

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

{ha_mcp_dev-7.13.0.dev2029 → ha_mcp_dev-7.13.0.dev2033}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ha-mcp-dev"
-version = "7.13.0.dev2029"
+version = "7.13.0.dev2033"
 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-7.13.0.dev2029 → ha_mcp_dev-7.13.0.dev2033}/src/ha_mcp/read_only.py

@@ -66,9 +66,11 @@ class ReadOnlyExemption(NamedTuple):
 def _backup_write(args: dict[str, Any]) -> str | None:
     scope = args.get("scope")
     action = args.get("action")
-    # Read-only-safe: per-edit backup listing/viewing, and snapshot listing
+    # Read-only-safe: per-edit backup listing/viewing/diffing, and snapshot listing
     # (issue #1586 — pure ``backup/info`` read, no tarball mutation).
-    if scope == "edits" and action in ("list", "view"):
+    # ``diff`` (added in #1632) only reads the stored snapshot and fetches
+    # the live config to compare; it never mutates (issue #1944).
+    if scope == "edits" and action in ("list", "view", "diff"):
         return None
     if scope == "snapshot" and action == "list":
         return None
@@ -195,8 +197,9 @@ READ_ONLY_EXEMPT_TOOLS: dict[str, ReadOnlyExemption] = {
     ),
     "ha_manage_backup": ReadOnlyExemption(
         _backup_write,
-        "listing and viewing per-edit backups (scope='edits', action='list' or "
-        "'view') and listing snapshots (scope='snapshot', action='list')",
+        "listing, viewing, and diffing per-edit backups (scope='edits', "
+        "action='list', 'view', or 'diff') and listing snapshots "
+        "(scope='snapshot', action='list')",
     ),
     "ha_manage_addon": ReadOnlyExemption(
         _addon_write,

{ha_mcp_dev-7.13.0.dev2029 → ha_mcp_dev-7.13.0.dev2033}/src/ha_mcp/tools/smart_search/_deep.py

@@ -21,7 +21,11 @@ from ._config import (
     INDIVIDUAL_FETCH_BATCH_SIZE,
     SCRIPT_CONFIG_TIME_BUDGET,
 )
-from ._fetch import is_timeout_error
+from ._fetch import (
+    http_500_diagnosis_hint,
+    is_timeout_error,
+    record_first_failure,
+)
 from ._scenes import SceneSearchMixin
 
 logger = logging.getLogger(__name__)
@@ -136,6 +140,7 @@ class DeepSearchMixin(SceneSearchMixin):
                 "timeout": 0,
                 "integration_skipped": 0,
                 "registry_failed": False,
+                "failed_sample": None,
             }
 
             # Diagnostic counters for the Attempt-C path on automations/
@@ -149,10 +154,12 @@ class DeepSearchMixin(SceneSearchMixin):
             automation_failed = 0
             automation_yaml_skipped = 0
             automation_timeout = 0
+            automation_failed_sample: str | None = None
             script_skipped = 0
             script_failed = 0
             script_yaml_skipped = 0
             script_timeout = 0
+            script_failed_sample: str | None = None
             helper_failed = 0
             dashboard_failed = 0
 
@@ -163,6 +170,7 @@ class DeepSearchMixin(SceneSearchMixin):
                     automation_failed,
                     automation_yaml_skipped,
                     automation_timeout,
+                    automation_failed_sample,
                 ) = await self._deep_search_automations(
                     all_entities,
                     automation_unique_id_map,
@@ -185,6 +193,7 @@ class DeepSearchMixin(SceneSearchMixin):
                     script_failed,
                     script_yaml_skipped,
                     script_timeout,
+                    script_failed_sample,
                 ) = await self._deep_search_scripts(
                     all_entities,
                     query_lower,
@@ -207,6 +216,7 @@ class DeepSearchMixin(SceneSearchMixin):
                     scene_stats["integration_skipped"],
                     scene_stats["registry_failed"],
                     scene_stats["timeout"],
+                    scene_stats["failed_sample"],
                 ) = await self._deep_search_scenes(
                     all_entities,
                     query_lower,
@@ -268,10 +278,12 @@ class DeepSearchMixin(SceneSearchMixin):
                 automation_failed=automation_failed,
                 automation_yaml_skipped=automation_yaml_skipped,
                 automation_timeout=automation_timeout,
+                automation_failed_sample=automation_failed_sample,
                 script_skipped=script_skipped,
                 script_failed=script_failed,
                 script_yaml_skipped=script_yaml_skipped,
                 script_timeout=script_timeout,
+                script_failed_sample=script_failed_sample,
                 helper_failed=helper_failed,
                 dashboard_failed=dashboard_failed,
             )
@@ -318,11 +330,11 @@ class DeepSearchMixin(SceneSearchMixin):
         exact_match: bool,
         *,
         config_time_budget: float | None = None,
-    ) -> tuple[list[dict[str, Any]], int, int, int, int]:
+    ) -> tuple[list[dict[str, Any]], int, int, int, int, str | None]:
         """Deep-search automations: two-tier config fetch (REST bulk -> budgeted individual).
 
         Returns ``(matches, skipped_count, failed_count, yaml_skipped_count,
-        timeout_count)``. ``skipped_count`` is non-zero only when bulk fetch
+        timeout_count, failed_sample)``. ``skipped_count`` is non-zero only when bulk fetch
         fell back to the per-id Attempt-C path AND its wall-clock budget
         exhausted before all configs were fetched; ``failed_count`` is
         non-zero when individual config fetches raised a non-404, non-timeout
@@ -338,6 +350,11 @@ class DeepSearchMixin(SceneSearchMixin):
         distinguish a complete zero-result from an incomplete one —
         skipped/failed ids carry their score-without-config through the
         merge and fall below the match threshold silently otherwise.
+        ``failed_sample`` is one representative
+        ``summarize_fetch_error`` summary of a ``failed``-class exception
+        (``None`` when none occurred), surfaced in the failed fragment so
+        the response names WHAT raised instead of pointing at debug logs
+        (#1784 follow-up).
         """
         automation_entities = [
             e for e in all_entities if e.get("entity_id", "").startswith("automation.")
@@ -376,6 +393,13 @@ class DeepSearchMixin(SceneSearchMixin):
         failed_count = 0
         yaml_skipped_count = 0
         timeout_count = 0
+        # One representative summary — only the FIRST ``failed``-class
+        # exception is kept (the fetch closure guards the append); it rides
+        # partial_reason as an ``e.g.`` (#1784 follow-up). The remaining
+        # failures are counted (``failed_count``) but not summarized, so the
+        # motivating "every per-id fetch 500s" case does N-1 fewer
+        # ``summarize_fetch_error`` calls.
+        failed_errors: list[str] = []
         if not bulk_fetched:
             uids_to_fetch = [
                 uid for _, _, uid, _ in scored if uid and uid not in configs
@@ -405,6 +429,7 @@ class DeepSearchMixin(SceneSearchMixin):
                     logger.debug(
                         f"Automation individual config fetch ({uid}) failed: {e}"
                     )
+                    record_first_failure(failed_errors, e)
                     return (uid, None, "failed")
                 except TimeoutError:
                     # asyncio.wait_for hit INDIVIDUAL_CONFIG_TIMEOUT. Classify
@@ -430,6 +455,7 @@ class DeepSearchMixin(SceneSearchMixin):
                     logger.debug(
                         f"Automation individual config fetch ({uid}) failed: {e}"
                     )
+                    record_first_failure(failed_errors, e)
                     return (uid, None, "failed")
 
             (
@@ -463,7 +489,14 @@ class DeepSearchMixin(SceneSearchMixin):
                 scored, configs, query_lower, exact_match
             )
         ]
-        return matches, skipped_count, failed_count, yaml_skipped_count, timeout_count
+        return (
+            matches,
+            skipped_count,
+            failed_count,
+            yaml_skipped_count,
+            timeout_count,
+            failed_errors[0] if failed_errors else None,
+        )
 
     async def _deep_search_scripts(
         self,
@@ -472,11 +505,11 @@ class DeepSearchMixin(SceneSearchMixin):
         exact_match: bool,
         *,
         config_time_budget: float | None = None,
-    ) -> tuple[list[dict[str, Any]], int, int, int, int]:
+    ) -> tuple[list[dict[str, Any]], int, int, int, int, str | None]:
         """Deep-search scripts: same two-tier strategy as automations.
 
         Returns ``(matches, skipped_count, failed_count, yaml_skipped_count,
-        timeout_count)``; semantics identical to ``_deep_search_automations``
+        timeout_count, failed_sample)``; semantics identical to ``_deep_search_automations``
         — the 404 path catches YAML-defined scripts (which
         ``client.get_script_config`` re-raises as
         ``HomeAssistantAPIError(status_code=404)``).
@@ -514,6 +547,13 @@ class DeepSearchMixin(SceneSearchMixin):
         failed_count = 0
         yaml_skipped_count = 0
         timeout_count = 0
+        # One representative summary — only the FIRST ``failed``-class
+        # exception is kept (the fetch closure guards the append); it rides
+        # partial_reason as an ``e.g.`` (#1784 follow-up). The remaining
+        # failures are counted (``failed_count``) but not summarized, so the
+        # motivating "every per-id fetch 500s" case does N-1 fewer
+        # ``summarize_fetch_error`` calls.
+        failed_errors: list[str] = []
         if not bulk_fetched:
             sids_to_fetch = [
                 sid for _, _, sid, _ in scored if sid and sid not in configs
@@ -540,6 +580,7 @@ class DeepSearchMixin(SceneSearchMixin):
                         )
                         return (sid, None, "yaml_skipped")
                     logger.debug(f"Script individual config fetch ({sid}) failed: {e}")
+                    record_first_failure(failed_errors, e)
                     return (sid, None, "failed")
                 except TimeoutError:
                     # See _fetch_automation_config: per-request timeout under
@@ -559,6 +600,7 @@ class DeepSearchMixin(SceneSearchMixin):
                         )
                         return (sid, None, "timeout")
                     logger.debug(f"Script individual config fetch ({sid}) failed: {e}")
+                    record_first_failure(failed_errors, e)
                     return (sid, None, "failed")
 
             (
@@ -593,7 +635,14 @@ class DeepSearchMixin(SceneSearchMixin):
                 scored, configs, query_lower, exact_match
             )
         ]
-        return matches, skipped_count, failed_count, yaml_skipped_count, timeout_count
+        return (
+            matches,
+            skipped_count,
+            failed_count,
+            yaml_skipped_count,
+            timeout_count,
+            failed_errors[0] if failed_errors else None,
+        )
 
     @staticmethod
     def _build_helper_registry_map(
@@ -966,6 +1015,8 @@ class DeepSearchMixin(SceneSearchMixin):
         script_yaml_skipped: int = 0,
         automation_timeout: int = 0,
         script_timeout: int = 0,
+        automation_failed_sample: str | None = None,
+        script_failed_sample: str | None = None,
         helper_failed: int = 0,
         dashboard_failed: int = 0,
     ) -> dict[str, Any]:
@@ -1028,6 +1079,8 @@ class DeepSearchMixin(SceneSearchMixin):
             script_yaml_skipped=script_yaml_skipped,
             automation_timeout=automation_timeout,
             script_timeout=script_timeout,
+            automation_failed_sample=automation_failed_sample,
+            script_failed_sample=script_failed_sample,
             helper_failed=helper_failed,
             dashboard_failed=dashboard_failed,
         )
@@ -1045,6 +1098,8 @@ class DeepSearchMixin(SceneSearchMixin):
         script_yaml_skipped: int = 0,
         automation_timeout: int = 0,
         script_timeout: int = 0,
+        automation_failed_sample: str | None = None,
+        script_failed_sample: str | None = None,
         helper_failed: int = 0,
         dashboard_failed: int = 0,
     ) -> None:
@@ -1077,6 +1132,15 @@ class DeepSearchMixin(SceneSearchMixin):
         rationalised away by blind agents who reported the result as
         complete; the harder phrasing closes that gap.
 
+        ``automation_failed_sample`` / ``script_failed_sample`` carry one
+        representative ``summarize_fetch_error`` summary for the generic
+        ``failed`` class, appended to its fragment as an ``e.g.`` so the
+        response names WHAT raised instead of pointing at debug logs
+        (#1784 follow-up). When that sample is an HTTP 500 — whose body is
+        aiohttp's generic placeholder, so the sample can't name the cause —
+        a static HA-log diagnosis is appended too (``http_500_diagnosis_hint``).
+        ``None`` keeps the fragment wording unchanged.
+
         Append-safe: the existing ``partial_reason`` (if any) is preserved
         and the new reasons are concatenated with ``" ; "``.
         """
@@ -1084,7 +1148,16 @@ class DeepSearchMixin(SceneSearchMixin):
         # The automation and script fragments are symmetric (noun, per-id
         # endpoint, budget env var); loop rather than duplicating the four
         # per-class fragments per type.
-        for noun, endpoint, budget_env, skipped, failed, yaml_skipped, timeout in (
+        for (
+            noun,
+            endpoint,
+            budget_env,
+            skipped,
+            failed,
+            yaml_skipped,
+            timeout,
+            failed_sample,
+        ) in (
             (
                 "automation",
                 "/config/automation/config",
@@ -1093,6 +1166,7 @@ class DeepSearchMixin(SceneSearchMixin):
                 automation_failed,
                 automation_yaml_skipped,
                 automation_timeout,
+                automation_failed_sample,
             ),
             (
                 "script",
@@ -1102,6 +1176,7 @@ class DeepSearchMixin(SceneSearchMixin):
                 script_failed,
                 script_yaml_skipped,
                 script_timeout,
+                script_failed_sample,
             ),
         ):
             if skipped:
@@ -1114,10 +1189,22 @@ class DeepSearchMixin(SceneSearchMixin):
                     "the web Settings UI's Advanced section)."
                 )
             if failed:
+                # Name ONE representative error inline when the fetch path
+                # captured one — the opaque bucket alone sent users on a
+                # debug-log dive for trivially-diagnosable server errors
+                # (#1784 follow-up: every per-id script fetch 500ing on a
+                # ``!secret`` reference in scripts.yaml).
+                sample_suffix = f"; e.g. {failed_sample}" if failed_sample else ""
+                # An HTTP 500 body is aiohttp's generic "500 Internal Server
+                # Error" — the real cause (e.g. a ``!secret`` the per-id
+                # config endpoint rejects) is HA-log-only, never in the
+                # response — so the sample can't name it. Append the static
+                # diagnosis the sample can't carry (#1784 follow-up).
+                hint = http_500_diagnosis_hint(failed_sample)
                 reasons.append(
                     f"{failed} {noun}(s) not scanned (per-id fetch raised "
-                    "a non-404 error) — their match status is unknown; this "
-                    "result is not exhaustive."
+                    f"a non-404 error{sample_suffix}) — their match status "
+                    f"is unknown; this result is not exhaustive.{hint}"
                 )
             if yaml_skipped:
                 reasons.append(

{ha_mcp_dev-7.13.0.dev2029 → ha_mcp_dev-7.13.0.dev2033}/src/ha_mcp/tools/smart_search/_fetch.py

@@ -2,17 +2,106 @@
 
 import asyncio
 import logging
+import re
 import time
 from collections.abc import Awaitable, Callable
 from typing import Any
 
 import httpx
 
+from ...client.rest_client import HomeAssistantAPIError
 from ._config import INDIVIDUAL_FETCH_BATCH_SIZE
 from ._scoring import ScoringMixin
 
 logger = logging.getLogger(__name__)
 
+# The REST client's own message prefix ("API error: <code> - "); stripped by
+# ``summarize_fetch_error`` so the summary doesn't state the status twice.
+_API_ERROR_PREFIX = re.compile(r"^API error:\s*\d+\s*-\s*")
+
+# Hard cap on a ``summarize_fetch_error`` summary. partial_reason fragments
+# are read inline by agents; one representative error needs a first line,
+# not a body dump.
+_ERROR_SAMPLE_MAX_LEN = 160
+
+
+def summarize_fetch_error(exc: BaseException) -> str:
+    """One-line, length-capped summary of a per-id config-fetch failure.
+
+    The generic ``failed`` bucket collapses every non-404, non-timeout
+    exception into one opaque partial_reason fragment ("per-id fetch raised
+    a non-404 error"), with the real exception visible only at debug-level
+    logging. The follow-up report on issue #1784 showed what that hides: a
+    box where every per-id script fetch returns a fast HTTP 500 because
+    ``scripts.yaml`` contains a ``!secret`` reference (HA core's config view
+    file-loads the YAML per request and rejects secrets before the id
+    lookup) — a five-minute diagnosis if the response named the error, a
+    log dive otherwise. This summary rides the fragment as an ``e.g.``.
+
+    HTTP errors render as ``HTTP <code>: <first line of the message>`` (the
+    client's own ``API error: <code> - `` prefix is stripped rather than
+    duplicated); everything else as ``<ExceptionType>: <first line>``.
+    """
+    lines = str(exc).strip().splitlines()
+    text = lines[0].strip() if lines else ""
+    if isinstance(exc, HomeAssistantAPIError) and exc.status_code is not None:
+        text = _API_ERROR_PREFIX.sub("", text)
+        prefix = f"HTTP {exc.status_code}"
+    else:
+        prefix = type(exc).__name__
+    summary = f"{prefix}: {text}" if text else prefix
+    if len(summary) > _ERROR_SAMPLE_MAX_LEN:
+        summary = summary[: _ERROR_SAMPLE_MAX_LEN - 1] + "…"
+    return summary
+
+
+# Marks a rendered ``summarize_fetch_error`` summary whose cause the sample
+# cannot name: an HTTP 500's body is aiohttp's generic "500 Internal Server
+# Error" placeholder, so the real error (a YAMLException the per-id config
+# view raised, most often a ``!secret`` reference it rejects) lives only in
+# the HA log, never in the response.
+_HTTP_500_PREFIX = "HTTP 500:"
+
+# Static diagnosis appended to an HTTP-500 failed fragment. The sample names
+# the status but not the cause (see ``_HTTP_500_PREFIX``); this points the
+# reader at the HA log and the single most common cause, delivering the
+# five-minute diagnosis the #1784 follow-up asked for without claiming a
+# cause the response can't actually confirm. Kept endpoint-agnostic — this
+# same string rides the automation, script, AND scene fragments, so it names
+# no specific YAML file (a scene 500 has nothing to do with scripts.yaml);
+# "the config file HA loads for this entity" covers all three.
+_HTTP_500_DIAGNOSIS = (
+    " A per-id config fetch returning HTTP 500 is most often a `!secret` "
+    "reference in the config file HA loads for this entity, which the per-id "
+    "config endpoint rejects; the specific cause is in the Home Assistant log "
+    "(the 500 body is a generic placeholder), not in this response."
+)
+
+
+def http_500_diagnosis_hint(failed_sample: str | None) -> str:
+    """Static HA-log hint to append when ``failed_sample`` is an HTTP 500.
+
+    Returns ``""`` for any other sample (or ``None``), so non-500 fragments
+    are byte-identical to before. See ``_HTTP_500_DIAGNOSIS``.
+    """
+    if failed_sample and failed_sample.startswith(_HTTP_500_PREFIX):
+        return _HTTP_500_DIAGNOSIS
+    return ""
+
+
+def record_first_failure(failed_errors: list[str], exc: BaseException) -> None:
+    """Capture ``exc``'s summary as the representative ``failed`` sample, once.
+
+    Only the FIRST generic-``failed`` exception per fetch pass is summarized
+    (subsequent ones are counted but not summarized) — in the motivating
+    "every per-id fetch 500s" case that is N-1 fewer ``summarize_fetch_error``
+    calls. The append is a no-op once ``failed_errors`` is non-empty. Called
+    from the per-id fetch closures, which run under ``asyncio.gather`` but
+    never suspend between the check and the append, so no lock is needed.
+    """
+    if not failed_errors:
+        failed_errors.append(summarize_fetch_error(exc))
+
 
 def is_timeout_error(exc: BaseException) -> bool:
     """True when ``exc`` is, or was directly caused by, a request timeout.

{ha_mcp_dev-7.13.0.dev2029 → ha_mcp_dev-7.13.0.dev2033}/src/ha_mcp/tools/smart_search/_scenes.py

@@ -10,7 +10,12 @@ from ._config import (
     INDIVIDUAL_FETCH_BATCH_SIZE,
     SCENE_CONFIG_TIME_BUDGET,
 )
-from ._fetch import ConfigFetchMixin, is_timeout_error
+from ._fetch import (
+    ConfigFetchMixin,
+    http_500_diagnosis_hint,
+    is_timeout_error,
+    record_first_failure,
+)
 
 logger = logging.getLogger(__name__)
 
@@ -211,15 +216,19 @@ class SceneSearchMixin(ConfigFetchMixin):
         *,
         config_time_budget: float | None = None,
         prefetched_registry: Any = None,
-    ) -> tuple[list[dict[str, Any]], int, int, int, bool, int]:
+    ) -> tuple[list[dict[str, Any]], int, int, int, bool, int, str | None]:
         """Deep-search scenes: two-tier strategy plus registry-walk augmentation.
 
         Scenes have no listing primitive, so entities are enumerated from
         get_states() and configs fetched per id. Returns the scene results plus
-        the five diagnostic signals feeding the response ``partial`` /
+        the six diagnostic signals feeding the response ``partial`` /
         ``partial_reason``:
         ``(results, failed_count, skipped_count, integration_skipped,
-        registry_failed, timeout_count)``.
+        registry_failed, timeout_count, failed_sample)``. ``failed_sample``
+        is one representative ``summarize_fetch_error`` summary of a
+        ``failed``-class exception (``None`` when none occurred) — see the
+        automation/script mirror in ``_deep_search_automations`` (#1784
+        follow-up).
         """
         scene_entities = [
             e for e in all_entities if e.get("entity_id", "").startswith("scene.")
@@ -264,6 +273,11 @@ class SceneSearchMixin(ConfigFetchMixin):
         skipped_count = 0
         integration_skipped = 0
         timeout_count = 0
+        # One representative summary — only the FIRST ``failed``-class
+        # exception is kept (the fetch closure guards the append); it rides
+        # partial_reason as an ``e.g.`` (#1784 follow-up). The remaining
+        # failures are counted (``failed_count``) but not summarized.
+        failed_errors: list[str] = []
 
         # Attempt C: parallel per-id fetch with a wall-clock budget so a few
         # slow scenes don't tank the whole search.
@@ -300,6 +314,7 @@ class SceneSearchMixin(ConfigFetchMixin):
                         )
                         return (sid, None, "timeout")
                     logger.debug(f"Scene individual config fetch ({sid}) failed: {e}")
+                    record_first_failure(failed_errors, e)
                     return (sid, None, "failed")
 
             (
@@ -347,6 +362,7 @@ class SceneSearchMixin(ConfigFetchMixin):
             integration_skipped,
             registry_failed,
             timeout_count,
+            failed_errors[0] if failed_errors else None,
         )
 
     @staticmethod
@@ -376,9 +392,20 @@ class SceneSearchMixin(ConfigFetchMixin):
         response["partial"] = True
         reason_parts: list[str] = []
         if failed:
+            # Name ONE representative error inline when Attempt C captured
+            # one (.get(): tolerate stats dicts built without the key) —
+            # mirrors the automation/script ``e.g.`` sample, #1784 follow-up.
+            failed_sample = scene_stats.get("failed_sample")
+            sample_suffix = f"; e.g. {failed_sample}" if failed_sample else ""
+            # An HTTP 500 sample names the status but not the cause (the body
+            # is aiohttp's generic placeholder); append the static HA-log
+            # diagnosis, mirroring the automation/script fragment (#1784).
+            hint = http_500_diagnosis_hint(failed_sample)
             reason_parts.append(
-                f"{failed} scene(s) not scanned (per-id fetch raised) — "
-                "their match status is unknown; this result is not exhaustive."
+                f"{failed} scene(s) not scanned (per-id fetch raised"
+                f"{sample_suffix}) — "
+                f"their match status is unknown; this result is not "
+                f"exhaustive.{hint}"
             )
         if timeout:
             reason_parts.append(

{ha_mcp_dev-7.13.0.dev2029 → ha_mcp_dev-7.13.0.dev2033/src/ha_mcp_dev.egg-info}/PKG-INFO

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