homeassistant-ai
diff --git a/‎src/ha_mcp/tools/tools_config_helpers.py‎
Lines changed: 110 additions & 4 deletions b/‎src/ha_mcp/tools/tools_config_helpers.py‎
Lines changed: 110 additions & 4 deletions
diff --git a/‎tests/src/e2e/workflows/config/test_helper_crud.py‎
Lines changed: 109 additions & 3 deletions b/‎tests/src/e2e/workflows/config/test_helper_crud.py‎
Lines changed: 109 additions & 3 deletions
diff --git a/‎tests/src/unit/test_ha_config_list_helpers_component_routing.py‎
Lines changed: 21 additions & 1 deletion b/‎tests/src/unit/test_ha_config_list_helpers_component_routing.py‎
Lines changed: 21 additions & 1 deletion
@@ -1399,6 +1399,85 @@ async def _find_collision_in_simple_helpers(
     return None
 
 
+_REGISTRY_JOIN_STALE_WARNING = (
+    "Could not read the entity registry, so a renamed helper's 'name' may be the "
+    "creation-time name and no current 'entity_id' is shown; use ha_search to find "
+    "the helper by name for the authoritative current values."
+)
+
+
+async def _enrich_helpers_with_current_registry(
+    client: Any, helper_type: str, items: list[Any]
+) -> list[str]:
+    """Join the entity registry onto storage-collection helper records.
+
+    The ``{helper_type}/list`` response carries the immutable storage ``id``
+    (the unique_id) and the creation-time ``name``; after a UI rename the
+    current ``entity_id`` and display name live only in the entity registry, so
+    the raw list goes stale (issue #1794). For each record matched by
+    ``unique_id`` **and** ``platform == helper_type`` this adds the current
+    ``entity_id``, moves the storage name to ``original_name``, and sets
+    ``name`` to the current display name (registry ``name``, falling back to
+    ``original_name``). ``items`` is mutated in place.
+
+    Storage types without a matching entity (e.g. ``tag``) and platform
+    mismatches are left untouched. Returns a warnings list — non-empty only
+    when the registry read failed, so the caller can flag the un-enriched
+    result instead of silently returning stale values.
+    """
+    if not items:
+        # Nothing to enrich — skip the full-registry fetch entirely.
+        return []
+    # Degrade-open: enrichment is cosmetic, so any failure — the registry read,
+    # an unexpected registry shape (e.g. a non-hashable ``id`` breaking the
+    # lookup), or a malformed response — flags the result rather than raising
+    # out and letting the caller's handler turn a list call into a failure.
+    # Mirrors _get_entities_for_config_entry, which reads the same endpoint.
+    # send_websocket_message returns {"success": false, ...} instead of raising,
+    # so the malformed-response check below is the branch production takes.
+    try:
+        reg_result = await client.send_websocket_message(
+            {"type": "config/entity_registry/list"}
+        )
+        # A missing / non-list ``result`` (or a non-dict / unsuccessful response)
+        # is a malformed read, not an empty registry — flag it rather than
+        # silently returning un-enriched records. A present-but-empty ``[]`` is a
+        # legitimate no-match and passes through below without a warning.
+        if not (
+            isinstance(reg_result, dict)
+            and reg_result.get("success")
+            and isinstance(reg_result.get("result"), list)
+        ):
+            logger.debug(
+                "list_helpers registry enrichment: malformed registry response: %r",
+                reg_result,
+            )
+            return [_REGISTRY_JOIN_STALE_WARNING]
+        registry = reg_result["result"]
+        reg_by_uid = {
+            entry["unique_id"]: entry
+            for entry in registry
+            if isinstance(entry, dict)
+            and entry.get("platform") == helper_type
+            and entry.get("unique_id")
+        }
+        for item in items:
+            if not isinstance(item, dict):
+                continue
+            entry = reg_by_uid.get(item.get("id"))
+            if entry is None:
+                continue
+            item["entity_id"] = entry.get("entity_id")
+            item["original_name"] = item.get("name")
+            item["name"] = (
+                entry.get("name") or entry.get("original_name") or item.get("name")
+            )
+    except Exception as e:
+        logger.debug(f"list_helpers registry enrichment failed: {e}")
+        return [_REGISTRY_JOIN_STALE_WARNING]
+    return []
+
+
 async def _check_name_collision(
     client: Any,
     helper_type: str,
@@ -3391,6 +3470,14 @@ def _shape_collection_helper_record(rec: dict[str, Any]) -> dict[str, Any]:
         out["entity_id"] = entity_id
     name = rec.get("name")
     if name is not None:
+        # The storage body's ``name`` is the creation-time name (a rename
+        # updates the registry, not the body — #1794); preserve it as
+        # ``original_name`` before the current display name overrides it, so a
+        # component-served record carries the same additive shape as the legacy
+        # join (both paths promise entity_id/original_name in the docstring).
+        original_name = out.get("name")
+        if original_name is not None:
+            out["original_name"] = original_name
         out["name"] = name
     return out
 
@@ -3538,11 +3625,19 @@ async def ha_config_list_helpers(
         List all Home Assistant helpers of a specific type with their configurations.
 
         Returns complete configuration for all helpers of the specified type including:
-        - ID (storage id), name, icon
-        - entity_id and current display name (where available)
+        - id (immutable storage key), entity_id (current — address the helper by
+          this, where available), name (current display name), original_name
+          (creation-time name), icon
         - Type-specific settings (min/max for input_number, options for input_select, etc.)
         - Area and label assignments
 
+        For a helper renamed in the UI, id/original_name keep the storage values while
+        entity_id/name reflect the current entity registry (entity_id is the identifier
+        ha_config_set_helper resolves against, so prefer it over id for a renamed helper).
+        entity_id/original_name are present only for storage-collection helpers matched in
+        the entity registry — types with no backing entity (e.g. tag), and every record when
+        the registry read degrades, carry only id/name (a warning flags the degraded case).
+
         SUPPORTED HELPER TYPES:
         - input_button: Virtual buttons for triggering automations
         - input_boolean: Toggle switches/checkboxes
@@ -3602,14 +3697,25 @@ async def ha_config_list_helpers(
                 {"type": f"{helper_type}/list"}
             )
             if result.get("success"):
-                items = result.get("result", [])
-                return {
+                # Flatten first: person/list returns {"storage": [...],
+                # "config": [...]} rather than a flat list, so a raw
+                # result["result"] would be a dict here — breaking both the
+                # count and the registry enrichment below (which iterates
+                # records). _flatten_helper_list_result normalises both shapes.
+                items = _flatten_helper_list_result(result)
+                warnings = await _enrich_helpers_with_current_registry(
+                    self._client, helper_type, items
+                )
+                response: dict[str, Any] = {
                     "success": True,
                     "helper_type": helper_type,
                     "count": len(items),
                     "helpers": items,
                     "message": f"Found {len(items)} {helper_type} helper(s)",
                 }
+                if warnings:
+                    response["warnings"] = warnings
+                return response
             raise_tool_error(
                 create_error_response(
                     ErrorCode.SERVICE_CALL_FAILED,
 
@@ -97,12 +97,17 @@ async def test_input_boolean_full_lifecycle(self, mcp_client, cleanup_tracker):
         )
         list_data = assert_mcp_success(list_result, "List after create")
 
-        found = False
+        found_helper = None
         for helper in list_data.get("helpers", []):
             if helper.get("name") == helper_name:
-                found = True
+                found_helper = helper
                 break
-        assert found, f"Created helper not found in list: {helper_name}"
+        assert found_helper, f"Created helper not found in list: {helper_name}"
+        # #1794: the list joins the entity registry, so each record carries the
+        # current entity_id (not just the storage id / creation name).
+        assert found_helper.get("entity_id") == entity_id, (
+            f"list_helpers should surface the current entity_id, got: {found_helper}"
+        )
         logger.info("Input boolean verified in list")
 
         # UPDATE
@@ -143,6 +148,107 @@ async def test_input_boolean_full_lifecycle(self, mcp_client, cleanup_tracker):
             )
         logger.info("Input boolean deletion verified")
 
+    async def test_renamed_helper_surfaces_current_registry_values(
+        self, mcp_client, cleanup_tracker
+    ):
+        """#1794 regression: after a rename the storage collection keeps the
+        creation-time id/name, while ha_config_list_helpers must surface the
+        registry's current entity_id/name — and that surfaced entity_id must be a
+        working key for ha_config_set_helper.
+
+        A dedicated test rather than an extension of the lifecycle case above:
+        the rename swaps the entity_id, so folding it into that flow would leave
+        its later update/delete steps pointing at the stale id.
+        """
+        original_name = "E2E Rename Join"
+        original_entity_id = "input_boolean.e2e_rename_join"
+        new_entity_id = "input_boolean.e2e_rename_join_renamed"
+        new_name = "E2E Rename Join Renamed"
+
+        # CREATE
+        create_data = assert_mcp_success(
+            await mcp_client.call_tool(
+                "ha_config_set_helper",
+                {"helper_type": "input_boolean", "name": original_name},
+            ),
+            "Create input_boolean",
+        )
+        assert (
+            get_entity_id_from_response(create_data, "input_boolean")
+            == original_entity_id
+        ), f"unexpected creation entity_id: {create_data}"
+        cleanup_tracker.track("input_boolean", new_entity_id)
+        assert await wait_for_entity_registration(mcp_client, original_entity_id), (
+            f"Entity not registered: {original_entity_id}"
+        )
+
+        # RENAME entity_id + display name (diverges the registry from storage)
+        assert_mcp_success(
+            await mcp_client.call_tool(
+                "ha_set_entity",
+                {
+                    "entity_id": original_entity_id,
+                    "new_entity_id": new_entity_id,
+                    "name": new_name,
+                },
+            ),
+            "Rename input_boolean",
+        )
+        assert await wait_for_entity_registration(mcp_client, new_entity_id), (
+            f"Renamed entity not registered: {new_entity_id}"
+        )
+
+        # LIST — the join must surface the renamed entity_id/name; storage keeps
+        # its creation-time id/original_name (the exact divergence #1794 is about).
+        list_data = assert_mcp_success(
+            await mcp_client.call_tool(
+                "ha_config_list_helpers", {"helper_type": "input_boolean"}
+            ),
+            "List after rename",
+        )
+        record = next(
+            (
+                h
+                for h in list_data.get("helpers", [])
+                if h.get("original_name") == original_name
+            ),
+            None,
+        )
+        assert record, f"renamed helper not found by original_name: {list_data}"
+        assert record.get("entity_id") == new_entity_id, (
+            f"list must surface the renamed entity_id, got: {record}"
+        )
+        assert record.get("name") == new_name, (
+            f"list must surface the current display name, got: {record}"
+        )
+        assert record.get("entity_id") != f"input_boolean.{record.get('id')}", (
+            f"entity_id should diverge from the storage-id slug after rename: {record}"
+        )
+
+        # ROUND-TRIP — the surfaced entity_id is the working key for set_helper.
+        assert_mcp_success(
+            await mcp_client.call_tool(
+                "ha_config_set_helper",
+                {
+                    "helper_type": "input_boolean",
+                    "helper_id": record["entity_id"],
+                    "icon": "mdi:check",
+                },
+            ),
+            "Update via surfaced entity_id",
+        )
+        logger.info("Round-tripped set_helper via the surfaced entity_id")
+
+        # CLEANUP
+        await mcp_client.call_tool(
+            "ha_remove_helpers_integrations",
+            {
+                "helper_type": "input_boolean",
+                "target": new_entity_id,
+                "confirm": True,
+            },
+        )
+
     async def test_input_boolean_with_initial_state(self, mcp_client, cleanup_tracker):
         """Test creating input_boolean with initial state."""
         logger.info("Testing input_boolean with initial state")
 
@@ -55,6 +55,21 @@
 # exact #1794 shape (legacy list would emit only the storage id + stale name).
 _LEGACY_ITEMS = [{"id": "abc123", "name": "Old Name", "icon": "mdi:flash"}]
 
+# Entity-registry entry the legacy path joins onto ``_LEGACY_ITEMS`` (#1794):
+# unique_id ``abc123`` on platform ``input_boolean`` currently lives at
+# ``input_boolean.foo`` with display name "New Name". Enriching the legacy list
+# with this yields the same record the component path emits, so the two paths
+# stay parity-equal instead of the legacy body degrading on an unhandled read.
+_LEGACY_REGISTRY = [
+    {
+        "entity_id": "input_boolean.foo",
+        "unique_id": "abc123",
+        "platform": "input_boolean",
+        "name": "New Name",
+        "original_name": "Old Name",
+    }
+]
+
 _CAPS_HELPERS = {
     "schema_version": 1,
     "component_version": "1.1.0",
@@ -106,8 +121,13 @@ def __init__(self) -> None:
         self.list_calls = 0
 
     async def send_websocket_message(self, msg: dict[str, Any]) -> dict[str, Any]:
-        self.list_calls += 1
         msg_type = msg.get("type", "")
+        # The legacy body joins the entity registry (#1794); serve it, but don't
+        # tally it as a {type}/list fetch — the counter tracks the helper-list
+        # round-trip the routing assertions care about.
+        if msg_type == "config/entity_registry/list":
+            return {"success": True, "result": [dict(e) for e in _LEGACY_REGISTRY]}
+        self.list_calls += 1
         if msg_type == "input_boolean/list":
             return {"success": True, "result": [dict(i) for i in _LEGACY_ITEMS]}
         if msg_type == "tag/list":