@aiwerk/mcp-bridge 1.8.0 → 2.0.0

package/README.md

@@ -139,6 +139,7 @@ Config: `~/.mcp-bridge/config.json` | Secrets: `~/.mcp-bridge/.env`
   "toolPrefix": true,
   "connectionTimeoutMs": 5000,
   "requestTimeoutMs": 60000,
+  "maxBatchSize": 10,
   "schemaCompression": {
     "enabled": true,
     "maxDescriptionLength": 80
@@ -170,6 +171,27 @@ mcp(server="todoist", action="schema", tool="find-tasks")
 
 Set `"enabled": false` to disable compression and return full descriptions.
 
+### Result Caching
+
+Router mode can cache successful `action=call` tool results in memory using an LRU policy.
+
+- Disabled by default (`resultCache.enabled: false`)
+- No external dependencies (Map-based implementation)
+- Defaults: `maxEntries: 100`, `defaultTtlMs: 300000` (5 minutes)
+- Cache key: `server:tool:stableJson(params)`
+- Per-tool TTL override via `resultCache.cacheTtl` (for example `"todoist:find-tasks": 60000`)
+- `action=refresh` clears the result cache
+- Error responses are never cached
+
+```json
+"resultCache": {
+  "enabled": true,
+  "maxEntries": 100,
+  "defaultTtlMs": 300000,
+  "cacheTtl": { "todoist:find-tasks": 60000 }
+}
+```
+
 ### Intent Routing
 
 Instead of specifying the exact server and tool, describe what you need:
@@ -200,6 +222,20 @@ The bridge uses vector embeddings to match your intent to the right server and t
 - `minScore`: minimum confidence to return a match (0-1, default: 0.3)
 - Index is built lazily on first `action=intent` call
 
+### Batch Calls
+
+Run multiple tool calls in one round-trip with `action="batch"` (parallel execution):
+
+```json
+{"action":"batch","calls":[{"server":"todoist","tool":"find-tasks","params":{"query":"today"}},{"server":"github","tool":"list_repos","params":{}}]}
+```
+
+```json
+{"action":"batch","results":[{"server":"todoist","tool":"find-tasks","result":{"tasks":[]}}, {"server":"github","tool":"list_repos","error":{"error":"mcp_error","message":"..."}}]}
+```
+
+Use `maxBatchSize` in config to cap requests (default: `10`). Failed calls return per-slot `error` while successful calls still return `result`.
+
 ### Security
 
 Three layers of protection for tool results:
@@ -304,6 +340,19 @@ Returns promoted tools (sorted by frequency) and full usage stats. All tracking
 
 **Router mode** — the agent calls `mcp(server="todoist", action="list")` to discover, then `mcp(server="todoist", tool="find-tasks", params={...})` to execute.
 
+### Multi-Server Tool Resolution
+
+When `action="call"` is used without `server=`, mcp-bridge can resolve collisions automatically.
+
+- Tool exists on exactly one server → direct dispatch.
+- Tool exists on multiple servers + explicit `server=` → explicit target wins.
+- Tool exists on multiple servers + no `server=` → score each candidate:
+  - **base_priority**: reverse config order (`last=1.0`, then `0.9`, `0.8`, floor `0.1`)
+  - **recency_boost**: `+0.3` if server used in last 5 successful calls
+  - **param_match**: up to `+0.2` based on parameter-name overlap with input schema
+- If top score gap is `>= 0.15` → auto-dispatch to the winner.
+- If top score gap is `< 0.15` → return normal `{ ambiguous: true, candidates: [...] }` response.
+
 **Direct mode** — tools are registered as `todoist_find_tasks`, `github_list_repos`, etc.
 
 ### Transports

package/dist/src/config.js

@@ -160,6 +160,7 @@ export function initConfigDir(logger) {
             requestTimeoutMs: 60000,
             routerIdleTimeoutMs: 600000,
             routerMaxConcurrent: 5,
+            maxBatchSize: 10,
             http: {
                 auth: {
                     type: "bearer",

package/dist/src/index.d.ts

@@ -1,13 +1,17 @@
-export { BaseTransport, resolveEnvVars, resolveEnvRecord, resolveArgs, warnIfNonTlsRemoteUrl } from "./transport-base.js";
+export { BaseTransport, resolveEnvVars, resolveEnvRecord, resolveArgs, resolveAuthHeaders, resolveServerHeaders, warnIfNonTlsRemoteUrl } from "./transport-base.js";
 export { StdioTransport } from "./transport-stdio.js";
 export { SseTransport } from "./transport-sse.js";
 export { StreamableHttpTransport } from "./transport-streamable-http.js";
 export { McpRouter } from "./mcp-router.js";
 export type { RouterToolHint, RouterServerStatus, RouterDispatchResponse, RouterTransportRefs } from "./mcp-router.js";
+export { ResultCache, createResultCacheKey, stableStringify } from "./result-cache.js";
+export type { ResultCacheConfig, ResultCacheStats } from "./result-cache.js";
+export { ToolResolver } from "./tool-resolution.js";
+export type { ToolResolutionResult, ToolResolutionCandidate } from "./tool-resolution.js";
 export { convertJsonSchemaToTypeBox, createToolParameters, setTypeBoxLoader, setSchemaLogger } from "./schema-convert.js";
 export { initializeProtocol, fetchToolsList, PACKAGE_VERSION } from "./protocol.js";
 export { loadConfig, parseEnvFile, initConfigDir, getConfigDir } from "./config.js";
-export type { Logger, McpServerConfig, McpClientConfig, McpTool, McpRequest, McpCallRequest, McpResponse, JsonRpcMessage, McpTransport, McpServerConnection, BridgeConfig, } from "./types.js";
+export type { Logger, McpServerConfig, McpClientConfig, HttpAuthConfig, RetryConfig, McpTool, McpRequest, McpCallRequest, McpResponse, JsonRpcMessage, McpTransport, McpServerConnection, BridgeConfig, } from "./types.js";
 export { nextRequestId } from "./types.js";
 export { pickRegisteredToolName } from "./tool-naming.js";
 export { StandaloneServer } from "./standalone-server.js";

package/dist/src/index.js

@@ -1,11 +1,14 @@
 // Core exports for @aiwerk/mcp-bridge
 // Transport classes
-export { BaseTransport, resolveEnvVars, resolveEnvRecord, resolveArgs, warnIfNonTlsRemoteUrl } from "./transport-base.js";
+export { BaseTransport, resolveEnvVars, resolveEnvRecord, resolveArgs, resolveAuthHeaders, resolveServerHeaders, warnIfNonTlsRemoteUrl } from "./transport-base.js";
 export { StdioTransport } from "./transport-stdio.js";
 export { SseTransport } from "./transport-sse.js";
 export { StreamableHttpTransport } from "./transport-streamable-http.js";
 // Router
 export { McpRouter } from "./mcp-router.js";
+// Result cache
+export { ResultCache, createResultCacheKey, stableStringify } from "./result-cache.js";
+export { ToolResolver } from "./tool-resolution.js";
 // Schema conversion
 export { convertJsonSchemaToTypeBox, createToolParameters, setTypeBoxLoader, setSchemaLogger } from "./schema-convert.js";
 // Protocol helpers

package/dist/src/mcp-router.d.ts

@@ -1,5 +1,16 @@
 import { McpClientConfig, McpServerConfig, McpTransport, Logger } from "./types.js";
 type RouterErrorCode = "unknown_server" | "unknown_tool" | "connection_failed" | "mcp_error" | "invalid_params";
+interface RouterBatchResult {
+    server: string;
+    tool: string;
+    result?: any;
+    error?: {
+        error: RouterErrorCode;
+        message: string;
+        available?: string[];
+        code?: number;
+    };
+}
 export interface RouterToolHint {
     name: string;
     description: string;
@@ -26,6 +37,7 @@ export type RouterDispatchResponse = {
     action: "call";
     tool: string;
     result: any;
+    retries?: number;
 } | {
     server: string;
     action: "schema";
@@ -35,6 +47,9 @@ export type RouterDispatchResponse = {
 } | {
     action: "status";
     servers: RouterServerStatus[];
+} | {
+    action: "batch";
+    results: RouterBatchResult[];
 } | {
     action: "promotions";
     promoted: Array<{
@@ -61,6 +76,15 @@ export type RouterDispatchResponse = {
         tool: string;
         score: number;
     }>;
+} | {
+    ambiguous: true;
+    message: string;
+    candidates: Array<{
+        server: string;
+        tool: string;
+        score: number;
+        suggested?: true;
+    }>;
 } | {
     error: RouterErrorCode;
     message: string;
@@ -79,13 +103,17 @@ export declare class McpRouter {
     private readonly transportRefs;
     private readonly idleTimeoutMs;
     private readonly maxConcurrent;
+    private readonly resultCache;
+    private readonly maxBatchSize;
     private readonly states;
+    private readonly toolResolver;
     private intentRouter;
     private promotion;
     constructor(servers: Record<string, McpServerConfig>, clientConfig: McpClientConfig, logger: Logger, transportRefs?: Partial<RouterTransportRefs>);
     static generateDescription(servers: Record<string, McpServerConfig>): string;
     dispatch(server?: string, action?: string, tool?: string, params?: any): Promise<RouterDispatchResponse>;
     getToolList(server: string): Promise<RouterToolHint[]>;
+    private primeToolResolutionIndex;
     private resolveIntent;
     private getStatus;
     getPromotedTools(): Array<{
@@ -95,7 +123,11 @@ export declare class McpRouter {
         inputSchema: any;
     }>;
     private getPromotionStats;
+    private getRetryPolicy;
+    private classifyTransientError;
+    private callToolWithRetry;
     disconnectAll(): Promise<void>;
+    shutdown(timeoutMs?: number): Promise<void>;
     private ensureConnected;
     private enforceMaxConcurrent;
     private disconnectServer;

package/dist/src/mcp-router.js

@@ -7,8 +7,12 @@ import { IntentRouter } from "./intent-router.js";
 import { createEmbeddingProvider } from "./embeddings.js";
 import { isToolAllowed, processResult } from "./security.js";
 import { AdaptivePromotion } from "./adaptive-promotion.js";
+import { ResultCache, createResultCacheKey } from "./result-cache.js";
+import { ToolResolver } from "./tool-resolution.js";
 const DEFAULT_IDLE_TIMEOUT_MS = 10 * 60 * 1000;
 const DEFAULT_MAX_CONCURRENT = 5;
+const DEFAULT_MAX_BATCH_SIZE = 10;
+const DEFAULT_SHUTDOWN_TIMEOUT_MS = 5000;
 export class McpRouter {
     servers;
     clientConfig;
@@ -16,7 +20,10 @@ export class McpRouter {
     transportRefs;
     idleTimeoutMs;
     maxConcurrent;
+    resultCache;
+    maxBatchSize;
     states = new Map();
+    toolResolver;
     intentRouter = null;
     promotion = null;
     constructor(servers, clientConfig, logger, transportRefs) {
@@ -30,6 +37,15 @@ export class McpRouter {
         };
         this.idleTimeoutMs = clientConfig.routerIdleTimeoutMs ?? DEFAULT_IDLE_TIMEOUT_MS;
         this.maxConcurrent = clientConfig.routerMaxConcurrent ?? DEFAULT_MAX_CONCURRENT;
+        this.resultCache = clientConfig.resultCache?.enabled
+            ? new ResultCache({
+                maxEntries: clientConfig.resultCache.maxEntries,
+                defaultTtlMs: clientConfig.resultCache.defaultTtlMs,
+                cacheTtl: clientConfig.resultCache.cacheTtl
+            })
+            : null;
+        this.maxBatchSize = clientConfig.maxBatchSize ?? DEFAULT_MAX_BATCH_SIZE;
+        this.toolResolver = new ToolResolver(Object.keys(servers));
         if (clientConfig.adaptivePromotion?.enabled) {
             this.promotion = new AdaptivePromotion(clientConfig.adaptivePromotion, logger);
         }
@@ -45,7 +61,7 @@ export class McpRouter {
             return desc ? `${name} (${desc})` : name;
         })
             .join(", ");
-        return `Call any MCP server tool. Servers: ${serverList}. Use action='list' to discover tools and required parameters, action='call' to execute a tool, action='refresh' to clear cache and re-discover tools, and action='status' to check server connection states. If the user mentions a specific tool by name, the call action auto-connects and works without listing first.`;
+        return `Call any MCP server tool. Servers: ${serverList}. Use action='list' to discover tools and required parameters, action='call' to execute a tool, action='batch' to execute multiple calls in one round-trip, action='refresh' to clear cache and re-discover tools, and action='status' to check server connection states. If the user mentions a specific tool by name, the call action auto-connects and works without listing first.`;
     }
     async dispatch(server, action = "call", tool, params) {
         try {
@@ -66,13 +82,45 @@ export class McpRouter {
                 }
                 return this.resolveIntent(intent);
             }
-            if (!server) {
-                return this.error("invalid_params", "server is required");
-            }
-            if (!this.servers[server]) {
-                return this.error("unknown_server", `Server '${server}' not found`, Object.keys(this.servers));
+            if (normalizedAction === "batch") {
+                const calls = params?.calls;
+                if (!Array.isArray(calls) || calls.length === 0) {
+                    return this.error("invalid_params", "calls must be a non-empty array for action=batch");
+                }
+                if (calls.length > this.maxBatchSize) {
+                    return this.error("invalid_params", `batch size exceeds maxBatchSize (${this.maxBatchSize})`);
+                }
+                const results = await Promise.all(calls.map(async (call) => {
+                    const callServer = typeof call?.server === "string" ? call.server : "";
+                    const callTool = typeof call?.tool === "string" ? call.tool : "";
+                    const response = await this.dispatch(callServer, "call", callTool, call?.params);
+                    if ("error" in response) {
+                        return {
+                            server: callServer,
+                            tool: callTool,
+                            error: {
+                                error: response.error,
+                                message: response.message,
+                                ...(response.available ? { available: response.available } : {}),
+                                ...(typeof response.code === "number" ? { code: response.code } : {})
+                            }
+                        };
+                    }
+                    return {
+                        server: callServer,
+                        tool: callTool,
+                        result: "result" in response ? response.result : response
+                    };
+                }));
+                return { action: "batch", results };
             }
             if (normalizedAction === "list") {
+                if (!server) {
+                    return this.error("invalid_params", "server is required for action=list");
+                }
+                if (!this.servers[server]) {
+                    return this.error("unknown_server", `Server '${server}' not found`, Object.keys(this.servers));
+                }
                 try {
                     const tools = await this.getToolList(server);
                     return { server, action: "list", tools };
@@ -82,6 +130,12 @@ export class McpRouter {
                 }
             }
             if (normalizedAction === "schema") {
+                if (!server) {
+                    return this.error("invalid_params", "server is required for action=schema");
+                }
+                if (!this.servers[server]) {
+                    return this.error("unknown_server", `Server '${server}' not found`, Object.keys(this.servers));
+                }
                 if (!tool) {
                     return this.error("invalid_params", "tool is required for action=schema");
                 }
@@ -99,11 +153,19 @@ export class McpRouter {
                 return { server, action: "schema", tool, schema: fullTool.inputSchema, description: fullTool.description };
             }
             if (normalizedAction === "refresh") {
+                if (!server) {
+                    return this.error("invalid_params", "server is required for action=refresh");
+                }
+                if (!this.servers[server]) {
+                    return this.error("unknown_server", `Server '${server}' not found`, Object.keys(this.servers));
+                }
+                this.resultCache?.invalidate();
                 try {
                     const state = await this.ensureConnected(server);
                     state.toolsCache = undefined;
                     state.fullToolsMap = undefined;
                     state.toolNames = [];
+                    this.toolResolver.removeServer(server);
                     // Clear intent index so it re-indexes on next intent query
                     if (this.intentRouter) {
                         this.intentRouter.clearIndex();
@@ -116,35 +178,58 @@ export class McpRouter {
                 }
             }
             if (normalizedAction !== "call") {
-                return this.error("invalid_params", `action must be one of: list, call, refresh, schema, intent`);
+                return this.error("invalid_params", `action must be one of: list, call, batch, refresh, schema, intent`);
             }
             if (!tool) {
                 return this.error("invalid_params", "tool is required for action=call");
             }
+            let targetServer = server;
+            if (!targetServer) {
+                await this.primeToolResolutionIndex();
+                const resolution = this.toolResolver.resolve(tool, params ?? {});
+                if (!resolution) {
+                    return this.error("unknown_tool", `Tool '${tool}' was not found on any connected server`, this.toolResolver.getKnownToolNames());
+                }
+                if ("ambiguous" in resolution) {
+                    return resolution;
+                }
+                targetServer = resolution.server;
+            }
+            if (!this.servers[targetServer]) {
+                return this.error("unknown_server", `Server '${targetServer}' not found`, Object.keys(this.servers));
+            }
             try {
-                await this.getToolList(server);
+                await this.getToolList(targetServer);
             }
             catch (error) {
-                return this.error("connection_failed", `Failed to connect to ${server}: ${error instanceof Error ? error.message : String(error)}`);
+                return this.error("connection_failed", `Failed to connect to ${targetServer}: ${error instanceof Error ? error.message : String(error)}`);
             }
-            const state = this.states.get(server);
+            const state = this.states.get(targetServer);
             if (!state.toolNames.includes(tool)) {
-                return this.error("unknown_tool", `Tool '${tool}' not found on server '${server}'`, state.toolNames);
+                return this.error("unknown_tool", `Tool '${tool}' not found on server '${targetServer}'`, state.toolNames);
             }
             // Defense in depth: double-check tool filter
-            const serverConfig = this.servers[server];
+            const serverConfig = this.servers[targetServer];
             if (!isToolAllowed(tool, serverConfig)) {
-                return this.error("unknown_tool", `Tool '${tool}' is not allowed on server '${server}'`, state.toolNames);
+                return this.error("unknown_tool", `Tool '${tool}' is not allowed on server '${targetServer}'`, state.toolNames);
             }
-            this.markUsed(server);
-            const response = await state.transport.sendRequest({
-                jsonrpc: "2.0",
-                method: "tools/call",
-                params: {
-                    name: tool,
-                    arguments: params ?? {}
+            server = targetServer;
+            const cacheKey = this.resultCache
+                ? createResultCacheKey(server, tool, params ?? {})
+                : null;
+            if (this.resultCache && cacheKey) {
+                const cachedResult = this.resultCache.get(cacheKey);
+                if (cachedResult !== undefined) {
+                    if (this.promotion) {
+                        this.promotion.recordCall(server, tool);
+                    }
+                    this.toolResolver.recordCall(server, tool);
+                    return { server, action: "call", tool, result: cachedResult };
                 }
-            });
+            }
+            this.markUsed(server);
+            const callOutcome = await this.callToolWithRetry(server, tool, params ?? {}, state.transport);
+            const response = callOutcome.response;
             if (response.error) {
                 return this.error("mcp_error", response.error.message, undefined, response.error.code);
             }
@@ -152,9 +237,19 @@ export class McpRouter {
             if (this.promotion) {
                 this.promotion.recordCall(server, tool);
             }
+            this.toolResolver.recordCall(server, tool);
             // Security pipeline: truncate → sanitize → trust-tag
             const result = processResult(response.result, server, serverConfig, this.clientConfig);
-            return { server, action: "call", tool, result };
+            if (this.resultCache && cacheKey) {
+                this.resultCache.set(cacheKey, result);
+            }
+            return {
+                server,
+                action: "call",
+                tool,
+                result,
+                ...(callOutcome.retries > 0 ? { retries: callOutcome.retries } : {})
+            };
         }
         catch (error) {
             return this.error("mcp_error", error instanceof Error ? error.message : String(error));
@@ -175,6 +270,10 @@ export class McpRouter {
         state.toolNames = tools.map((tool) => tool.name);
         // Store full tool metadata for action=schema
         state.fullToolsMap = new Map(tools.map((tool) => [tool.name, { description: tool.description || "", inputSchema: tool.inputSchema }]));
+        this.toolResolver.registerServerTools(server, tools.map((tool) => ({
+            name: tool.name,
+            inputSchema: tool.inputSchema
+        })));
         const compressionEnabled = this.clientConfig.schemaCompression?.enabled ?? true;
         const maxLen = this.clientConfig.schemaCompression?.maxDescriptionLength ?? 80;
         state.toolsCache = tools.map((tool) => ({
@@ -187,6 +286,17 @@ export class McpRouter {
         this.markUsed(server);
         return state.toolsCache;
     }
+    async primeToolResolutionIndex() {
+        for (const serverName of Object.keys(this.servers)) {
+            try {
+                await this.getToolList(serverName);
+            }
+            catch (error) {
+                this.toolResolver.removeServer(serverName);
+                this.logger.warn(`[mcp-bridge] Tool resolution: failed to load tools from ${serverName}:`, error);
+            }
+        }
+    }
     async resolveIntent(intent) {
         try {
             // Lazily create the intent router
@@ -281,11 +391,103 @@ export class McpRouter {
         }));
         return { action: "promotions", promoted, stats };
     }
+    getRetryPolicy(server) {
+        const globalRetry = this.clientConfig.retry ?? {};
+        const serverRetry = this.servers[server].retry ?? {};
+        const maxAttemptsRaw = serverRetry.maxAttempts ?? globalRetry.maxAttempts ?? 1;
+        const delayMsRaw = serverRetry.delayMs ?? globalRetry.delayMs ?? 1000;
+        const backoffMultiplierRaw = serverRetry.backoffMultiplier ?? globalRetry.backoffMultiplier ?? 2;
+        const retryOn = serverRetry.retryOn ?? globalRetry.retryOn ?? ["timeout", "connection_error"];
+        return {
+            maxAttempts: Math.max(1, Math.floor(maxAttemptsRaw)),
+            delayMs: Math.max(0, Math.floor(delayMsRaw)),
+            backoffMultiplier: Math.max(1, backoffMultiplierRaw),
+            retryOn: new Set(retryOn)
+        };
+    }
+    classifyTransientError(error) {
+        const message = error instanceof Error ? error.message.toLowerCase() : String(error).toLowerCase();
+        if (message.includes("timeout") ||
+            message.includes("timed out") ||
+            message.includes("abort")) {
+            return "timeout";
+        }
+        if (message.includes("connection") ||
+            message.includes("econnreset") ||
+            message.includes("socket hang up") ||
+            message.includes("network") ||
+            message.includes("fetch failed") ||
+            message.includes("econnrefused") ||
+            message.includes("enotfound")) {
+            return "connection_error";
+        }
+        return null;
+    }
+    async callToolWithRetry(server, tool, args, transport) {
+        const retryPolicy = this.getRetryPolicy(server);
+        let retries = 0;
+        let lastError;
+        for (let attempt = 0; attempt < retryPolicy.maxAttempts; attempt++) {
+            try {
+                const response = await transport.sendRequest({
+                    jsonrpc: "2.0",
+                    method: "tools/call",
+                    params: {
+                        name: tool,
+                        arguments: args
+                    }
+                });
+                return { response, retries };
+            }
+            catch (error) {
+                lastError = error;
+                const category = this.classifyTransientError(error);
+                const shouldRetry = category !== null &&
+                    retryPolicy.retryOn.has(category) &&
+                    attempt < retryPolicy.maxAttempts - 1;
+                if (!shouldRetry) {
+                    throw error;
+                }
+                retries += 1;
+                const delay = retryPolicy.delayMs * Math.pow(retryPolicy.backoffMultiplier, attempt);
+                if (delay > 0) {
+                    await new Promise((resolve) => setTimeout(resolve, delay));
+                }
+            }
+        }
+        throw lastError instanceof Error ? lastError : new Error(String(lastError));
+    }
     async disconnectAll() {
         for (const serverName of Object.keys(this.servers)) {
             await this.disconnectServer(serverName);
         }
     }
+    async shutdown(timeoutMs = this.clientConfig.shutdownTimeoutMs ?? DEFAULT_SHUTDOWN_TIMEOUT_MS) {
+        const effectiveTimeout = Math.max(0, timeoutMs);
+        for (const [serverName, state] of this.states) {
+            if (state.idleTimer) {
+                clearTimeout(state.idleTimer);
+                state.idleTimer = null;
+            }
+            try {
+                if (state.transport.shutdown) {
+                    await state.transport.shutdown(effectiveTimeout);
+                }
+                else {
+                    await state.transport.disconnect();
+                }
+            }
+            catch (error) {
+                this.logger.warn(`[mcp-bridge] Router shutdown: failed to close ${serverName}:`, error);
+            }
+        }
+        this.states.clear();
+        this.toolResolver.clear();
+        if (this.intentRouter) {
+            this.intentRouter.clearIndex();
+        }
+        this.resultCache?.invalidate();
+    }
     async ensureConnected(server) {
         let state = this.states.get(server);
         if (!state) {
@@ -354,6 +556,8 @@ export class McpRouter {
         state.toolsCache = undefined;
         state.fullToolsMap = undefined;
         state.toolNames = [];
+        this.toolResolver.removeServer(server);
+        this.resultCache?.invalidate(`${server}:`);
     }
     markUsed(server) {
         const state = this.states.get(server);
@@ -382,6 +586,8 @@ export class McpRouter {
             state.toolsCache = undefined;
             state.fullToolsMap = undefined;
             state.toolNames = [];
+            this.toolResolver.removeServer(serverName);
+            this.resultCache?.invalidate(`${serverName}:`);
         };
         if (serverConfig.transport === "sse") {
             return new this.transportRefs.sse(serverConfig, this.clientConfig, this.logger, onReconnected);

package/dist/src/result-cache.d.ts

@@ -0,0 +1,29 @@
+export interface ResultCacheConfig {
+    maxEntries?: number;
+    defaultTtlMs?: number;
+    cacheTtl?: Record<string, number>;
+}
+export interface ResultCacheStats {
+    hits: number;
+    misses: number;
+    evictions: number;
+    size: number;
+}
+export declare function stableStringify(value: unknown): string;
+export declare function createResultCacheKey(server: string, tool: string, params: unknown): string;
+export declare class ResultCache {
+    private readonly maxEntries;
+    private readonly defaultTtlMs;
+    private readonly cacheTtl;
+    private readonly entries;
+    private hits;
+    private misses;
+    private evictions;
+    constructor(config?: ResultCacheConfig);
+    get(key: string): unknown;
+    set(key: string, value: unknown, ttlMs?: number): void;
+    invalidate(pattern?: string | RegExp): number;
+    stats(): ResultCacheStats;
+    private resolveTtlMsForKey;
+    private trimToCapacity;
+}