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

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

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ha-mcp-dev"
-version = "7.12.3.dev1891"
+version = "7.12.3.dev1895"
 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.12.3.dev1891 → ha_mcp_dev-7.12.3.dev1895}/src/ha_mcp/client/websocket_client.py

@@ -1083,6 +1083,23 @@ class WebSocketManager:
         """Create a cache key from credentials."""
         return hashlib.sha256(f"{url.rstrip('/')}:{token}".encode()).hexdigest()
 
+    @staticmethod
+    def _effective_verify_ssl(verify_ssl: bool | None) -> bool:
+        """Resolve the effective TLS-verification mode for the pool key."""
+        if verify_ssl is not None:
+            return verify_ssl
+        try:
+            return bool(get_global_settings().verify_ssl)
+        except Exception as e:
+            # Mirror HomeAssistantWebSocketClient.__init__: a bad env var
+            # elsewhere should not crash pooling or silently flip TLS off.
+            logger.warning(
+                "Could not load settings while resolving the pool verify_ssl "
+                "key (%s); falling back to verify_ssl=True.",
+                e,
+            )
+            return True
+
     async def get_client(
         self,
         url: str | None = None,
@@ -1138,9 +1155,16 @@ class WebSocketManager:
                 ws_url = settings.homeassistant_url
                 ws_token = settings.homeassistant_token
 
-            key = self._client_key(ws_url, ws_token)
-            if verify_ssl is not None:
-                key = f"{key}|verify_ssl={verify_ssl}"
+            # Key on the EFFECTIVE verification mode: a caller passing the
+            # resolved settings default (send_websocket_message) must share
+            # the pooled connection with callers that omit the argument
+            # (listener, HACS, installer) — only a genuine override such as
+            # verify_ssl=False gets its own isolated connection.
+            effective_verify_ssl = self._effective_verify_ssl(verify_ssl)
+            key = (
+                f"{self._client_key(ws_url, ws_token)}"
+                f"|verify_ssl={effective_verify_ssl}"
+            )
 
             # Return existing connected client for these credentials
             existing = self._clients.get(key)

{ha_mcp_dev-7.12.3.dev1891 → ha_mcp_dev-7.12.3.dev1895}/src/ha_mcp/tools/tools_calendar.py

@@ -15,7 +15,10 @@ from fastmcp.exceptions import ToolError
 from fastmcp.tools import tool
 from pydantic import Field
 
-from ..client.rest_client import HomeAssistantCommandError
+from ..client.rest_client import (
+    HomeAssistantCommandError,
+    HomeAssistantConnectionError,
+)
 from ..errors import ErrorCode, create_error_response
 from .auto_backup import with_auto_backup
 from .helpers import (
@@ -25,6 +28,7 @@ from .helpers import (
     register_tool_methods,
     validate_identifier_not_empty,
 )
+from .util_helpers import is_connection_error_message
 
 logger = logging.getLogger(__name__)
 
@@ -201,17 +205,20 @@ class CalendarTools:
 
         # Route through the shared pooled WebSocket (issue #1813) instead of a
         # dedicated connect/auth handshake per call. The pooled path collapses a
-        # failed WS command into ``{"success": False, "error": ...}``; re-raise
-        # it as the same ``HomeAssistantCommandError`` the dedicated send_command
-        # used to raise so the caller's error handler still attaches the
-        # rrule-specific suggestions.
+        # failed WS command into ``{"success": False, "error": ...}``; a
+        # transport-shaped failure re-raises as ``HomeAssistantConnectionError``
+        # (the classifier type-matches it to connectivity guidance), anything
+        # else as the same ``HomeAssistantCommandError`` the dedicated
+        # send_command used to raise so the caller's error handler still
+        # attaches the rrule-specific suggestions.
         result = await self._client.send_websocket_message(
             {"type": "calendar/event/create", "entity_id": entity_id, "event": event}
         )
         if not result.get("success"):
-            raise HomeAssistantCommandError(
-                str(result.get("error", "calendar/event/create failed"))
-            )
+            error = str(result.get("error", "calendar/event/create failed"))
+            if is_connection_error_message(error):
+                raise HomeAssistantConnectionError(error)
+            raise HomeAssistantCommandError(error)
         return result
 
     async def _create_simple_calendar_event(
@@ -242,6 +249,13 @@ class CalendarTools:
         self, entity_id: str, rrule: str | None, error: Exception
     ) -> list[str]:
         """Build suggestions for a failed ha_config_set_calendar_event call."""
+        if isinstance(error, HomeAssistantConnectionError):
+            # A transport drop is not a calendar problem — domain hints would
+            # send the agent chasing a non-issue during an HA restart.
+            return [
+                "Home Assistant may be restarting or unreachable — retry shortly",
+                "Check the connection to Home Assistant",
+            ]
         suggestions = [
             f"Verify calendar entity '{entity_id}' exists and supports event creation",
             "Check datetime format (ISO 8601)",
@@ -527,17 +541,20 @@ class CalendarTools:
                 ws_kwargs["recurrence_range"] = recurrence_range
 
             # Route through the shared pooled WebSocket (issue #1813) instead of a
-            # dedicated connect/auth handshake per call. Re-raise a failed WS
-            # command as the same ``HomeAssistantCommandError`` the dedicated
-            # send_command used to raise so the outer handler builds the
-            # delete-specific suggestions (404 / not-supported).
+            # dedicated connect/auth handshake per call. Transport-shaped
+            # failures raise ``HomeAssistantConnectionError`` (connectivity
+            # guidance); anything else re-raises as the same
+            # ``HomeAssistantCommandError`` the dedicated send_command used to
+            # raise so the outer handler builds the delete-specific
+            # suggestions (404 / not-supported).
             result = await self._client.send_websocket_message(
                 {"type": "calendar/event/delete", **ws_kwargs}
             )
             if not result.get("success"):
-                raise HomeAssistantCommandError(
-                    str(result.get("error", "calendar/event/delete failed"))
-                )
+                error = str(result.get("error", "calendar/event/delete failed"))
+                if is_connection_error_message(error):
+                    raise HomeAssistantConnectionError(error)
+                raise HomeAssistantCommandError(error)
 
             return {
                 "success": True,
@@ -554,28 +571,41 @@ class CalendarTools:
         except Exception as error:
             logger.error(f"Failed to delete calendar event from {entity_id}: {error}")
 
-            suggestions = [
-                f"Verify calendar entity '{entity_id}' exists",
-                f"Verify event with UID '{uid}' exists in the calendar",
-                "Use ha_config_get_calendar_events() to find the correct event UID",
-                "Some calendar integrations may not support event deletion",
-            ]
-
-            error_str = str(error)
-            if "404" in error_str or "not found" in error_str.lower():
-                suggestions.insert(
-                    0, f"Calendar entity '{entity_id}' or event '{uid}' not found"
-                )
-            if "not supported" in error_str.lower():
-                suggestions.insert(0, "This calendar does not support event deletion")
-
             exception_to_structured_error(
                 error,
                 context={"entity_id": entity_id, "uid": uid},
-                suggestions=suggestions,
+                suggestions=self._build_remove_calendar_event_error_suggestions(
+                    entity_id, uid, error
+                ),
             )
             return None  # unreachable: exception_to_structured_error always raises
 
+    def _build_remove_calendar_event_error_suggestions(
+        self, entity_id: str, uid: str, error: Exception
+    ) -> list[str]:
+        """Build suggestions for a failed ha_config_remove_calendar_event call."""
+        if isinstance(error, HomeAssistantConnectionError):
+            # A transport drop is not a calendar problem — domain hints would
+            # send the agent chasing a non-issue during an HA restart.
+            return [
+                "Home Assistant may be restarting or unreachable — retry shortly",
+                "Check the connection to Home Assistant",
+            ]
+        suggestions = [
+            f"Verify calendar entity '{entity_id}' exists",
+            f"Verify event with UID '{uid}' exists in the calendar",
+            "Use ha_config_get_calendar_events() to find the correct event UID",
+            "Some calendar integrations may not support event deletion",
+        ]
+        error_str = str(error)
+        if "404" in error_str or "not found" in error_str.lower():
+            suggestions.insert(
+                0, f"Calendar entity '{entity_id}' or event '{uid}' not found"
+            )
+        if "not supported" in error_str.lower():
+            suggestions.insert(0, "This calendar does not support event deletion")
+        return suggestions
+
 
 def register_calendar_tools(mcp: Any, client: Any, **kwargs: Any) -> None:
     """Register calendar management tools with the MCP server."""

{ha_mcp_dev-7.12.3.dev1891 → ha_mcp_dev-7.12.3.dev1895}/src/ha_mcp/tools/tools_dev.py

@@ -44,8 +44,25 @@ COMPONENT_DOMAIN = "ha_mcp_tools"
 # (custom_components/ha_mcp_tools/const.py OPT_CHANNEL / OPT_PIP_SPEC).
 _OPT_CHANNEL = "channel"
 _OPT_PIP_SPEC = "pip_spec"
+_OPT_SERVER_URL = "server_url"
+_OPT_EXTERNAL_URL = "external_url"
+_OPT_WEBHOOK_ID_OVERRIDE = "webhook_id_override"
+_OPT_SECRET_PATH_OVERRIDE = "secret_path_override"
 _VALID_CHANNELS = ("stable", "dev")
 
+# Optional text fields the component's options flow pre-fills via
+# suggested_value (so the UI can clear them). Because an OMITTED optional field
+# reads as "cleared" rather than "unchanged", a partial update_source submit
+# must resend these at their current values or it would blank the user's
+# server-URL / connect-secret overrides.
+_PRESERVED_OPTION_KEYS = (
+    _OPT_PIP_SPEC,
+    _OPT_SERVER_URL,
+    _OPT_EXTERNAL_URL,
+    _OPT_WEBHOOK_ID_OVERRIDE,
+    _OPT_SECRET_PATH_OVERRIDE,
+)
+
 # Delay before a self-affecting action (embedded entry reload / options
 # submit) fires, so this tool's JSON response flushes to the MCP client
 # before the serving thread is torn down. Mirrors
@@ -85,6 +102,23 @@ def _spawn_background(coro: Any) -> None:
     task.add_done_callback(_BACKGROUND_TASKS.discard)
 
 
+def _field_prefill(item: dict[str, Any]) -> Any:
+    """Return a serialized options-flow field's current value.
+
+    Reads ``description.suggested_value`` first: a persisted option is
+    serialized there (as ``add_suggested_values_to_schema`` does; this component
+    sets it directly on the ``vol.Optional`` marker), and the clearable text
+    fields carry their value there rather than as a schema ``default`` (a
+    ``default`` equal to the value would make the field impossible to clear).
+    Falls back to ``default`` then ``value`` for the dropdown/toggle fields.
+    Mirrors ``tools_integrations.options_from_form_flow``.
+    """
+    description = item.get("description")
+    if isinstance(description, dict) and description.get("suggested_value") is not None:
+        return description["suggested_value"]
+    return item.get("default", item.get("value"))
+
+
 async def find_server_config_entry(
     client: Any,
 ) -> tuple[str, dict[str, Any], dict[str, Any]] | None:
@@ -95,8 +129,9 @@ async def find_server_config_entry(
     (services) entry's flow aborts immediately. Returns
     ``(entry_id, open_flow, current_options)`` with the options flow left
     OPEN (callers must submit or abort it), or ``None`` when no server
-    entry exists. ``current_options`` maps schema field names to their
-    defaults — i.e. the entry's current option values.
+    entry exists. ``current_options`` maps schema field names to their current
+    values (persisted ``suggested_value`` first, else the schema ``default`` or
+    ``value``, via ``_field_prefill``).
 
     Module-level (not a DevTools method) so the settings UI's embedded
     restart handler can share it.
@@ -131,7 +166,7 @@ async def find_server_config_entry(
             continue
         schema = flow.get("data_schema") or []
         fields: dict[str, Any] = {
-            str(item["name"]): item.get("default")
+            str(item["name"]): _field_prefill(item)
             for item in schema
             if isinstance(item, dict) and item.get("name")
         }
@@ -400,7 +435,16 @@ class DevTools:
         await asyncio.sleep(_SELF_ACTION_FLUSH_DELAY_S)
         try:
             result = await self._client.submit_options_flow_step(flow_id, user_input)
-            logger.info("Deferred options submit result: %s", result.get("type"))
+            if result.get("type") == "create_entry":
+                logger.info("Deferred options submit applied")
+            else:
+                # Fire-and-forget: no caller is left to raise to, so a rejected
+                # self-restart must at least be discoverable in the log.
+                logger.warning(
+                    "Deferred options submit was not applied (type=%s, errors=%s)",
+                    result.get("type"),
+                    result.get("errors") or result.get("reason"),
+                )
         except Exception:
             logger.exception("Deferred options-flow submit failed")
 
@@ -819,7 +863,12 @@ class DevTools:
                 )
             )
         entry_id, flow, current = found
-        user_input: dict[str, Any] = {}
+        # Resend the user's current overrides (see _PRESERVED_OPTION_KEYS) so a
+        # channel/pip-spec change here does not blank them — an omitted optional
+        # field reads as "cleared", not "unchanged".
+        user_input: dict[str, Any] = {
+            key: current[key] for key in _PRESERVED_OPTION_KEYS if current.get(key)
+        }
         if channel is not None:
             user_input[_OPT_CHANNEL] = channel
         if pip_spec is not None:

{ha_mcp_dev-7.12.3.dev1891 → ha_mcp_dev-7.12.3.dev1895}/src/ha_mcp/tools/tools_history.py

@@ -32,6 +32,7 @@ from .util_helpers import (
     JSON_STRING_COERCION,
     add_timezone_metadata,
     build_pagination_metadata,
+    is_connection_error_message,
     parse_string_list_param,
     project_fields,
 )
@@ -490,16 +491,6 @@ def _parse_time_range(
     return start_dt, end_dt
 
 
-_WS_CONNECTION_SIGNATURES = (
-    "failed to connect",
-    "timed out",
-    "timeout",
-    "connection closed",
-    "disconnected",
-    "not connected",
-)
-
-
 def _raise_recorder_ws_failure(
     kind: str,
     error_msg: str,
@@ -513,8 +504,7 @@ def _raise_recorder_ws_failure(
     as CONNECTION_FAILED (retry/connectivity guidance) instead of presenting
     recorder-retention suggestions during an HA restart or WS outage.
     """
-    lowered = error_msg.lower()
-    if any(sig in lowered for sig in _WS_CONNECTION_SIGNATURES):
+    if is_connection_error_message(error_msg):
         raise_tool_error(
             create_error_response(
                 ErrorCode.CONNECTION_FAILED,

{ha_mcp_dev-7.12.3.dev1891 → ha_mcp_dev-7.12.3.dev1895}/src/ha_mcp/tools/tools_radio.py

@@ -31,7 +31,7 @@ from .radio import thread as thread_handler
 from .radio import zigbee as zigbee_handler
 from .radio import zwave as zwave_handler
 from .radio.base import confirm_required, require
-from .util_helpers import JSON_STRING_COERCION
+from .util_helpers import JSON_STRING_COERCION, is_connection_error_message
 
 logger = logging.getLogger(__name__)
 
@@ -62,6 +62,20 @@ class RadioTools:
             device_id = (result.get("result") or {}).get("device_id")
             if device_id:
                 return str(device_id)
+        else:
+            error = str(result.get("error", ""))
+            if is_connection_error_message(error):
+                # A transport drop is not evidence the entity is missing.
+                raise_tool_error(
+                    create_error_response(
+                        ErrorCode.CONNECTION_FAILED,
+                        f"Could not resolve entity '{entity_id}': {error}",
+                        context={"entity_id": entity_id},
+                        suggestions=[
+                            "Home Assistant may be restarting or unreachable — retry shortly",
+                        ],
+                    )
+                )
         raise_tool_error(
             create_error_response(
                 ErrorCode.ENTITY_NOT_FOUND,

{ha_mcp_dev-7.12.3.dev1891 → ha_mcp_dev-7.12.3.dev1895}/src/ha_mcp/tools/util_helpers.py

@@ -2236,3 +2236,35 @@ def merge_visibility_warnings(
     if warnings:
         response.setdefault("warnings", []).extend(warnings)
     return response
+
+
+# Error strings produced by the pooled WebSocket path when the transport (not
+# the command) fails: the manager's connect raise, send timeouts, and socket
+# drops. ``send_websocket_message`` collapses these into
+# ``{"success": False, "error": ...}``, so callers that attach domain-specific
+# suggestions must first check the shape or an HA restart gets presented as a
+# domain problem (issue #1832 review).
+WS_CONNECTION_SIGNATURES = (
+    "failed to connect",
+    "timed out",
+    "timeout",
+    "connection closed",
+    # reset_connection: "WebSocket connection to Home Assistant closed while
+    # waiting for a response" — "connection closed" is not adjacent there.
+    "closed while waiting",
+    # listener close reason: "connection dropped without a close frame".
+    "connection dropped",
+    "disconnected",
+    "not connected",
+    "not authenticated",
+)
+
+
+def is_connection_error_message(error_msg: Any) -> bool:
+    """True when a pooled-WS failure payload is connection/transport-shaped.
+
+    Accepts any payload shape: HA error frames can carry a dict (or None)
+    in the error slot, so the value is stringified before matching.
+    """
+    lowered = str(error_msg).lower()
+    return any(sig in lowered for sig in WS_CONNECTION_SIGNATURES)

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

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