ha-mcp-dev 7.8.0.dev707__tar.gz → 7.8.0.dev709__tar.gz

{ha_mcp_dev-7.8.0.dev707/src/ha_mcp_dev.egg-info → ha_mcp_dev-7.8.0.dev709}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ha-mcp-dev
-Version: 7.8.0.dev707
+Version: 7.8.0.dev709
 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.8.0.dev707 → ha_mcp_dev-7.8.0.dev709}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ha-mcp-dev"
-version = "7.8.0.dev707"
+version = "7.8.0.dev709"
 description = "Home Assistant MCP Server - Complete control of Home Assistant through MCP"
 readme = "README.md"
 requires-python = ">=3.13,<3.14"
@@ -187,6 +187,7 @@ asyncio_mode = "auto"
 dev = [
     "build>=1.2.2",
     "docker>=7.1.0",
+    "httpx2>=2.4.0",
     "mypy>=1.17.0",
     "openai>=1.0.0",
     "psutil>=7.0.0",

{ha_mcp_dev-7.8.0.dev707 → ha_mcp_dev-7.8.0.dev709}/src/ha_mcp/backup_manager.py

@@ -47,7 +47,7 @@ from collections.abc import Awaitable, Callable
 from dataclasses import dataclass
 from datetime import UTC, datetime
 from pathlib import Path
-from typing import Any
+from typing import Any, TypedDict
 
 import yaml  # type: ignore[import-untyped]
 from fastmcp.exceptions import ToolError
@@ -293,6 +293,14 @@ class BackupManager:
             try:
                 config = await handler.fetch(self._client, entity_id)
             except _CAPTURE_TRANSIENT_ERRORS as err:
+                # Degraded fetches (a non-list WS envelope from an
+                # auth-scope change or API drift) raise rather than return
+                # None — see ``_require_list``. During auto-backup we skip
+                # the snapshot with a WARNING (operator-visible) instead of
+                # crashing the pipeline; the same error during a diff/
+                # restore propagates to the tool layer as a structured
+                # error. The warning level (vs the debug log below) is what
+                # distinguishes "fetch broke" from "entity didn't exist".
                 logger.warning(
                     "Auto-backup: fetch failed for %s — %s: %s",
                     key,
@@ -522,7 +530,7 @@ class BackupManager:
     async def restore_snapshot(
         self, name: str, *, take_safety_backup: bool = True
     ) -> dict[str, Any]:
-        data = self.read_snapshot(name)
+        data = await asyncio.to_thread(self.read_snapshot, name)
         domain = data["domain"]
         entity_id = data["entity_id"]
         config = data["config"]
@@ -544,6 +552,254 @@ class BackupManager:
             "result": result,
         }
 
+    # ----- diff ----------------------------------------------------------
+
+    async def diff_snapshot(self, name: str) -> DiffResponse:
+        """Compare a stored snapshot against the live config of the same entity.
+
+        Returns an RFC 6902-shaped JSON-Patch — the ops a client would
+        apply to ``current`` to recover ``stored`` (i.e. what
+        ``restore_snapshot`` would functionally do). ``entity_missing``
+        flags the case where the entity is gone from HA, so the diff has
+        no live target to compare against; ``truncated`` flags that the
+        patch exceeded ``_MAX_PATCH_OPS`` and was cut short to keep the
+        tool response bounded.
+
+        ``unchanged`` means the live config matches the snapshot — it is
+        ``True`` only when the entity exists *and* the patch is empty.
+        Under ``entity_missing=True`` it is ``False``: there is no live
+        target to match, so "no action needed" would be wrong (the
+        empty patch is an artefact of the missing entity, not a match).
+        """
+        data = await asyncio.to_thread(self.read_snapshot, name)
+        domain = data["domain"]
+        entity_id = data["entity_id"]
+        stored = data["config"]
+        handler = self._handlers.get(domain)
+        if handler is None:
+            raise LookupError(f"No diff handler registered for domain {domain!r}")
+        current = await handler.fetch(self._client, entity_id)
+        captured_at = data.get("captured")
+        if current is None:
+            return _build_diff_response(
+                name,
+                domain,
+                entity_id,
+                captured_at,
+                entity_missing=True,
+                patch=[],
+                counts=_summarize_patch_counts([]),
+                truncated=False,
+            )
+        patch: list[dict[str, Any]] = []
+        truncated = _compute_json_patch(stored, current, _MAX_PATCH_OPS, patch)
+        return _build_diff_response(
+            name,
+            domain,
+            entity_id,
+            captured_at,
+            entity_missing=False,
+            patch=patch,
+            counts=_summarize_patch_counts(patch),
+            truncated=truncated,
+        )
+
+
+# --------------------------- diff helpers -----------------------------------
+
+
+class DiffCounts(TypedDict):
+    """Per-op-class tallies for a diff patch. ``total`` is the op count;
+    ``add + remove + replace`` equals it today (see ``_summarize_patch_counts``)."""
+
+    add: int
+    remove: int
+    replace: int
+    total: int
+
+
+class DiffResponse(TypedDict):
+    """Return shape of ``BackupManager.diff_snapshot``. Both the
+    entity-present and ``entity_missing`` branches build this through
+    ``_build_diff_response`` so the key set can't drift between them."""
+
+    kind: str
+    backup_name: str
+    domain: str
+    entity_id: str
+    captured_at: str | None
+    entity_missing: bool
+    patch: list[dict[str, Any]]
+    counts: DiffCounts
+    unchanged: bool
+    truncated: bool
+
+
+def _build_diff_response(
+    name: str,
+    domain: str,
+    entity_id: str,
+    captured_at: str | None,
+    *,
+    entity_missing: bool,
+    patch: list[dict[str, Any]],
+    counts: DiffCounts,
+    truncated: bool,
+) -> DiffResponse:
+    """Assemble the diff return payload for either branch.
+
+    ``unchanged`` means "live config matches the snapshot" — only true
+    when the entity exists and the patch is empty. Under
+    ``entity_missing`` it is forced ``False``: the empty patch is an
+    artefact of the absent target, not evidence of a match.
+    """
+    return {
+        "kind": "dict",
+        "backup_name": name,
+        "domain": domain,
+        "entity_id": entity_id,
+        "captured_at": captured_at,
+        "entity_missing": entity_missing,
+        "patch": patch,
+        "counts": counts,
+        "unchanged": not entity_missing and counts["total"] == 0,
+        "truncated": truncated,
+    }
+
+
+# Output cap for diff_snapshot. Bounded payload keeps the tool response
+# token-friendly even when the user diffs against a freshly-rewritten
+# automation. Picked to comfortably cover typical edits (a handful of
+# field changes) while still cutting off pathological cases like "I
+# renamed every step of a 500-step script".
+_MAX_PATCH_OPS = 200
+
+
+def _compute_json_patch(
+    stored: Any, current: Any, max_ops: int, out: list[dict[str, Any]]
+) -> bool:
+    """Generate an RFC 6902 JSON-Patch from ``current`` to ``stored``.
+
+    The patch is the op sequence a client would apply to ``current`` to
+    recover ``stored`` (the captured snapshot is the target state).
+    Appends ops to ``out`` in place (capped at ``max_ops`` entries).
+
+    Returns True only when the diff genuinely exceeded ``max_ops``. The
+    generator collects one op beyond the cap so an exactly-full patch
+    (``len == max_ops``) isn't mistaken for a truncated one; the
+    overflow op is trimmed before returning.
+    """
+    _diff_node(stored, current, "", out, max_ops + 1)
+    truncated = len(out) > max_ops
+    if truncated:
+        del out[max_ops:]
+    return truncated
+
+
+def _diff_node(
+    stored: Any,
+    current: Any,
+    path: str,
+    out: list[dict[str, Any]],
+    max_ops: int,
+) -> None:
+    if len(out) >= max_ops:
+        return
+    # ``type(s) is type(c)`` keeps ``True``/``1`` apart (both compare
+    # equal but represent different states for HA toggles); YAML loaders
+    # only emit plain dict/list/scalar containers, so subclass surprises
+    # aren't in scope.
+    if type(stored) is type(current):
+        if isinstance(stored, dict):
+            assert isinstance(current, dict)
+            for key in stored:
+                seg = _pointer_segment(str(key))
+                sub_path = f"{path}/{seg}"
+                if key not in current:
+                    out.append({"op": "add", "path": sub_path, "value": stored[key]})
+                    if len(out) >= max_ops:
+                        return
+                else:
+                    _diff_node(stored[key], current[key], sub_path, out, max_ops)
+                    if len(out) >= max_ops:
+                        return
+            for key in current:
+                if key not in stored:
+                    seg = _pointer_segment(str(key))
+                    out.append({"op": "remove", "path": f"{path}/{seg}"})
+                    if len(out) >= max_ops:
+                        return
+            return
+        if isinstance(stored, list):
+            assert isinstance(current, list)
+            min_len = min(len(stored), len(current))
+            for i in range(min_len):
+                _diff_node(stored[i], current[i], f"{path}/{i}", out, max_ops)
+                if len(out) >= max_ops:
+                    return
+            if len(stored) > len(current):
+                for value in stored[len(current) :]:
+                    out.append({"op": "add", "path": f"{path}/-", "value": value})
+                    if len(out) >= max_ops:
+                        return
+            elif len(current) > len(stored):
+                # Remove tail entries from highest to lowest index so
+                # successive removes stay valid (RFC 6902 reindexes
+                # after each op).
+                for i in range(len(current) - 1, len(stored) - 1, -1):
+                    out.append({"op": "remove", "path": f"{path}/{i}"})
+                    if len(out) >= max_ops:
+                        return
+            return
+        if stored != current:
+            out.append({"op": "replace", "path": path or "", "value": stored})
+        return
+    # ``True == 1`` / ``False == 0`` in Python, so equality alone would
+    # let a bool/int type swap pass silently even though it represents
+    # a different state for HA toggles. The different-type branch
+    # forces a replace unconditionally. No post-append length guard here
+    # (unlike the loop sites above): this append is terminal, and
+    # ``_compute_json_patch`` budgets ``max_ops + 1`` precisely to absorb
+    # one final overflow op before trimming.
+    out.append({"op": "replace", "path": path or "", "value": stored})
+
+
+def _pointer_segment(key: str) -> str:
+    """Escape one JSON-Pointer reference token per RFC 6901 §3.
+
+    Order matters: ``~`` → ``~0`` must run before ``/`` → ``~1``. The
+    reverse order would first turn a literal ``/`` into ``~1``, and the
+    following ``~`` pass would then corrupt that fresh ``~1`` into
+    ``~01``.
+    """
+    return key.replace("~", "~0").replace("/", "~1")
+
+
+def _summarize_patch_counts(patch: list[dict[str, Any]]) -> DiffCounts:
+    """Tally op classes. ``add + remove + replace == total`` holds today
+    because ``_diff_node`` only emits those three ops; if a future change
+    starts emitting ``move``/``copy``/``test``, the class counts would sum
+    to less than ``total``. Warn on any unrecognized op so that drift is
+    visible instead of silently undercounting.
+    """
+    classes: dict[str, int] = {"add": 0, "remove": 0, "replace": 0}
+    for op in patch:
+        op_type = op.get("op")
+        if isinstance(op_type, str) and op_type in classes:
+            classes[op_type] += 1
+        else:
+            logger.warning(
+                "diff: unrecognized JSON-Patch op %r — not reflected in "
+                "per-class counts (add/remove/replace)",
+                op_type,
+            )
+    return {
+        "add": classes["add"],
+        "remove": classes["remove"],
+        "replace": classes["replace"],
+        "total": len(patch),
+    }
+
 
 # --------------------------- attach to client -------------------------------
 
@@ -651,8 +907,8 @@ async def _ws_send(client: Any, message: dict[str, Any]) -> Any:
     # — unwrap so fetch / restore handlers downstream see the inner
     # shape directly (list for ``<type>/list`` calls, dict for
     # ``execute_script`` calls, etc.). Without the unwrap the
-    # ``isinstance(items, list)`` guards in every fetch handler would
-    # treat the envelope as a non-list and silently return None.
+    # ``_require_list`` checks in every fetch handler would see the
+    # envelope as a non-list and raise a spurious degraded-fetch error.
     if isinstance(envelope, dict) and "result" in envelope:
         return envelope["result"]
     return envelope
@@ -764,13 +1020,52 @@ async def _restore_dashboard(client: Any, entity_id: str, config: Any) -> Any:
     )
 
 
+def _require_list(value: Any, endpoint: str) -> list[Any]:
+    """Return ``value`` if it's a list, else raise.
+
+    The WS registry-list fetchers below distinguish two cases that used
+    to both collapse to ``None`` (which the diff/capture callers read as
+    "entity missing"): a genuine miss (entity not in the list) stays
+    ``None``, but an unexpected non-list envelope — a degraded response
+    from an auth-scope change or API drift — raises instead. The raise
+    funnels through the diff tool's ``exception_to_structured_error`` and
+    the capture pipeline's ``_CAPTURE_TRANSIENT_ERRORS`` warning, so a
+    broken fetch is never reported as a confident ``entity_missing``.
+    """
+    if not isinstance(value, list):
+        raise HomeAssistantError(
+            f"Expected a list from {endpoint!r}, got {type(value).__name__}"
+        )
+    return value
+
+
+def _require_dict(value: Any, endpoint: str) -> dict[str, Any]:
+    """Return ``value`` if it's a dict, else raise.
+
+    Dict-shaped counterpart to :func:`_require_list` for the
+    ``execute_script``-backed fetchers (calendar / todo). Their service
+    response is a dict envelope; a non-dict body is a degraded/malformed
+    200 (auth-scope change, API drift), not a genuine miss. Raising
+    funnels it through the diff tool's ``exception_to_structured_error``
+    and the capture pipeline's ``_CAPTURE_TRANSIENT_ERRORS`` warning,
+    instead of collapsing to ``None`` — which callers read as
+    ``entity_missing``. The genuine-miss signal stays the nested ``uid``
+    lookup returning ``None``.
+    """
+    if not isinstance(value, dict):
+        raise HomeAssistantError(
+            f"Expected a dict from {endpoint!r}, got {type(value).__name__}"
+        )
+    return value
+
+
 # Dashboard resources — WS lovelace_resources commands.
 
 
 async def _fetch_dashboard_resource(client: Any, entity_id: str) -> Any:
-    resources = await _ws_send(client, {"type": "lovelace/resources"})
-    if not isinstance(resources, list):
-        return None
+    resources = _require_list(
+        await _ws_send(client, {"type": "lovelace/resources"}), "lovelace/resources"
+    )
     for res in resources:
         if str(res.get("id")) == entity_id:
             return res
@@ -808,9 +1103,10 @@ def _strip_readonly(config: dict[str, Any], *extra: str) -> dict[str, Any]:
 
 
 async def _fetch_label(client: Any, entity_id: str) -> Any:
-    items = await _ws_send(client, {"type": "config/label_registry/list"})
-    if not isinstance(items, list):
-        return None
+    items = _require_list(
+        await _ws_send(client, {"type": "config/label_registry/list"}),
+        "config/label_registry/list",
+    )
     for item in items:
         if item.get("label_id") == entity_id:
             return item
@@ -831,11 +1127,12 @@ async def _fetch_category(client: Any, entity_id: str) -> Any:
     scope, _, cat_id = entity_id.partition(":")
     if not cat_id:
         return None
-    items = await _ws_send(
-        client, {"type": "config/category_registry/list", "scope": scope}
+    items = _require_list(
+        await _ws_send(
+            client, {"type": "config/category_registry/list", "scope": scope}
+        ),
+        "config/category_registry/list",
     )
-    if not isinstance(items, list):
-        return None
     for item in items:
         if item.get("category_id") == cat_id:
             return {"scope": scope, **item}
@@ -925,8 +1222,7 @@ async def _fetch_calendar_event(client: Any, entity_id: str) -> Any:
         if getattr(err, "status_code", None) == 404:
             return None
         raise
-    if not isinstance(result, dict):
-        return None
+    result = _require_dict(result, "execute_script")
     events = result.get("response", {}).get("events", {}).get(cal, {}).get("events", [])
     for ev in events:
         if ev.get("uid") == uid:
@@ -951,9 +1247,7 @@ async def _restore_calendar_event(client: Any, entity_id: str, config: Any) -> A
 
 
 async def _fetch_zone(client: Any, entity_id: str) -> Any:
-    items = await _ws_send(client, {"type": "zone/list"})
-    if not isinstance(items, list):
-        return None
+    items = _require_list(await _ws_send(client, {"type": "zone/list"}), "zone/list")
     for item in items:
         if item.get("id") == entity_id or item.get("name") == entity_id:
             return item
@@ -975,16 +1269,18 @@ async def _fetch_area_or_floor(client: Any, entity_id: str) -> Any:
     if not real_id:
         return None
     if kind == "area":
-        items = await _ws_send(client, {"type": "config/area_registry/list"})
-        if not isinstance(items, list):
-            return None
+        items = _require_list(
+            await _ws_send(client, {"type": "config/area_registry/list"}),
+            "config/area_registry/list",
+        )
         for item in items:
             if item.get("area_id") == real_id:
                 return {"kind": "area", **item}
     elif kind == "floor":
-        items = await _ws_send(client, {"type": "config/floor_registry/list"})
-        if not isinstance(items, list):
-            return None
+        items = _require_list(
+            await _ws_send(client, {"type": "config/floor_registry/list"}),
+            "config/floor_registry/list",
+        )
         for item in items:
             if item.get("floor_id") == real_id:
                 return {"kind": "floor", **item}
@@ -1033,8 +1329,7 @@ async def _fetch_todo_item(client: Any, entity_id: str) -> Any:
         if getattr(err, "status_code", None) == 404:
             return None
         raise
-    if not isinstance(result, dict):
-        return None
+    result = _require_dict(result, "execute_script")
     items = result.get("response", {}).get("items", {}).get(cal, {}).get("items", [])
     for item in items:
         if item.get("uid") == uid:
@@ -1075,9 +1370,9 @@ async def _restore_entity_state(client: Any, entity_id: str, config: Any) -> Any
 
 
 async def _fetch_integration(client: Any, entity_id: str) -> Any:
-    items = await _ws_send(client, {"type": "config_entries/get"})
-    if not isinstance(items, list):
-        return None
+    items = _require_list(
+        await _ws_send(client, {"type": "config_entries/get"}), "config_entries/get"
+    )
     for item in items:
         if item.get("entry_id") == entity_id:
             return item
@@ -1133,9 +1428,9 @@ async def _fetch_helper(client: Any, entity_id: str, helper_type: str) -> Any:
             helper_type,
         )
         return None
-    items = await _ws_send(client, {"type": f"{helper_type}/list"})
-    if not isinstance(items, list):
-        return None
+    items = _require_list(
+        await _ws_send(client, {"type": f"{helper_type}/list"}), f"{helper_type}/list"
+    )
     object_id = entity_id.split(".", 1)[-1] if "." in entity_id else entity_id
     for item in items:
         if item.get("id") == object_id or item.get("id") == entity_id:

{ha_mcp_dev-7.8.0.dev707 → ha_mcp_dev-7.8.0.dev709}/src/ha_mcp/tools/backup.py

@@ -855,6 +855,7 @@ _VALID_COMBOS: set[tuple[str, str]] = {
     ("edits", "create"),
     ("edits", "list"),
     ("edits", "view"),
+    ("edits", "diff"),
     ("edits", "restore"),
     ("edits", "delete"),
 }
@@ -920,6 +921,7 @@ def register_backup_tools(
 | `edits` | `create` | On-demand snapshot of one entity (`domain` + `entity_id` required). Use before the user manually edits in the HA UI. Same handler path the decorator takes on writes; bypasses the `enable_auto_backup` toggle. |
 | `edits` | `list` | List per-entity auto-backups (lightweight). Filter by `domain` and/or `entity_id`. |
 | `edits` | `view` | Read one auto-backup file by name; returns YAML and parsed `config`. |
+| `edits` | `diff` | Compare one auto-backup against the entity's current config. RFC 6902 JSON-Patch + add/remove/replace counts; bounded output. Read-only — fetches the live config, makes no changes. |
 | `edits` | `restore` | Re-apply one auto-backup. Creates a fresh safety snapshot first. **No HA restart.** |
 | `edits` | `delete` | Delete one auto-backup by `backup_name`, or bulk-delete by filter. |
 
@@ -939,6 +941,7 @@ def register_backup_tools(
 - On-demand entity snapshot before a manual UI edit: `ha_manage_backup(scope="edits", action="create", domain="helper_input_boolean", entity_id="kitchen_lights_active")`
 - List recent auto-backups for one automation: `ha_manage_backup(scope="edits", action="list", domain="automation", entity_id="kitchen_lights")`
 - View an auto-backup: `ha_manage_backup(scope="edits", action="view", backup_name="automation.kitchen_lights.20260521_153000.yaml")`
+- Diff an auto-backup vs current state: `ha_manage_backup(scope="edits", action="diff", backup_name="automation.kitchen_lights.20260521_153000.yaml")`
 - Restore an auto-backup: `ha_manage_backup(scope="edits", action="restore", backup_name="automation.kitchen_lights.20260521_153000.yaml")`
 - Delete one auto-backup: `ha_manage_backup(scope="edits", action="delete", backup_name="...")`
 - Bulk-delete old auto-backups: `ha_manage_backup(scope="edits", action="delete", older_than_days=30)`
@@ -958,7 +961,7 @@ def register_backup_tools(
             ),
         ],
         action: Annotated[
-            Literal["create", "restore", "list", "view", "delete"],
+            Literal["create", "restore", "list", "view", "diff", "delete"],
             Field(
                 description="Operation to perform. Valid (scope, action) combinations are listed in the tool description."
             ),
@@ -1140,6 +1143,72 @@ def register_backup_tools(
                 )
             return {"success": True, "data": data}
 
+        if action == "diff":
+            bname = _require("backup_name", backup_name, scope, action)
+            try:
+                diff = await mgr.diff_snapshot(bname)
+            except FileNotFoundError:
+                raise_tool_error(
+                    create_error_response(
+                        ErrorCode.RESOURCE_NOT_FOUND,
+                        f"Backup {bname!r} not found",
+                        context={"backup_name": bname},
+                    )
+                )
+            except (ValueError, LookupError) as err:
+                raise_tool_error(
+                    create_error_response(
+                        ErrorCode.VALIDATION_INVALID_PARAMETER,
+                        str(err),
+                        context={"backup_name": bname},
+                    )
+                )
+            except ToolError:
+                raise
+            except Exception as err:
+                # Fetching the live config for diff goes through the
+                # same domain handler ``restore`` uses, so the same
+                # HA-side failure modes (4xx/5xx, WS errors, schema
+                # drift) apply. Funnel through
+                # ``exception_to_structured_error`` so the structured
+                # response carries enough context to retry.
+                exception_to_structured_error(
+                    err,
+                    context={"backup_name": bname, "action": "diff"},
+                    suggestions=[
+                        "Verify the entity referenced by the backup still "
+                        + "exists; diff fetches its current config",
+                        "Inspect the snapshot YAML via "
+                        + "ha_manage_backup(scope='edits', action='view', "
+                        + "backup_name=...) to confirm it parses",
+                    ],
+                )
+                return None  # unreachable: exception_to_structured_error always raises
+            warnings: list[str] = []
+            if diff.get("entity_missing"):
+                # ``restore_snapshot`` outcome on a missing entity is
+                # domain-dependent: upsert paths (automation, script,
+                # dashboard) recreate it, but helper / label / category
+                # restores go through ``<domain>/update`` WS commands
+                # that expect the entity to exist and would surface a
+                # WS error if it does not. Hedge rather than promise
+                # one specific outcome.
+                warnings.append(
+                    "Entity is missing from HA; restore behaviour is "
+                    "domain-dependent (upsert paths recreate it; "
+                    "update-only paths return an error)"
+                )
+            if diff.get("truncated"):
+                warnings.append(
+                    "Patch truncated; entity has more changes than the bounded "
+                    "diff captures — view the snapshot for the full state"
+                )
+            return {
+                "success": True,
+                "data": diff,
+                **({"warnings": warnings} if warnings else {}),
+            }
+
         if action == "restore":
             bname = _require("backup_name", backup_name, scope, action)
             try:
@@ -1185,6 +1254,7 @@ def register_backup_tools(
                         + "backup_name=...)",
                     ],
                 )
+                return None  # unreachable: exception_to_structured_error always raises
             return {
                 "success": True,
                 "data": result,

{ha_mcp_dev-7.8.0.dev707 → ha_mcp_dev-7.8.0.dev709/src/ha_mcp_dev.egg-info}/PKG-INFO

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