ha-mcp-dev 7.14.1.dev2073__tar.gz → 7.14.2.dev2083__tar.gz

{ha_mcp_dev-7.14.1.dev2073/src/ha_mcp_dev.egg-info → ha_mcp_dev-7.14.2.dev2083}/PKG-INFO

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

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

@@ -8,6 +8,7 @@ This module handles WebSocket connections to Home Assistant for:
 """
 
 import asyncio
+import concurrent.futures
 import hashlib
 import json
 import logging
@@ -1036,6 +1037,21 @@ class HomeAssistantWebSocketClient:
 MAX_POOL_SIZE = 50
 
 
+def _log_stale_disconnect(future: "concurrent.futures.Future[None]") -> None:
+    """Report how a disconnect scheduled on a stale event loop ended.
+
+    Nothing awaits that future, so without this the outcome would be invisible
+    at every log level: a ``concurrent.futures.Future`` never warns about an
+    exception no one retrieved.
+    """
+    if future.cancelled():
+        logger.debug("Stale WebSocket disconnect was cancelled with its loop")
+        return
+    error = future.exception()
+    if error is not None:
+        logger.debug("Stale WebSocket disconnect failed: %s", error)
+
+
 class WebSocketManager:
     """Singleton manager for Home Assistant WebSocket connections.
 
@@ -1114,6 +1130,56 @@ class WebSocketManager:
             )
             return True
 
+    @staticmethod
+    def _release_stale_clients(
+        clients: list[HomeAssistantWebSocketClient],
+        loop: asyncio.AbstractEventLoop | None,
+    ) -> None:
+        """Best-effort cleanup of clients orphaned by an event-loop change.
+
+        Never awaits: the connections belong to ``loop``, and awaiting them
+        from the loop that replaced it is exactly the cross-loop failure this
+        avoids. Each disconnect is scheduled on the owning loop and
+        deliberately not waited for. A merely stopped loop is scheduled too:
+        it still owns live transports and still accepts callbacks, so the
+        disconnect runs once that loop is resumed, and otherwise stays an
+        unrun callback like any other the abandoned loop still holds. Only a
+        closed or unknown loop has nothing left to schedule on; its
+        connection is abandoned and the socket closes when the orphaned
+        transport is garbage-collected (with a ``ResourceWarning``), because
+        closing a loop does not close the transports it carried. Either way
+        the caller has already detached the pool, so a failure here cannot
+        make it stale again.
+        """
+        if not clients:
+            return
+        if loop is None or loop.is_closed():
+            logger.debug(
+                "Abandoning %d stale WebSocket client(s): the owning event "
+                "loop is gone",
+                len(clients),
+            )
+            return
+        for client in clients:
+            coro = client.disconnect()
+            try:
+                future = asyncio.run_coroutine_threadsafe(coro, loop)
+            except RuntimeError:
+                # The loop closed between the check above and now. Closing the
+                # coroutine keeps it from surfacing as "never awaited". The
+                # narrower window stays open by construction: a loop that
+                # accepts the callback and then stops before draining it never
+                # runs the coroutine at all, and ``run_coroutine_threadsafe``
+                # needs the coroutine object up front, so there is nothing left
+                # to reclaim from this side.
+                coro.close()
+                logger.debug(
+                    "Could not schedule disconnect of a stale WebSocket client",
+                    exc_info=True,
+                )
+                continue
+            future.add_done_callback(_log_stale_disconnect)
+
     async def get_client(
         self,
         url: str | None = None,
@@ -1143,22 +1209,21 @@ class WebSocketManager:
         if not self._lock:
             raise Exception("Lock not initialized")
         async with self._lock:
-            if self._current_loop is not None and self._current_loop != current_loop:
-                # Event loop changed — disconnect all clients
-                for client in self._clients.values():
-                    try:
-                        await client.disconnect()
-                    except (OSError, asyncio.CancelledError):
-                        # Best-effort cleanup — failure is expected when the
-                        # event loop changed and connections are stale.
-                        logger.debug(
-                            "Ignoring error disconnecting stale WebSocket client",
-                            exc_info=True,
-                        )
+            previous_loop = self._current_loop
+            stale_clients: list[HomeAssistantWebSocketClient] = []
+            if previous_loop is not None and previous_loop is not current_loop:
+                # Event loop changed: detach the pool BEFORE cleaning it up.
+                # The pooled clients' futures belong to ``previous_loop``, so
+                # awaiting their ``disconnect()`` here raises ``RuntimeError:
+                # ... attached to a different loop``, which used to escape the
+                # best-effort catch and leave both the pool and the loop
+                # reference stale for every later call (issue #1994).
+                stale_clients = list(self._clients.values())
                 self._clients.clear()
                 self._last_used.clear()
 
             self._current_loop = current_loop
+            self._release_stale_clients(stale_clients, previous_loop)
 
             # Determine credentials to use
             if url and token:
@@ -1226,7 +1291,7 @@ class WebSocketManager:
         if stale:
             try:
                 await stale.disconnect()
-            except (OSError, asyncio.CancelledError):
+            except (OSError, RuntimeError, asyncio.CancelledError):
                 logger.warning(
                     "Error disconnecting evicted WebSocket client",
                     exc_info=True,
@@ -1239,16 +1304,27 @@ class WebSocketManager:
         if not self._lock:
             raise Exception("Lock not initialized")
         async with self._lock:
-            for client in self._clients.values():
+            # Detach the pool before disconnecting so a raising disconnect
+            # cannot leave it populated (the bookkeeping half of the
+            # loop-change branch in ``get_client``). The only caller,
+            # ``__main__``'s shutdown, runs on the pool's own loop, so each
+            # ``disconnect()`` is awaited to completion here. ``RuntimeError``
+            # is caught purely defensively: were this ever driven from a
+            # different loop, the cross-loop future would raise instead of
+            # hanging the shutdown. Unlike ``get_client`` it does not
+            # reschedule onto the owning loop, because the process is going
+            # away and there is nothing left to resume it.
+            clients = list(self._clients.values())
+            self._clients.clear()
+            self._last_used.clear()
+            self._current_loop = None
+            for client in clients:
                 try:
                     await client.disconnect()
-                except (OSError, asyncio.CancelledError):
+                except (OSError, RuntimeError, asyncio.CancelledError):
                     logger.warning(
                         "Error disconnecting WebSocket client", exc_info=True
                     )
-            self._clients.clear()
-            self._last_used.clear()
-            self._current_loop = None
 
 
 # Global WebSocket manager instance

{ha_mcp_dev-7.14.1.dev2073 → ha_mcp_dev-7.14.2.dev2083}/src/ha_mcp/tools/smart_search/_overview.py

@@ -3,6 +3,7 @@
 import asyncio
 import logging
 import random
+from itertools import islice
 from typing import Any
 
 from ...visibility.resolver import load_hidden_set
@@ -433,65 +434,41 @@ class SystemOverviewMixin(_SearchBase):
         return formatted_domain_stats
 
     @staticmethod
-    def _allocate_page_one(
+    def _allocate_page(
         formatted_domain_stats: dict[str, dict[str, Any]],
         effective_limit: int,
-        total_entity_count: int,
+        offset: int,
     ) -> int:
-        """Distribute the page-1 budget: a min allocation per domain, rest proportional.
+        """Take one stable round-robin page across domains.
+
+        A single ordering must drive every page. Otherwise a specially balanced
+        first page followed by sequential offset pages can repeat entities.
 
-        Gives each domain a minimum slice so the LLM sees entities from every
-        domain, then distributes the remaining budget proportionally. Mutates
-        ``formatted_domain_stats`` in place; returns the count included.
+        Mutates ``formatted_domain_stats`` in place; returns the count included.
         """
-        min_per_domain = 3
-        num_domains = len(formatted_domain_stats)
-        reserved = min(min_per_domain * num_domains, effective_limit)
-        remaining_budget = effective_limit - reserved
-
-        entities_included = 0
-        for domain_data in formatted_domain_stats.values():
-            domain_entities = domain_data["entities"]
-            domain_len = len(domain_entities)
-            base = min(min_per_domain, domain_len)
-            if total_entity_count > 0 and remaining_budget > 0:
-                extra = int(remaining_budget * domain_len / total_entity_count)
-            else:
-                extra = 0
-            take = min(base + extra, domain_len)
-            if take < domain_len:
-                domain_data["entities"] = domain_entities[:take]
-                domain_data["truncated"] = True
-            entities_included += len(domain_data["entities"])
-        return entities_included
+        max_domain_size = max(
+            (len(data["entities"]) for data in formatted_domain_stats.values()),
+            default=0,
+        )
+        ordered = (
+            (domain, data["entities"][index])
+            for index in range(max_domain_size)
+            for domain, data in formatted_domain_stats.items()
+            if index < len(data["entities"])
+        )
 
-    @staticmethod
-    def _allocate_subsequent_pages(
-        formatted_domain_stats: dict[str, dict[str, Any]],
-        effective_limit: int,
-        offset: int,
-    ) -> int:
-        """Apply pages-2+ sequential skip/take across domains. Mutates in place."""
-        entities_skipped = 0
-        entities_included = 0
-        for domain_data in formatted_domain_stats.values():
-            domain_entities = domain_data["entities"]
-            domain_len = len(domain_entities)
-
-            skip_from_domain = max(0, min(domain_len, offset - entities_skipped))
-            budget_left = effective_limit - entities_included
-            take_from_domain = max(0, min(domain_len - skip_from_domain, budget_left))
-
-            if skip_from_domain > 0 or take_from_domain < domain_len:
-                domain_data["entities"] = domain_entities[
-                    skip_from_domain : skip_from_domain + take_from_domain
-                ]
-                if take_from_domain < domain_len:
-                    domain_data["truncated"] = True
+        selected: dict[str, list[dict[str, Any]]] = {
+            domain: [] for domain in formatted_domain_stats
+        }
+        for domain, entity in islice(ordered, offset, offset + effective_limit):
+            selected[domain].append(entity)
 
-            entities_skipped += skip_from_domain
-            entities_included += take_from_domain
-        return entities_included
+        for domain, data in formatted_domain_stats.items():
+            original_count = len(data["entities"])
+            data["entities"] = selected[domain]
+            if len(data["entities"]) < original_count:
+                data["truncated"] = True
+        return sum(len(entities) for entities in selected.values())
 
     def _paginate_overview_entities(
         self,
@@ -514,14 +491,9 @@ class SystemOverviewMixin(_SearchBase):
         total_entity_count = sum(
             len(ds["entities"]) for ds in formatted_domain_stats.values()
         )
-        if offset == 0:
-            entities_included = self._allocate_page_one(
-                formatted_domain_stats, effective_limit, total_entity_count
-            )
-        else:
-            entities_included = self._allocate_subsequent_pages(
-                formatted_domain_stats, effective_limit, offset
-            )
+        entities_included = self._allocate_page(
+            formatted_domain_stats, effective_limit, offset
+        )
 
         has_more = (offset + entities_included) < total_entity_count
         return {

{ha_mcp_dev-7.14.1.dev2073 → ha_mcp_dev-7.14.2.dev2083/src/ha_mcp_dev.egg-info}/PKG-INFO

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