modality-mcp-kit 1.6.0 → 1.6.2

package/dist/util_mcp_proxy.js

@@ -226,6 +226,93 @@ function clearStoredOAuthTokens(serverUrl) {
         return false;
     }
 }
+// ============================================
+// TOOL PREFETCH HELPERS
+// ============================================
+function parseToolsFromBody(body) {
+    try {
+        const parsed = JSON.parse(body);
+        if (parsed?.result?.tools)
+            return parsed.result.tools;
+    }
+    catch {
+        // Try SSE format
+        const lines = body.split("\n");
+        for (const line of lines) {
+            if (line.startsWith("data: ")) {
+                try {
+                    const parsed = JSON.parse(line.substring(6));
+                    if (parsed?.result?.tools)
+                        return parsed.result.tools;
+                }
+                catch { }
+            }
+        }
+    }
+    return null;
+}
+async function prefetchAndCacheTools(mcpName, serverUrl, cache, storedToken) {
+    const cacheKey = "tools/list";
+    const cached = cache.get(cacheKey);
+    if (cached) {
+        const dataLine = cached.match(/^data: (.+)$/m)?.[1] ?? cached;
+        return { tools: parseToolsFromBody(dataLine), fromCache: true };
+    }
+    try {
+        const headers = {
+            "Content-Type": "application/json",
+            Accept: "application/json, text/event-stream",
+        };
+        if (storedToken) {
+            headers.authorization = `Bearer ${storedToken}`;
+        }
+        // Step 1: initialize session (required by MCP protocol before tools/list)
+        const initResponse = await fetch(serverUrl, {
+            method: "POST",
+            headers,
+            body: JSON.stringify({
+                jsonrpc: "2.0",
+                id: 1,
+                method: "initialize",
+                params: {
+                    protocolVersion: "2024-11-05",
+                    capabilities: {},
+                    clientInfo: { name: "mcp-proxy", version: "1.0" },
+                },
+            }),
+        });
+        if (!initResponse.ok) {
+            console.warn(`[MCP-PROXY] Initialize failed for ${mcpName} — status: ${initResponse.status}`);
+            return { tools: null, fromCache: false };
+        }
+        const sessionId = initResponse.headers.get("mcp-session-id");
+        if (sessionId) {
+            headers["mcp-session-id"] = sessionId;
+        }
+        // Step 2: fetch tools/list
+        const response = await fetch(serverUrl, {
+            method: "POST",
+            headers,
+            body: JSON.stringify({ jsonrpc: "2.0", id: 2, method: "tools/list", params: {} }),
+        });
+        const body = await response.text();
+        const tools = parseToolsFromBody(body);
+        if (response.ok && tools !== null) {
+            const ttl = METHOD_TTL_MS["tools/list"];
+            const cacheValue = body.includes("event:") ? body : `event: message\ndata: ${body}\n\n`;
+            cache.set(cacheKey, cacheValue, ttl);
+            console.log(`[MCP-PROXY] Prefetched and cached tools/list for ${mcpName}`);
+        }
+        else {
+            console.warn(`[MCP-PROXY] Skipping cache for ${mcpName} tools/list — status: ${response.status}, tools parsed: ${tools !== null}`);
+        }
+        return { tools, fromCache: false };
+    }
+    catch (e) {
+        console.error(`[MCP-PROXY] Failed to prefetch tools for ${mcpName}:`, e);
+        return { tools: null, fromCache: false };
+    }
+}
 /**
  * Hono handler for MCP proxy
  * @param c - Hono context with mcpName param
@@ -271,6 +358,26 @@ export const mcpProxyHandler = (MCP_SERVERS, oauthAllowAccess) => async (c) => {
                 : "No cached OAuth state found",
         });
     }
+    // Handle /_tools sub-route — prefetch and return cached tool list
+    if (c.req.path.endsWith("/_tools")) {
+        const serverConfig = MCP_SERVERS[mcpName];
+        if (!serverConfig) {
+            return c.json({ error: "MCP server not found", availableServers: Object.keys(MCP_SERVERS) }, 404);
+        }
+        const cache = getServerCache(mcpName);
+        const storedToken = getStoredOAuthToken(serverConfig.url);
+        const { tools, fromCache } = await prefetchAndCacheTools(mcpName, serverConfig.url, cache, storedToken);
+        const namesOnly = c.req.query("names") !== undefined;
+        if (namesOnly) {
+            return c.json(tools?.map((t) => t.name) ?? []);
+        }
+        return c.json({
+            mcpName,
+            fromCache,
+            count: tools?.length ?? 0,
+            tools: tools ?? [],
+        });
+    }
     // Handle /_cache sub-routes (matched via app.use prefix routing)
     const cachePathMatch = c.req.path.match(/\/_cache(?:\/(.+))?$/);
     if (cachePathMatch) {
@@ -385,6 +492,7 @@ export const mcpProxyHandler = (MCP_SERVERS, oauthAllowAccess) => async (c) => {
             endpoints: {
                 sse: `${basePath} (GET, Accept: text/event-stream)`,
                 rpc: `${basePath} (POST)`,
+                tools: `${basePath}/_tools`,
                 allow: `${basePath}/_allow`,
                 clearAuth: `${basePath}/_clear-auth`,
                 cache: `${basePath}/_cache`,

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.6.0",
+  "version": "1.6.2",
   "name": "modality-mcp-kit",
   "repository": {
     "type": "git",