@aiwerk/mcp-bridge 1.8.0 → 1.9.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

@@ -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;
+        }
+    }
+}

package/dist/src/standalone-server.js

@@ -207,11 +207,24 @@ export class StandaloneServer {
                                 type: "object",
                                 properties: {
                                     server: { type: "string", description: "Server name" },
-                                    action: { type: "string", description: "list | call | refresh | status" },
-                                    tool: { type: "string", description: "Tool name for action=call" },
-                                    params: { type: "object", description: "Tool arguments" }
+                                    action: { type: "string", description: "list | call | batch | refresh | status | intent | schema | promotions" },
+                                    tool: { type: "string", description: "Tool name for action=call/schema" },
+                                    params: { type: "object", description: "Tool arguments" },
+                                    calls: {
+                                        type: "array",
+                                        description: "Batch calls for action=batch",
+                                        items: {
+                                            type: "object",
+                                            properties: {
+                                                server: { type: "string" },
+                                                tool: { type: "string" },
+                                                params: { type: "object" }
+                                            },
+                                            required: ["server", "tool"]
+                                        }
+                                    }
                                 },
-                                required: ["server"]
+                                required: []
                             }
                         }]
                 }
@@ -244,7 +257,10 @@ export class StandaloneServer {
                     error: { code: -32004, message: `Unknown tool: ${toolName}. In router mode, use the 'mcp' tool.` }
                 };
             }
-            const result = await this.router.dispatch(toolArgs.server, toolArgs.action, toolArgs.tool, toolArgs.params);
+            const dispatchParams = toolArgs.action === "batch"
+                ? { ...(toolArgs.params ?? {}), calls: toolArgs.calls }
+                : toolArgs.params;
+            const result = await this.router.dispatch(toolArgs.server, toolArgs.action, toolArgs.tool, dispatchParams);
             // Check if result is an error
             if ("error" in result) {
                 return {

package/dist/src/tool-resolution.d.ts

@@ -0,0 +1,32 @@
+export interface ToolResolutionCandidate {
+    server: string;
+    tool: string;
+    score: number;
+    suggested?: true;
+}
+export type ToolResolutionResult = {
+    server: string;
+    tool: string;
+} | {
+    ambiguous: true;
+    message: string;
+    candidates: ToolResolutionCandidate[];
+} | null;
+export declare class ToolResolver {
+    private readonly basePriority;
+    private readonly toolsByName;
+    private readonly toolNamesByServer;
+    private readonly recentCalls;
+    constructor(serverOrder: string[]);
+    registerServerTools(server: string, tools: Array<{
+        name: string;
+        inputSchema: any;
+    }>): void;
+    removeServer(server: string): void;
+    resolve(toolName: string, params?: Record<string, unknown>, serverHint?: string): ToolResolutionResult;
+    recordCall(server: string, tool: string): void;
+    getKnownToolNames(): string[];
+    private scoreCandidate;
+    private wasUsedRecently;
+    private computeParamMatch;
+}

package/dist/src/tool-resolution.js

@@ -0,0 +1,130 @@
+const RECENT_CALL_LIMIT = 5;
+const BASE_PRIORITY_STEP = 0.1;
+const BASE_PRIORITY_MIN = 0.1;
+const RECENCY_BOOST = 0.3;
+const PARAM_MATCH_WEIGHT = 0.2;
+const AUTO_RESOLVE_DELTA = 0.15;
+export class ToolResolver {
+    basePriority = new Map();
+    toolsByName = new Map();
+    toolNamesByServer = new Map();
+    recentCalls = [];
+    constructor(serverOrder) {
+        const reversed = [...serverOrder].reverse();
+        reversed.forEach((server, index) => {
+            const score = Math.max(1.0 - (index * BASE_PRIORITY_STEP), BASE_PRIORITY_MIN);
+            this.basePriority.set(server, score);
+        });
+    }
+    registerServerTools(server, tools) {
+        this.removeServer(server);
+        const names = new Set();
+        for (const tool of tools) {
+            if (!tool?.name)
+                continue;
+            const registered = {
+                server,
+                tool: tool.name,
+                inputSchema: tool.inputSchema
+            };
+            const existing = this.toolsByName.get(tool.name) ?? [];
+            existing.push(registered);
+            this.toolsByName.set(tool.name, existing);
+            names.add(tool.name);
+        }
+        this.toolNamesByServer.set(server, names);
+    }
+    removeServer(server) {
+        const previousNames = this.toolNamesByServer.get(server);
+        if (previousNames) {
+            for (const toolName of previousNames) {
+                const filtered = (this.toolsByName.get(toolName) ?? []).filter((entry) => entry.server !== server);
+                if (filtered.length === 0) {
+                    this.toolsByName.delete(toolName);
+                    continue;
+                }
+                this.toolsByName.set(toolName, filtered);
+            }
+        }
+        this.toolNamesByServer.delete(server);
+    }
+    resolve(toolName, params, serverHint) {
+        const candidates = this.toolsByName.get(toolName) ?? [];
+        if (candidates.length === 0) {
+            return null;
+        }
+        if (serverHint) {
+            const explicit = candidates.find((candidate) => candidate.server === serverHint);
+            if (!explicit) {
+                return null;
+            }
+            return { server: explicit.server, tool: explicit.tool };
+        }
+        if (candidates.length === 1) {
+            return { server: candidates[0].server, tool: candidates[0].tool };
+        }
+        const scored = candidates
+            .map((candidate) => ({
+            ...candidate,
+            score: this.scoreCandidate(candidate.server, candidate.inputSchema, params)
+        }))
+            .sort((a, b) => {
+            if (b.score !== a.score) {
+                return b.score - a.score;
+            }
+            return (this.basePriority.get(b.server) ?? BASE_PRIORITY_MIN) - (this.basePriority.get(a.server) ?? BASE_PRIORITY_MIN);
+        });
+        const first = scored[0];
+        const second = scored[1];
+        if (!second || (first.score - second.score) >= AUTO_RESOLVE_DELTA) {
+            return { server: first.server, tool: first.tool };
+        }
+        return {
+            ambiguous: true,
+            message: `Multiple servers provide '${toolName}'. Please specify server=`,
+            candidates: scored.map((candidate, index) => ({
+                server: candidate.server,
+                tool: candidate.tool,
+                score: Number(candidate.score.toFixed(2)),
+                ...(index === 0 ? { suggested: true } : {})
+            }))
+        };
+    }
+    recordCall(server, tool) {
+        this.recentCalls.push({ server, tool });
+        if (this.recentCalls.length > RECENT_CALL_LIMIT) {
+            this.recentCalls.shift();
+        }
+    }
+    getKnownToolNames() {
+        return [...this.toolsByName.keys()];
+    }
+    scoreCandidate(server, inputSchema, params) {
+        const base = this.basePriority.get(server) ?? BASE_PRIORITY_MIN;
+        const recency = this.wasUsedRecently(server) ? RECENCY_BOOST : 0;
+        const paramMatch = this.computeParamMatch(inputSchema, params) * PARAM_MATCH_WEIGHT;
+        return base + recency + paramMatch;
+    }
+    wasUsedRecently(server) {
+        return this.recentCalls.some((call) => call.server === server);
+    }
+    computeParamMatch(inputSchema, params) {
+        if (!params || typeof params !== "object") {
+            return 0;
+        }
+        const paramNames = Object.keys(params);
+        if (paramNames.length === 0) {
+            return 0;
+        }
+        const schemaProperties = inputSchema?.properties;
+        if (!schemaProperties || typeof schemaProperties !== "object") {
+            return 0;
+        }
+        const propertyNames = new Set(Object.keys(schemaProperties));
+        if (propertyNames.size === 0) {
+            return 0;
+        }
+        const matching = paramNames.filter((paramName) => propertyNames.has(paramName)).length;
+        return matching / paramNames.length;
+    }
+}

package/dist/src/types.d.ts

@@ -30,6 +30,7 @@ export interface McpClientConfig {
     requestTimeoutMs?: number;
     routerIdleTimeoutMs?: number;
     routerMaxConcurrent?: number;
+    maxBatchSize?: number;
     schemaCompression?: {
         enabled?: boolean;
         maxDescriptionLength?: number;
@@ -48,6 +49,12 @@ export interface McpClientConfig {
         minCalls?: number;
         decayMs?: number;
     };
+    resultCache?: {
+        enabled?: boolean;
+        maxEntries?: number;
+        defaultTtlMs?: number;
+        cacheTtl?: Record<string, number>;
+    };
 }
 export interface McpTool {
     name: string;

package/package.json

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