@aiwerk/mcp-bridge 1.9.0 → 2.0.0

package/dist/src/index.d.ts

@@ -1,4 +1,4 @@
-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";
@@ -11,7 +11,7 @@ export type { ToolResolutionResult, ToolResolutionCandidate } from "./tool-resol
 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,6 +1,6 @@
 // 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";

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

@@ -37,6 +37,7 @@ export type RouterDispatchResponse = {
     action: "call";
     tool: string;
     result: any;
+    retries?: number;
 } | {
     server: string;
     action: "schema";
@@ -122,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

@@ -12,6 +12,7 @@ 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;
@@ -227,14 +228,8 @@ export class McpRouter {
                 }
             }
             this.markUsed(server);
-            const response = await state.transport.sendRequest({
-                jsonrpc: "2.0",
-                method: "tools/call",
-                params: {
-                    name: tool,
-                    arguments: params ?? {}
-                }
-            });
+            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);
             }
@@ -248,7 +243,13 @@ export class McpRouter {
             if (this.resultCache && cacheKey) {
                 this.resultCache.set(cacheKey, result);
             }
-            return { server, action: "call", tool, 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));
@@ -390,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) {

package/dist/src/standalone-server.js

@@ -413,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

@@ -26,6 +26,7 @@ export declare class ToolResolver {
     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

@@ -99,6 +99,11 @@ export class ToolResolver {
     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;

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

package/dist/src/transport-streamable-http.js

@@ -1,15 +1,17 @@
 import { nextRequestId } from "./types.js";
-import { BaseTransport, resolveEnvRecord, warnIfNonTlsRemoteUrl } from "./transport-base.js";
+import { BaseTransport, resolveServerHeaders, warnIfNonTlsRemoteUrl } from "./transport-base.js";
 export class StreamableHttpTransport extends BaseTransport {
     sessionId;
+    resolvedHeaders = null;
+    pendingRequestControllers = new Map();
     get transportName() { return "streamable-http"; }
     async connect() {
         if (!this.config.url) {
             throw new Error("Streamable HTTP transport requires URL");
         }
         warnIfNonTlsRemoteUrl(this.config.url, this.logger);
-        // Validate that all header env vars resolve (fail fast)
-        resolveEnvRecord(this.config.headers || {}, "header");
+        // Validate that all header/auth env vars resolve (fail fast)
+        this.resolvedHeaders = resolveServerHeaders(this.config);
         await this.probeServer();
         this.connected = true;
         this.backoffDelay = this.clientConfig.reconnectIntervalMs || 30000;
@@ -23,25 +25,32 @@ export class StreamableHttpTransport extends BaseTransport {
         const requestWithId = { ...request, id };
         return new Promise((resolve, reject) => {
             const requestTimeout = this.clientConfig.requestTimeoutMs || 60000;
+            const abortController = new AbortController();
             const timeout = setTimeout(() => {
+                abortController.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 headers = resolveEnvRecord({
+            this.pendingRequestControllers.set(id, abortController);
+            const base = this.resolvedHeaders ?? resolveServerHeaders(this.config);
+            const headers = {
+                ...base,
                 "Accept": "application/json, text/event-stream",
-                ...this.config.headers,
                 "Content-Type": "application/json"
-            }, "header");
+            };
             if (this.sessionId) {
                 headers["mcp-session-id"] = this.sessionId;
             }
             fetch(this.config.url, {
                 method: "POST",
                 headers,
-                body: JSON.stringify(requestWithId)
+                body: JSON.stringify(requestWithId),
+                signal: abortController.signal
             })
                 .then(async (response) => {
+                this.pendingRequestControllers.delete(id);
                 const responseSessionId = response.headers.get("mcp-session-id");
                 if (responseSessionId) {
                     this.sessionId = responseSessionId;
@@ -98,6 +107,7 @@ export class StreamableHttpTransport extends BaseTransport {
                 }
             })
                 .catch(error => {
+                this.pendingRequestControllers.delete(id);
                 clearTimeout(timeout);
                 this.pendingRequests.delete(id);
                 if (error.name === 'TypeError' && error.message.includes('fetch')) {
@@ -112,11 +122,12 @@ export class StreamableHttpTransport extends BaseTransport {
         if (!this.connected || !this.config.url) {
             throw new Error("Streamable HTTP transport not connected");
         }
-        const headers = resolveEnvRecord({
+        const base = this.resolvedHeaders ?? resolveServerHeaders(this.config);
+        const headers = {
+            ...base,
             "Accept": "application/json, text/event-stream",
-            ...this.config.headers,
             "Content-Type": "application/json"
-        }, "header");
+        };
         if (this.sessionId) {
             headers["mcp-session-id"] = this.sessionId;
         }
@@ -146,10 +157,10 @@ export class StreamableHttpTransport extends BaseTransport {
         if (!this.config.url)
             return;
         try {
-            const optionsResponse = await fetch(this.config.url, { method: "OPTIONS" });
+            const headers = this.resolvedHeaders ?? resolveServerHeaders(this.config);
+            const optionsResponse = await fetch(this.config.url, { method: "OPTIONS", headers });
             if (optionsResponse.ok)
                 return;
-            const headers = resolveEnvRecord(this.config.headers || {}, "header");
             const headResponse = await fetch(this.config.url, { method: "HEAD", headers });
             if (!headResponse.ok) {
                 this.logger.warn(`[mcp-bridge] Streamable HTTP server probe: OPTIONS ${optionsResponse.status}, HEAD ${headResponse.status} (non-blocking, connection continues)`);
@@ -162,11 +173,15 @@ export class StreamableHttpTransport extends BaseTransport {
     async disconnect() {
         this.connected = false;
         this.cleanupReconnectTimer();
+        for (const [, controller] of this.pendingRequestControllers) {
+            controller.abort();
+        }
+        this.pendingRequestControllers.clear();
         // Send DELETE request if we have a session to clean up
         if (this.sessionId && this.config.url) {
             try {
-                const headers = resolveEnvRecord(this.config.headers || {}, "header");
-                headers["mcp-session-id"] = this.sessionId;
+                const base = this.resolvedHeaders ?? resolveServerHeaders(this.config);
+                const headers = { ...base, "mcp-session-id": this.sessionId };
                 await fetch(this.config.url, {
                     method: "DELETE",
                     headers
@@ -180,4 +195,7 @@ export class StreamableHttpTransport extends BaseTransport {
         }
         this.rejectAllPending("Connection closed");
     }
+    async shutdown() {
+        await this.disconnect();
+    }
 }

package/dist/src/types.d.ts

@@ -4,12 +4,26 @@ export interface Logger {
     error: (...args: unknown[]) => void;
     debug: (...args: unknown[]) => void;
 }
+export type HttpAuthConfig = {
+    type: "bearer";
+    token: string;
+} | {
+    type: "header";
+    headers: Record<string, string>;
+};
+export interface RetryConfig {
+    maxAttempts?: number;
+    delayMs?: number;
+    backoffMultiplier?: number;
+    retryOn?: Array<"timeout" | "connection_error">;
+}
 export interface McpServerConfig {
     transport: "sse" | "stdio" | "streamable-http";
     /** Human-readable description for router tool description generation */
     description?: string;
     url?: string;
     headers?: Record<string, string>;
+    auth?: HttpAuthConfig;
     command?: string;
     args?: string[];
     env?: Record<string, string>;
@@ -20,6 +34,7 @@ export interface McpServerConfig {
         allow?: string[];
     };
     maxResultChars?: number;
+    retry?: RetryConfig;
 }
 export interface McpClientConfig {
     servers: Record<string, McpServerConfig>;
@@ -28,6 +43,7 @@ export interface McpClientConfig {
     reconnectIntervalMs?: number;
     connectionTimeoutMs?: number;
     requestTimeoutMs?: number;
+    shutdownTimeoutMs?: number;
     routerIdleTimeoutMs?: number;
     routerMaxConcurrent?: number;
     maxBatchSize?: number;
@@ -49,6 +65,7 @@ export interface McpClientConfig {
         minCalls?: number;
         decayMs?: number;
     };
+    retry?: RetryConfig;
     resultCache?: {
         enabled?: boolean;
         maxEntries?: number;
@@ -98,6 +115,7 @@ export interface McpResponse {
 export interface McpTransport {
     connect(): Promise<void>;
     disconnect(): Promise<void>;
+    shutdown?(timeoutMs?: number): Promise<void>;
     sendRequest(request: McpRequest): Promise<McpResponse>;
     sendNotification(notification: any): Promise<void>;
     isConnected(): boolean;

package/package.json

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