@aiwerk/mcp-bridge 1.7.2 → 1.9.0

package/README.md

@@ -59,6 +59,26 @@ Add to `~/Library/Application Support/Claude/claude_desktop_config.json`:
 }
 ```
 
+## Recipe Spec v2
+
+Bundled servers now ship with `recipe.json` using **Universal Recipe Spec v2.0**.
+During install, MCP Bridge prefers `recipe.json` when present and falls back to legacy `config.json` (v1) for backwards compatibility.
+
+- Spec: [`docs/universal-recipe-spec.md`](docs/universal-recipe-spec.md)
+- Runtime compatibility: v1 and v2 are both supported
+- Existing v1-only servers continue to work unchanged
+
+For third-party recipe authors:
+
+1. Author `recipe.json` per the spec above.
+2. Validate your recipe before publishing:
+
+```bash
+npx @aiwerk/mcp-bridge validate-recipe ./recipe.json
+```
+
+`config.json` (v1) remains supported, but `recipe.json` (v2) is the recommended format going forward.
+
 ## Use with Cursor / Windsurf
 
 Add to your MCP config:
@@ -119,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
@@ -150,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:
@@ -180,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:
@@ -284,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/bin/validate-recipe.d.ts

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+/**
+ * CLI entry point for the Universal MCP Recipe Validator.
+ * Usage: npx tsx bin/validate-recipe.ts <path-to-recipe.json>
+ */
+export {};

package/dist/bin/validate-recipe.js

@@ -0,0 +1,33 @@
+#!/usr/bin/env node
+/**
+ * CLI entry point for the Universal MCP Recipe Validator.
+ * Usage: npx tsx bin/validate-recipe.ts <path-to-recipe.json>
+ */
+import { validateRecipeFile, formatValidationResult } from "../src/validate-recipe.js";
+async function main() {
+    const args = process.argv.slice(2);
+    if (args.length === 0 || args[0] === "--help" || args[0] === "-h") {
+        console.log("Usage: validate-recipe <path-to-recipe.json>");
+        console.log("");
+        console.log("Validates a Universal MCP Recipe against spec v2.0.");
+        console.log("Exits 0 if valid, 1 if invalid.");
+        process.exit(0);
+    }
+    const filePath = args[0];
+    let result;
+    try {
+        result = await validateRecipeFile(filePath);
+    }
+    catch (e) {
+        console.error(`❌ Could not read file: ${filePath}`);
+        console.error(`   ${e.message}`);
+        process.exit(1);
+    }
+    const output = formatValidationResult(filePath, result);
+    console.log(output);
+    process.exit(result.valid ? 0 : 1);
+}
+main().catch((e) => {
+    console.error("Unexpected error:", e);
+    process.exit(1);
+});

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

@@ -4,6 +4,10 @@ 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";

package/dist/src/index.js

@@ -6,6 +6,9 @@ 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;
@@ -35,6 +46,9 @@ export type RouterDispatchResponse = {
 } | {
     action: "status";
     servers: RouterServerStatus[];
+} | {
+    action: "batch";
+    results: RouterBatchResult[];
 } | {
     action: "promotions";
     promoted: Array<{
@@ -61,6 +75,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 +102,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<{

package/dist/src/mcp-router.js

@@ -7,8 +7,11 @@ 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;
 export class McpRouter {
     servers;
     clientConfig;
@@ -16,7 +19,10 @@ export class McpRouter {
     transportRefs;
     idleTimeoutMs;
     maxConcurrent;
+    resultCache;
+    maxBatchSize;
     states = new Map();
+    toolResolver;
     intentRouter = null;
     promotion = null;
     constructor(servers, clientConfig, logger, transportRefs) {
@@ -30,6 +36,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 +60,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 +81,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 +129,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 +152,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,25 +177,54 @@ 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);
+            }
+            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 response = await state.transport.sendRequest({
@@ -152,8 +242,12 @@ 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);
+            if (this.resultCache && cacheKey) {
+                this.resultCache.set(cacheKey, result);
+            }
             return { server, action: "call", tool, result };
         }
         catch (error) {
@@ -175,6 +269,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 +285,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
@@ -354,6 +463,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 +493,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;
+}

package/dist/src/result-cache.js

@@ -0,0 +1,120 @@
+const DEFAULT_MAX_ENTRIES = 100;
+const DEFAULT_TTL_MS = 300_000;
+function normalizeForStableJson(value, inArray) {
+    if (value === undefined || typeof value === "function" || typeof value === "symbol") {
+        return inArray ? null : undefined;
+    }
+    if (value === null || typeof value !== "object") {
+        return value;
+    }
+    if (Array.isArray(value)) {
+        return value.map((item) => normalizeForStableJson(item, true));
+    }
+    const obj = value;
+    const normalized = {};
+    const keys = Object.keys(obj).sort();
+    for (const key of keys) {
+        const normalizedValue = normalizeForStableJson(obj[key], false);
+        if (normalizedValue !== undefined) {
+            normalized[key] = normalizedValue;
+        }
+    }
+    return normalized;
+}
+export function stableStringify(value) {
+    const normalized = normalizeForStableJson(value, false);
+    const serialized = JSON.stringify(normalized);
+    return serialized === undefined ? "undefined" : serialized;
+}
+export function createResultCacheKey(server, tool, params) {
+    return `${server}:${tool}:${stableStringify(params)}`;
+}
+export class ResultCache {
+    maxEntries;
+    defaultTtlMs;
+    cacheTtl;
+    entries = new Map();
+    hits = 0;
+    misses = 0;
+    evictions = 0;
+    constructor(config = {}) {
+        this.maxEntries = config.maxEntries ?? DEFAULT_MAX_ENTRIES;
+        this.defaultTtlMs = config.defaultTtlMs ?? DEFAULT_TTL_MS;
+        this.cacheTtl = config.cacheTtl ?? {};
+    }
+    get(key) {
+        const entry = this.entries.get(key);
+        if (!entry) {
+            this.misses += 1;
+            return undefined;
+        }
+        if (entry.expiresAt <= Date.now()) {
+            this.entries.delete(key);
+            this.misses += 1;
+            return undefined;
+        }
+        this.entries.delete(key);
+        this.entries.set(key, entry);
+        this.hits += 1;
+        return entry.value;
+    }
+    set(key, value, ttlMs) {
+        const effectiveTtlMs = ttlMs ?? this.resolveTtlMsForKey(key);
+        const entry = {
+            value,
+            expiresAt: Date.now() + effectiveTtlMs
+        };
+        if (this.entries.has(key)) {
+            this.entries.delete(key);
+        }
+        this.entries.set(key, entry);
+        this.trimToCapacity();
+    }
+    invalidate(pattern) {
+        if (!pattern) {
+            const size = this.entries.size;
+            this.entries.clear();
+            return size;
+        }
+        let removed = 0;
+        for (const key of this.entries.keys()) {
+            const matches = typeof pattern === "string"
+                ? key.includes(pattern)
+                : pattern.test(key);
+            if (matches) {
+                this.entries.delete(key);
+                removed += 1;
+            }
+        }
+        return removed;
+    }
+    stats() {
+        return {
+            hits: this.hits,
+            misses: this.misses,
+            evictions: this.evictions,
+            size: this.entries.size
+        };
+    }
+    resolveTtlMsForKey(key) {
+        const firstColon = key.indexOf(":");
+        const secondColon = key.indexOf(":", firstColon + 1);
+        if (firstColon === -1 || secondColon === -1) {
+            return this.defaultTtlMs;
+        }
+        const server = key.slice(0, firstColon);
+        const tool = key.slice(firstColon + 1, secondColon);
+        const override = this.cacheTtl[`${server}:${tool}`];
+        return override ?? this.defaultTtlMs;
+    }
+    trimToCapacity() {
+        while (this.entries.size > this.maxEntries) {
+            const oldestKey = this.entries.keys().next().value;
+            if (oldestKey === undefined) {
+                break;
+            }
+            this.entries.delete(oldestKey);
+            this.evictions += 1;
+        }
+    }
+}