ha-mcp-dev 9.2.0.dev3435__tar.gz → 9.2.0.dev3444__tar.gz

{ha_mcp_dev-9.2.0.dev3435 → ha_mcp_dev-9.2.0.dev3444}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ha-mcp-dev
-Version: 9.2.0.dev3435
+Version: 9.2.0.dev3444
 Summary: Configure and automate Home Assistant with Claude, ChatGPT, and other AI assistants.
 Keywords: mcp,home-assistant,ai,automation,smart-home
 Author: Julien

{ha_mcp_dev-9.2.0.dev3435 → ha_mcp_dev-9.2.0.dev3444}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "uv_build"
 
 [project]
 name = "ha-mcp-dev"
-version = "9.2.0.dev3435"
+version = "9.2.0.dev3444"
 description = "Configure and automate Home Assistant with Claude, ChatGPT, and other AI assistants."
 readme = "README.md"
 requires-python = ">=3.13,<3.15"

{ha_mcp_dev-9.2.0.dev3435 → ha_mcp_dev-9.2.0.dev3444}/pyproject.toml.orig

@@ -4,7 +4,7 @@ build-backend = "uv_build"
 
 [project]
 name = "ha-mcp-dev"
-version = "9.2.0.dev3435"
+version = "9.2.0.dev3444"
 description = "Configure and automate Home Assistant with Claude, ChatGPT, and other AI assistants."
 readme = "README.md"
 # Upper bound widened to <3.15 so the package installs on Home Assistant's

{ha_mcp_dev-9.2.0.dev3435 → ha_mcp_dev-9.2.0.dev3444}/src/ha_mcp/backup_entity_ids.py

@@ -46,9 +46,9 @@ async def with_registry_icon(
     """The stored item plus the icon its entity's registry entry sets, if any.
 
     The registry icon is the one the entity shows, and the helper tools write
-    it there (an update always; a create for a zone, or when Core's schema
-    has no icon field or cannot be read), so the stored item alone can miss
-    it. A failed registry read
+    it there when Core's schema has no icon field or cannot be read (older
+    versions also for zones and on every update), so the stored item alone
+    can miss it. A failed registry read
     propagates, so the capture reports it instead of saving a snapshot
     without the icon.
     """

{ha_mcp_dev-9.2.0.dev3435 → ha_mcp_dev-9.2.0.dev3444}/src/ha_mcp/backup_zones.py

@@ -1,8 +1,9 @@
 """The zone a zone tool names, its registry icon, and a removed zone on restore.
 
-The helper tools keep a zone's icon in the entity registry unless the stored
-zone already has one (#2643), so the stored item alone can miss it: the
-snapshot records the registry's icon too. Core's ``zone/update`` needs the
+A zone's entity can carry an icon override in the entity registry (set with
+ha_set_entity, or by older ha-mcp versions in place of the stored icon), so
+the stored item alone can miss it: the snapshot records the registry's icon
+too. Core's ``zone/update`` needs the
 stored zone; once it was removed, the restore creates it again, and Core takes
 the new zone's id from the slug of its name. Core keeps a removed zone's
 registry entry for 30 days, so a zone created again under its old id in that

{ha_mcp_dev-9.2.0.dev3435 → ha_mcp_dev-9.2.0.dev3444}/src/ha_mcp/tools/config_helpers/core_payload.py

@@ -61,7 +61,6 @@ def merged_update(
     name: str | None,
     icon: str | None,
     fields: dict[str, Any],
-    entity_id: str,
 ) -> dict[str, Any]:
     """The stored item plus the changes: Core's update writes the whole item.
 
@@ -75,8 +74,6 @@ def merged_update(
         body.pop("name", None)
     if name is not None:
         body["name"] = name
-    if helper_type == "zone":
-        icon = _zone_item_icon(stored, icon, entity_id)
     if icon is not None:
         if icon:
             body["icon"] = icon
@@ -86,33 +83,6 @@ def merged_update(
     return body
 
 
-def _zone_item_icon(
-    stored: dict[str, Any], icon: str | None, entity_id: str
-) -> str | None:
-    """The icon to write into a zone's stored item, ``None`` to leave it (#2643).
-
-    The zone entity shows the registry icon over the item's, and Core's zone
-    update merges into the item and rejects an empty icon, so an icon stored
-    there can never be removed. A new icon therefore goes into the item only
-    when it already holds one; otherwise the registry alone carries it and
-    stays clearable. Clearing an icon the item holds is refused.
-    """
-    if not stored.get("icon"):
-        return None
-    if icon == "":
-        raise_tool_error(
-            create_error_response(
-                ErrorCode.VALIDATION_INVALID_PARAMETER,
-                f"The icon of {entity_id} cannot be removed: the zone's stored "
-                f"icon ({stored['icon']}) is kept by Home Assistant's zone update "
-                "and would show again.",
-                context=_simple_helper_error_context("zone", entity_id=entity_id),
-                suggestions=["Set a different icon instead of an empty one"],
-            )
-        )
-    return icon
-
-
 def _reject(helper_type: str, message: str, **context: Any) -> None:
     raise_tool_error(
         create_error_response(

{ha_mcp_dev-9.2.0.dev3435 → ha_mcp_dev-9.2.0.dev3444}/src/ha_mcp/tools/config_helpers/create.py

@@ -17,7 +17,7 @@ from ..ws_waiters import wait_for_entity_registered
 from .core_payload import (
     with_create_defaults,
 )
-from .icon_route import collection_icon
+from .icon_route import icon_targets, note_hidden_icon
 from .registry import _ws_error_msg
 from .schemas import (
     _attach_helper_skill,
@@ -125,24 +125,14 @@ async def _execute_create_simple_helper(
             )
         )
 
-    # A zone's update merges into the stored item and rejects an empty icon, so
-    # an icon stored there can never be removed: a new zone's icon goes to the
-    # entity registry (#2643), like the icon of a type whose schema has none or
-    # cannot be read.
-    item_icon = (
-        None
-        if helper_type == "zone"
-        else await collection_icon(client, helper_type, "create", icon)
-    )
-    registry_icon = icon if item_icon is None else None
-    message = _build_create_message(
-        helper_type, name, None if registry_icon else icon, fields
-    )
+    item_icon, registry_icon = await icon_targets(client, helper_type, "create", icon)
+    message = _build_create_message(helper_type, name, item_icon, fields)
     native = await _create_via_component(
         client, helper_type, message, area_id, labels, category, registry_icon
     )
     if native is not None:
         native_data, native_entity_id, native_warnings = native
+        await note_hidden_icon(client, native_entity_id, item_icon, native_warnings)
         create_response = _helper_response(
             "create",
             helper_type,
@@ -212,6 +202,7 @@ async def _execute_create_simple_helper(
             registry_icon,
         )
         await _apply_create_category(client, entity_id, category, helper_data, warnings)
+        await note_hidden_icon(client, entity_id, item_icon, warnings)
 
     create_response = _helper_response(
         "create",

ha_mcp_dev-9.2.0.dev3444/src/ha_mcp/tools/config_helpers/icon_route.py

@@ -0,0 +1,72 @@
+"""Route a storage helper's icon by the running Core collection's own fields."""
+
+from typing import Any
+
+from ...client.rest_client import HomeAssistantError
+from ..component_helper_collections import fetch_helper_schemas
+
+
+async def icon_targets(
+    client: Any, helper_type: str, action: str, icon: str | None
+) -> tuple[str | None, str | None]:
+    """Where an icon is written: ``(stored item, entity registry)``.
+
+    The item takes the icon when Core's ``action`` schema for the type
+    declares an ``icon`` field (person and tag declare none), and then the
+    registry does not: the helper and zone dialogs write the icon only to the
+    item, and a registry override would hide every later change made there
+    (#3001). A type without the field keeps its icon in the registry.
+
+    When the schemas cannot be read (no component, or a failed read) or do
+    not list the type or action, nothing is guessed: the icon goes to the
+    registry, as the entity settings set it, and a cleared icon ('') clears
+    both, since clearing only the registry would bring an older stored icon
+    back. A zone keeps its icon in the item even then: its schema has always
+    declared one, and the Zones editor shows only the stored icon.
+    """
+    if icon is None:
+        return None, None
+    schemas = await fetch_helper_schemas(client)
+    fields = schemas.get(helper_type, {}).get(action) if schemas else None
+    if isinstance(fields, list):
+        if any(isinstance(f, dict) and f.get("name") == "icon" for f in fields):
+            return icon, None
+        return None, icon
+    if helper_type == "zone":
+        return icon, None
+    return (icon, icon) if icon == "" else (None, icon)
+
+
+async def note_hidden_icon(
+    client: Any, entity_id: str | None, item_icon: str | None, warnings: list[str]
+) -> None:
+    """Warn when the entity's registry icon hides the icon just stored or
+    cleared.
+
+    The entity shows a registry icon over the stored one, and older ha-mcp
+    versions kept icons there (a zone's alone, every helper's on update), so
+    a changed or cleared stored icon can stay invisible. The registry read is
+    advisory: when it fails the write has still succeeded, so no warning is
+    given.
+    """
+    if item_icon is None or not entity_id:
+        return
+    try:
+        result = await client.send_websocket_message(
+            {"type": "config/entity_registry/get", "entity_id": entity_id}
+        )
+    except (HomeAssistantError, OSError, TimeoutError):
+        return
+    entry = result.get("result") if result.get("success") else None
+    override = entry.get("icon") if isinstance(entry, dict) else None
+    if not override or override == item_icon:
+        return
+    shown = (
+        f"shows its entity registry icon {override} over the stored icon {item_icon}"
+        if item_icon
+        else f"still shows its entity registry icon {override}"
+    )
+    warnings.append(
+        f"{entity_id} {shown}; clear it with "
+        f"ha_set_entity(entity_id='{entity_id}', icon='')."
+    )

{ha_mcp_dev-9.2.0.dev3435 → ha_mcp_dev-9.2.0.dev3444}/src/ha_mcp/tools/config_helpers/update.py

@@ -22,7 +22,7 @@ from ..config_write_helpers import apply_entity_category
 from ..helpers import raise_tool_error, ws_failure_code
 from ..ws_waiters import wait_for_entity_registered
 from .core_payload import merged_update
-from .icon_route import collection_icon
+from .icon_route import icon_targets, note_hidden_icon
 from .listing import listed_items
 from .registry import _ws_error_msg
 from .schemas import (
@@ -67,13 +67,12 @@ async def _execute_legacy_update(
     entity_id: str,
     unique_id: str,
     name: str | None,
-    icon: str | None,
+    item_icon: str | None,
     fields: dict[str, Any],
 ) -> dict[str, Any]:
     """Update through Core's ``<type>/update`` WS command (no component)."""
     stored = await _stored_item(client, helper_type, entity_id, unique_id)
-    item_icon = await collection_icon(client, helper_type, "update", icon)
-    body = merged_update(helper_type, stored, name, item_icon, fields, entity_id)
+    body = merged_update(helper_type, stored, name, item_icon, fields)
     result = await client.send_websocket_message(
         {**body, "type": f"{helper_type}/update", f"{helper_type}_id": unique_id}
     )
@@ -246,13 +245,15 @@ async def _execute_update_simple_helper(
         )
 
     warnings: list[str] = []
+    item_icon, registry_icon = await icon_targets(client, helper_type, "update", icon)
     native = await _update_via_component(
         client,
         helper_type,
         entity_id,
         helper_id,
         name,
-        icon,
+        item_icon,
+        registry_icon,
         area_id,
         labels,
         category,
@@ -260,6 +261,7 @@ async def _execute_update_simple_helper(
     )
     if native is not None:
         updated_data, entity, warnings = native
+        _note_kept_icon(helper_type, item_icon, updated_data, warnings)
     else:
         stored = await stored_helper_target(client, helper_type, helper_id, name)
         if stored is not None:
@@ -270,13 +272,14 @@ async def _execute_update_simple_helper(
             )
             entity, reason = entity_id, None
         updated_data = await _execute_legacy_update(
-            client, helper_type, entity or helper_id, unique_id, name, icon, fields
+            client, helper_type, entity or helper_id, unique_id, name, item_icon, fields
         )
+        _note_kept_icon(helper_type, item_icon, updated_data, warnings)
         if entity is None:
             given = [
                 field
                 for field, value in (
-                    ("icon", icon),
+                    ("icon", registry_icon),
                     ("area", area_id),
                     ("labels", labels),
                     ("category", category),
@@ -298,7 +301,7 @@ async def _execute_update_simple_helper(
             await _apply_update_registry_and_category(
                 client,
                 entity_id,
-                icon,
+                registry_icon,
                 area_id,
                 labels,
                 category,
@@ -315,6 +318,7 @@ async def _execute_update_simple_helper(
                 except Exception as e:  # noqa: BLE001
                     warnings.append(f"Update applied but verification failed: {e}")
 
+    await note_hidden_icon(client, entity, item_icon, warnings)
     update_response = _helper_response(
         "update",
         helper_type,
@@ -333,7 +337,8 @@ async def _update_via_component(
     entity_id: str,
     helper_id: str,
     name: str | None,
-    icon: str | None,
+    item_icon: str | None,
+    registry_icon: str | None,
     area_id: str | None,
     labels: list[str] | None,
     category: str | None,
@@ -353,12 +358,11 @@ async def _update_via_component(
     # The component names the item's own entity; without one the storage id
     # names the item, never the caller's guessed entity_id.
     entity_id = item.get("entity_id") or helper_id
-    item_icon = await collection_icon(client, helper_type, "update", icon)
-    body = merged_update(helper_type, item["item"], name, item_icon, fields, entity_id)
+    body = merged_update(helper_type, item["item"], name, item_icon, fields)
     registry = {
         key: value
         for key, value in (
-            ("icon", icon),
+            ("icon", registry_icon),
             ("area_id", area_id),
             ("labels", labels),
             ("category", category),
@@ -375,3 +379,22 @@ async def _update_via_component(
         error_context=_simple_helper_error_context(helper_type, entity_id=entity_id),
     )
     return None if result is None else native_result(result)
+
+
+def _note_kept_icon(
+    helper_type: str,
+    item_icon: str | None,
+    updated_data: dict[str, Any],
+    warnings: list[str],
+) -> None:
+    """Say so when Core kept a stored icon the caller cleared.
+
+    A zone's update merges into the stored item, so leaving the icon out keeps
+    it, as it does when the zone dialog's icon is emptied and saved.
+    """
+    if item_icon == "" and updated_data.get("icon"):
+        warnings.append(
+            f"Home Assistant kept the {helper_type}'s icon "
+            f"{updated_data['icon']}: its update keeps a stored icon, as the "
+            f"{helper_type} dialog does, so it can be changed but not removed."
+        )

{ha_mcp_dev-9.2.0.dev3435 → ha_mcp_dev-9.2.0.dev3444}/src/ha_mcp/tools/tools_config_helpers.py

@@ -598,7 +598,7 @@ class HelperConfigTools:
         icon: Annotated[
             str | None,
             Field(
-                description="Material Design Icon (e.g., 'mdi:bell'); '' or ' ' clears it, except a zone's stored icon (the icon in the zone's own config, as the Home Assistant UI stores it; ha_get_zone shows it), which cannot be removed. On create, a storage helper's icon goes into its stored config when Home Assistant's schema for the type has an icon field, otherwise (person, tag, a new zone, or without the ha_mcp_tools component) into the entity registry; an update always sets the registry icon, and the stored icon too where the schema has one. Restoring a storage helper's automatic backup also puts back its registry icon, unless the backup predates registry icons being recorded; a flow helper's backup holds no icon, so its restore does not set one",
+                description="Material Design Icon (e.g., 'mdi:bell'); '' or ' ' clears it, except a zone's stored icon, which Home Assistant keeps on update as the zone dialog does: it can be changed but not removed. A storage helper's icon goes into its stored config when Home Assistant's schema for the type has an icon field, as the helper's own dialog stores it, and the entity registry is left alone; otherwise (person, tag, or another type without the ha_mcp_tools component) it goes into the entity registry. An icon override in the entity registry is set or cleared with ha_set_entity. Restoring a storage helper's automatic backup also puts back its registry icon, unless the backup predates registry icons being recorded; a flow helper's backup holds no icon, so its restore does not set one",
                 default=None,
             ),
         ] = None,

{ha_mcp_dev-9.2.0.dev3435 → ha_mcp_dev-9.2.0.dev3444}/src/ha_mcp/tools/tools_zones.py

@@ -15,6 +15,7 @@ from ha_mcp._vendor.fastmcp.tools import tool
 
 from ..backup_helper_target import stored_target
 from ..client.rest_client import (
+    _NO_ANSWER_ERRORS,
     HomeAssistantAPIError,
     HomeAssistantAuthError,
     HomeAssistantCommandError,
@@ -45,6 +46,9 @@ from .ws_waiters import wait_for_entity_removed
 
 logger = logging.getLogger(__name__)
 
+# The zone state attributes that say who is in the zone.
+_OCCUPANCY_ATTRS = ("persons", "device_trackers")
+
 
 def _build_zone_result(
     zones: list[dict[str, Any]], zone_id: str | None, gaps: list[str] | None = None
@@ -133,17 +137,33 @@ def _shape_component_zone_record(rec: dict[str, Any]) -> dict[str, Any]:
 def _with_registry_icons(
     rows: list[dict[str, Any]], entries: list[dict[str, Any]]
 ) -> list[dict[str, Any]]:
-    """The rows with the icon each zone's entity shows: its registry icon, where
-    the zone tools keep a new zone's icon (#2643), over the stored one."""
+    """The rows with each zone entity's registry icon override as
+    ``entity_icon``, beside the stored ``icon`` the Zones editor shows: the
+    override is what the map and the zone's state show (#3001)."""
     icons = {e.get("entity_id"): e["icon"] for e in entries if e.get("icon")}
     return [
-        {**row, "icon": icons[row["entity_id"]]}
+        {**row, "entity_icon": icons[row["entity_id"]]}
         if row.get("entity_id") in icons
         else row
         for row in rows
     ]
 
 
+def _with_occupancy(
+    rows: list[dict[str, Any]], states: list[dict[str, Any]]
+) -> list[dict[str, Any]]:
+    """The rows with who is in each zone, from the zone entity's state: Core
+    puts it there for every zone, stored or not, as the Map panel shows it."""
+    occupancy = {
+        s.get("entity_id"): {
+            key: attrs[key] for key in _OCCUPANCY_ATTRS if key in attrs
+        }
+        for s in states
+        if isinstance(s, dict) and isinstance(attrs := s.get("attributes"), dict)
+    }
+    return [{**row, **occupancy.get(row.get("entity_id"), {})} for row in rows]
+
+
 def _shape_component_zone_rows(result: dict[str, Any]) -> list[dict[str, Any]]:
     """Reshape the component's zone ``helpers_list`` result into legacy rows."""
     raw = result.get("helpers")
@@ -191,6 +211,11 @@ class ZoneTools:
         settings) and YAML zones, are listed with ``editable=false`` /
         ``source="yaml"``; editable means ha_set_zone and ha_remove_zone can
         change the zone. Each zone carries its entity_id.
+
+        A stored zone's ``icon`` is the one stored in the zone, which the
+        Zones editor shows. ``entity_icon`` is an icon override in the zone
+        entity's registry entry: the map and the zone's state show it instead.
+        Set or clear the override with ha_set_entity.
         """
         try:
             # Prefer the ha_mcp_tools component's helpers_list, one call for
@@ -284,26 +309,69 @@ class ZoneTools:
             entries, registry_error = await self._zone_registry()
         except HomeAssistantConnectionError as exc:
             entries, registry_error = [], str(exc)
-        # The listing is complete without the registry; only its icons are missing.
-        response = _build_zone_result(_with_registry_icons(rows, entries), zone_id)
+        states_error = None
+        try:
+            states = await self._zone_states(
+                [row["entity_id"] for row in rows if row.get("entity_id")]
+            )
+        except (HomeAssistantAPIError, HomeAssistantConnectionError) as exc:
+            states, states_error = [], str(exc)
+        # The listing is complete without the registry and the states; only
+        # their icons and persons are missing.
+        rows = _with_occupancy(_with_registry_icons(rows, entries), states)
+        response = _build_zone_result(rows, zone_id)
         if registry_error:
             response.setdefault("warnings", []).append(
                 f"Icons set in the entity registry are missing: {registry_error}"
             )
+        if states_error:
+            response.setdefault("warnings", []).append(
+                f"Who is in each zone (persons) is missing: {states_error}"
+            )
         return response
 
-    async def _send_component_zone_list(self) -> dict[str, Any]:
-        """Send one ``ha_mcp_tools/helpers_list`` zone query over the per-client WS."""
-        ws = await get_websocket_client(
+    async def _component_ws(self) -> Any:
+        """The per-client WebSocket the component commands go over."""
+        return await get_websocket_client(
             url=self._client.base_url,
             token=self._client.token,
             verify_ssl=getattr(self._client, "verify_ssl", None),
         )
-        return await ws.send_command(
+
+    async def _send_component_zone_list(self) -> dict[str, Any]:
+        """Send one ``ha_mcp_tools/helpers_list`` zone query over the per-client WS."""
+        ws = await self._component_ws()
+        result: dict[str, Any] = await ws.send_command(
             "ha_mcp_tools/helpers_list",
             helper_types=["zone"],
             include_flow_helpers=False,
         )
+        return result
+
+    async def _zone_states(self, entity_ids: list[str]) -> list[dict[str, Any]]:
+        """The zones' states through the component's targeted read, or every
+        state when the component has no ``states`` command or it fails."""
+        caps = await get_component_caps(self._client)
+        if component_supports(caps, "states"):
+            try:
+                ws = await self._component_ws()
+                raw = await ws.send_command(
+                    "ha_mcp_tools/states", entity_ids=entity_ids
+                )
+                found = (raw.get("result") or {}).get("states")
+                if isinstance(found, dict):
+                    return list(found.values())
+                logger.warning("ha_mcp_tools/states returned a malformed payload")
+            # A raw socket reset reaches here unwrapped (send_command keeps
+            # writes at-most-once), and every state is still readable.
+            except (HomeAssistantCommandError, *_NO_ANSWER_ERRORS) as exc:
+                if is_unknown_command(exc):
+                    invalidate_caps(self._client)
+                logger.warning(
+                    "ha_mcp_tools/states failed; reading all states: %r", exc
+                )
+        states: list[dict[str, Any]] = await self._client.get_states()
+        return states
 
     async def _legacy_zone_result(self, zone_id: str | None) -> dict[str, Any]:
         """Serve ha_get_zone from Core's own commands."""
@@ -314,9 +382,9 @@ class ZoneTools:
         """Storage zones from Core's ``zone/list``, then every other zone state.
 
         A storage row is the stored body with its registry icon; the home
-        zone's and YAML zones' rows are their state attributes
-        (``friendly_name`` also as ``name``, plus ``persons`` and
-        ``device_trackers``). Every row carries ``entity_id``,
+        zone's and YAML zones' rows are their state attributes, with
+        ``friendly_name`` as ``name``. Every row carries who is in the zone
+        (``persons``, ``device_trackers``) from its state, ``entity_id``,
         ``editable`` and ``source``, like the component's. The registry links a
         storage zone to its entity (its ``unique_id`` is the zone_id); a zone
         state without such an entry is not stored. Returns the rows and the
@@ -354,19 +422,22 @@ class ZoneTools:
             states = await self._client.get_states()
         except (HomeAssistantAPIError, HomeAssistantConnectionError) as exc:
             return rows, [
-                f"Zones outside the zone storage such as 'home' are missing: {exc}"
+                "Zones outside the zone storage such as 'home', and who is in "
+                f"each zone, are missing: {exc}"
             ]
+        rows = _with_occupancy(rows, states)
         stored = set(entity_ids.values())
         for state in states:
             entity_id = state.get("entity_id", "") if isinstance(state, dict) else ""
             if not entity_id.startswith("zone.") or entity_id in stored:
                 continue
-            attrs = state.get("attributes") or {}
+            attrs = dict(state.get("attributes") or {})
             object_id = entity_id.split(".", 1)[1]
+            name = attrs.pop("friendly_name", object_id)
             rows.append(
                 {
                     **attrs,
-                    "name": attrs.get("friendly_name", object_id),
+                    "name": name,
                     "id": object_id,
                     "entity_id": entity_id,
                     "editable": False,
@@ -410,17 +481,16 @@ class ZoneTools:
             )
         return state
 
-    async def _resolve_zone(self, zone_id: str) -> tuple[str | None, str, str | None]:
-        """The entity_id, storage zone_id and registry icon of a stored zone,
-        given its entity_id or zone_id.
+    async def _resolve_zone(self, zone_id: str) -> tuple[str | None, str]:
+        """The entity_id and storage zone_id of a stored zone, given its
+        entity_id or zone_id.
 
         Resolved as ``stored_target`` resolves it, and so as the zone backups
         do: a bare ``zone_id`` is a storage id from ``zone/list``, and
         ``zone.<name>`` is the zone whose registry entry has that entity_id. A
         renamed entity can carry another zone's id as its name, so a bare id
         never names an entity, and a repeated removal deletes nothing.
-        Both entity_id and icon are None for a stored zone without a registry
-        entry; the icon is also None when the entry sets none. The
+        The entity_id is None for a stored zone without a registry entry. The
         home zone and YAML zones are not in the storage; Core gives them no
         ``unique_id``, so they have no registry entry.
         """
@@ -446,11 +516,7 @@ class ZoneTools:
         stored = {str(zone.get("id")) for zone in listed.get("result") or []}
         storage_id, entity = stored_target("zone", zone_id, stored, entries)
         if storage_id in stored:
-            icon = next(
-                (e.get("icon") for e in entries if e.get("unique_id") == storage_id),
-                None,
-            )
-            return entity, storage_id, icon
+            return entity, storage_id
         entity_id = zone_id if zone_id.startswith("zone.") else f"zone.{zone_id}"
         # A registry entry links a stored zone, so only a state without one is
         # a YAML or the home zone.
@@ -533,7 +599,7 @@ class ZoneTools:
         icon: Annotated[
             str | None,
             Field(
-                description="Material Design Icon (e.g., 'mdi:briefcase'). On update, '' clears it, except an icon stored in the zone itself (as the Home Assistant UI stores it; ha_get_zone shows it), which cannot be removed",
+                description="Material Design Icon (e.g., 'mdi:briefcase'), stored in the zone as the Home Assistant zone dialog stores it. Home Assistant keeps a zone's stored icon on update: it can be changed but not removed, so '' leaves it. An icon override in the entity registry (ha_get_zone's entity_icon) is set or cleared with ha_set_entity",
                 default=None,
             ),
         ] = None,
@@ -616,10 +682,8 @@ class ZoneTools:
                             context={"zone_id": zone_id},
                         )
                     )
-                entity_id, storage_id, registry_icon = await self._resolve_zone(zone_id)
-                # The helper write path merges into the stored zone and keeps a
-                # new icon in the registry, where it stays clearable, unless the
-                # zone already stores one (#2643). It takes the storage id first.
+                entity_id, storage_id = await self._resolve_zone(zone_id)
+                # The helper write path takes the storage id first.
                 result = await _execute_update_simple_helper(
                     self._client,
                     "zone",
@@ -635,20 +699,14 @@ class ZoneTools:
                     fields,
                 )
                 response = _zone_write_response(result, storage_id, "updated")
-                # The reply holds the stored zone plus the registry fields this
-                # write set; the entity shows its registry icon over the stored
-                # one, as ha_get_zone reports it. An icon this write set or
-                # cleared ('') is already in the reply.
-                if icon is None and registry_icon:
-                    response["zone_data"]["icon"] = registry_icon
                 response["updated_fields"] = updated
                 return response
 
-            if name is None or latitude is None or longitude is None:
+            # Core's zone/create names any other missing field itself; the
+            # shared create path refuses a missing name in its own tool's terms.
+            if name is None:
                 raise_tool_error(
-                    create_validation_error(
-                        "name, latitude, and longitude are required when creating a zone.",
-                    )
+                    create_validation_error("name is required when creating a zone.")
                 )
             result = await _execute_create_simple_helper(
                 self._client,
@@ -725,7 +783,7 @@ class ZoneTools:
                 suggestions=["Use ha_get_zone() to find existing zone_ids"],
                 context={"operation": "remove_zone"},
             )
-            entity_id, storage_id, _ = await self._resolve_zone(zone_id)
+            entity_id, storage_id = await self._resolve_zone(zone_id)
             result = await self._client.send_websocket_message(
                 {"type": "zone/delete", "zone_id": storage_id}
             )