@aiwerk/mcp-bridge 2.8.26 → 2.8.28

package/dist/src/standalone-server.d.ts

@@ -30,6 +30,14 @@ export declare class StandaloneServer {
     /** Connect to all backend servers and discover their tools (direct mode). */
     private discoverDirectTools;
     private _doDiscovery;
+    /** Extract server name from a tool name like "todoist_call" or "github_call" */
+    private guessServerFromToolName;
+    /** Discover tools from a single server (lazy, per-server) */
+    private discoverSingleServer;
+    /** Save discovered tools to disk cache */
+    private saveToolCache;
+    /** Load cached tools from disk */
+    private loadToolCache;
     private nextRequestId;
     private createTransport;
     /** Graceful shutdown: disconnect all backend servers. */

package/dist/src/standalone-server.js

@@ -7,6 +7,9 @@ import { StdioTransport } from "./transport-stdio.js";
 import { StreamableHttpTransport } from "./transport-streamable-http.js";
 import { OAuth2TokenManager } from "./oauth2-token-manager.js";
 import { FileTokenStore } from "./token-store.js";
+import { homedir } from "os";
+import { join } from "path";
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
 /**
  * Standalone MCP server that wraps the router.
  * Implements the MCP protocol (initialize, tools/list, tools/call)
@@ -244,14 +247,54 @@ export class StandaloneServer {
                 }
             };
         }
-        // Direct mode: discover all tools from all servers
-        await this.discoverDirectTools();
-        const tools = this.directTools.map(t => ({
-            name: t.registeredName,
-            description: t.description,
-            inputSchema: t.inputSchema
-        }));
-        return { jsonrpc: "2.0", id, result: { tools } };
+        // Direct mode: return tools lazily
+        // If already discovered, use real tool list. Otherwise, generate placeholder
+        // tools from config descriptions (no child process startup on tools/list).
+        if (this.directTools.length > 0) {
+            const tools = this.directTools.map(t => ({
+                name: t.registeredName,
+                description: t.description,
+                inputSchema: t.inputSchema
+            }));
+            return { jsonrpc: "2.0", id, result: { tools } };
+        }
+        // Lazy: try cache first, then placeholder
+        const lazyTools = [];
+        const globalNames = new Set();
+        for (const [serverName, serverConfig] of Object.entries(this.config.servers)) {
+            const cached = this.loadToolCache(serverName);
+            if (cached && cached.length > 0) {
+                // Use cached tools (real tool names + descriptions, no child process)
+                const localNames = new Set();
+                for (const tool of cached) {
+                    const registeredName = pickRegisteredToolName(serverName, tool.name, this.config.toolPrefix, localNames, globalNames, this.logger);
+                    localNames.add(registeredName);
+                    globalNames.add(registeredName);
+                    lazyTools.push({ name: registeredName, description: tool.description, inputSchema: tool.inputSchema });
+                    // Also populate directTools so call works with lazy connect
+                    this.directTools.push({
+                        serverName, originalName: tool.name, registeredName,
+                        description: tool.description, inputSchema: tool.inputSchema
+                    });
+                }
+            }
+            else {
+                // No cache: single placeholder per server
+                const desc = serverConfig.description || serverName;
+                const registeredName = pickRegisteredToolName(serverName, "call", this.config.toolPrefix, new Set(), globalNames, this.logger);
+                globalNames.add(registeredName);
+                lazyTools.push({
+                    name: registeredName,
+                    description: `[${serverName}] ${desc} — call this tool to discover all available tools from this server.`,
+                    inputSchema: { type: "object", properties: { _discover: { type: "boolean", description: "Set to true to discover all tools" } } }
+                });
+                this.directTools.push({
+                    serverName, originalName: "call", registeredName,
+                    description: `[${serverName}] ${desc}`, inputSchema: {}
+                });
+            }
+        }
+        return { jsonrpc: "2.0", id, result: { tools: lazyTools } };
     }
     async handleToolsCall(id, params) {
         const toolName = params?.name;
@@ -295,7 +338,29 @@ export class StandaloneServer {
             };
         }
         // Direct mode: find and call the tool
-        const entry = this.directTools.find(t => t.registeredName === toolName);
+        let entry = this.directTools.find(t => t.registeredName === toolName);
+        // Lazy discovery: if tool not found, discover only the relevant server (not all)
+        if (!entry) {
+            // Extract server name from tool name (prefix_toolname pattern)
+            const serverName = this.guessServerFromToolName(toolName);
+            if (serverName) {
+                this.logger.info(`[mcp-bridge] Lazy discovery for server: ${serverName} (triggered by ${toolName})`);
+                await this.discoverSingleServer(serverName);
+                entry = this.directTools.find(t => t.registeredName === toolName);
+                // If the original call was a placeholder (_discover), return discovered tools
+                if (!entry && toolArgs?._discover) {
+                    const serverTools = this.directTools.filter(t => t.serverName === serverName);
+                    const discovered = serverTools.map(t => `${t.registeredName}: ${t.description}`);
+                    return {
+                        jsonrpc: "2.0",
+                        id,
+                        result: {
+                            content: [{ type: "text", text: `Discovered ${serverTools.length} tools from ${serverName}:\n${discovered.join("\n")}` }]
+                        }
+                    };
+                }
+            }
+        }
         if (!entry) {
             return {
                 jsonrpc: "2.0",
@@ -308,7 +373,32 @@ export class StandaloneServer {
             };
         }
         try {
-            const conn = this.directConnections.get(entry.serverName);
+            let conn = this.directConnections.get(entry.serverName);
+            // Lazy connect: if server not connected yet, connect now
+            if (!conn || !conn.transport.isConnected()) {
+                const serverConfig = this.config.servers[entry.serverName];
+                if (serverConfig) {
+                    try {
+                        this.logger.info(`[mcp-bridge] Lazy connecting to ${entry.serverName}...`);
+                        const transport = this.createTransport(entry.serverName, serverConfig);
+                        await transport.connect();
+                        await initializeProtocol(transport, PACKAGE_VERSION);
+                        conn = { transport, initialized: true };
+                        this.directConnections.set(entry.serverName, conn);
+                    }
+                    catch (connErr) {
+                        return {
+                            jsonrpc: "2.0",
+                            id,
+                            error: {
+                                code: -32001,
+                                message: `Failed to connect to ${entry.serverName}: ${connErr instanceof Error ? connErr.message : String(connErr)}`,
+                                data: { errorType: "connection_failed", server: entry.serverName, retriable: true }
+                            }
+                        };
+                    }
+                }
+            }
             if (!conn || !conn.transport.isConnected()) {
                 return {
                     jsonrpc: "2.0",
@@ -407,6 +497,76 @@ export class StandaloneServer {
             }
         }
     }
+    /** Extract server name from a tool name like "todoist_call" or "github_call" */
+    guessServerFromToolName(toolName) {
+        // Try exact match with placeholder pattern: serverName_call
+        for (const serverName of Object.keys(this.config.servers)) {
+            if (toolName.startsWith(serverName + "_") || toolName === serverName) {
+                return serverName;
+            }
+        }
+        return null;
+    }
+    /** Discover tools from a single server (lazy, per-server) */
+    async discoverSingleServer(serverName) {
+        const serverConfig = this.config.servers[serverName];
+        if (!serverConfig)
+            return;
+        // Skip if already connected
+        const existing = this.directConnections.get(serverName);
+        if (existing?.initialized)
+            return;
+        try {
+            const transport = this.createTransport(serverName, serverConfig);
+            await transport.connect();
+            await initializeProtocol(transport, PACKAGE_VERSION);
+            this.directConnections.set(serverName, { transport, initialized: true });
+            const tools = await fetchToolsList(transport);
+            const globalNames = new Set(this.directTools.map(t => t.registeredName));
+            const localNames = new Set();
+            // Remove placeholder entries for this server
+            this.directTools = this.directTools.filter(t => t.serverName !== serverName);
+            for (const tool of tools) {
+                const registeredName = pickRegisteredToolName(serverName, tool.name, this.config.toolPrefix, localNames, globalNames, this.logger);
+                localNames.add(registeredName);
+                globalNames.add(registeredName);
+                this.directTools.push({
+                    serverName,
+                    originalName: tool.name,
+                    registeredName,
+                    description: tool.description,
+                    inputSchema: tool.inputSchema
+                });
+            }
+            // Cache tools to disk
+            this.saveToolCache(serverName, tools);
+            this.logger.info(`[mcp-bridge] Discovered ${tools.length} tools from ${serverName}`);
+        }
+        catch (err) {
+            this.logger.error(`[mcp-bridge] Failed to discover ${serverName}:`, err);
+        }
+    }
+    /** Save discovered tools to disk cache */
+    saveToolCache(serverName, tools) {
+        try {
+            const cacheDir = join(homedir(), ".mcp-bridge", "cache");
+            mkdirSync(cacheDir, { recursive: true });
+            const cachePath = join(cacheDir, `${serverName}-tools.json`);
+            writeFileSync(cachePath, JSON.stringify(tools, null, 2), "utf-8");
+        }
+        catch { /* ignore cache write errors */ }
+    }
+    /** Load cached tools from disk */
+    loadToolCache(serverName) {
+        try {
+            const cachePath = join(homedir(), ".mcp-bridge", "cache", `${serverName}-tools.json`);
+            if (existsSync(cachePath)) {
+                return JSON.parse(readFileSync(cachePath, "utf-8"));
+            }
+        }
+        catch { /* ignore cache read errors */ }
+        return null;
+    }
     nextRequestId() {
         return nextRequestId(this.requestIdState);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aiwerk/mcp-bridge",
-  "version": "2.8.26",
+  "version": "2.8.28",
   "description": "Standalone MCP server that multiplexes multiple MCP servers into one interface",
   "type": "module",
   "main": "./dist/src/index.js",