ha-mcp-dev 7.0.0.dev264__tar.gz → 7.0.0.dev266__tar.gz

{ha_mcp_dev-7.0.0.dev264/src/ha_mcp_dev.egg-info → ha_mcp_dev-7.0.0.dev266}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ha-mcp-dev
-Version: 7.0.0.dev264
+Version: 7.0.0.dev266
 Summary: Home Assistant MCP Server - Complete control of Home Assistant through MCP
 Author-email: Julien <github@qc-h.net>
 License: MIT
@@ -159,7 +159,7 @@ Spend less time configuring, more time enjoying your smart home.
 | **💾 System** | Backup/restore, updates, add-ons, device registry |
 
 <details>
-<summary><b>🛠️ Complete Tool List (97 tools)</b></summary>
+<summary><b>🛠️ Complete Tool List (96 tools)</b></summary>
 
 | Category | Tools |
 |----------|-------|
@@ -171,7 +171,7 @@ Spend less time configuring, more time enjoying your smart home.
 | **Dashboards** | `ha_config_get_dashboard`, `ha_config_set_dashboard`, `ha_config_delete_dashboard`, `ha_get_dashboard_guide`, `ha_get_card_documentation` |
 | **Areas & Floors** | `ha_config_list_areas`, `ha_config_set_area`, `ha_config_remove_area`, `ha_config_list_floors`, `ha_config_set_floor`, `ha_config_remove_floor` |
 | **Labels** | `ha_config_get_label`, `ha_config_set_label`, `ha_config_remove_label`, `ha_manage_entity_labels` |
-| **Zones** | `ha_get_zone`, `ha_create_zone`, `ha_update_zone`, `ha_delete_zone` |
+| **Zones** | `ha_get_zone`, `ha_set_zone`, `ha_remove_zone` |
 | **Groups** | `ha_config_list_groups`, `ha_config_set_group`, `ha_config_remove_group` |
 | **Todo Lists** | `ha_get_todo`, `ha_add_todo_item`, `ha_update_todo_item`, `ha_remove_todo_item` |
 | **Calendar** | `ha_config_get_calendar_events`, `ha_config_set_calendar_event`, `ha_config_remove_calendar_event` |

{ha_mcp_dev-7.0.0.dev264 → ha_mcp_dev-7.0.0.dev266}/README.md

@@ -129,7 +129,7 @@ Spend less time configuring, more time enjoying your smart home.
 | **💾 System** | Backup/restore, updates, add-ons, device registry |
 
 <details>
-<summary><b>🛠️ Complete Tool List (97 tools)</b></summary>
+<summary><b>🛠️ Complete Tool List (96 tools)</b></summary>
 
 | Category | Tools |
 |----------|-------|
@@ -141,7 +141,7 @@ Spend less time configuring, more time enjoying your smart home.
 | **Dashboards** | `ha_config_get_dashboard`, `ha_config_set_dashboard`, `ha_config_delete_dashboard`, `ha_get_dashboard_guide`, `ha_get_card_documentation` |
 | **Areas & Floors** | `ha_config_list_areas`, `ha_config_set_area`, `ha_config_remove_area`, `ha_config_list_floors`, `ha_config_set_floor`, `ha_config_remove_floor` |
 | **Labels** | `ha_config_get_label`, `ha_config_set_label`, `ha_config_remove_label`, `ha_manage_entity_labels` |
-| **Zones** | `ha_get_zone`, `ha_create_zone`, `ha_update_zone`, `ha_delete_zone` |
+| **Zones** | `ha_get_zone`, `ha_set_zone`, `ha_remove_zone` |
 | **Groups** | `ha_config_list_groups`, `ha_config_set_group`, `ha_config_remove_group` |
 | **Todo Lists** | `ha_get_todo`, `ha_add_todo_item`, `ha_update_todo_item`, `ha_remove_todo_item` |
 | **Calendar** | `ha_config_get_calendar_events`, `ha_config_set_calendar_event`, `ha_config_remove_calendar_event` |

{ha_mcp_dev-7.0.0.dev264 → ha_mcp_dev-7.0.0.dev266}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ha-mcp-dev"
-version = "7.0.0.dev264"
+version = "7.0.0.dev266"
 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.0.0.dev264 → ha_mcp_dev-7.0.0.dev266}/src/ha_mcp/client/rest_client.py

@@ -830,91 +830,43 @@ class HomeAssistantClient:
         self, ws_client: Any, message: dict[str, Any]
     ) -> dict[str, Any]:
         """Handle render_template WebSocket command with event-based response."""
-
-        # Generate our own message ID to track the response
-        message_id = ws_client.get_next_message_id()
-
-        # Construct the full message with proper ID
-        full_message = {
-            "id": message_id,
-            "type": "render_template",
-            "template": message.get("template"),
-            "timeout": message.get("timeout", 3),
-            "report_errors": message.get("report_errors", True),
-        }
-
-        # Create futures for both result and event responses
-        result_future = ws_client.register_pending_response(message_id)
-        event_future = ws_client.register_render_template_event(message_id)
-
-        # Use WebSocket client's send helper to transmit the message
-        try:
-            await ws_client.send_json_message(full_message)
-        except Exception as e:
-            ws_client.cancel_pending_response(message_id)
-            ws_client.cancel_render_template_event(message_id)
-            raise e
+        template_timeout = message.get("timeout", 3)
 
         try:
-            # Wait for the initial result response (should be success with null result)
-            result_response = await asyncio.wait_for(
-                result_future, timeout=message.get("timeout", 3) + 2
+            _, event_response = await ws_client.send_command_with_event(
+                "render_template",
+                wait_timeout=template_timeout + 2,
+                template=message.get("template"),
+                timeout=template_timeout,
+                report_errors=message.get("report_errors", True),
             )
-            logger.debug(f"WebSocket render_template result: {result_response}")
+            logger.debug(f"WebSocket render_template event: {event_response}")
+
+            # Extract template result from event
+            if "event" in event_response and "result" in event_response["event"]:
+                template_result = event_response["event"]["result"]
+                listeners_info = event_response["event"].get("listeners", {})
 
-            if not result_response.get("success"):
-                ws_client.cancel_render_template_event(message_id)
-                error = result_response.get("error", "Unknown error")
                 return {
-                    "success": False,
-                    "error": str(error),
+                    "success": True,
+                    "result": template_result,
                     "template": message.get("template"),
+                    "listeners": listeners_info,
                 }
-
-            # Wait for the event with the actual template result
-            try:
-                event_response = await asyncio.wait_for(
-                    event_future, timeout=message.get("timeout", 3) + 1
-                )
-                logger.debug(f"WebSocket render_template event: {event_response}")
-
-                # Extract template result from event
-                if "event" in event_response and "result" in event_response["event"]:
-                    template_result = event_response["event"]["result"]
-                    listeners_info = event_response["event"].get("listeners", {})
-
-                    return {
-                        "success": True,
-                        "result": template_result,
-                        "template": message.get("template"),
-                        "listeners": listeners_info,
-                    }
-                else:
-                    return {
-                        "success": False,
-                        "error": "Invalid event response format",
-                        "template": message.get("template"),
-                    }
-
-            except TimeoutError:
-                ws_client.cancel_render_template_event(message_id)
+            else:
                 return {
                     "success": False,
-                    "error": "Event timeout - template result not received",
+                    "error": "Invalid event response format",
                     "template": message.get("template"),
                 }
 
         except TimeoutError:
-            ws_client.cancel_pending_response(message_id)
-            ws_client.cancel_render_template_event(message_id)
             return {
                 "success": False,
-                "error": "Command timeout",
+                "error": "Event timeout - template result not received",
                 "template": message.get("template"),
             }
         except Exception as e:
-            ws_client.cancel_pending_response(message_id)
-            ws_client.cancel_render_template_event(message_id)
             return {
                 "success": False,
                 "error": str(e),

{ha_mcp_dev-7.0.0.dev264 → ha_mcp_dev-7.0.0.dev266}/src/ha_mcp/client/websocket_client.py

@@ -33,7 +33,7 @@ class WebSocketConnectionState:
         self._message_id = 0
         self._pending_requests: dict[int, asyncio.Future[dict[str, Any]]] = {}
         self._auth_messages: dict[str, dict[str, Any]] = {}
-        self._render_template_events: dict[int, asyncio.Future[dict[str, Any]]] = {}
+        self._event_responses: dict[int, asyncio.Future[dict[str, Any]]] = {}
         self._event_handlers: dict[
             str, set[Callable[[dict[str, Any]], Awaitable[None]]]
         ] = defaultdict(set)
@@ -64,25 +64,25 @@ class WebSocketConnectionState:
         if future and not future.done():
             future.cancel()
 
-    def register_render_template_event(
+    def register_event_response(
         self, message_id: int
     ) -> asyncio.Future[dict[str, Any]]:
-        """Create and register a future for a render_template follow-up event."""
+        """Create and register a future for a follow-up event."""
         future: asyncio.Future[dict[str, Any]] = (
             asyncio.get_running_loop().create_future()
         )
-        self._render_template_events[message_id] = future
+        self._event_responses[message_id] = future
         return future
 
-    def resolve_render_template_event(
+    def resolve_event_response(
         self, message_id: int
     ) -> asyncio.Future[dict[str, Any]] | None:
-        """Resolve a stored render_template event future."""
-        return self._render_template_events.pop(message_id, None)
+        """Resolve a stored event future."""
+        return self._event_responses.pop(message_id, None)
 
-    def cancel_render_template_event(self, message_id: int) -> None:
-        """Cancel a stored render_template event future."""
-        future = self._render_template_events.pop(message_id, None)
+    def cancel_event_response(self, message_id: int) -> None:
+        """Cancel a stored event future."""
+        future = self._event_responses.pop(message_id, None)
         if future and not future.done():
             future.cancel()
 
@@ -105,10 +105,10 @@ class WebSocketConnectionState:
                 future.cancel()
         self._pending_requests.clear()
 
-        for future in self._render_template_events.values():
+        for future in self._event_responses.values():
             if not future.done():
                 future.cancel()
-        self._render_template_events.clear()
+        self._event_responses.clear()
 
         self._auth_messages.clear()
 
@@ -325,7 +325,7 @@ class HomeAssistantWebSocketClient:
         # Handle events
         if message_type == "event":
             if message_id is not None:
-                render_future = self._state.resolve_render_template_event(message_id)
+                render_future = self._state.resolve_event_response(message_id)
                 if render_future:
                     if not render_future.cancelled():
                         render_future.set_result(data)
@@ -384,15 +384,15 @@ class HomeAssistantWebSocketClient:
         """Cancel and drop a pending response future."""
         self._state.cancel_pending_request(message_id)
 
-    def register_render_template_event(
+    def register_event_response(
         self, message_id: int
     ) -> asyncio.Future[dict[str, Any]]:
-        """Register a future for a render_template follow-up event."""
-        return self._state.register_render_template_event(message_id)
+        """Register a future for a follow-up event."""
+        return self._state.register_event_response(message_id)
 
-    def cancel_render_template_event(self, message_id: int) -> None:
-        """Cancel and drop a stored render_template event future."""
-        self._state.cancel_render_template_event(message_id)
+    def cancel_event_response(self, message_id: int) -> None:
+        """Cancel and drop a stored event future."""
+        self._state.cancel_event_response(message_id)
 
     async def send_command(self, command_type: str, **kwargs: Any) -> dict[str, Any]:
         """Send command and wait for response.
@@ -457,6 +457,71 @@ class HomeAssistantWebSocketClient:
             self.cancel_pending_response(message_id)
             raise
 
+    async def send_command_with_event(
+        self,
+        command_type: str,
+        wait_timeout: float = 10.0,
+        **kwargs: Any,
+    ) -> tuple[dict[str, Any], dict[str, Any]]:
+        """Send a command that returns a result followed by an event response.
+
+        Some HA WebSocket commands (e.g. system_health/info, render_template)
+        reply with an immediate result message and then deliver the actual data
+        in a subsequent event message sharing the same message ID.
+
+        Args:
+            command_type: Type of command to send.
+            wait_timeout: Seconds to wait for each response phase.
+            **kwargs: Additional fields merged into the outgoing message.
+
+        Returns:
+            A (result_response, event_response) tuple.
+        """
+        if not self._state.is_ready:
+            raise Exception("WebSocket not authenticated")
+
+        message_id = self.get_next_message_id()
+        message = {"id": message_id, "type": command_type, **kwargs}
+
+        result_future = self.register_pending_response(message_id)
+        event_future = self.register_event_response(message_id)
+
+        try:
+            await self.send_json_message(message)
+        except Exception:
+            self.cancel_pending_response(message_id)
+            self.cancel_event_response(message_id)
+            raise
+
+        try:
+            result_response = await asyncio.wait_for(
+                result_future, timeout=wait_timeout
+            )
+        except TimeoutError:
+            self.cancel_pending_response(message_id)
+            self.cancel_event_response(message_id)
+            raise
+
+        if not result_response.get("success"):
+            self.cancel_event_response(message_id)
+            error = result_response.get("error", {})
+            error_msg = (
+                error.get("message", str(error))
+                if isinstance(error, dict)
+                else str(error)
+            )
+            raise Exception(f"Command failed: {error_msg}")
+
+        try:
+            event_response = await asyncio.wait_for(
+                event_future, timeout=wait_timeout
+            )
+        except TimeoutError:
+            self.cancel_event_response(message_id)
+            raise
+
+        return result_response, event_response
+
     async def subscribe_events(self, event_type: str | None = None) -> int:
         """Subscribe to Home Assistant events.
 

{ha_mcp_dev-7.0.0.dev264 → ha_mcp_dev-7.0.0.dev266}/src/ha_mcp/tools/tools_system.py

@@ -333,16 +333,23 @@ def register_system_tools(mcp: Any, client: Any, **kwargs: Any) -> None:
                     "Failed to connect to Home Assistant WebSocket",
                 ))
 
-            # Request system health info via WebSocket
-            health_response = await ws_client.send_command("system_health/info")
-
-            if not health_response.get("success"):
+            # system_health/info returns a result + follow-up event
+            try:
+                _, event_response = await ws_client.send_command_with_event(
+                    "system_health/info", wait_timeout=10.0
+                )
+            except TimeoutError:
+                raise_tool_error(create_error_response(
+                    ErrorCode.SERVICE_CALL_FAILED,
+                    "Timeout waiting for system health data",
+                ))
+            except Exception as e:
                 raise_tool_error(create_error_response(
                     ErrorCode.SERVICE_CALL_FAILED,
-                    health_response.get("error", "Failed to retrieve system health"),
+                    str(e),
                 ))
 
-            health_info = health_response.get("result") or {}
+            health_info = event_response.get("event", {})
 
             return {
                 "success": True,