@juspay/neurolink 9.30.0 → 9.31.0

package/dist/client/mcp/httpRateLimiter.js

@@ -0,0 +1,391 @@
+/**
+ * HTTP Rate Limiter for MCP HTTP Transport
+ * Implements token bucket algorithm for rate limiting
+ * Provides fault tolerance and prevents server overload
+ */
+import { mcpLogger } from "../utils/logger.js";
+import { SpanSerializer, SpanType, SpanStatus, } from "../observability/index.js";
+import { getMetricsAggregator } from "../observability/index.js";
+/**
+ * Default rate limit configuration
+ * Provides sensible defaults for most MCP HTTP transport use cases
+ */
+export const DEFAULT_RATE_LIMIT_CONFIG = {
+    requestsPerWindow: 60,
+    windowMs: 60000,
+    useTokenBucket: true,
+    refillRate: 1,
+    maxBurst: 10,
+};
+/**
+ * HTTPRateLimiter
+ * Implements token bucket algorithm for rate limiting HTTP requests
+ *
+ * The token bucket algorithm works as follows:
+ * - Tokens are added to the bucket at a fixed rate (refillRate per second)
+ * - Each request consumes one token
+ * - If no tokens are available, the request must wait
+ * - Maximum tokens are capped at maxBurst to allow controlled bursting
+ */
+export class HTTPRateLimiter {
+    tokens;
+    lastRefill;
+    config;
+    waitQueue = [];
+    processingQueue = false;
+    constructor(config = {}) {
+        this.config = { ...DEFAULT_RATE_LIMIT_CONFIG, ...config };
+        this.tokens = this.config.maxBurst;
+        this.lastRefill = Date.now();
+        mcpLogger.debug(`[HTTPRateLimiter] Initialized with config:`, {
+            requestsPerWindow: this.config.requestsPerWindow,
+            windowMs: this.config.windowMs,
+            useTokenBucket: this.config.useTokenBucket,
+            refillRate: this.config.refillRate,
+            maxBurst: this.config.maxBurst,
+        });
+    }
+    /**
+     * Refill tokens based on elapsed time since last refill
+     * Tokens are added at the configured refillRate (tokens per second)
+     */
+    refillTokens() {
+        const now = Date.now();
+        const elapsedMs = now - this.lastRefill;
+        const elapsedSeconds = elapsedMs / 1000;
+        // Calculate tokens to add based on elapsed time and refill rate
+        const tokensToAdd = elapsedSeconds * this.config.refillRate;
+        if (tokensToAdd >= 1) {
+            // Only refill if at least one token should be added
+            const previousTokens = this.tokens;
+            this.tokens = Math.min(this.config.maxBurst, this.tokens + tokensToAdd);
+            this.lastRefill = now;
+            if (this.tokens > previousTokens) {
+                mcpLogger.debug(`[HTTPRateLimiter] Refilled tokens: ${previousTokens.toFixed(2)} -> ${this.tokens.toFixed(2)} (+${tokensToAdd.toFixed(2)})`);
+            }
+        }
+    }
+    /**
+     * Acquire a token, waiting if necessary
+     * This is the primary method for rate-limited operations
+     *
+     * @returns Promise that resolves when a token is acquired
+     * @throws Error if the wait queue is too long
+     */
+    async acquire() {
+        const span = SpanSerializer.createSpan(SpanType.MCP_TRANSPORT, "mcp.rateLimit", {
+            "mcp.transport": "http",
+            "mcp.operation": "rateLimit",
+            "mcp.rateLimit.tokensAvailable": this.tokens,
+            "mcp.rateLimit.maxBurst": this.config.maxBurst,
+        });
+        const startTime = Date.now();
+        try {
+            // First, try to acquire without waiting
+            if (this.tryAcquire()) {
+                span.durationMs = Date.now() - startTime;
+                span.attributes["mcp.rateLimit.waited"] = false;
+                const endedSpan = SpanSerializer.endSpan(span, SpanStatus.OK);
+                getMetricsAggregator().recordSpan(endedSpan);
+                return;
+            }
+            // Add to wait queue
+            await new Promise((resolve, reject) => {
+                this.waitQueue.push({ resolve, reject });
+                mcpLogger.debug(`[HTTPRateLimiter] Request queued, queue length: ${this.waitQueue.length}`);
+                // Start processing the queue if not already processing
+                if (!this.processingQueue) {
+                    this.processQueue();
+                }
+            });
+            span.durationMs = Date.now() - startTime;
+            span.attributes["mcp.rateLimit.waited"] = true;
+            const endedSpan = SpanSerializer.endSpan(span, SpanStatus.OK);
+            getMetricsAggregator().recordSpan(endedSpan);
+        }
+        catch (error) {
+            span.durationMs = Date.now() - startTime;
+            const endedSpan = SpanSerializer.endSpan(span, SpanStatus.ERROR);
+            endedSpan.statusMessage =
+                error instanceof Error ? error.message : String(error);
+            getMetricsAggregator().recordSpan(endedSpan);
+            throw error;
+        }
+    }
+    /**
+     * Process the wait queue, granting tokens as they become available
+     */
+    async processQueue() {
+        if (this.processingQueue) {
+            return;
+        }
+        this.processingQueue = true;
+        while (this.waitQueue.length > 0) {
+            // Refill tokens
+            this.refillTokens();
+            // If we have tokens, grant to next waiter
+            if (this.tokens >= 1) {
+                const waiter = this.waitQueue.shift();
+                if (waiter) {
+                    this.tokens -= 1;
+                    mcpLogger.debug(`[HTTPRateLimiter] Token granted from queue, remaining: ${this.tokens.toFixed(2)}, queue: ${this.waitQueue.length}`);
+                    waiter.resolve();
+                }
+            }
+            else {
+                // Calculate wait time until next token is available
+                const tokensNeeded = 1 - this.tokens;
+                const waitTimeMs = (tokensNeeded / this.config.refillRate) * 1000;
+                const actualWait = Math.max(10, Math.ceil(waitTimeMs));
+                mcpLogger.debug(`[HTTPRateLimiter] Waiting ${actualWait}ms for token refill`);
+                // Wait for the calculated time
+                await this.sleep(actualWait);
+            }
+        }
+        this.processingQueue = false;
+    }
+    /**
+     * Sleep helper function
+     */
+    sleep(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+    /**
+     * Try to acquire a token without waiting
+     *
+     * @returns true if a token was acquired, false otherwise
+     */
+    tryAcquire() {
+        // Refill tokens based on elapsed time
+        this.refillTokens();
+        // Check if we have tokens available
+        if (this.tokens >= 1) {
+            this.tokens -= 1;
+            mcpLogger.debug(`[HTTPRateLimiter] Token acquired, remaining: ${this.tokens.toFixed(2)}`);
+            return true;
+        }
+        mcpLogger.debug(`[HTTPRateLimiter] No tokens available, current: ${this.tokens.toFixed(2)}`);
+        return false;
+    }
+    /**
+     * Handle rate limit response headers from server
+     * Parses Retry-After header and returns wait time in milliseconds
+     *
+     * @param headers - Response headers from the server
+     * @returns Wait time in milliseconds, or 0 if no rate limit headers found
+     */
+    handleRateLimitResponse(headers) {
+        // Check for Retry-After header (standard HTTP 429 response)
+        const retryAfter = headers.get("Retry-After");
+        if (retryAfter) {
+            // Retry-After can be either a number of seconds or an HTTP-date
+            const seconds = parseInt(retryAfter, 10);
+            if (!isNaN(seconds)) {
+                // It's a number of seconds
+                const waitTimeMs = seconds * 1000;
+                mcpLogger.info(`[HTTPRateLimiter] Server requested retry after ${seconds} seconds`);
+                return waitTimeMs;
+            }
+            else {
+                // Try to parse as HTTP-date
+                const retryDate = new Date(retryAfter);
+                if (!isNaN(retryDate.getTime())) {
+                    const waitTimeMs = Math.max(0, retryDate.getTime() - Date.now());
+                    mcpLogger.info(`[HTTPRateLimiter] Server requested retry at ${retryDate.toISOString()} (${waitTimeMs}ms)`);
+                    return waitTimeMs;
+                }
+            }
+        }
+        // Check for X-RateLimit-Reset header (common non-standard header)
+        const rateLimitReset = headers.get("X-RateLimit-Reset");
+        if (rateLimitReset) {
+            const resetTimestamp = parseInt(rateLimitReset, 10);
+            if (!isNaN(resetTimestamp)) {
+                // Could be Unix timestamp (seconds) or milliseconds
+                const resetTime = resetTimestamp > 1e12 ? resetTimestamp : resetTimestamp * 1000;
+                const waitTimeMs = Math.max(0, resetTime - Date.now());
+                mcpLogger.info(`[HTTPRateLimiter] Rate limit resets at ${new Date(resetTime).toISOString()} (${waitTimeMs}ms)`);
+                return waitTimeMs;
+            }
+        }
+        // Check for X-RateLimit-Remaining header
+        const remaining = headers.get("X-RateLimit-Remaining");
+        if (remaining === "0") {
+            // No remaining requests, use default backoff
+            const defaultBackoffMs = 1000;
+            mcpLogger.info(`[HTTPRateLimiter] Rate limit exhausted, using default backoff: ${defaultBackoffMs}ms`);
+            return defaultBackoffMs;
+        }
+        return 0;
+    }
+    /**
+     * Get the number of remaining tokens
+     *
+     * @returns Current number of available tokens
+     */
+    getRemainingTokens() {
+        this.refillTokens();
+        return this.tokens;
+    }
+    /**
+     * Reset the rate limiter to initial state
+     * Useful for testing or when server indicates rate limits have been reset
+     */
+    reset() {
+        this.tokens = this.config.maxBurst;
+        this.lastRefill = Date.now();
+        // Reject all pending waiters
+        while (this.waitQueue.length > 0) {
+            const waiter = this.waitQueue.shift();
+            if (waiter) {
+                waiter.reject(new Error("Rate limiter was reset"));
+            }
+        }
+        mcpLogger.info(`[HTTPRateLimiter] Reset to initial state, tokens: ${this.tokens}`);
+    }
+    /**
+     * Get current rate limiter statistics
+     */
+    getStats() {
+        this.refillTokens();
+        return {
+            tokens: this.tokens,
+            maxBurst: this.config.maxBurst,
+            refillRate: this.config.refillRate,
+            queueLength: this.waitQueue.length,
+            lastRefill: new Date(this.lastRefill),
+        };
+    }
+    /**
+     * Update configuration dynamically
+     * Useful when server provides rate limit information
+     */
+    updateConfig(config) {
+        Object.assign(this.config, config);
+        mcpLogger.info(`[HTTPRateLimiter] Configuration updated:`, config);
+    }
+    /**
+     * Get current configuration
+     */
+    getConfig() {
+        return { ...this.config };
+    }
+}
+/**
+ * RateLimiterManager
+ * Manages multiple rate limiters for different servers
+ * Each server can have its own rate limiting configuration
+ */
+export class RateLimiterManager {
+    limiters = new Map();
+    /**
+     * Get or create a rate limiter for a server
+     *
+     * @param serverId - Unique identifier for the server
+     * @param config - Optional configuration for the rate limiter
+     * @returns HTTPRateLimiter instance for the server
+     */
+    getLimiter(serverId, config) {
+        let limiter = this.limiters.get(serverId);
+        if (!limiter) {
+            limiter = new HTTPRateLimiter(config);
+            this.limiters.set(serverId, limiter);
+            mcpLogger.debug(`[RateLimiterManager] Created rate limiter for server: ${serverId}`);
+        }
+        else if (config) {
+            // Update existing limiter's configuration if provided
+            limiter.updateConfig(config);
+        }
+        return limiter;
+    }
+    /**
+     * Check if a rate limiter exists for a server
+     *
+     * @param serverId - Unique identifier for the server
+     * @returns true if a rate limiter exists for the server
+     */
+    hasLimiter(serverId) {
+        return this.limiters.has(serverId);
+    }
+    /**
+     * Remove a rate limiter for a server
+     *
+     * @param serverId - Unique identifier for the server
+     */
+    removeLimiter(serverId) {
+        const limiter = this.limiters.get(serverId);
+        if (limiter) {
+            limiter.reset(); // Clean up any pending operations
+            this.limiters.delete(serverId);
+            mcpLogger.debug(`[RateLimiterManager] Removed rate limiter for server: ${serverId}`);
+        }
+    }
+    /**
+     * Get all server IDs with active rate limiters
+     *
+     * @returns Array of server IDs
+     */
+    getServerIds() {
+        return Array.from(this.limiters.keys());
+    }
+    /**
+     * Get statistics for all rate limiters
+     *
+     * @returns Record of server IDs to their rate limiter statistics
+     */
+    getAllStats() {
+        const stats = {};
+        for (const [serverId, limiter] of this.limiters) {
+            stats[serverId] = limiter.getStats();
+        }
+        return stats;
+    }
+    /**
+     * Reset all rate limiters
+     */
+    resetAll() {
+        for (const limiter of this.limiters.values()) {
+            limiter.reset();
+        }
+        mcpLogger.info("[RateLimiterManager] Reset all rate limiters");
+    }
+    /**
+     * Destroy all rate limiters and clean up resources
+     * This should be called during application shutdown
+     */
+    destroyAll() {
+        for (const limiter of this.limiters.values()) {
+            limiter.reset();
+        }
+        this.limiters.clear();
+        mcpLogger.info("[RateLimiterManager] Destroyed all rate limiters");
+    }
+    /**
+     * Get health summary for all rate limiters
+     */
+    getHealthSummary() {
+        const serversWithQueuedRequests = [];
+        let totalQueuedRequests = 0;
+        let totalTokens = 0;
+        for (const [serverId, limiter] of this.limiters) {
+            const stats = limiter.getStats();
+            if (stats.queueLength > 0) {
+                serversWithQueuedRequests.push(serverId);
+                totalQueuedRequests += stats.queueLength;
+            }
+            totalTokens += stats.tokens;
+        }
+        const averageTokensAvailable = this.limiters.size > 0 ? totalTokens / this.limiters.size : 0;
+        return {
+            totalLimiters: this.limiters.size,
+            serversWithQueuedRequests,
+            totalQueuedRequests,
+            averageTokensAvailable,
+        };
+    }
+}
+/**
+ * Global rate limiter manager instance
+ * Use this for application-wide rate limiting management
+ */
+export const globalRateLimiterManager = new RateLimiterManager();

package/dist/client/mcp/httpRetryHandler.js

@@ -0,0 +1,178 @@
+/**
+ * HTTP Retry Handler for MCP Transport
+ *
+ * Provides retry logic with exponential backoff and jitter
+ * specifically designed for HTTP-based MCP transport connections.
+ */
+import { isAbortError } from "../utils/errorHandling.js";
+import { calculateBackoffDelay } from "../utils/retryHandler.js";
+import { logger } from "../utils/logger.js";
+import { SpanSerializer, SpanType, SpanStatus, } from "../observability/index.js";
+import { getMetricsAggregator } from "../observability/index.js";
+/**
+ * Default HTTP retry configuration
+ */
+export const DEFAULT_HTTP_RETRY_CONFIG = {
+    maxAttempts: 3,
+    initialDelay: 1000,
+    maxDelay: 30000,
+    backoffMultiplier: 2,
+    retryableStatusCodes: [408, 429, 500, 502, 503, 504],
+};
+/**
+ * Sleep utility for retry delays
+ */
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+ * Check if an HTTP status code is retryable based on configuration
+ *
+ * @param status - HTTP status code to check
+ * @param config - HTTP retry configuration
+ * @returns True if the status code should trigger a retry
+ */
+export function isRetryableStatusCode(status, config = DEFAULT_HTTP_RETRY_CONFIG) {
+    return config.retryableStatusCodes.includes(status);
+}
+/**
+ * Check if an error is retryable for HTTP operations
+ *
+ * Considers:
+ * - Network errors (ECONNRESET, ENOTFOUND, ECONNREFUSED, ETIMEDOUT)
+ * - Timeout errors
+ * - HTTP status codes in the retryable list
+ * - Fetch/network-related errors
+ *
+ * @param error - Error to check
+ * @param config - HTTP retry configuration (optional)
+ * @returns True if the error is retryable
+ */
+export function isRetryableHTTPError(error, config = DEFAULT_HTTP_RETRY_CONFIG) {
+    if (!error || typeof error !== "object") {
+        return false;
+    }
+    const errorObj = error;
+    // User-initiated aborts are NOT retryable — the caller explicitly cancelled
+    if (isAbortError(error)) {
+        return false;
+    }
+    // Check for timeout errors
+    if (errorObj.name === "TimeoutError" ||
+        errorObj.code === "TIMEOUT" ||
+        errorObj.code === "ETIMEDOUT") {
+        return true;
+    }
+    // Check for network-related errors
+    if (errorObj.code === "ECONNRESET" ||
+        errorObj.code === "ENOTFOUND" ||
+        errorObj.code === "ECONNREFUSED" ||
+        errorObj.code === "ECONNABORTED" ||
+        errorObj.code === "EPIPE" ||
+        errorObj.code === "ENETUNREACH" ||
+        errorObj.code === "EHOSTUNREACH") {
+        return true;
+    }
+    // Check for fetch errors (network failures)
+    if (errorObj.name === "TypeError" && typeof errorObj.message === "string") {
+        const message = errorObj.message.toLowerCase();
+        if (message.includes("fetch") ||
+            message.includes("network") ||
+            message.includes("connection")) {
+            return true;
+        }
+    }
+    // Check for HTTP status codes
+    if (typeof errorObj.status === "number") {
+        return isRetryableStatusCode(errorObj.status, config);
+    }
+    // Check for response object with status
+    if (errorObj.response &&
+        typeof errorObj.response === "object" &&
+        typeof errorObj.response.status === "number") {
+        return isRetryableStatusCode(errorObj.response.status, config);
+    }
+    // Check for statusCode (alternative property name)
+    if (typeof errorObj.statusCode === "number") {
+        return isRetryableStatusCode(errorObj.statusCode, config);
+    }
+    return false;
+}
+/**
+ * Execute an HTTP operation with retry logic
+ *
+ * Implements exponential backoff with jitter to avoid thundering herd problems.
+ * Uses the calculateBackoffDelay function from the core retry handler for
+ * consistent delay calculation across the codebase.
+ *
+ * @param operation - Async operation to execute with retries
+ * @param config - Partial HTTP retry configuration (merged with defaults)
+ * @returns Result of the operation
+ * @throws Last error if all retry attempts fail
+ *
+ * @example
+ * ```typescript
+ * const result = await withHTTPRetry(
+ *   async () => {
+ *     const response = await fetch(url);
+ *     if (!response.ok) {
+ *       const error = new Error(`HTTP ${response.status}`) as Error & { status: number };
+ *       error.status = response.status;
+ *       throw error;
+ *     }
+ *     return response.json();
+ *   },
+ *   { maxAttempts: 5, initialDelay: 500 }
+ * );
+ * ```
+ */
+export async function withHTTPRetry(operation, config = {}) {
+    const mergedConfig = {
+        ...DEFAULT_HTTP_RETRY_CONFIG,
+        ...config,
+    };
+    const span = SpanSerializer.createSpan(SpanType.MCP_TRANSPORT, "mcp.retry", {
+        "mcp.transport": "http",
+        "mcp.operation": "retry",
+        "mcp.maxAttempts": mergedConfig.maxAttempts,
+    });
+    const startTime = Date.now();
+    let lastError;
+    let actualAttempts = 0;
+    for (let attempt = 1; attempt <= mergedConfig.maxAttempts; attempt++) {
+        actualAttempts = attempt;
+        try {
+            const result = await operation();
+            span.durationMs = Date.now() - startTime;
+            span.attributes["mcp.retryAttempt"] = attempt;
+            const endedSpan = SpanSerializer.endSpan(span, SpanStatus.OK);
+            getMetricsAggregator().recordSpan(endedSpan);
+            return result;
+        }
+        catch (error) {
+            lastError = error;
+            // Don't retry if it's the last attempt
+            if (attempt === mergedConfig.maxAttempts) {
+                logger.debug(`HTTP retry: All ${mergedConfig.maxAttempts} attempts exhausted`);
+                break;
+            }
+            // Check if we should retry this error
+            if (!isRetryableHTTPError(error, mergedConfig)) {
+                logger.debug(`HTTP retry: Non-retryable error encountered`, error instanceof Error ? error.message : String(error));
+                break;
+            }
+            // Calculate delay using the shared backoff calculation
+            const delay = calculateBackoffDelay(attempt, mergedConfig.initialDelay, mergedConfig.backoffMultiplier, mergedConfig.maxDelay, true);
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            logger.warn(`HTTP retry: Attempt ${attempt}/${mergedConfig.maxAttempts} failed: ${errorMessage}. Retrying in ${Math.round(delay)}ms...`);
+            await sleep(delay);
+        }
+    }
+    span.durationMs = Date.now() - startTime;
+    span.attributes["mcp.retryAttempt"] = actualAttempts;
+    const endedSpan = SpanSerializer.endSpan(span, SpanStatus.ERROR);
+    endedSpan.statusMessage =
+        lastError instanceof Error ? lastError.message : String(lastError);
+    getMetricsAggregator().recordSpan(endedSpan);
+    throw lastError;
+}

package/dist/client/mcp/index.js

@@ -0,0 +1,74 @@
+import { ErrorFactory } from "../utils/errorHandling.js";
+export { mcpLogger } from "../utils/logger.js";
+// MCP Server Factory
+export { createMCPServer, getServerInfo, validateServerTools, validateTool, } from "./factory.js";
+// OAuth Authentication
+export { calculateExpiresAt, createOAuthProviderFromConfig, FileTokenStorage, InMemoryTokenStorage, isTokenExpired, NeuroLinkOAuthProvider, } from "./auth/index.js";
+// HTTP Rate Limiter
+export { DEFAULT_RATE_LIMIT_CONFIG, globalRateLimiterManager, HTTPRateLimiter, RateLimiterManager, } from "./httpRateLimiter.js";
+// HTTP Retry Handler
+export { DEFAULT_HTTP_RETRY_CONFIG, isRetryableHTTPError, isRetryableStatusCode, withHTTPRetry, } from "./httpRetryHandler.js";
+// Circuit Breaker
+export { CircuitBreakerManager, globalCircuitBreakerManager, MCPCircuitBreaker, CircuitBreakerOpenError, } from "./mcpCircuitBreaker.js";
+// Core MCP Components
+export { MCPToolRegistry } from "./toolRegistry.js";
+export { ExternalServerManager } from "./externalServerManager.js";
+export { MCPClientFactory } from "./mcpClientFactory.js";
+// Agent and Workflow Exposure
+export { AgentExposureManager, exposeAgentAsTool, exposeAgentsAsTools, exposeWorkflowAsTool, exposeWorkflowsAsTools, globalAgentExposureManager, } from "./agentExposure.js";
+// Elicitation Protocol - Manager
+export { ElicitationManager, globalElicitationManager, } from "./elicitation/index.js";
+// Elicitation Protocol - Protocol Layer
+export { createConfirmationRequest, createElicitationCancel, createElicitationRequest, createElicitationResponse, createFormRequest, createSelectRequest, createTextInputRequest, ElicitationProtocolAdapter, elicitationResponseToProtocol, globalElicitationProtocol, isElicitationProtocolMessage, protocolMessageToElicitation, } from "./elicitationProtocol.js";
+// Enhanced Tool Discovery
+export { EnhancedToolDiscovery } from "./enhancedToolDiscovery.js";
+// MCP Registry Client
+export { getAllWellKnownServers, getWellKnownServer, globalMCPRegistryClient, MCPRegistryClient, } from "./mcpRegistryClient.js";
+// MCP Server Base Class
+export { MCPServerBase } from "./mcpServerBase.js";
+// Multi-Server Manager
+export { globalMultiServerManager, MultiServerManager, } from "./multiServerManager.js";
+// Server Capabilities (Resources and Prompts)
+export { createJsonResource, createPrompt, createTextResource, ServerCapabilitiesManager, } from "./serverCapabilities.js";
+// Tool Annotations System
+export { createAnnotatedTool, filterToolsByAnnotations, getAnnotationSummary, getToolSafetyLevel, inferAnnotations, isSafeToRetry, mergeAnnotations, requiresConfirmation, validateAnnotations, } from "./toolAnnotations.js";
+// Tool Converter Utilities
+export { batchConvertToMCP, batchConvertToNeuroLink, createToolFromFunction, mcpProtocolToolToServerTool, mcpToolToNeuroLink, neuroLinkToolToMCP, sanitizeToolName, serverToolToMCPProtocol, TOOL_COMPATIBILITY, validateToolName, } from "./toolConverter.js";
+// Tool Integration with Elicitation
+export { confirmationMiddleware, createElicitationContext, createRetryMiddleware, createTimeoutMiddleware, createToolMiddlewareChain, globalToolIntegrationManager, loggingMiddleware, ToolIntegrationManager, validationMiddleware, wrapToolsWithElicitation, wrapToolWithElicitation, } from "./toolIntegration.js";
+// Request Batcher - Efficient batch processing
+export { createRequestBatcher, createToolCallBatcher, DEFAULT_BATCH_CONFIG, RequestBatcher, ToolCallBatcher, } from "./batching/index.js";
+// Tool Cache - Result and response caching
+export { createToolCache, createToolResultCache, DEFAULT_CACHE_CONFIG, ToolCache, ToolResultCache, } from "./caching/index.js";
+// Tool Router - Intelligent routing for multi-server environments
+export { createToolRouter, DEFAULT_ROUTER_CONFIG, ToolRouter, } from "./routing/index.js";
+/**
+ * Initialize the MCP ecosystem - simplified
+ */
+export async function initializeMCPEcosystem() {
+    // Simplified initialization - no complex ecosystem needed
+    return Promise.resolve();
+}
+/**
+ * List available MCPs - simplified
+ */
+export async function listMCPs() {
+    return [];
+}
+/**
+ * Execute an MCP operation - simplified
+ */
+export async function executeMCP(_name, _config, _args, _context) {
+    throw ErrorFactory.invalidConfiguration("executeMCP", "Direct legacy MCP execution is deprecated. Use the new module APIs (createMCPServer, MultiServerManager, ToolRouter, etc.) instead.");
+}
+/**
+ * Get MCP ecosystem statistics - simplified
+ */
+export async function getMCPStats() {
+    return {
+        initialized: false,
+        pluginsDiscovered: 0,
+        pluginsBySource: {},
+        availablePlugins: [],
+    };
+}