ha-mcp-dev 7.14.2.dev2188__tar.gz → 7.14.2.dev2190__tar.gz

{ha_mcp_dev-7.14.2.dev2188/src/ha_mcp_dev.egg-info → ha_mcp_dev-7.14.2.dev2190}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ha-mcp-dev
-Version: 7.14.2.dev2188
+Version: 7.14.2.dev2190
 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.14.2.dev2188 → ha_mcp_dev-7.14.2.dev2190}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ha-mcp-dev"
-version = "7.14.2.dev2188"
+version = "7.14.2.dev2190"
 description = "Home Assistant MCP Server - Complete control of Home Assistant through MCP"
 readme = "README.md"
 # Upper bound widened to <3.15 so the package installs on Home Assistant's

{ha_mcp_dev-7.14.2.dev2188 → ha_mcp_dev-7.14.2.dev2190}/src/ha_mcp/client/websocket_listener.py

@@ -9,7 +9,6 @@ import asyncio
 import logging
 from typing import Any
 
-from ..config import get_global_settings
 from ..utils.operation_manager import get_operation_manager, update_pending_operations
 from .websocket_client import HomeAssistantWebSocketClient, get_websocket_client
 
@@ -21,7 +20,6 @@ class WebSocketListenerService:
 
     def __init__(self) -> None:
         """Initialize the WebSocket listener service."""
-        self.settings = get_global_settings()
         self.operation_manager = get_operation_manager()
         self.websocket_client: HomeAssistantWebSocketClient | None = None
         self.listener_task: asyncio.Task | None = None

{ha_mcp_dev-7.14.2.dev2188 → ha_mcp_dev-7.14.2.dev2190}/src/ha_mcp/tools/device_control.py

@@ -301,33 +301,50 @@ class DeviceControlTools:
         action: str,
         parameters: dict[str, Any] | None,
     ) -> tuple[str, dict[str, Any] | None]:
-        service_mapping = {
-            "on": "turn_on",
-            "off": "turn_off",
-            "toggle": "toggle",
-            "open": "open_cover" if domain == "cover" else "turn_on",
-            "close": "close_cover" if domain == "cover" else "turn_off",
-            "set": "turn_on" if domain == "light" else "set_temperature",
-        }
-
-        service_name = service_mapping.get(action, action)
+        if domain == "climate" and action in ("heat", "cool", "auto", "heat_cool"):
+            parameters = dict(parameters or {})
+            parameters["hvac_mode"] = action
+            return "set_hvac_mode", parameters
 
-        if domain == "climate":
-            if action in ["heat", "cool", "auto"]:
-                service_name = "set_hvac_mode"
-                if not parameters:
-                    parameters = {}
-                parameters["hvac_mode"] = action
-            elif action == "set":
-                service_name = "set_temperature"
+        service_name = self._SERVICE_OVERRIDES.get(
+            (domain, action), self._GENERIC_SERVICE_MAP.get(action, action)
+        )
+        return service_name, parameters
 
-        elif domain == "media_player":
-            if action in ["play", "pause", "stop"]:
-                service_name = f"media_{action}"
-            elif action == "set":
-                service_name = "volume_set"
+    # Domain-specific action-to-service mappings; anything not listed
+    # falls through to _GENERIC_SERVICE_MAP, then to the action verbatim.
+    # tests/src/e2e/workflows/device_control/test_action_service_resolution.py
+    # pins every DOMAIN_HANDLERS table entry through this resolver against
+    # a live instance's service list.
+    _SERVICE_OVERRIDES: ClassVar[dict[tuple[str, str], str]] = {
+        ("cover", "open"): "open_cover",
+        ("cover", "close"): "close_cover",
+        ("cover", "stop"): "stop_cover",
+        ("cover", "set"): "set_cover_position",
+        ("light", "set"): "turn_on",
+        # lock.open exists; the generic mapping's turn_on does not.
+        ("lock", "open"): "open",
+        ("climate", "set"): "set_temperature",
+        ("media_player", "play"): "media_play",
+        ("media_player", "pause"): "media_pause",
+        ("media_player", "stop"): "media_stop",
+        ("media_player", "next"): "media_next_track",
+        ("media_player", "previous"): "media_previous_track",
+        ("media_player", "set"): "volume_set",
+        ("alarm_control_panel", "arm_home"): "alarm_arm_home",
+        ("alarm_control_panel", "arm_away"): "alarm_arm_away",
+        ("alarm_control_panel", "arm_night"): "alarm_arm_night",
+        ("alarm_control_panel", "disarm"): "alarm_disarm",
+    }
 
-        return service_name, parameters
+    _GENERIC_SERVICE_MAP: ClassVar[dict[str, str]] = {
+        "on": "turn_on",
+        "off": "turn_off",
+        "toggle": "toggle",
+        "open": "turn_on",
+        "close": "turn_off",
+        "set": "set_temperature",
+    }
 
     _DOMAIN_PARAMS: ClassVar[dict[str, list[str]]] = {
         "light": ["brightness", "color_temp_kelvin", "rgb_color", "effect"],
@@ -1274,13 +1291,20 @@ class DeviceControlTools:
         return response
 
     async def get_bulk_operation_status(
-        self, operation_ids: list[str]
+        self, operation_ids: list[str], timeout_seconds: int = 10
     ) -> dict[str, Any]:
         """
         Check status of multiple operations.
 
+        Polls all operations concurrently under one shared
+        ``timeout_seconds`` window, so the wall time is bounded by the
+        window rather than growing with the batch size. Per-item failures
+        become structured entries in ``detailed_results`` rather than
+        aborting the batch.
+
         Args:
             operation_ids: List of operation IDs to check
+            timeout_seconds: Wait window applied to every operation
 
         Returns:
             Status summary for all operations
@@ -1296,26 +1320,69 @@ class DeviceControlTools:
                 )
             )
 
-        # Check all operations
-        statuses = []
-        for op_id in operation_ids:
-            status = await self.get_device_operation_status(op_id)
-            statuses.append(status)
+        # Check all operations concurrently under one shared wait window.
+        # Per-item failures must not abort the batch: get_device_operation_status
+        # raises ToolError for failed / timed-out / not-found operations, so each
+        # one is caught and folded back into detailed_results as a structured
+        # entry — otherwise the first bad operation would discard the status of
+        # every other one. The whole parsed error payload is preserved (context
+        # keys like entity_id / duration_ms sit at its top level), with the
+        # batch "status" field layered on for the summary counts.
+        error_code_to_status = {
+            ErrorCode.SERVICE_CALL_FAILED.value: "failed",
+            ErrorCode.TIMEOUT_OPERATION.value: "timeout",
+            ErrorCode.RESOURCE_NOT_FOUND.value: "not_found",
+        }
+
+        async def check_one(op_id: str) -> dict[str, Any]:
+            try:
+                return await self.get_device_operation_status(
+                    op_id, timeout_seconds=timeout_seconds
+                )
+            except ToolError as e:
+                try:
+                    err = json.loads(str(e))
+                except ValueError:
+                    err = {"success": False, "error": {"message": str(e)}}
+                error_info = err.get("error") or {}
+                return {
+                    **err,
+                    "operation_id": op_id,
+                    "status": error_code_to_status.get(
+                        error_info.get("code", ""), "failed"
+                    ),
+                }
+
+        statuses = list(
+            await asyncio.gather(*(check_one(op_id) for op_id in operation_ids))
+        )
 
         # Summarize results
         completed = len([s for s in statuses if s.get("status") == "completed"])
         failed = len([s for s in statuses if s.get("status") in ["failed", "timeout"]])
+        not_found = len([s for s in statuses if s.get("status") == "not_found"])
         pending = len([s for s in statuses if s.get("status") == "pending"])
 
+        # The batch call itself succeeded; per-item failures live inside
+        # detailed_results (batch-item pattern). Top-level ``success`` is
+        # the repo-wide response contract every tool return carries.
         return {
+            "success": True,
             "total_operations": len(operation_ids),
             "completed": completed,
             "failed": failed,
+            "not_found": not_found,
             "pending": pending,
             "all_complete": pending == 0,
             "summary": {
                 "success_rate": f"{completed}/{len(operation_ids)}",
-                "completion_percentage": (completed / len(operation_ids)) * 100,
+                # Terminal fraction (nothing left in flight) — consistent
+                # with all_complete; success_rate carries the successful
+                # fraction separately.
+                "completion_percentage": (
+                    (completed + failed + not_found) / len(operation_ids)
+                )
+                * 100,
             },
             "detailed_results": statuses,
             "recommendations": (
@@ -1324,7 +1391,7 @@ class DeviceControlTools:
                     "Check failed operations for specific error messages",
                     "Retry failed operations with different parameters if needed",
                 ]
-                if pending > 0 or failed > 0
+                if pending > 0 or failed > 0 or not_found > 0
                 else ["All operations completed successfully!"]
             ),
         }

{ha_mcp_dev-7.14.2.dev2188 → ha_mcp_dev-7.14.2.dev2190}/src/ha_mcp/tools/tools_service.py

@@ -1385,13 +1385,15 @@ class ServiceTools:
         timeout_seconds: int = 10,
     ) -> dict[str, Any]:
         """
-        Check status of one or more device operations with real-time WebSocket verification.
+        Get the status of one or more device operations with real-time WebSocket verification.
 
         Pass a single operation_id string to check one operation, or a list of IDs
         to check multiple operations at once (bulk status).
 
-        The timeout_seconds parameter applies to single-operation checks only.
-        Bulk checks poll each operation individually with a short internal timeout.
+        The timeout_seconds wait window bounds both modes. Bulk checks poll
+        all operations concurrently under one shared window and report
+        per-item failures inside detailed_results instead of aborting the
+        batch.
 
         Use this to track operations initiated by ha_bulk_control or ha_call_service.
         For current entity states, use ha_get_state instead.
@@ -1401,7 +1403,7 @@ class ServiceTools:
             # before the body runs, so operation_id is already the final shape.
             if isinstance(operation_id, list):
                 result = await self._device_tools.get_bulk_operation_status(
-                    operation_ids=operation_id
+                    operation_ids=operation_id, timeout_seconds=timeout_seconds
                 )
                 return cast(dict[str, Any], result)
             result = await self._device_tools.get_device_operation_status(

{ha_mcp_dev-7.14.2.dev2188 → ha_mcp_dev-7.14.2.dev2190}/src/ha_mcp/tools/util_helpers.py

@@ -77,43 +77,14 @@ def summarize_theme_listing(raw_themes: dict[str, Any]) -> dict[str, Any]:
     }
 
 
-def strip_internal_fields(obj: Any, _seen: set[int] | None = None) -> Any:
-    """Remove leading-underscore keys from ``obj`` and any nested dicts
-    or lists in place.
+def public_fields(d: dict[str, Any]) -> dict[str, Any]:
+    """Return a shallow copy of ``d`` with leading-underscore keys removed.
 
     The ha-mcp tool layer enriches entity / area dicts with internal
     fields like ``_hidden_by`` and ``_aliases`` so downstream branches
     can rank without re-querying the entity registry. Those keys must
     not leak through public tool returns: this helper centralises the
     convention so individual call sites don't have to remember to strip.
-
-    Mutates in place and returns the same reference for chaining. Cycle
-    guard via ``_seen`` (id-tracked) keeps the recursion safe if a
-    future caller ever feeds it a non-tree structure — JSON payloads
-    don't, but the helper is now a generic utility (importable from
-    ``server.py``) so the protection is cheap insurance.
-    """
-    if _seen is None:
-        _seen = set()
-    obj_id = id(obj)
-    if obj_id in _seen:
-        return obj
-    if isinstance(obj, dict):
-        _seen.add(obj_id)
-        for key in [k for k in obj if isinstance(k, str) and k.startswith("_")]:
-            obj.pop(key, None)
-        for value in obj.values():
-            strip_internal_fields(value, _seen)
-    elif isinstance(obj, list):
-        _seen.add(obj_id)
-        for item in obj:
-            strip_internal_fields(item, _seen)
-    return obj
-
-
-def public_fields(d: dict[str, Any]) -> dict[str, Any]:
-    """Return a shallow copy of ``d`` with leading-underscore keys
-    removed. Non-mutating counterpart to :func:`strip_internal_fields`.
     Shallow only — list/dict values are shared with the source, so a
     later mutation of those values would propagate.
     """

{ha_mcp_dev-7.14.2.dev2188 → ha_mcp_dev-7.14.2.dev2190}/src/ha_mcp/utils/domain_handlers.py

@@ -10,7 +10,7 @@ from typing import Any
 # Domain-specific handler configurations
 DOMAIN_HANDLERS = {
     "light": {
-        "valid_actions": ["on", "off", "toggle", "set", "adjust"],
+        "valid_actions": ["on", "off", "toggle", "set"],
         "parameters": [
             "brightness",
             "color_temp_kelvin",
@@ -30,7 +30,16 @@ DOMAIN_HANDLERS = {
         "supports_color": True,
     },
     "climate": {
-        "valid_actions": ["on", "off", "set", "heat", "cool", "auto", "heat_cool"],
+        "valid_actions": [
+            "on",
+            "off",
+            "toggle",
+            "set",
+            "heat",
+            "cool",
+            "auto",
+            "heat_cool",
+        ],
         "parameters": [
             "temperature",
             "target_temp_high",
@@ -60,7 +69,17 @@ DOMAIN_HANDLERS = {
         "supports_color": False,
     },
     "media_player": {
-        "valid_actions": ["play", "pause", "stop", "toggle", "set", "next", "previous"],
+        "valid_actions": [
+            "on",
+            "off",
+            "play",
+            "pause",
+            "stop",
+            "toggle",
+            "set",
+            "next",
+            "previous",
+        ],
         "parameters": [
             "volume_level",
             "media_content_id",
@@ -73,7 +92,7 @@ DOMAIN_HANDLERS = {
         "supports_media": True,
     },
     "fan": {
-        "valid_actions": ["on", "off", "toggle", "set"],
+        "valid_actions": ["on", "off", "toggle"],
         # HA removed the legacy `speed` param / `fan.set_speed` service in the
         # 2021-2022 percentage migration (absent in 2026.6). Use percentage
         # (fan.set_percentage) and preset_mode (fan.set_preset_mode).
@@ -116,7 +135,7 @@ DOMAIN_HANDLERS = {
         "supports_modes": True,
     },
     "humidifier": {
-        "valid_actions": ["on", "off", "toggle", "set"],
+        "valid_actions": ["on", "off", "toggle"],
         "parameters": ["humidity", "mode"],
         "quick_actions": ["toggle", "humidity_up", "humidity_down"],
         "state_attributes": ["current_humidity", "target_humidity"],
@@ -124,7 +143,7 @@ DOMAIN_HANDLERS = {
         "supports_modes": True,
     },
     "camera": {
-        "valid_actions": ["snapshot", "record", "stream"],
+        "valid_actions": ["on", "off", "snapshot", "record"],
         "parameters": ["filename", "duration"],
         "quick_actions": ["take_snapshot"],
         "state_attributes": ["entity_picture", "access_token"],
@@ -132,7 +151,7 @@ DOMAIN_HANDLERS = {
         "supports_recording": True,
     },
     "scene": {
-        "valid_actions": ["turn_on", "activate"],
+        "valid_actions": ["on", "turn_on"],
         "parameters": [],
         "quick_actions": ["activate"],
         "state_attributes": ["state"],
@@ -140,7 +159,7 @@ DOMAIN_HANDLERS = {
         "action_only": True,
     },
     "script": {
-        "valid_actions": ["turn_on", "turn_off", "toggle"],
+        "valid_actions": ["on", "off", "toggle", "turn_on", "turn_off"],
         "parameters": [],
         "quick_actions": ["run", "stop"],
         "state_attributes": ["state"],
@@ -148,7 +167,7 @@ DOMAIN_HANDLERS = {
         "can_be_stopped": True,
     },
     "automation": {
-        "valid_actions": ["turn_on", "turn_off", "toggle", "trigger"],
+        "valid_actions": ["on", "off", "toggle", "turn_on", "turn_off", "trigger"],
         "parameters": [],
         "quick_actions": ["enable", "disable", "trigger"],
         "state_attributes": ["state", "last_triggered"],
@@ -192,20 +211,20 @@ DOMAIN_HANDLERS = {
 }
 
 
-def get_domain_handler(entity_id: str) -> dict[str, Any]:
-    """Get domain-specific configuration for an entity.
+def get_domain_handler(entity_or_domain: str) -> dict[str, Any]:
+    """Get domain-specific configuration for an entity ID or bare domain.
 
     Args:
-        entity_id: Full entity ID (e.g., 'light.living_room')
+        entity_or_domain: Full entity ID ('light.living_room') or bare
+            domain ('light'). Both call sites in device_control pass the
+            bare domain — the old dot-guard sent those to the default
+            handler, making every per-domain valid_actions table
+            unreachable (e.g. climate's 'heat' was rejected upfront).
 
     Returns:
         Domain handler configuration dictionary
     """
-    if "." not in entity_id:
-        # Fallback for invalid entity ID format
-        return get_default_handler()
-
-    domain = entity_id.split(".", maxsplit=1)[0]
+    domain = entity_or_domain.split(".", maxsplit=1)[0] if entity_or_domain else ""
     return DOMAIN_HANDLERS.get(domain, get_default_handler())
 
 

{ha_mcp_dev-7.14.2.dev2188 → ha_mcp_dev-7.14.2.dev2190}/src/ha_mcp/utils/operation_manager.py

@@ -23,7 +23,6 @@ class OperationStatus(Enum):
     COMPLETED = "completed"
     FAILED = "failed"
     TIMEOUT = "timeout"
-    CANCELLED = "cancelled"
 
 
 @dataclass
@@ -286,42 +285,51 @@ class OperationManager:
 
         initial_count = len(self.operations)
 
-        # Remove completed operations older than 5 minutes
-        # Remove failed/cancelled operations older than 1 minute
+        # Remove completed operations 5 minutes after completion
+        # Remove failed/timed-out operations 1 minute after completion
+        # (TIMEOUT can be set outside this pass: get_operation() marks an
+        # expired PENDING op in place on the read path — anchoring the TTL
+        # on completion_time keeps such an op queryable for its full
+        # terminal minute even when it timed out long after start_time)
         # Remove expired pending operations
         to_remove = []
 
         for op_id, operation in self.operations.items():
-            age_seconds = (current_time * 1000 - operation.start_time) / 1000
+            terminal_anchor = operation.completion_time or operation.start_time
+            age_seconds = (current_time * 1000 - terminal_anchor) / 1000
 
             if (
                 operation.status == OperationStatus.COMPLETED and age_seconds > 300
             ) or (
-                operation.status in [OperationStatus.FAILED, OperationStatus.CANCELLED]
+                operation.status in (OperationStatus.FAILED, OperationStatus.TIMEOUT)
                 and age_seconds > 60
             ):
                 to_remove.append(op_id)
             elif operation.status == OperationStatus.PENDING and operation.is_expired:
-                # Mark as timeout first
+                # Mark as timeout and KEEP it for the terminal minute — same
+                # treatment as a read-path timeout, so a poll shortly after
+                # expiry reports "timeout" rather than not_found regardless
+                # of which path noticed first. The TTL branch above reclaims
+                # it once completion_time is a minute old.
                 operation.status = OperationStatus.TIMEOUT
                 operation.completion_time = current_time * 1000
-                to_remove.append(op_id)
 
         # Remove operations
         for op_id in to_remove:
             del self.operations[op_id]
 
-        # If still over limit, remove oldest completed operations
+        # If still over limit, remove oldest terminal operations (never
+        # in-flight PENDING ones — those expire on their own timeout).
         if len(self.operations) > self.max_operations:
-            completed_ops = [
+            terminal_ops = [
                 (op_id, op)
                 for op_id, op in self.operations.items()
-                if op.status == OperationStatus.COMPLETED
+                if op.status != OperationStatus.PENDING
             ]
-            completed_ops.sort(key=lambda x: x[1].completion_time or 0)
+            terminal_ops.sort(key=lambda x: x[1].completion_time or 0)
 
             excess = len(self.operations) - self.max_operations
-            for op_id, _ in completed_ops[:excess]:
+            for op_id, _ in terminal_ops[:excess]:
                 del self.operations[op_id]
 
         removed_count = initial_count - len(self.operations)

{ha_mcp_dev-7.14.2.dev2188 → ha_mcp_dev-7.14.2.dev2190/src/ha_mcp_dev.egg-info}/PKG-INFO

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