ha-mcp-dev 7.0.0.dev265__tar.gz → 7.0.0.dev267__tar.gz

{ha_mcp_dev-7.0.0.dev265/src/ha_mcp_dev.egg-info → ha_mcp_dev-7.0.0.dev267}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ha-mcp-dev
-Version: 7.0.0.dev265
+Version: 7.0.0.dev267
 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.0.0.dev265 → ha_mcp_dev-7.0.0.dev267}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ha-mcp-dev"
-version = "7.0.0.dev265"
+version = "7.0.0.dev267"
 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.dev265 → ha_mcp_dev-7.0.0.dev267}/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.dev265 → ha_mcp_dev-7.0.0.dev267}/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.dev265 → ha_mcp_dev-7.0.0.dev267}/src/ha_mcp/tools/device_control.py

@@ -90,7 +90,7 @@ class DeviceControlTools:
                         f"Invalid JSON in parameters: {parameters}",
                         suggestions=[
                             "Parameters should be a valid JSON object",
-                            "Example: {'brightness': 102, 'color_temp': 4000}",
+                            "Example: {'brightness': 102, 'color_temp_kelvin': 4000}",
                         ],
                         context={"entity_id": entity_id, "action": action},
                     ))
@@ -268,12 +268,22 @@ class DeviceControlTools:
         # Add parameters based on domain
         if parameters:
             if domain == "light":
+                # Backward compat: convert deprecated color temp parameters
+                if "color_temp_kelvin" not in parameters:
+                    if "kelvin" in parameters:
+                        parameters["color_temp_kelvin"] = parameters.pop("kelvin")
+                    elif "color_temp" in parameters:
+                        mired_val = parameters.pop("color_temp")
+                        if isinstance(mired_val, (int, float)) and mired_val > 0:
+                            parameters["color_temp_kelvin"] = round(
+                                1_000_000 / mired_val
+                            )
+
                 light_params = [
                     "brightness",
-                    "color_temp",
+                    "color_temp_kelvin",
                     "rgb_color",
                     "effect",
-                    "kelvin",
                 ]
                 for param in light_params:
                     if param in parameters:
@@ -344,8 +354,8 @@ class DeviceControlTools:
             if domain == "light" and action in ["on", "set"]:
                 if "brightness" in parameters:
                     expected["brightness"] = parameters["brightness"]
-                if "color_temp" in parameters:
-                    expected["color_temp"] = parameters["color_temp"]
+                if "color_temp_kelvin" in parameters:
+                    expected["color_temp_kelvin"] = parameters["color_temp_kelvin"]
 
             elif domain == "climate" and action in ["set", "heat", "cool", "auto"]:
                 if "temperature" in parameters:

{ha_mcp_dev-7.0.0.dev265 → ha_mcp_dev-7.0.0.dev267}/src/ha_mcp/tools/tools_services.py

@@ -325,8 +325,8 @@ def _get_field_type(selector: dict[str, Any]) -> str:
     if "datetime" in selector:
         return "datetime"
 
-    if "color_temp" in selector:
-        return "color_temp"
+    if "color_temp" in selector or "color_temp_kelvin" in selector:
+        return "color_temp_kelvin"
 
     if "color_rgb" in selector:
         return "color_rgb"

{ha_mcp_dev-7.0.0.dev265 → ha_mcp_dev-7.0.0.dev267}/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,

{ha_mcp_dev-7.0.0.dev265 → ha_mcp_dev-7.0.0.dev267}/src/ha_mcp/utils/domain_handlers.py

@@ -13,14 +13,19 @@ DOMAIN_HANDLERS = {
         "valid_actions": ["on", "off", "toggle", "set", "adjust"],
         "parameters": [
             "brightness",
-            "color_temp",
+            "color_temp_kelvin",
             "rgb_color",
             "effect",
-            "kelvin",
             "hs_color",
         ],
         "quick_actions": ["toggle", "dim", "brighten"],
-        "state_attributes": ["brightness", "color_temp", "rgb_color"],
+        "state_attributes": [
+            "brightness",
+            "color_temp_kelvin",
+            "min_color_temp_kelvin",
+            "max_color_temp_kelvin",
+            "rgb_color",
+        ],
         "supports_dimming": True,
         "supports_color": True,
     },
@@ -312,8 +317,8 @@ def get_suggested_parameters(domain: str, action: str) -> list[str]:
     # Action-specific parameter suggestions
     action_params = {
         "light": {
-            "set": ["brightness", "color_temp", "rgb_color"],
-            "on": ["brightness", "color_temp"],
+            "set": ["brightness", "color_temp_kelvin", "rgb_color"],
+            "on": ["brightness", "color_temp_kelvin"],
             "adjust": ["brightness"],
         },
         "climate": {

{ha_mcp_dev-7.0.0.dev265 → ha_mcp_dev-7.0.0.dev267/src/ha_mcp_dev.egg-info}/PKG-INFO

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