cache resources and prompts

Author: lorenss-m

hud/environment/connection.py

@@ -134,7 +134,11 @@ async def disconnect(self) -> None:
         self._resources_cache = None
 
     async def list_tools(self) -> list[mcp_types.Tool]:
-        """Fetch tools from server, apply filters/transforms/prefix, and cache."""
+        """Fetch tools from server, apply filters/transforms/prefix, and cache.
+
+        Always fetches fresh data from the server (no caching check).
+        The result is cached for use by router.build() via cached_tools property.
+        """
         if self.client is None:
             raise RuntimeError("Not connected - call connect() first")
         tools = await self.client.list_tools()
@@ -189,21 +193,25 @@ async def call_tool(
             name = name[len(self.config.prefix) + 1 :]
         return await self.client.call_tool_mcp(name, arguments or {})
 
-    async def list_resources(self, *, refresh: bool = False) -> list[mcp_types.Resource]:
-        """Fetch resources from server and cache."""
+    async def list_resources(self) -> list[mcp_types.Resource]:
+        """Fetch resources from server and cache.
+
+        Always fetches fresh data from the server (no caching check).
+        The result is cached for use by router.build_resources() via cached_resources property.
+        """
         if self.client is None:
             raise RuntimeError("Not connected - call connect() first")
-        if self._resources_cache is not None and not refresh:
-            return self._resources_cache
         self._resources_cache = await self.client.list_resources()
         return self._resources_cache
 
-    async def list_prompts(self, *, refresh: bool = False) -> list[mcp_types.Prompt]:
-        """Fetch prompts from server and cache."""
+    async def list_prompts(self) -> list[mcp_types.Prompt]:
+        """Fetch prompts from server and cache.
+
+        Always fetches fresh data from the server (no caching check).
+        The result is cached for use by router.build_prompts() via cached_prompts property.
+        """
         if self.client is None:
             raise RuntimeError("Not connected - call connect() first")
-        if self._prompts_cache is not None and not refresh:
-            return self._prompts_cache
         self._prompts_cache = await self.client.list_prompts()
         return self._prompts_cache
 

hud/environment/environment.py

@@ -455,14 +455,14 @@ async def _build_prompt_routing(self) -> None:
         """Build prompt routing from local prompts and connections."""
         local_prompts_dict = await self._prompt_manager.get_prompts()
         local_prompts = [p.to_mcp_prompt() for p in local_prompts_dict.values()]
-        await self._router.build_prompts(local_prompts, self._connections)
+        self._router.build_prompts(local_prompts, self._connections)
         self._prompt_routing_built = True
 
     async def _build_resource_routing(self) -> None:
         """Build resource routing from local resources and connections."""
         local_resources_dict = await self._resource_manager.get_resources()
         local_resources = [r.to_mcp_resource() for r in local_resources_dict.values()]
-        await self._router.build_resources(local_resources, self._connections)
+        self._router.build_resources(local_resources, self._connections)
         self._resource_routing_built = True
 
     # =========================================================================
@@ -540,7 +540,7 @@ async def _execute_tool(self, name: str, arguments: dict[str, Any]) -> MCPToolRe
     async def list_resources(self) -> list[mcp_types.Resource]:
         """Refresh resources from all connections and rebuild resource routing."""
         if self._connections:
-            await asyncio.gather(*[c.list_resources(refresh=True) for c in self._connections.values()])
+            await asyncio.gather(*[c.list_resources() for c in self._connections.values()])
         await self._build_resource_routing()
         return self._router.resources
 
@@ -588,7 +588,7 @@ async def read_resource(
     async def list_prompts(self) -> list[mcp_types.Prompt]:
         """Refresh prompts from all connections and rebuild prompt routing."""
         if self._connections:
-            await asyncio.gather(*[c.list_prompts(refresh=True) for c in self._connections.values()])
+            await asyncio.gather(*[c.list_prompts() for c in self._connections.values()])
         await self._build_prompt_routing()
         return self._router.prompts
 

hud/environment/router.py

@@ -2,7 +2,6 @@
 
 from __future__ import annotations
 
-import asyncio
 import logging
 from dataclasses import dataclass, field
 from enum import Enum
@@ -162,14 +161,14 @@ def build(
 
         logger.debug("Router: %d tools (%d local)", len(self._tools), len(self._local_tool_names))
 
-    async def build_prompts(
+    def build_prompts(
         self,
         local_prompts: list[mcp_types.Prompt],
         connections: dict[str, Connector],
     ) -> None:
         """Build prompt routing from local prompts and connections.
 
-        Fetches prompts from all connections in parallel for performance.
+        Uses cached prompts from connections (populated during __aenter__).
         """
         self._prompts.clear()
         self._prompt_routing.clear()
@@ -182,17 +181,10 @@ async def build_prompts(
             self._prompt_routing[prompt.name] = LOCAL_CONNECTION
             self._prompts.append(prompt)
 
-        # Fetch remote prompts in parallel
-        async def fetch_prompts(
-            conn_name: str, conn: Connector
-        ) -> tuple[str, list[mcp_types.Prompt]]:
-            try:
-                return conn_name, conn.cached_prompts or await conn.list_prompts()
-            except Exception as e:
-                logger.debug("Failed to list prompts from %s: %s", conn_name, e)
-                return conn_name, []
-
-        results = await asyncio.gather(*[fetch_prompts(n, c) for n, c in connections.items()])
+        # Use cached prompts from each connection (populated during __aenter__)
+        results: list[tuple[str, list[mcp_types.Prompt]]] = [
+            (conn_name, conn.cached_prompts) for conn_name, conn in connections.items()
+        ]
 
         # Process results in connection order (dict preserves insertion order)
         for conn_name, remote_prompts in results:
@@ -213,14 +205,14 @@ async def fetch_prompts(
 
         logger.debug("Router: %d prompts", len(self._prompts))
 
-    async def build_resources(
+    def build_resources(
         self,
         local_resources: list[mcp_types.Resource],
         connections: dict[str, Connector],
     ) -> None:
         """Build resource routing from local resources and connections.
 
-        Fetches resources from all connections in parallel for performance.
+        Uses cached resources from connections (populated during __aenter__).
         """
         self._resources.clear()
         self._resource_routing.clear()
@@ -234,17 +226,10 @@ async def build_resources(
             self._resource_routing[uri] = LOCAL_CONNECTION
             self._resources.append(resource)
 
-        # Fetch remote resources in parallel
-        async def fetch_resources(
-            conn_name: str, conn: Connector
-        ) -> tuple[str, list[mcp_types.Resource]]:
-            try:
-                return conn_name, conn.cached_resources or await conn.list_resources()
-            except Exception as e:
-                logger.debug("Failed to list resources from %s: %s", conn_name, e)
-                return conn_name, []
-
-        results = await asyncio.gather(*[fetch_resources(n, c) for n, c in connections.items()])
+        # Use cached resources from each connection (populated during __aenter__)
+        results: list[tuple[str, list[mcp_types.Resource]]] = [
+            (conn_name, conn.cached_resources) for conn_name, conn in connections.items()
+        ]
 
         # Process results in connection order (dict preserves insertion order)
         for conn_name, remote_resources in results:

hud/environment/tests/test_environment.py

@@ -214,6 +214,14 @@ class MockConnector:
             def cached_tools(self) -> list[mcp_types.Tool]:
                 return self._tools_cache
 
+            @property
+            def cached_prompts(self) -> list[mcp_types.Prompt]:
+                return []
+
+            @property
+            def cached_resources(self) -> list[mcp_types.Resource]:
+                return []
+
             async def connect(self) -> None:
                 pass
 
@@ -294,6 +302,14 @@ class MockConnector:
             def cached_tools(self) -> list[mcp_types.Tool]:
                 return self._tools_cache
 
+            @property
+            def cached_prompts(self) -> list[mcp_types.Prompt]:
+                return []
+
+            @property
+            def cached_resources(self) -> list[mcp_types.Resource]:
+                return []
+
             async def connect(self) -> None:
                 pass