fix(component): keep the pre-rename SDK fallback off env proxies too

The trust_env=False fix only covered the canonical streamable_http_client
path. The deprecated streamablehttp_client fallback (older fastmcp/mcp
pinned via a pip-spec override) takes no http_client param, but it DOES
accept an httpx_client_factory override for the client it builds
internally - so it was still trusting HTTP_PROXY/NO_PROXY by default.
Pass _loopback_httpx_client_factory there too, which builds the same
verify=False/trust_env=False client as the canonical path.

Review finding (chatgpt-codex-connector) on #2276.

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

Author: swissmo

custom_components/ha_mcp_tools/llm_api.py

@@ -71,6 +71,7 @@
 )
 
 if TYPE_CHECKING:
+    import httpx
     from homeassistant.config_entries import ConfigEntry
     from homeassistant.util.json import JsonObjectType
     from mcp import types as mcp_types
@@ -222,6 +223,28 @@ async def async_probe_mcp_sdk(hass: HomeAssistant) -> bool:
     return True
 
 
+def _loopback_httpx_client_factory(
+    headers: dict[str, str] | None = None,
+    timeout: httpx.Timeout | None = None,
+    auth: httpx.Auth | None = None,
+) -> httpx.AsyncClient:
+    """``httpx_client_factory`` for the pre-rename SDK's ``streamablehttp_client``.
+
+    That deprecated entry point takes no ``http_client`` — it always builds
+    its own via this factory — but the factory itself IS overridable, so the
+    same ``verify=False`` / ``trust_env=False`` posture as the canonical path
+    in :func:`_mcp_session` still applies: this fallback is loopback-only
+    too, so a real SSL context is pure waste and this call must never be
+    diverted through an environment proxy (which would also leak the URL's
+    embedded ``secret_path`` to it).
+    """
+    import httpx
+
+    return httpx.AsyncClient(
+        headers=headers, timeout=timeout, auth=auth, verify=False, trust_env=False
+    )
+
+
 @asynccontextmanager
 async def _mcp_session(
     url: str,
@@ -273,11 +296,15 @@ async def _mcp_session(
         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.
+            # and no http_client kwarg — but it does accept a factory for the
+            # client it builds internally, so _loopback_httpx_client_factory
+            # keeps this fallback on the same verify=False/trust_env=False
+            # posture as the canonical path below.
             from mcp.client.streamable_http import streamablehttp_client
 
-            transport = streamablehttp_client(url=url)
+            transport = streamablehttp_client(
+                url=url, httpx_client_factory=_loopback_httpx_client_factory
+            )
         else:
             import httpx
 

tests/src/unit/test_llm_api.py

@@ -770,8 +770,9 @@ async def test_falls_back_to_deprecated_client_name(self, monkeypatch):
         opened: dict[str, Any] = {}
 
         @asynccontextmanager
-        async def _old_name_client(url):
+        async def _old_name_client(url, httpx_client_factory=None):
             opened["url"] = url
+            opened["httpx_client_factory"] = httpx_client_factory
             yield "read-stream", "write-stream", lambda: None
 
         fake_transport = ModuleType("mcp.client.streamable_http")
@@ -806,3 +807,16 @@ async def initialize(self):
 
         assert opened["url"] == "http://127.0.0.1:9584/private_x"
         assert opened["streams"] == ("read-stream", "write-stream")
+        # Regression (review finding on #2276): the deprecated entry point
+        # takes no http_client, but it DOES accept a factory for the client
+        # it builds internally — _mcp_session must hand it one that keeps
+        # this fallback off environment proxies too, not just the canonical
+        # path.
+        assert opened["httpx_client_factory"] is llm_api._loopback_httpx_client_factory
+
+    async def test_loopback_factory_builds_a_client_that_ignores_env_proxies(self):
+        client = llm_api._loopback_httpx_client_factory()
+        try:
+            assert client.trust_env is False
+        finally:
+            await client.aclose()