@aiwerk/mcp-bridge 2.8.31 → 2.8.33

package/dist/bin/mcp-bridge.js

@@ -593,6 +593,41 @@ async function cmdInstall(serverName, args, logger) {
     }
     else {
         process.stdout.write(`All required environment variables are set. Ready to use.\n`);
+        // Pre-discover tools and cache them (so direct mode has tools on first start)
+        process.stdout.write(`\nDiscovering tools...\n`);
+        try {
+            const { StdioTransport } = await import("../src/transport-stdio.js");
+            const { SseTransport } = await import("../src/transport-sse.js");
+            const { StreamableHttpTransport } = await import("../src/transport-streamable-http.js");
+            const { fetchToolsList, initializeProtocol, PACKAGE_VERSION } = await import("../src/protocol.js");
+            let transport;
+            if (serverConfig.transport === "stdio") {
+                transport = new StdioTransport(serverConfig, { servers: {} }, logger, async () => { });
+            }
+            else if (serverConfig.transport === "sse") {
+                transport = new SseTransport(serverConfig, { servers: {} }, logger, async () => { });
+            }
+            else if (serverConfig.transport === "streamable-http") {
+                transport = new StreamableHttpTransport(serverConfig, { servers: {} }, logger, async () => { });
+            }
+            if (transport) {
+                await transport.connect();
+                await initializeProtocol(transport, PACKAGE_VERSION);
+                const tools = await fetchToolsList(transport);
+                // Save to cache
+                const cacheToolDir = join(configDir, "cache");
+                mkdirSync(cacheToolDir, { recursive: true });
+                writeFileSync(join(cacheToolDir, `${serverName}-tools.json`), JSON.stringify(tools, null, 2), "utf-8");
+                process.stdout.write(`✓ Cached ${tools.length} tools from "${serverName}"\n`);
+                // Disconnect
+                await transport.disconnect().catch(() => { });
+            }
+        }
+        catch (discErr) {
+            // Non-fatal: tool discovery is a nice-to-have, server still installed
+            logger.info(`Tool discovery skipped: ${discErr instanceof Error ? discErr.message : String(discErr)}`);
+            process.stdout.write(`Tool discovery skipped (server will discover tools on first use).\n`);
+        }
     }
 }
 async function cmdUpdate(logger, checkOnly) {

package/dist/src/standalone-server.js

@@ -260,9 +260,10 @@ export class StandaloneServer {
             }));
             return { jsonrpc: "2.0", id, result: { tools } };
         }
-        // Lazy: try cache first, then placeholder
+        // Lazy: try cache first, add discover tool for uncached servers
         const lazyTools = [];
         const globalNames = new Set();
+        const uncachedServers = [];
         for (const [serverName, serverConfig] of Object.entries(this.config.servers)) {
             const cached = this.loadToolCache(serverName);
             if (cached && cached.length > 0) {
@@ -273,7 +274,6 @@ export class StandaloneServer {
                     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
@@ -281,21 +281,31 @@ export class StandaloneServer {
                 }
             }
             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: {}
-                });
+                uncachedServers.push(serverName);
             }
         }
+        // Add a single discover tool if there are uncached servers
+        if (uncachedServers.length > 0) {
+            const serverDescs = uncachedServers.map(name => {
+                const desc = this.config.servers[name]?.description || name;
+                return `${name} (${desc})`;
+            });
+            lazyTools.push({
+                name: "mcp_discover",
+                description: `Connect to MCP servers and discover their tools. Servers not yet connected: ${serverDescs.join(", ")}. Call this before using any of these servers.`,
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        server: {
+                            type: "string",
+                            description: `Server to discover. Available: ${uncachedServers.join(", ")}`,
+                            enum: uncachedServers
+                        }
+                    },
+                    required: ["server"]
+                }
+            });
+        }
         return { jsonrpc: "2.0", id, result: { tools: lazyTools } };
     }
     async handleToolsCall(id, params) {
@@ -339,29 +349,34 @@ export class StandaloneServer {
                 }
             };
         }
+        // Handle mcp_discover tool
+        if (toolName === "mcp_discover") {
+            const serverName = toolArgs?.server;
+            if (!serverName || !this.config.servers[serverName]) {
+                const available = Object.keys(this.config.servers).join(", ");
+                return {
+                    jsonrpc: "2.0", id,
+                    result: { content: [{ type: "text", text: `Please specify a server. Available: ${available}` }] }
+                };
+            }
+            this.logger.info(`[mcp-bridge] Discovering server: ${serverName}`);
+            await this.discoverSingleServer(serverName);
+            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: `Connected to "${serverName}". Discovered ${serverTools.length} tools:\n\n${discovered.join("\n")}\n\nThese tools are now available. Call them directly by name.` }] }
+            };
+        }
         // Direct mode: find and call the tool
         let entry = this.directTools.find(t => t.registeredName === toolName);
-        // Lazy discovery: if tool not found, discover only the relevant server (not all)
+        // Lazy discovery: if tool not found, try to discover the relevant server
         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})`);
+            if (serverName && !this.directConnections.get(serverName)?.initialized) {
+                this.logger.info(`[mcp-bridge] Auto-discovering server: ${serverName} (triggered by ${toolName})`);
                 await this.discoverSingleServer(serverName);
-                // After discovery, try to find the real tool
                 entry = this.directTools.find(t => t.registeredName === toolName);
-                if (!entry) {
-                    // Placeholder was called — return discovered tools list and notify client to refresh
-                    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: `Server "${serverName}" is now connected with ${serverTools.length} tools. The tool list has been updated — please retry your request. Available tools:\n\n${discovered.join("\n")}` }]
-                        }
-                    };
-                }
             }
         }
         if (!entry) {

package/package.json

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