@juspay/neurolink 9.32.0 → 9.32.1

package/dist/client/mcp/httpRateLimiter.js

@@ -1,391 +0,0 @@
-/**
- * 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

@@ -1,178 +0,0 @@
-/**
- * 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

@@ -1,74 +0,0 @@
-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: [],
-    };
-}