@aiwerk/mcp-bridge 1.8.0 → 2.0.0

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 {
@@ -397,7 +413,7 @@ export class StandaloneServer {
     async shutdown() {
         this.logger.info("[mcp-bridge] Shutting down...");
         if (this.router) {
-            await this.router.disconnectAll();
+            await this.router.shutdown(this.config.shutdownTimeoutMs);
         }
         for (const [name, conn] of this.directConnections) {
             try {

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

@@ -0,0 +1,33 @@
+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[];
+    clear(): void;
+    private scoreCandidate;
+    private wasUsedRecently;
+    private computeParamMatch;
+}

package/dist/src/tool-resolution.js

@@ -0,0 +1,135 @@
+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()];
+    }
+    clear() {
+        this.toolsByName.clear();
+        this.toolNamesByServer.clear();
+        this.recentCalls.length = 0;
+    }
+    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/transport-base.d.ts

@@ -70,6 +70,14 @@ export declare function resolveEnvRecord(record: Record<string, string>, context
  * @param extraEnv - Additional env vars to check before process.env
  */
 export declare function resolveArgs(args: string[], extraEnv?: Record<string, string | undefined>, envFallback?: () => Record<string, string>): string[];
+/**
+ * Resolve auth config into HTTP headers.
+ */
+export declare function resolveAuthHeaders(config: McpServerConfig, extraEnv?: Record<string, string | undefined>, envFallback?: () => Record<string, string>): Record<string, string>;
+/**
+ * Resolve server headers and merge auth headers (auth takes precedence).
+ */
+export declare function resolveServerHeaders(config: McpServerConfig, extraEnv?: Record<string, string | undefined>, envFallback?: () => Record<string, string>): Record<string, string>;
 /**
  * Warn if a URL uses non-TLS HTTP to a remote (non-localhost) host.
  */

package/dist/src/transport-base.js

@@ -159,6 +159,26 @@ export function resolveEnvRecord(record, contextPrefix, extraEnv, envFallback) {
 export function resolveArgs(args, extraEnv, envFallback) {
     return args.map(arg => resolveEnvVars(arg, `arg "${arg}"`, extraEnv, envFallback));
 }
+/**
+ * Resolve auth config into HTTP headers.
+ */
+export function resolveAuthHeaders(config, extraEnv, envFallback) {
+    if (!config.auth)
+        return {};
+    if (config.auth.type === "bearer") {
+        const token = resolveEnvVars(config.auth.token, "auth token", extraEnv, envFallback);
+        return { Authorization: `Bearer ${token}` };
+    }
+    return resolveEnvRecord(config.auth.headers, "auth header", extraEnv, envFallback);
+}
+/**
+ * Resolve server headers and merge auth headers (auth takes precedence).
+ */
+export function resolveServerHeaders(config, extraEnv, envFallback) {
+    const base = resolveEnvRecord(config.headers || {}, "header", extraEnv, envFallback);
+    const auth = resolveAuthHeaders(config, extraEnv, envFallback);
+    return { ...base, ...auth };
+}
 /**
  * Warn if a URL uses non-TLS HTTP to a remote (non-localhost) host.
  */

package/dist/src/transport-sse.d.ts

@@ -4,6 +4,7 @@ export declare class SseTransport extends BaseTransport {
     private endpointUrl;
     private sseAbortController;
     private resolvedHeaders;
+    private pendingRequestControllers;
     protected get transportName(): string;
     connect(): Promise<void>;
     private _onEndpointReceived;
@@ -13,4 +14,5 @@ export declare class SseTransport extends BaseTransport {
     sendRequest(request: McpRequest): Promise<McpResponse>;
     private isSameOrigin;
     disconnect(): Promise<void>;
+    shutdown(): Promise<void>;
 }

package/dist/src/transport-sse.js

@@ -1,9 +1,10 @@
 import { nextRequestId } from "./types.js";
-import { BaseTransport, resolveEnvRecord, warnIfNonTlsRemoteUrl } from "./transport-base.js";
+import { BaseTransport, resolveServerHeaders, warnIfNonTlsRemoteUrl } from "./transport-base.js";
 export class SseTransport extends BaseTransport {
     endpointUrl = null;
     sseAbortController = null;
     resolvedHeaders = null;
+    pendingRequestControllers = new Map();
     get transportName() { return "SSE"; }
     async connect() {
         if (!this.config.url) {
@@ -11,7 +12,7 @@ export class SseTransport extends BaseTransport {
         }
         warnIfNonTlsRemoteUrl(this.config.url, this.logger);
         // Resolve headers once and cache for all subsequent requests
-        this.resolvedHeaders = resolveEnvRecord(this.config.headers || {}, "header");
+        this.resolvedHeaders = resolveServerHeaders(this.config);
         if (this.sseAbortController) {
             this.sseAbortController.abort();
         }
@@ -36,7 +37,7 @@ export class SseTransport extends BaseTransport {
     async startEventStream() {
         if (!this.config.url)
             return;
-        const base = this.resolvedHeaders ?? resolveEnvRecord(this.config.headers || {}, "header");
+        const base = this.resolvedHeaders ?? resolveServerHeaders(this.config);
         const headers = { ...base, "Accept": "text/event-stream" };
         try {
             const response = await fetch(this.config.url, {
@@ -130,7 +131,7 @@ export class SseTransport extends BaseTransport {
         if (!this.connected || !this.endpointUrl) {
             throw new Error("SSE transport not connected or no endpoint URL");
         }
-        const base = this.resolvedHeaders ?? resolveEnvRecord(this.config.headers || {}, "header");
+        const base = this.resolvedHeaders ?? resolveServerHeaders(this.config);
         const headers = { ...base, "Content-Type": "application/json" };
         const response = await fetch(this.endpointUrl, {
             method: "POST",
@@ -150,21 +151,27 @@ export class SseTransport extends BaseTransport {
         return new Promise((resolve, reject) => {
             const requestTimeout = this.clientConfig.requestTimeoutMs || 60000;
             const timeout = setTimeout(() => {
+                this.pendingRequestControllers.get(id)?.abort();
+                this.pendingRequestControllers.delete(id);
                 this.pendingRequests.delete(id);
                 reject(new Error(`Request timeout after ${requestTimeout}ms`));
             }, requestTimeout);
             this.pendingRequests.set(id, { resolve, reject, timeout });
-            const base = this.resolvedHeaders ?? resolveEnvRecord(this.config.headers || {}, "header");
+            const base = this.resolvedHeaders ?? resolveServerHeaders(this.config);
             const headers = { ...base, "Content-Type": "application/json" };
+            const abortController = new AbortController();
+            this.pendingRequestControllers.set(id, abortController);
             // The response arrives via the SSE stream (handleMessage), not from this fetch.
             // The fetch only confirms the server accepted the request (HTTP 200).
             // If the fetch fails, we reject immediately; otherwise we wait for the SSE stream.
             fetch(this.endpointUrl, {
                 method: "POST",
                 headers,
-                body: JSON.stringify(requestWithId)
+                body: JSON.stringify(requestWithId),
+                signal: abortController.signal
             })
                 .then((response) => {
+                this.pendingRequestControllers.delete(id);
                 if (!response.ok) {
                     clearTimeout(timeout);
                     this.pendingRequests.delete(id);
@@ -172,6 +179,7 @@ export class SseTransport extends BaseTransport {
                 }
             })
                 .catch((error) => {
+                this.pendingRequestControllers.delete(id);
                 clearTimeout(timeout);
                 this.pendingRequests.delete(id);
                 reject(error);
@@ -197,6 +205,13 @@ export class SseTransport extends BaseTransport {
             this.sseAbortController.abort();
             this.sseAbortController = null;
         }
+        for (const [, controller] of this.pendingRequestControllers) {
+            controller.abort();
+        }
+        this.pendingRequestControllers.clear();
         this.rejectAllPending("Connection closed");
     }
+    async shutdown() {
+        await this.disconnect();
+    }
 }

package/dist/src/transport-stdio.d.ts

@@ -15,6 +15,7 @@ export declare class StdioTransport extends BaseTransport {
     private parseNewlineMessageFromBuffer;
     private parseLspMessageFromBuffer;
     disconnect(): Promise<void>;
+    shutdown(timeoutMs?: number): Promise<void>;
     isConnected(): boolean;
     private terminateProcessGracefully;
 }

package/dist/src/transport-stdio.js

@@ -264,7 +264,20 @@ export class StdioTransport extends BaseTransport {
                     this.logger.debug("[mcp-bridge] Failed to send close notification during stdio disconnect");
                 }
             }
-            await this.terminateProcessGracefully(activeProcess);
+            await this.terminateProcessGracefully(activeProcess, this.clientConfig.shutdownTimeoutMs ?? 5000);
+            if (this.process === activeProcess) {
+                this.process = null;
+            }
+        }
+        this.rejectAllPending("Connection closed");
+    }
+    async shutdown(timeoutMs = this.clientConfig.shutdownTimeoutMs ?? 5000) {
+        this.isShuttingDown = true;
+        this.connected = false;
+        this.cleanupReconnectTimer();
+        const activeProcess = this.process;
+        if (activeProcess) {
+            await this.terminateProcessGracefully(activeProcess, timeoutMs);
             if (this.process === activeProcess) {
                 this.process = null;
             }
@@ -274,8 +287,8 @@ export class StdioTransport extends BaseTransport {
     isConnected() {
         return this.connected && this.process !== null;
     }
-    async terminateProcessGracefully(proc) {
-        if (proc.exitCode !== null || proc.killed)
+    async terminateProcessGracefully(proc, timeoutMs) {
+        if (proc.exitCode !== null)
             return;
         await new Promise((resolve) => {
             let done = false;
@@ -292,21 +305,20 @@ export class StdioTransport extends BaseTransport {
             const onExit = () => finish();
             proc.once("exit", onExit);
             try {
-                proc.kill("SIGINT");
+                proc.kill("SIGTERM");
             }
             catch {
                 finish();
                 return;
             }
             forceKillTimer = setTimeout(() => {
-                if (proc.exitCode === null && !proc.killed) {
+                if (proc.exitCode === null) {
                     try {
-                        proc.kill("SIGTERM");
+                        proc.kill("SIGKILL");
                     }
                     catch { /* ignore */ }
                 }
-                setTimeout(finish, 200);
-            }, 2000);
+            }, Math.max(0, timeoutMs));
         });
     }
 }

package/dist/src/transport-streamable-http.d.ts

@@ -2,10 +2,13 @@ import { McpRequest, McpResponse } from "./types.js";
 import { BaseTransport } from "./transport-base.js";
 export declare class StreamableHttpTransport extends BaseTransport {
     private sessionId?;
+    private resolvedHeaders;
+    private pendingRequestControllers;
     protected get transportName(): string;
     connect(): Promise<void>;
     sendRequest(request: McpRequest): Promise<McpResponse>;
     sendNotification(notification: any): Promise<void>;
     private probeServer;
     disconnect(): Promise<void>;
+    shutdown(): Promise<void>;
 }