@aiwerk/mcp-bridge 2.8.30 → 2.8.32

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

@@ -14,6 +14,7 @@ export declare class StandaloneServer {
     private readonly requestIdState;
     private directTools;
     private directConnections;
+    private stdoutRef;
     constructor(config: BridgeConfig, logger: Logger);
     private isRouterMode;
     /** Start stdio mode: read JSON-RPC from stdin, write responses to stdout.
@@ -30,6 +31,8 @@ export declare class StandaloneServer {
     /** Connect to all backend servers and discover their tools (direct mode). */
     private discoverDirectTools;
     private _doDiscovery;
+    /** Send notifications/tools/list_changed to the client via stdout */
+    private sendToolsChanged;
     /** Extract server name from a tool name like "todoist_call" or "github_call" */
     private guessServerFromToolName;
     /** Discover tools from a single server (lazy, per-server) */

package/dist/src/standalone-server.js

@@ -26,6 +26,7 @@ export class StandaloneServer {
     // Direct mode state
     directTools = [];
     directConnections = new Map();
+    stdoutRef = null;
     constructor(config, logger) {
         this.config = config;
         this.logger = logger;
@@ -50,6 +51,7 @@ export class StandaloneServer {
     async startStdio() {
         const stdin = process.stdin;
         const stdout = process.stdout;
+        this.stdoutRef = stdout;
         let buffer = Buffer.alloc(0);
         // LSP framing state
         let lspContentLength = -1; // -1 means not in LSP mode for current message
@@ -258,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) {
@@ -271,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
@@ -279,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) {
@@ -337,25 +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, the placeholder tool no longer exists - return discovered tools
-                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}. Available tools:\n\n${discovered.join("\n")}\n\nCall any of these tools directly by name.` }]
-                    }
-                };
+                entry = this.directTools.find(t => t.registeredName === toolName);
             }
         }
         if (!entry) {
@@ -494,6 +515,14 @@ export class StandaloneServer {
             }
         }
     }
+    /** Send notifications/tools/list_changed to the client via stdout */
+    sendToolsChanged() {
+        if (!this.stdoutRef)
+            return;
+        const notification = { jsonrpc: "2.0", method: "notifications/tools/list_changed" };
+        this.writeResponse(this.stdoutRef, notification);
+        this.logger.info("[mcp-bridge] Sent notifications/tools/list_changed");
+    }
     /** Extract server name from a tool name like "todoist_call" or "github_call" */
     guessServerFromToolName(toolName) {
         // Try exact match with placeholder pattern: serverName_call
@@ -538,6 +567,8 @@ export class StandaloneServer {
             // Cache tools to disk
             this.saveToolCache(serverName, tools);
             this.logger.info(`[mcp-bridge] Discovered ${tools.length} tools from ${serverName}`);
+            // Notify client that tool list changed (MCP spec: notifications/tools/list_changed)
+            this.sendToolsChanged();
         }
         catch (err) {
             this.logger.error(`[mcp-bridge] Failed to discover ${serverName}:`, err);

package/package.json

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