fix(component): give the loopback MCP session an actual generous timeout

llm_api._mcp_session handed the SDK Home Assistant's shared httpx client
(helpers.httpx_client.get_async_client) so the SDK would never build its
own client mid-event-loop (blocking CA-bundle load). But the SDK applies
no timeout of its own when a caller-provided client is passed, and HA's
shared client is built with no explicit timeout=, so it silently carried
httpx's own hardcoded 5-second default — capping every tool call at 5s
of read-idle no matter how generous _CALL_TOOL_TIMEOUT_SECONDS (300s) /
_LIST_TOOLS_TIMEOUT_SECONDS (10s) looked.

_mcp_session now builds its own short-lived client per session instead,
with an explicit generous timeout and verify=False (the loopback URL is
always plain http://127.0.0.1 and never negotiates TLS, so skipping
verification is not a security relaxation — it just avoids the same
blocking SSL-context setup the shared-client approach was working around).

Found investigating a ~60s Assist-pipeline hang; ruled out as root cause
for that specific report, but a real, independent bug regardless.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

Author: swissmo

custom_components/ha_mcp_tools/llm_api.py

@@ -50,15 +50,14 @@
 import importlib
 import logging
 from collections.abc import AsyncIterator, Iterable
-from contextlib import asynccontextmanager
+from contextlib import AsyncExitStack, asynccontextmanager
 from dataclasses import dataclass
 from typing import TYPE_CHECKING, Any, cast
 
 import voluptuous as vol
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers import llm
-from homeassistant.helpers.httpx_client import get_async_client
 from voluptuous_openapi import convert_to_voluptuous
 
 from .const import (
@@ -226,47 +225,63 @@ async def async_probe_mcp_sdk(hass: HomeAssistant) -> bool:
 @asynccontextmanager
 async def _mcp_session(
     url: str,
-    http_client: Any = None,
 ) -> AsyncIterator[tuple[ClientSession, mcp_types.InitializeResult]]:
     """Open an initialized MCP session against the loopback server.
 
     Imports resolve from ``sys.modules`` — :func:`async_probe_mcp_sdk` did the
     real (blocking) import on the executor before the API was registered.
 
-    ``http_client`` is Home Assistant's shared httpx client
-    (``helpers.httpx_client.get_async_client``). Passing it is what keeps
-    this loop-safe: without it the SDK constructs its own httpx client per
-    session, whose SSL setup loads the CA bundle SYNCHRONOUSLY inside HA's
-    event loop (live-found — HA's blocking-call monitor flagged this exact
-    line). HA's shared client is built against the process-cached SSL
-    context, and the SDK does not close caller-owned clients (HA core's mcp
-    integration relies on the same contract).
+    Builds a throwaway httpx client scoped to this one session rather than
+    reusing Home Assistant's shared one (``helpers.httpx_client.
+    get_async_client`` — the prior approach): the SDK applies NO timeout of
+    its own when a caller-provided client is passed, so whatever timeout
+    THAT client happens to carry becomes the real wire-level ceiling. HA's
+    shared client is built with no explicit ``timeout=``, so it silently
+    carries httpx's own hardcoded 5-second default — capping every tool call
+    at 5 seconds of read-idle no matter how generous
+    ``_CALL_TOOL_TIMEOUT_SECONDS`` / ``_LIST_TOOLS_TIMEOUT_SECONDS`` looked
+    (live-found investigating a ~60s Assist-pipeline hang: a real tool doing
+    real work never got anywhere near its own asyncio budget).
+
+    ``verify=False`` is not a security relaxation: ``url`` is always
+    ``http://127.0.0.1:<port>...`` (see ``async_register_llm_api``) — a
+    plain-HTTP loopback call that never negotiates TLS — so building a real
+    SSL context would be pure waste. It also keeps this loop-safe the same
+    way the shared client did: an SSL context built with ``verify=True``
+    loads the system CA bundle SYNCHRONOUSLY (live-found — HA's
+    blocking-call monitor flagged this exact line when the SDK built its own
+    default client), and skipping verification skips that load entirely.
+    The client is entered on the exit stack so it closes with the rest of
+    the session.
     """
     from mcp.client.session import ClientSession
 
-    try:
-        from mcp.client.streamable_http import streamable_http_client
-
-        transport = (
-            streamable_http_client(url=url, http_client=http_client)
-            if http_client is not None
-            else streamable_http_client(url=url)
-        )
-    except ImportError:
-        # Pre-rename SDK (an older ha-mcp resolved by a pip-spec override
-        # pins an older fastmcp/mcp): same call shape, deprecated name, but
-        # no http_client kwarg — it builds its own client, so on those old
-        # SDKs the blocking-SSL-setup warning is the accepted cost.
-        from mcp.client.streamable_http import (
-            streamablehttp_client,
-        )
+    async with AsyncExitStack() as stack:
+        try:
+            from mcp.client.streamable_http import streamable_http_client
+        except ImportError:
+            # Pre-rename SDK (an older ha-mcp resolved by a pip-spec override
+            # pins an older fastmcp/mcp): same call shape, deprecated name,
+            # and no http_client kwarg — it builds its own default client, so
+            # on those old SDKs the blocking-SSL-setup cost is unavoidable.
+            from mcp.client.streamable_http import streamablehttp_client
+
+            transport = streamablehttp_client(url=url)
+        else:
+            import httpx
 
-        transport = streamablehttp_client(url=url)
+            http_client = await stack.enter_async_context(
+                httpx.AsyncClient(
+                    verify=False,
+                    timeout=httpx.Timeout(_CALL_TOOL_TIMEOUT_SECONDS),
+                )
+            )
+            transport = streamable_http_client(url=url, http_client=http_client)
 
-    async with (
-        transport as (read_stream, write_stream, _),
-        ClientSession(read_stream, write_stream) as session,
-    ):
+        read_stream, write_stream, _ = await stack.enter_async_context(transport)
+        session = await stack.enter_async_context(
+            ClientSession(read_stream, write_stream)
+        )
         init_result = await session.initialize()
         yield session, init_result
 
@@ -350,7 +365,7 @@ async def _forward_tool_call(
     try:
         async with (
             asyncio.timeout(_CALL_TOOL_TIMEOUT_SECONDS),
-            _mcp_session(server_url, get_async_client(hass)) as (session, _init),
+            _mcp_session(server_url) as (session, _init),
         ):
             result = await session.call_tool(name, arguments)
     except _transport_errors() as err:
@@ -496,7 +511,7 @@ async def async_get_api_instance(
         try:
             async with (
                 asyncio.timeout(_LIST_TOOLS_TIMEOUT_SECONDS),
-                _mcp_session(self.server_url, get_async_client(self.hass)) as (
+                _mcp_session(self.server_url) as (
                     session,
                     init_result,
                 ),

tests/src/unit/_embedded_stubs.py

@@ -626,13 +626,6 @@ def setmod(name: str, **attrs: Any) -> ModuleType:
         "homeassistant.helpers.aiohttp_client",
         async_get_clientsession=MagicMock(name="async_get_clientsession"),
     )
-    # Shared httpx client helper (#1745 llm_api): the SDK receives it as
-    # http_client so session opens never build a client (and its blocking
-    # SSL setup) inside the event loop.
-    setmod(
-        "homeassistant.helpers.httpx_client",
-        get_async_client=MagicMock(name="get_async_client"),
-    )
     setmod(
         "homeassistant.helpers.event",
         async_track_time_interval=MagicMock(

tests/src/unit/test_llm_api.py

@@ -94,9 +94,8 @@ def _fake_session(
     init_result = SimpleNamespace(instructions=instructions)
 
     @asynccontextmanager
-    async def fake_mcp_session(url, http_client=None):
+    async def fake_mcp_session(url):
         session.url = url
-        session.http_client = http_client
         if raise_on_open is not None:
             raise raise_on_open
         if delay:
@@ -690,15 +689,25 @@ async def test_unknown_mode_degrades_to_tool_search(self, monkeypatch):
         assert [t.name for t in instance.tools] == ["ha_search_tools", "ha_call_tool"]
 
 
-class TestSharedHttpClientPassthrough:
-    async def test_canonical_sdk_receives_hass_shared_client(self, monkeypatch):
-        # The blocking-SSL-setup fix (live-found by HA's event-loop monitor):
-        # sessions must hand HA's shared httpx client to the SDK so it never
-        # constructs its own inside the loop. Faked at the sys.modules level
-        # so _mcp_session's REAL wiring runs.
+class TestLoopbackHttpClientTimeout:
+    async def test_sdk_receives_a_dedicated_client_with_generous_timeout(
+        self, monkeypatch
+    ):
+        # Regression test (kpop-timeout investigation): _mcp_session used to
+        # hand the SDK Home Assistant's shared httpx client
+        # (helpers.httpx_client.get_async_client). HA never configures that
+        # client with an explicit timeout, so it silently carried httpx's own
+        # hardcoded 5-second default — and the SDK applies no timeout of its
+        # own when a caller-provided client is passed, so that 5s became the
+        # REAL wire-level ceiling for every tool call regardless of how
+        # generous _CALL_TOOL_TIMEOUT_SECONDS looked. _mcp_session must
+        # instead build its own client with an explicit, generous timeout.
+        # Faked at the sys.modules level so _mcp_session's REAL wiring runs.
         import sys
         from types import ModuleType
 
+        import httpx
+
         opened: dict[str, Any] = {}
 
         @asynccontextmanager
@@ -729,13 +738,18 @@ async def initialize(self):
         monkeypatch.setitem(sys.modules, "mcp.client.streamable_http", fake_transport)
         monkeypatch.setitem(sys.modules, "mcp.client.session", fake_session_mod)
 
-        shared_client = object()
-        async with llm_api._mcp_session(
-            "http://127.0.0.1:9584/private_x", shared_client
-        ):
-            pass
+        async with llm_api._mcp_session("http://127.0.0.1:9584/private_x"):
+            used_client = opened["http_client"]
+            assert isinstance(used_client, httpx.AsyncClient)
+            assert used_client.timeout == httpx.Timeout(
+                llm_api._CALL_TOOL_TIMEOUT_SECONDS
+            )
+            # Not httpx's hardcoded default — the exact bug being fixed.
+            assert used_client.timeout != httpx.Timeout(5.0)
+            assert not used_client.is_closed
 
-        assert opened["http_client"] is shared_client
+        # Scoped to this one session: closed when the session exits.
+        assert used_client.is_closed
 
 
 class TestPreRenameSdkFallback: