fix(entities): refetch entity state after exposure so the response reflects new should_expose (#1697)

* fix(entities): refetch entity state after exposure so the response reflects new should_expose

When a phase before exposure already populated entity_entry (a registry
field update, an options update, or a device rename), the post-exposure
refetch in _apply_expose_to was gated on `if not entity_entry` and was
therefore skipped, so ha_set_entity returned the pre-exposure snapshot --
its options[...].should_expose did not reflect the exposure just applied.
The exposure was always applied correctly; only the returned entity was
stale.

Refetch now also fires when exposure was applied (exposure_result is not
None). Pure expose_to-only calls are unchanged. Regression from #1692.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* fix(entities): don't fail ha_set_entity when the cosmetic post-exposure refetch fails

PR review of the refetch surfaced three issues, all fixed here:
- A failed post-exposure refetch could turn a fully-committed combined call
  (registry/options/device-rename + expose) into a reported ENTITY_NOT_FOUND.
  When a prior phase already produced a snapshot, warn and return it instead.
- The failure swallowed the real WebSocket error and hard-coded "not found";
  now surfaces _extract_ws_error + has_registry_updates/options_succeeded.
- Removed the dead `or not entity_entry` clause.

Tests added for the fallback and the options-only / new_device_name combos.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* refactor(entities): make post-exposure refetch unconditional

The `if exposure_result is not None` guard is always True at that point
(empty expose_to returns early; any exposure failure raises above), so the
refetch is now unconditional, per Gemini review feedback on #1697. Adds
test_expose_hide_only_still_refetches to pin that a hide-only expose
(should_expose=False, a truthy {assistant: False} result) still refetches.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

---------

Co-authored-by: kingpanther13 <kingpanther13@users.noreply.github.com>
Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: kingpanther13

src/ha_mcp/tools/tools_entities.py

@@ -745,30 +745,45 @@ async def _apply_expose_to(
 
         exposure_result: dict[str, bool] | None = succeeded if succeeded else None
 
-        # If no prior phase populated entity_entry, fetch current entity state
-        if not entity_entry:
-            get_msg: dict[str, Any] = {
-                "type": "config/entity_registry/get",
-                "entity_id": entity_id,
-            }
-            get_result = await self._client.send_websocket_message(get_msg)
-            if get_result.get("success"):
-                entity_entry = get_result.get("result") or {}
-            else:
-                raise_tool_error(
-                    create_error_response(
-                        ErrorCode.ENTITY_NOT_FOUND,
-                        f"Entity '{entity_id}' not found in registry after applying exposure changes",
-                        context={
-                            "entity_id": entity_id,
-                            "exposure_succeeded": exposure_result,
-                        },
-                        suggestions=[
-                            "Verify the entity_id exists using ha_search()",
-                            "The entity's exposure settings were likely changed, but its current state could not be confirmed.",
-                        ],
-                    )
+        # Exposure mutates the registry entry's options, so refetch to return the
+        # post-exposure state. This is unconditional: the method returns early on
+        # an empty expose_to (line 695) and any exposure failure already raised
+        # above, so reaching here always means at least one exposure was applied.
+        get_msg: dict[str, Any] = {
+            "type": "config/entity_registry/get",
+            "entity_id": entity_id,
+        }
+        get_result = await self._client.send_websocket_message(get_msg)
+        if get_result.get("success"):
+            entity_entry = get_result.get("result") or {}
+        elif entity_entry:
+            # The exposure already committed; only the cosmetic post-exposure
+            # refresh failed. Keep the pre-exposure snapshot and warn rather
+            # than reporting the whole (successful) operation as a failure.
+            logger.warning(
+                f"Exposure applied to {entity_id} but its registry state could "
+                f"not be refreshed: {_extract_ws_error(get_result)}"
+            )
+        else:
+            # No prior-phase snapshot to fall back on -- surface the read
+            # failure with the actual WebSocket error.
+            raise_tool_error(
+                create_error_response(
+                    ErrorCode.ENTITY_NOT_FOUND,
+                    f"Entity '{entity_id}' could not be read after applying "
+                    f"exposure changes: {_extract_ws_error(get_result)}",
+                    context={
+                        "entity_id": entity_id,
+                        "exposure_succeeded": exposure_result,
+                        "has_registry_updates": has_registry_updates,
+                        "options_succeeded": options_succeeded,
+                    },
+                    suggestions=[
+                        "Verify the entity_id exists using ha_search()",
+                        "The entity's exposure settings were likely changed, but its current state could not be confirmed.",
+                    ],
                 )
+            )
 
         return exposure_result, entity_entry