ha-mcp-dev 7.12.3.dev1895__tar.gz → 7.12.3.dev1901__tar.gz

{ha_mcp_dev-7.12.3.dev1895/src/ha_mcp_dev.egg-info → ha_mcp_dev-7.12.3.dev1901}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ha-mcp-dev
-Version: 7.12.3.dev1895
+Version: 7.12.3.dev1901
 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.12.3.dev1895 → ha_mcp_dev-7.12.3.dev1901}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ha-mcp-dev"
-version = "7.12.3.dev1895"
+version = "7.12.3.dev1901"
 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
@@ -176,9 +176,7 @@ ignore = [
 "packaging/mcpb/generate_manifest.py" = ["C901"]
 "scripts/extract_tools.py" = ["C901"]
 "src/ha_mcp/backup_manager.py" = ["C901"]
-"src/ha_mcp/client/rest_client.py" = ["C901"]
 "src/ha_mcp/config.py" = ["C901"]
-"src/ha_mcp/policy/evaluator.py" = ["C901"]
 "src/ha_mcp/policy/handlers.py" = ["C901"]
 "src/ha_mcp/server.py" = ["C901"]
 "src/ha_mcp/settings_ui/__init__.py" = ["C901"]
@@ -188,7 +186,6 @@ ignore = [
 "src/ha_mcp/tools/radio/zigbee.py" = ["C901"]
 "src/ha_mcp/tools/radio/zwave.py" = ["C901"]
 "src/ha_mcp/tools/reference_validator.py" = ["C901"]
-"src/ha_mcp/tools/tools_addons.py" = ["C901"]
 "src/ha_mcp/tools/tools_areas.py" = ["C901"]
 "src/ha_mcp/tools/tools_code.py" = ["C901"]
 "src/ha_mcp/tools/tools_config_automations.py" = ["C901"]
@@ -196,18 +193,13 @@ ignore = [
 "src/ha_mcp/tools/tools_config_scripts.py" = ["C901"]
 "src/ha_mcp/tools/tools_dev.py" = ["C901"]
 "src/ha_mcp/tools/tools_energy.py" = ["C901"]
-"src/ha_mcp/tools/tools_hacs.py" = ["C901"]
 "src/ha_mcp/tools/tools_history.py" = ["C901"]
 "src/ha_mcp/tools/tools_integrations.py" = ["C901"]
 "src/ha_mcp/tools/tools_system.py" = ["C901"]
-"src/ha_mcp/tools/tools_traces.py" = ["C901"]
-"src/ha_mcp/tools/tools_updates.py" = ["C901"]
 "src/ha_mcp/tools/tools_yaml_config.py" = ["C901"]
 "src/ha_mcp/tools/tools_zones.py" = ["C901"]
 "src/ha_mcp/transforms/categorized_search.py" = ["C901"]
-"src/ha_mcp/utils/data_paths.py" = ["C901"]
 "src/ha_mcp/utils/fuzzy_search.py" = ["C901"]
-"src/ha_mcp/utils/skill_loader.py" = ["C901"]
 "src/ha_mcp/visibility/resolver.py" = ["C901"]
 "tests/src/e2e/conftest.py" = ["C901"]
 "tests/src/e2e/error_handling/test_network_errors.py" = ["C901"]

{ha_mcp_dev-7.12.3.dev1895 → ha_mcp_dev-7.12.3.dev1901}/src/ha_mcp/client/rest_client.py

@@ -191,6 +191,25 @@ class HomeAssistantClient:
         await self.httpx_client.aclose()
         logger.debug("Closed Home Assistant client")
 
+    @staticmethod
+    def _error_message_from_response(
+        response: httpx.Response,
+    ) -> tuple[str, dict[str, Any]]:
+        """Build a human message and structured error data from a 4xx/5xx body.
+
+        Prefers the JSON ``message`` field; falls back to reason phrase or a
+        placeholder when the body is empty or unparseable.
+        """
+        try:
+            error_data = response.json()
+        except Exception:
+            error_data = {"message": response.text}
+
+        message = error_data.get("message")
+        if not message or not message.strip():
+            message = response.reason_phrase or "<empty body>"
+        return message, error_data
+
     async def _raw_request(
         self, method: str, endpoint: str, **kwargs: Any
     ) -> httpx.Response:
@@ -216,14 +235,7 @@ class HomeAssistantClient:
                     raise HomeAssistantAuthError("Invalid authentication token")
 
                 if response.status_code >= 400:
-                    try:
-                        error_data = response.json()
-                    except Exception:
-                        error_data = {"message": response.text}
-
-                    message = error_data.get("message")
-                    if not message or not message.strip():
-                        message = response.reason_phrase or "<empty body>"
+                    message, error_data = self._error_message_from_response(response)
 
                     if (
                         response.status_code in _RETRYABLE_STATUS
@@ -665,6 +677,28 @@ class HomeAssistantClient:
         )
         return response.text
 
+    @staticmethod
+    def _supervisor_error_message(text_body: str, reason_phrase: str) -> str:
+        """Extract a human message from a Supervisor 4xx/5xx body.
+
+        Supervisor returns ``{"result":"error","message":"..."}`` on some paths;
+        prefer that message, then fall back to the raw text, reason phrase, or a
+        placeholder.
+        """
+        message = ""
+        try:
+            envelope = json.loads(text_body) if text_body else None
+            if isinstance(envelope, dict):
+                msg = envelope.get("message")
+                if isinstance(msg, str) and msg:
+                    message = msg
+        except json.JSONDecodeError:
+            # Body wasn't a JSON envelope; fall back to raw text below.
+            pass
+        if not message:
+            message = text_body.strip() or reason_phrase or "<empty body>"
+        return message
+
     async def _supervisor_logs_get(self, path: str, lines: int | None = None) -> str:
         """Fetch ``text/plain`` logs from a Supervisor REST endpoint.
 
@@ -751,22 +785,7 @@ class HomeAssistantClient:
             )
         if response.status_code >= 400:
             text_body = response.text
-            # Supervisor returns {"result":"error","message":"..."} JSON on
-            # some 4xx paths. Try parsing that first so the user sees the
-            # human message instead of a JSON blob; then fall back to the
-            # text body, then reason_phrase, then a placeholder.
-            message = ""
-            try:
-                envelope = json.loads(text_body) if text_body else None
-                if isinstance(envelope, dict):
-                    msg = envelope.get("message")
-                    if isinstance(msg, str) and msg:
-                        message = msg
-            except json.JSONDecodeError:
-                # Body wasn't a JSON envelope; fall back to raw text below.
-                pass
-            if not message:
-                message = text_body.strip() or response.reason_phrase or "<empty body>"
+            message = self._supervisor_error_message(text_body, response.reason_phrase)
             logger.warning(
                 "Supervisor returned %s for /%s/logs: %s",
                 response.status_code,

{ha_mcp_dev-7.12.3.dev1895 → ha_mcp_dev-7.12.3.dev1901}/src/ha_mcp/policy/evaluator.py

@@ -56,6 +56,33 @@ def _ci(x: Any) -> Any:
     return x.lower() if isinstance(x, str) else x
 
 
+def _contains_matches(val: Any, pv: Any) -> bool:
+    if isinstance(val, str) and isinstance(pv, str):
+        return pv.lower() in val.lower()
+    # Mirror the case-insensitive treatment that ``eq`` / ``in`` /
+    # ``not_in`` already apply: a rule listing ``["light.kitchen"]``
+    # must match an LLM passing ``"Light.Kitchen"``. Per-element
+    # ``_ci`` guards non-string entries so mixed-type collections
+    # (e.g. ``[1, "two"]``) keep their natural equality semantics.
+    return isinstance(val, (list, tuple, set)) and any(_ci(pv) == _ci(x) for x in val)
+
+
+def _numeric_matches(val: Any, op: str, pv: Any) -> bool:
+    try:
+        return bool(val > pv) if op == "gt" else bool(val < pv)
+    except TypeError:
+        # Numeric rule against a non-numeric arg value — log so
+        # users can tell their "temperature > 30" rule isn't
+        # silently never firing because the arg is a string.
+        logger.debug(
+            "policy: %s type-mismatch (val=%r pv=%r) — predicate skipped",
+            op,
+            val,
+            pv,
+        )
+        return False
+
+
 def _op_matches(val: Any, op: str, pv: Any) -> bool:
     """Apply one op to one concrete value. Predicate dispatches over
     the candidate values (which may be many for wildcard paths).
@@ -82,39 +109,9 @@ def _op_matches(val: Any, op: str, pv: Any) -> bool:
                 and re.search(pv, val, re.IGNORECASE) is not None
             )
         case "contains":
-            if isinstance(val, str) and isinstance(pv, str):
-                return pv.lower() in val.lower()
-            # Mirror the case-insensitive treatment that ``eq`` / ``in`` /
-            # ``not_in`` already apply: a rule listing ``["light.kitchen"]``
-            # must match an LLM passing ``"Light.Kitchen"``. Per-element
-            # ``_ci`` guards non-string entries so mixed-type collections
-            # (e.g. ``[1, "two"]``) keep their natural equality semantics.
-            return isinstance(val, (list, tuple, set)) and any(
-                _ci(pv) == _ci(x) for x in val
-            )
-        case "gt":
-            try:
-                return bool(val > pv)
-            except TypeError:
-                # Numeric rule against a non-numeric arg value — log so
-                # users can tell their "temperature > 30" rule isn't
-                # silently never firing because the arg is a string.
-                logger.debug(
-                    "policy: gt type-mismatch (val=%r pv=%r) — predicate skipped",
-                    val,
-                    pv,
-                )
-                return False
-        case "lt":
-            try:
-                return bool(val < pv)
-            except TypeError:
-                logger.debug(
-                    "policy: lt type-mismatch (val=%r pv=%r) — predicate skipped",
-                    val,
-                    pv,
-                )
-                return False
+            return _contains_matches(val, pv)
+        case "gt" | "lt":
+            return _numeric_matches(val, op, pv)
     return False
 
 

{ha_mcp_dev-7.12.3.dev1895 → ha_mcp_dev-7.12.3.dev1901}/src/ha_mcp/tools/tools_addons.py

@@ -2273,6 +2273,151 @@ class AddOnTools:
             )
         return await self._execute_repository_action(action, repository.strip())
 
+    @staticmethod
+    def _reject_action_mode_conflicts(
+        action: str,
+        path: str | None,
+        config_data: dict[str, Any],
+        array_patch: dict[str, Any] | None,
+    ) -> None:
+        """Raise if lifecycle-action mode is combined with another mode's params."""
+        conflicts = []
+        if path is not None:
+            conflicts.append("path")
+        if config_data:
+            conflicts.append("config parameters")
+        if array_patch is not None:
+            conflicts.append("array_patch")
+        if conflicts:
+            raise_tool_error(
+                create_validation_error(
+                    f"action='{action}' (lifecycle mode) cannot be combined "
+                    f"with {', '.join(conflicts)}. Use one mode at a time.",
+                    parameter="action",
+                )
+            )
+
+    def _reject_config_mode_proxy_params(
+        self,
+        *,
+        method: str,
+        body: dict[str, Any] | str | None,
+        debug: bool,
+        port: int | None,
+        offset: int,
+        limit: int | None,
+        websocket: bool,
+        wait_for_close: bool,
+        message_limit: int | None,
+        message_offset: int,
+        summarize: bool,
+        python_transform: str | None,
+        array_patch: dict[str, Any] | None,
+        request_headers: dict[str, str] | None,
+    ) -> None:
+        """Raise if any proxy-mode-only param is set while config mode is active."""
+        proxy_overrides = self._proxy_overrides_basic(
+            method, body, debug, port, offset, limit, websocket
+        ) + self._proxy_overrides_ws_and_extra(
+            wait_for_close,
+            message_limit,
+            message_offset,
+            summarize,
+            python_transform,
+            array_patch,
+            request_headers,
+        )
+        if proxy_overrides:
+            raise_tool_error(
+                create_validation_error(
+                    f"Proxy-mode parameters cannot be used in config mode: {', '.join(d for _, d in proxy_overrides)}. "
+                    "Remove these parameters or switch to proxy mode by providing 'path'.",
+                    parameter=proxy_overrides[0][0],
+                )
+            )
+
+    async def _execute_ws_proxy(
+        self,
+        slug: str,
+        path: str,
+        body: dict[str, Any] | str | None,
+        debug: bool,
+        port: int | None,
+        wait_for_close: bool,
+        message_limit: int | None,
+        message_offset: int,
+        summarize: bool,
+        python_transform: str | None,
+    ) -> dict[str, Any]:
+        result = await _call_addon_ws(
+            client=self._client,
+            slug=slug,
+            path=path,
+            body=body,
+            timeout=120 if wait_for_close else 10,
+            debug=debug,
+            port=port,
+            wait_for_close=wait_for_close,
+            message_limit=message_limit,
+            message_offset=message_offset,
+            summarize=summarize,
+            python_transform=python_transform,
+        )
+        if not result.get("success"):
+            raise_tool_error(result)
+        return result
+
+    async def _execute_http_proxy(
+        self,
+        *,
+        slug: str,
+        path: str,
+        method: str,
+        body: dict[str, Any] | str | None,
+        debug: bool,
+        port: int | None,
+        offset: int,
+        limit: int | None,
+        python_transform: str | None,
+        request_headers: dict[str, str] | None,
+        message_limit: int | None,
+        message_offset: int,
+        summarize: bool,
+    ) -> dict[str, Any]:
+        valid_methods = {"GET", "POST", "PUT", "DELETE", "PATCH"}
+        if method.upper() not in valid_methods:
+            raise_tool_error(
+                create_validation_error(
+                    f"Invalid HTTP method: {method}. Must be one of: {', '.join(sorted(valid_methods))}",
+                    parameter="method",
+                )
+            )
+        if message_limit is not None or message_offset != 0 or not summarize:
+            raise_tool_error(
+                create_validation_error(
+                    "message_limit / message_offset / summarize apply only to "
+                    "WebSocket mode. Set websocket=True or remove them.",
+                    parameter="message_limit",
+                )
+            )
+
+        result = await _call_addon_api(
+            client=self._client,
+            slug=slug,
+            path=path,
+            method=method,
+            body=body,
+            debug=debug,
+            port=port,
+            offset=offset,
+            limit=limit,
+            python_transform=python_transform,
+            extra_headers=request_headers,
+        )
+        if not result.get("success"):
+            raise_tool_error(result)
+        return result
+
     async def manage_addon(
         self,
         slug: str,
@@ -2326,45 +2471,28 @@ class AddOnTools:
         # Lifecycle mode takes precedence and is mutually exclusive with the
         # proxy / config / array-patch modes.
         if action is not None:
-            conflicts = []
-            if path is not None:
-                conflicts.append("path")
-            if config_data:
-                conflicts.append("config parameters")
-            if array_patch is not None:
-                conflicts.append("array_patch")
-            if conflicts:
-                raise_tool_error(
-                    create_validation_error(
-                        f"action='{action}' (lifecycle mode) cannot be combined "
-                        f"with {', '.join(conflicts)}. Use one mode at a time.",
-                        parameter="action",
-                    )
-                )
+            self._reject_action_mode_conflicts(action, path, config_data, array_patch)
             return await self._execute_action_mode(slug, action)
 
         self._validate_manage_mode(path, config_data)
 
         if config_data:
-            proxy_overrides = self._proxy_overrides_basic(
-                method, body, debug, port, offset, limit, websocket
-            ) + self._proxy_overrides_ws_and_extra(
-                wait_for_close,
-                message_limit,
-                message_offset,
-                summarize,
-                python_transform,
-                array_patch,
-                request_headers,
+            self._reject_config_mode_proxy_params(
+                method=method,
+                body=body,
+                debug=debug,
+                port=port,
+                offset=offset,
+                limit=limit,
+                websocket=websocket,
+                wait_for_close=wait_for_close,
+                message_limit=message_limit,
+                message_offset=message_offset,
+                summarize=summarize,
+                python_transform=python_transform,
+                array_patch=array_patch,
+                request_headers=request_headers,
             )
-            if proxy_overrides:
-                raise_tool_error(
-                    create_validation_error(
-                        f"Proxy-mode parameters cannot be used in config mode: {', '.join(d for _, d in proxy_overrides)}. "
-                        "Remove these parameters or switch to proxy mode by providing 'path'.",
-                        parameter=proxy_overrides[0][0],
-                    )
-                )
             return await self._execute_config_mode(slug, config_data)
 
         # _call_addon_ws does not accept caller headers — reject the combo rather
@@ -2399,43 +2527,20 @@ class AddOnTools:
             )
 
         if websocket:
-            result = await _call_addon_ws(
-                client=self._client,
-                slug=slug,
-                path=path,
-                body=body,
-                timeout=120 if wait_for_close else 10,
-                debug=debug,
-                port=port,
-                wait_for_close=wait_for_close,
-                message_limit=message_limit,
-                message_offset=message_offset,
-                summarize=summarize,
-                python_transform=python_transform,
-            )
-            if not result.get("success"):
-                raise_tool_error(result)
-            return result
-
-        valid_methods = {"GET", "POST", "PUT", "DELETE", "PATCH"}
-        if method.upper() not in valid_methods:
-            raise_tool_error(
-                create_validation_error(
-                    f"Invalid HTTP method: {method}. Must be one of: {', '.join(sorted(valid_methods))}",
-                    parameter="method",
-                )
-            )
-        if message_limit is not None or message_offset != 0 or not summarize:
-            raise_tool_error(
-                create_validation_error(
-                    "message_limit / message_offset / summarize apply only to "
-                    "WebSocket mode. Set websocket=True or remove them.",
-                    parameter="message_limit",
-                )
+            return await self._execute_ws_proxy(
+                slug,
+                path,
+                body,
+                debug,
+                port,
+                wait_for_close,
+                message_limit,
+                message_offset,
+                summarize,
+                python_transform,
             )
 
-        result = await _call_addon_api(
-            client=self._client,
+        return await self._execute_http_proxy(
             slug=slug,
             path=path,
             method=method,
@@ -2445,11 +2550,11 @@ class AddOnTools:
             offset=offset,
             limit=limit,
             python_transform=python_transform,
-            extra_headers=request_headers,
+            request_headers=request_headers,
+            message_limit=message_limit,
+            message_offset=message_offset,
+            summarize=summarize,
         )
-        if not result.get("success"):
-            raise_tool_error(result)
-        return result
 
 
 def register_addon_tools(mcp: Any, client: HomeAssistantClient, **kwargs: Any) -> None: