ha-mcp-dev 7.9.0.dev759__tar.gz → 7.9.0.dev760__tar.gz

{ha_mcp_dev-7.9.0.dev759/src/ha_mcp_dev.egg-info → ha_mcp_dev-7.9.0.dev760}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ha-mcp-dev
-Version: 7.9.0.dev759
+Version: 7.9.0.dev760
 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.9.0.dev759 → ha_mcp_dev-7.9.0.dev760}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ha-mcp-dev"
-version = "7.9.0.dev759"
+version = "7.9.0.dev760"
 description = "Home Assistant MCP Server - Complete control of Home Assistant through MCP"
 readme = "README.md"
 requires-python = ">=3.13,<3.14"

{ha_mcp_dev-7.9.0.dev759 → ha_mcp_dev-7.9.0.dev760}/src/ha_mcp/read_only.py

@@ -131,6 +131,16 @@ def _custom_tool_write(args: dict[str, Any]) -> str | None:
     return "sandbox code execution"
 
 
+def _updates_write(args: dict[str, Any]) -> str | None:
+    # ``action`` defaults to "list" at the schema layer, so a missing action
+    # executes as a read (the middleware sees RAW pre-validation arguments —
+    # an absent key here means the tool itself will run the list branch).
+    action = args.get("action")
+    if action in (None, "list", "get"):
+        return None
+    return f"action={action!r}"
+
+
 def _radio_write(args: dict[str, Any]) -> str | None:
     action = args.get("action")
     # Reads (allowed): per-node diagnostics, the integration/network summary,
@@ -200,6 +210,14 @@ READ_ONLY_EXEMPT_TOOLS: dict[str, ReadOnlyExemption] = {
         "cluster-attribute read ('cluster_read'), and the Thread dataset "
         "listing ('list_datasets')",
     ),
+    # Update listing/details exist only here — ha_get_updates was merged
+    # into this tool (issue #1726), so hiding it would remove the read
+    # surface entirely.
+    "ha_manage_updates": ReadOnlyExemption(
+        _updates_write,
+        "listing pending updates (action='list', the default) and reading "
+        "update details/release notes (action='get')",
+    ),
 }
 
 

{ha_mcp_dev-7.9.0.dev759 → ha_mcp_dev-7.9.0.dev760}/src/ha_mcp/tools/best_practice_checker.py

@@ -162,6 +162,28 @@ _TARGET_FIELDS = ("entity_id", "device_id", "area_id", "floor_id", "label_id")
 # ``service:`` (legacy) and ``action:`` (modern, 2024+) for the same field.
 _SERVICE_KEYS = ("service", "action")
 
+# Purpose-specific trigger/condition keys renamed in HA 2026.7 — the old keys
+# no longer load (home-assistant/core#174463).
+_RENAMED_TRIGGER_KEYS = {
+    "battery.low": "battery.became_low",
+    "battery.not_low": "battery.no_longer_low",
+    "lawn_mower.docked": "lawn_mower.returned_to_dock",
+    "schedule.turned_on": "schedule.block_started",
+    "schedule.turned_off": "schedule.block_ended",
+    "timer.time_remaining": "timer.remaining_time_reached",
+    "update.update_became_available": "update.became_available",
+    "vacuum.docked": "vacuum.returned_to_dock",
+}
+_RENAMED_CONDITION_KEYS = {
+    "climate.target_temperature": "climate.is_target_temperature",
+    "climate.target_humidity": "climate.is_target_humidity",
+}
+# Trigger ``options.behavior`` values renamed in HA 2026.7: any→each,
+# last→all (home-assistant/core#173259). The old values still load but raise
+# an HA repair issue and face removal. Condition ``options.behavior`` keeps
+# ``any``/``all`` — conditions are never flagged.
+_DEPRECATED_TRIGGER_BEHAVIOR = {"any": "each", "last": "all"}
+
 
 # ---------------------------------------------------------------------------
 # Public API
@@ -318,6 +340,23 @@ def _check_condition_templates(
             # Shorthand template condition
             _check_template_string(cond, warnings, skill_prefix, "condition")
         elif isinstance(cond, dict):
+            # 2026.7 renamed purpose-specific condition keys — old keys no
+            # longer load.
+            condition_key = cond.get("condition")
+            renamed_condition = (
+                _RENAMED_CONDITION_KEYS.get(condition_key)
+                if isinstance(condition_key, str)
+                else None
+            )
+            if renamed_condition:
+                _emit(
+                    warnings,
+                    f"Condition key `{condition_key}` was renamed to "
+                    f"`{renamed_condition}` in HA 2026.7 and the old key no "
+                    f"longer loads — use `condition: {renamed_condition}`.",
+                    skill_prefix,
+                    "automation-patterns.md#native-conditions",
+                )
             if cond.get("condition") == "template":
                 vt = cond.get("value_template", "")
                 if isinstance(vt, str):
@@ -655,12 +694,44 @@ def _check_triggers(
 
         platform = trigger.get("platform", trigger.get("trigger", ""))
 
+        # 2026.7 renamed purpose-specific trigger keys — old keys no longer load.
+        renamed_trigger = (
+            _RENAMED_TRIGGER_KEYS.get(platform) if isinstance(platform, str) else None
+        )
+        if renamed_trigger:
+            _emit(
+                warnings,
+                f"Trigger key `{platform}` was renamed to `{renamed_trigger}` "
+                "in HA 2026.7 and the old key no longer loads — use "
+                f"`trigger: {renamed_trigger}`.",
+                skill_prefix,
+                "automation-patterns.md#trigger-types",
+            )
+
+        # 2026.7 renamed trigger `options.behavior` values (any→each, last→all).
+        options = trigger.get("options")
+        if isinstance(options, dict):
+            behavior = options.get("behavior")
+            if isinstance(behavior, str) and behavior in _DEPRECATED_TRIGGER_BEHAVIOR:
+                _emit(
+                    warnings,
+                    f"Trigger `options.behavior: {behavior}` was renamed to "
+                    f"`{_DEPRECATED_TRIGGER_BEHAVIOR[behavior]}` in HA 2026.7 — "
+                    "the old value still loads but raises a repair issue and "
+                    "will be removed. Valid trigger values: `each`, `first`, "
+                    "`all` (conditions keep `any`/`all`).",
+                    skill_prefix,
+                    "automation-patterns.md#trigger-types",
+                )
+
         # Device trigger → prefer entity_id-based triggers
         if platform == "device":
             _emit(
                 warnings,
-                "Trigger uses `device` platform with `device_id` — prefer "
-                "`state` or `event` trigger with `entity_id` when possible "
+                "Trigger uses `device` platform with `device_id` — prefer a "
+                "purpose-specific trigger (`<domain>.<name>` with a `target:` "
+                "of entities/areas/floors/labels, HA 2026.7+) or a `state`/"
+                "`event` trigger with `entity_id` when possible "
                 "(device_id breaks on re-add).",
                 skill_prefix,
                 "device-control.md#entity-id-vs-device-id",

{ha_mcp_dev-7.9.0.dev759 → ha_mcp_dev-7.9.0.dev760}/src/ha_mcp/tools/tools_config_automations.py

@@ -440,6 +440,8 @@ class AutomationConfigTools:
             Field(
                 description="Complete automation configuration with required fields: 'alias', 'triggers', 'actions'. "
                 "Optional: 'description', 'conditions', 'mode', 'max', 'initial_state', 'variables'. "
+                "Purpose-specific triggers/conditions (HA 2026.7+ default: 'trigger': '<domain>.<name>' "
+                "with 'target'/'options') are valid config. "
                 "Mutually exclusive with python_transform.",
                 default=None,
             ),

{ha_mcp_dev-7.9.0.dev759 → ha_mcp_dev-7.9.0.dev760}/src/ha_mcp/tools/tools_traces.py

@@ -712,6 +712,8 @@ def _populate_trigger_info(
             )
         if "entity_id" in trigger_vars:
             result["trigger"]["entity_id"] = trigger_vars["entity_id"]
+        if "error" in trigger_step:
+            result["trigger"]["error"] = trigger_step["error"]
 
     if "trigger" not in result and "trigger" in trace:
         result["trigger"] = {"description": trace["trigger"]}
@@ -731,6 +733,11 @@ def _populate_condition_results(
             }
             if "timestamp" in cond:
                 cond_result["timestamp"] = cond["timestamp"]
+            # HA 2026.7+ always records template errors on the failing step
+            # (core #172917) — dropping this field would hide the reason a
+            # condition evaluated to None.
+            if "error" in cond:
+                cond_result["error"] = cond["error"]
             condition_results.append(cond_result)
         result["condition_results"] = condition_results
 

{ha_mcp_dev-7.9.0.dev759 → ha_mcp_dev-7.9.0.dev760}/src/ha_mcp/tools/tools_updates.py

@@ -15,6 +15,10 @@ from fastmcp.exceptions import ToolError
 from fastmcp.tools import tool
 from pydantic import Field
 
+from ..client.rest_client import (
+    HomeAssistantAuthError,
+    HomeAssistantConnectionError,
+)
 from ..errors import ErrorCode, create_error_response
 from .helpers import (
     exception_to_structured_error,
@@ -22,9 +26,16 @@ from .helpers import (
     raise_tool_error,
     register_tool_methods,
 )
+from .util_helpers import JSON_STRING_COERCION
 
 logger = logging.getLogger(__name__)
 
+# Batch-install category split, mirroring the HA 2026.7 Updates page: the
+# "Update all" button never covers core/OS/supervisor — those are applied
+# individually, on purpose.
+_INSTALL_ALL_CATEGORIES = ("addons", "hacs", "devices", "other")
+_PROTECTED_UPDATE_CATEGORIES = ("core", "os", "supervisor")
+
 _GITHUB_CORE_RELEASE_URL = (
     "https://api.github.com/repos/home-assistant/core/releases/tags/{version}"
 )
@@ -654,112 +665,299 @@ class UpdateTools:
 
         return None, None
 
+    async def _resolve_update_targets(
+        self,
+        action: str,
+        entity_ids: list[str] | str | None,
+        categories: list[str] | str | None,
+    ) -> list[str]:
+        """Validate parameters and resolve the update entity_ids to act on."""
+        ids = [entity_ids] if isinstance(entity_ids, str) else list(entity_ids or [])
+        cats = [categories] if isinstance(categories, str) else list(categories or [])
+
+        if action != "install" and (not ids or cats):
+            raise_tool_error(
+                create_error_response(
+                    ErrorCode.VALIDATION_INVALID_PARAMETER,
+                    f"'{action}' requires entity_ids; categories is install-only.",
+                )
+            )
+        if action == "install" and bool(ids) == bool(cats):
+            raise_tool_error(
+                create_error_response(
+                    ErrorCode.VALIDATION_INVALID_PARAMETER,
+                    "'install' requires exactly one of entity_ids or categories.",
+                )
+            )
+
+        invalid = [e for e in ids if not e.startswith("update.")]
+        if invalid:
+            raise_tool_error(
+                create_error_response(
+                    ErrorCode.VALIDATION_INVALID_PARAMETER,
+                    "entity_ids must be 'update.' entities.",
+                    context={"invalid_entity_ids": invalid},
+                )
+            )
+
+        if not cats:
+            return list(dict.fromkeys(ids))
+
+        protected = sorted(set(cats) & set(_PROTECTED_UPDATE_CATEGORIES))
+        unknown = sorted(
+            set(cats) - set(_INSTALL_ALL_CATEGORIES) - set(_PROTECTED_UPDATE_CATEGORIES)
+        )
+        if protected or unknown:
+            problems = []
+            if protected:
+                problems.append(
+                    f"categories {protected} are excluded from batch install by "
+                    "design (mirrors the HA Updates page, which never bundles "
+                    "core/OS/supervisor into 'Update all') — target those "
+                    "individually via entity_ids"
+                )
+            if unknown:
+                problems.append(f"unknown categories {unknown}")
+            raise_tool_error(
+                create_error_response(
+                    ErrorCode.VALIDATION_INVALID_PARAMETER,
+                    "; ".join(problems),
+                    context={"allowed_categories": list(_INSTALL_ALL_CATEGORIES)},
+                )
+            )
+
+        listing = await self._list_updates(include_skipped=False)
+        listed_categories = listing.get("categories", {})
+        return [
+            update["entity_id"]
+            for cat in dict.fromkeys(cats)
+            for update in listed_categories.get(cat, [])
+            if update.get("can_install")
+        ]
+
     @tool(
-        name="ha_get_updates",
+        name="ha_manage_updates",
         tags={"System"},
         annotations={
-            "idempotentHint": True,
+            "destructiveHint": True,
             "openWorldHint": True,
-            "readOnlyHint": True,
-            "title": "Get Updates",
+            "title": "Manage Updates",
         },
     )
     @log_tool_usage
-    async def ha_get_updates(
+    async def ha_manage_updates(
         self,
-        entity_id: Annotated[
-            str | None,
+        action: Annotated[
+            str,
+            Field(
+                description="'list' (all pending updates, default), 'get' "
+                "(details/release notes for one update), 'install' (apply "
+                "pending updates), 'skip' (hide the offered version), or "
+                "'clear_skipped' (re-offer a skipped version).",
+                default="list",
+            ),
+        ] = "list",
+        entity_ids: Annotated[
+            list[str] | str | None,
+            JSON_STRING_COERCION,
             Field(
-                description="Update entity ID to get details for (e.g., 'update.home_assistant_core_update'). "
-                "If omitted, lists all available updates.",
+                description="Update entity_id(s) to act on. 'get' takes exactly "
+                "one; skip/clear_skipped require at least one; for install, "
+                "mutually exclusive with categories.",
+                default=None,
+            ),
+        ] = None,
+        categories: Annotated[
+            list[str] | str | None,
+            JSON_STRING_COERCION,
+            Field(
+                description="For install: apply every pending update in these "
+                "categories ('addons', 'hacs', 'devices', 'other'). Mirrors the "
+                "HA 2026.7 'Update all' button: core/os/supervisor are excluded "
+                "by design (target those individually via entity_ids) and "
+                "skipped updates are never included.",
                 default=None,
             ),
         ] = None,
         include_skipped: Annotated[
             bool,
             Field(
-                description="When listing all updates, include updates that have been skipped (default: False)",
+                description="For list: include updates that have been skipped "
+                "(default: False).",
                 default=False,
             ),
         ] = False,
         include_release_notes: Annotated[
             bool,
             Field(
-                description="When getting a Core update entity, fetch multi-version release notes "
-                "and breaking changes for all versions between installed and latest (default: False). "
-                "Adds breaking_changes, multi_version_release_notes, and installed_integrations to the response.",
+                description="For get on a Core update entity: fetch multi-version "
+                "release notes and breaking changes for all versions between "
+                "installed and latest (default: False). Adds breaking_changes, "
+                "multi_version_release_notes, and installed_integrations to the "
+                "response.",
+                default=False,
+            ),
+        ] = False,
+        backup: Annotated[
+            bool,
+            Field(
+                description="For install: create a backup before installing where "
+                "the update entity supports it (apps/add-ons). Default: False.",
                 default=False,
             ),
         ] = False,
     ) -> dict[str, Any]:
-        """
-        Get update information -- list all updates or get details for a specific one.
-
-        Without an entity_id: Lists all available updates across the system including
-        Home Assistant Core, add-ons, device firmware, HACS, and OS updates.
+        """Manage Home Assistant updates -- list, read details, batch install, skip, or un-skip.
 
-        With an entity_id: Returns detailed information about a specific update including
-        version info, category, and release notes (if available).
+        Covers Core, OS, supervisor, apps (add-ons), device firmware, and HACS
+        update entities. In Read Only Mode the read actions ('list', 'get') stay
+        available; write actions are blocked.
 
-        With include_release_notes=True (Core updates only): Also fetches HA release
-        blog posts for every monthly version between installed and latest. Returns
-        structured breaking changes and installed integration domains for cross-referencing.
+        Installs run asynchronously in Home Assistant and can take minutes:
+        'install' returns once the service calls are accepted, with per-entity
+        results. Poll action='list' to watch in_progress until installed_version
+        reaches latest_version.
 
         EXAMPLES:
-        - List all updates: ha_get_updates()
-        - List including skipped: ha_get_updates(include_skipped=True)
-        - Get specific update: ha_get_updates(entity_id="update.home_assistant_core_update")
-        - Pre-update analysis: ha_get_updates(entity_id="update.home_assistant_core_update", include_release_notes=True)
-
-        RETURNS (when listing):
-        - updates_available: Count of available updates
-        - updates: List of update entities with version info
-        - categories: Updates grouped by category (core, addons, devices, hacs, os)
-        - ha_mcp_update: This MCP server's own update status
-          {current, latest, update_available} — so you can flag a newer ha-mcp
-          release (from PyPI for pip/Docker, the Supervisor add-on store for the
-          add-on). Present on all install types; omitted only for the unknown
-          version and when HA_MCP_DISABLE_UPDATE_CHECK is set.
-
-        RETURNS (when getting specific update):
-        - Update details including installed/latest versions
-        - Release notes (fetched from WebSocket API or GitHub)
-        - Category and installation status
-
-        RETURNS (with include_release_notes=True, Core only):
-        - breaking_changes.entries[]: Each has integration, description, version
-        - multi_version_release_notes[]: Full text per version {version, content, source_url}
-        - installed_integrations: Your integration domains for cross-referencing
+        - List all updates: ha_manage_updates()
+        - Pre-update analysis: ha_manage_updates(action="get", entity_ids=["update.home_assistant_core_update"], include_release_notes=True)
+        - Update everything pending in a category: ha_manage_updates(action="install", categories=["addons", "hacs"])
+
+        RETURNS (action='list'): updates_available, updates, categories, and
+        ha_mcp_update -- this MCP server's own update status {current, latest,
+        update_available}, so a newer ha-mcp release can be flagged.
+
+        RETURNS (action='get'): update details, release notes; with
+        include_release_notes=True on Core also breaking_changes.entries[],
+        multi_version_release_notes[], and installed_integrations.
         """
         try:
-            if entity_id is None:
+            if action == "list":
                 return await self._list_updates(bool(include_skipped))
-            else:
+
+            if action == "get":
+                ids = (
+                    [entity_ids]
+                    if isinstance(entity_ids, str)
+                    else list(entity_ids or [])
+                )
+                if len(ids) != 1:
+                    raise_tool_error(
+                        create_error_response(
+                            ErrorCode.VALIDATION_INVALID_PARAMETER,
+                            "'get' requires exactly one entity in entity_ids.",
+                            context={"entity_ids": ids},
+                        )
+                    )
                 return await self._get_update_details(
-                    entity_id, bool(include_release_notes)
+                    ids[0], bool(include_release_notes)
+                )
+
+            if action not in ("install", "skip", "clear_skipped"):
+                raise_tool_error(
+                    create_error_response(
+                        ErrorCode.VALIDATION_INVALID_PARAMETER,
+                        f"Invalid action '{action}'. Must be 'list', 'get', "
+                        "'install', 'skip', or 'clear_skipped'.",
+                        context={"action": action},
+                    )
+                )
+
+            targets = await self._resolve_update_targets(action, entity_ids, categories)
+
+            results: list[dict[str, Any]] = []
+            requested = len(targets)
+
+            # Explicit-id mode: verify the entities exist up front. HA service
+            # calls targeting nonexistent entities no-op silently, which would
+            # otherwise read as success.
+            if entity_ids:
+                states = await self._client.get_states()
+                known = {s.get("entity_id") for s in states if isinstance(s, dict)}
+                results.extend(
+                    create_error_response(
+                        ErrorCode.ENTITY_NOT_FOUND,
+                        f"Update entity not found: {eid}",
+                        context={"entity_id": eid},
+                        suggestions=["Use ha_manage_updates() to list update entities"],
+                    )
+                    for eid in targets
+                    if eid not in known
+                )
+                targets = [e for e in targets if e in known]
+
+            succeeded = 0
+            for eid in targets:
+                data: dict[str, Any] = {"entity_id": eid}
+                if action == "install" and backup:
+                    data["backup"] = True
+                try:
+                    await self._client.call_service("update", action, data)
+                    results.append({"success": True, "entity_id": eid})
+                    succeeded += 1
+                except (HomeAssistantConnectionError, HomeAssistantAuthError):
+                    # Fatal transport/auth failure — the connection is gone,
+                    # so remaining items would fail identically. Propagate to
+                    # surface the root cause instead of N per-item errors.
+                    raise
+                except Exception as e:
+                    # Batch item failure — collect, don't raise.
+                    results.append(
+                        create_error_response(
+                            ErrorCode.SERVICE_CALL_FAILED,
+                            str(e),
+                            context={"entity_id": eid},
+                        )
+                    )
+
+            failed = requested - succeeded
+            response: dict[str, Any] = {
+                # Aggregate convention (matches ha_bulk-style tools): True only
+                # when nothing failed — zero requested counts as success.
+                "success": failed == 0,
+                "action": action,
+                "requested": requested,
+                "succeeded": succeeded,
+                "failed": failed,
+                "results": results,
+            }
+            if not requested:
+                response["note"] = "No matching pending updates to act on."
+            elif action == "install" and succeeded:
+                response["note"] = (
+                    "Installs run asynchronously in Home Assistant and can take "
+                    "minutes; poll ha_manage_updates(action='list') to track "
+                    "progress."
                 )
+            return response
 
         except ToolError:
             raise
         except Exception as e:
             error_msg = str(e)
-            if entity_id and ("404" in error_msg or "not found" in error_msg.lower()):
+            if (
+                action == "get"
+                and entity_ids
+                and ("404" in error_msg or "not found" in error_msg.lower())
+            ):
+                eid = entity_ids if isinstance(entity_ids, str) else entity_ids[0]
                 raise_tool_error(
                     create_error_response(
                         ErrorCode.ENTITY_NOT_FOUND,
-                        f"Update entity not found: {entity_id}",
-                        context={"entity_id": entity_id},
+                        f"Update entity not found: {eid}",
+                        context={"entity_id": eid},
                         suggestions=[
-                            "Use ha_get_updates() without entity_id to see all available updates"
+                            "Use ha_manage_updates() without entity_ids to see "
+                            "all available updates"
                         ],
                     )
                 )
-            logger.error(f"Failed to get updates: {e}")
+            logger.error(f"Failed to manage updates: {e}")
             exception_to_structured_error(
                 e,
                 suggestions=[
                     "Check Home Assistant connection",
-                    "Verify API access permissions",
+                    "Use ha_manage_updates() to inspect available updates",
                 ],
             )
             return (

{ha_mcp_dev-7.9.0.dev759 → ha_mcp_dev-7.9.0.dev760}/src/ha_mcp/update_check.py

@@ -3,7 +3,7 @@
 An operator can sit on an old build without ever knowing. This does a
 fail-silent check, holds the result in memory for the process, and surfaces a
 newer release via a startup log banner and the ``ha_get_overview`` /
-``ha_get_system_health`` / ``ha_get_updates`` tool fields.
+``ha_get_system_health`` / ``ha_manage_updates`` tool fields.
 
 The comparison reference depends on how ha-mcp is deployed, because the running
 version only means something against the matching source:
@@ -216,7 +216,7 @@ async def get_update_field() -> UpdateField | None:
     so it never blocks the event loop, and shapes the result for embedding under
     an ``ha_mcp_update`` key. Never raises — a hiccup yields None (the tool omits
     the field) and is logged at debug. Shared by every status tool that surfaces
-    the notice (``ha_get_overview`` / ``ha_get_system_health`` / ``ha_get_updates``)
+    the notice (``ha_get_overview`` / ``ha_get_system_health`` / ``ha_manage_updates``)
     so the shaping and event-loop offload live in one place.
     """
     try:

{ha_mcp_dev-7.9.0.dev759 → ha_mcp_dev-7.9.0.dev760}/src/ha_mcp/utils/domain_handlers.py

@@ -176,7 +176,16 @@ DOMAIN_HANDLERS = {
         "valid_actions": [],
         "parameters": [],
         "quick_actions": [],
-        "state_attributes": ["state", "latitude", "longitude"],
+        # in_zones (all containing zones, smallest first) and tracking_type
+        # ("connection"/"location") were added in HA 2026.7; latitude/longitude
+        # may be absent when a person/tracker is located by a presence scanner.
+        "state_attributes": [
+            "state",
+            "latitude",
+            "longitude",
+            "in_zones",
+            "tracking_type",
+        ],
         "read_only": True,
         "provides_location": True,
     },

{ha_mcp_dev-7.9.0.dev759 → ha_mcp_dev-7.9.0.dev760/src/ha_mcp_dev.egg-info}/PKG-INFO

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