@juspay/neurolink 8.28.0 → 8.30.0

package/dist/mcp/externalServerManager.js

@@ -51,6 +51,7 @@ function safeMetadataConversion(metadata) {
 }
 /**
  * Type guard to validate external MCP server configuration
+ * Supports both stdio transport (requires command) and HTTP transport (requires url)
  */
 function isValidExternalMCPServerConfig(config) {
     if (!isNonNullObject(config)) {
@@ -66,7 +67,13 @@ function isValidExternalMCPServerConfig(config) {
             return false;
         }
     }
-    return (typeof record.command === "string" &&
+    // Must have either command (for stdio) or url (for HTTP/SSE transport)
+    const hasCommand = typeof record.command === "string";
+    const hasUrl = typeof record.url === "string";
+    if (!hasCommand && !hasUrl) {
+        return false;
+    }
+    return ((record.command === undefined || typeof record.command === "string") &&
         (record.args === undefined || Array.isArray(record.args)) &&
         (record.env === undefined || isNonNullObject(record.env)) &&
         (record.transport === undefined || typeof record.transport === "string") &&
@@ -78,8 +85,17 @@ function isValidExternalMCPServerConfig(config) {
             typeof record.autoRestart === "boolean") &&
         (record.cwd === undefined || typeof record.cwd === "string") &&
         (record.url === undefined || typeof record.url === "string") &&
+        (record.headers === undefined || isNonNullObject(record.headers)) &&
+        (record.httpOptions === undefined || isNonNullObject(record.httpOptions)) &&
+        (record.retryConfig === undefined || isNonNullObject(record.retryConfig)) &&
+        (record.rateLimiting === undefined ||
+            isNonNullObject(record.rateLimiting)) &&
         (record.metadata === undefined || isNonNullObject(record.metadata)));
 }
+/**
+ * ExternalServerManager
+ * Core class for managing external MCP servers
+ */
 export class ExternalServerManager extends EventEmitter {
     servers = new Map();
     config;
@@ -180,13 +196,17 @@ export class ExternalServerManager extends EventEmitter {
                     const externalConfig = {
                         id: serverId,
                         name: serverId,
-                        description: `External MCP server: ${serverId}`,
+                        description: typeof serverConfig.description === "string"
+                            ? serverConfig.description
+                            : `External MCP server: ${serverId}`,
                         transport: typeof serverConfig.transport === "string"
                             ? serverConfig.transport
                             : "stdio",
                         status: "initializing",
                         tools: [],
-                        command: serverConfig.command,
+                        command: typeof serverConfig.command === "string"
+                            ? serverConfig.command
+                            : undefined,
                         args: Array.isArray(serverConfig.args)
                             ? serverConfig.args
                             : [],
@@ -211,6 +231,19 @@ export class ExternalServerManager extends EventEmitter {
                         url: typeof serverConfig.url === "string"
                             ? serverConfig.url
                             : undefined,
+                        // HTTP transport-specific fields
+                        headers: isNonNullObject(serverConfig.headers)
+                            ? serverConfig.headers
+                            : undefined,
+                        httpOptions: isNonNullObject(serverConfig.httpOptions)
+                            ? serverConfig.httpOptions
+                            : undefined,
+                        retryConfig: isNonNullObject(serverConfig.retryConfig)
+                            ? serverConfig.retryConfig
+                            : undefined,
+                        rateLimiting: isNonNullObject(serverConfig.rateLimiting)
+                            ? serverConfig.rateLimiting
+                            : undefined,
                         blockedTools: Array.isArray(serverConfig.blockedTools)
                             ? serverConfig.blockedTools
                             : undefined,
@@ -294,13 +327,17 @@ export class ExternalServerManager extends EventEmitter {
                     const externalConfig = {
                         id: serverId,
                         name: serverId,
-                        description: `External MCP server: ${serverId}`,
+                        description: typeof serverConfig.description === "string"
+                            ? serverConfig.description
+                            : `External MCP server: ${serverId}`,
                         transport: typeof serverConfig.transport === "string"
                             ? serverConfig.transport
                             : "stdio",
                         status: "initializing",
                         tools: [],
-                        command: serverConfig.command,
+                        command: typeof serverConfig.command === "string"
+                            ? serverConfig.command
+                            : undefined,
                         args: Array.isArray(serverConfig.args)
                             ? serverConfig.args
                             : [],
@@ -325,6 +362,19 @@ export class ExternalServerManager extends EventEmitter {
                         url: typeof serverConfig.url === "string"
                             ? serverConfig.url
                             : undefined,
+                        // HTTP transport-specific fields
+                        headers: isNonNullObject(serverConfig.headers)
+                            ? serverConfig.headers
+                            : undefined,
+                        httpOptions: isNonNullObject(serverConfig.httpOptions)
+                            ? serverConfig.httpOptions
+                            : undefined,
+                        retryConfig: isNonNullObject(serverConfig.retryConfig)
+                            ? serverConfig.retryConfig
+                            : undefined,
+                        rateLimiting: isNonNullObject(serverConfig.rateLimiting)
+                            ? serverConfig.rateLimiting
+                            : undefined,
                         blockedTools: Array.isArray(serverConfig.blockedTools)
                             ? serverConfig.blockedTools
                             : undefined,
@@ -368,19 +418,26 @@ export class ExternalServerManager extends EventEmitter {
         if (!config.id || typeof config.id !== "string") {
             errors.push("Server ID is required and must be a string");
         }
-        if (!config.command || typeof config.command !== "string") {
-            errors.push("Command is required and must be a string");
+        if (!["stdio", "sse", "websocket", "http"].includes(config.transport)) {
+            errors.push("Transport must be one of: stdio, sse, websocket, http");
         }
-        if (!Array.isArray(config.args)) {
-            errors.push("Args must be an array");
-        }
-        if (!["stdio", "sse", "websocket"].includes(config.transport)) {
-            errors.push("Transport must be one of: stdio, sse, websocket");
+        // Transport-specific validation
+        if (config.transport === "stdio") {
+            // stdio transport requires command
+            if (!config.command || typeof config.command !== "string") {
+                errors.push("Command is required and must be a string for stdio transport");
+            }
+            if (!Array.isArray(config.args)) {
+                errors.push("Args must be an array");
+            }
         }
-        // URL validation for non-stdio transports
-        if ((config.transport === "sse" || config.transport === "websocket") &&
-            !config.url) {
-            errors.push(`URL is required for ${config.transport} transport`);
+        else if (config.transport === "sse" ||
+            config.transport === "websocket" ||
+            config.transport === "http") {
+            // HTTP-based transports require URL
+            if (!config.url || typeof config.url !== "string") {
+                errors.push(`URL is required for ${config.transport} transport`);
+            }
         }
         // Warnings for common issues
         if (config.timeout && config.timeout < 5000) {
@@ -461,14 +518,19 @@ export class ExternalServerManager extends EventEmitter {
                 command: serverInfo.command || "",
                 args: serverInfo.args || [],
                 env: serverInfo.env || {},
-                timeout: serverInfo.metadata?.timeout,
-                retries: serverInfo.metadata?.retries,
-                healthCheckInterval: serverInfo.metadata?.healthCheckInterval,
-                autoRestart: serverInfo.metadata?.autoRestart,
-                cwd: serverInfo.metadata?.cwd,
-                url: serverInfo.metadata?.url,
+                timeout: serverInfo.timeout,
+                retries: serverInfo.retries,
+                healthCheckInterval: serverInfo.healthCheckInterval,
+                autoRestart: serverInfo.autoRestart,
+                cwd: serverInfo.cwd,
+                url: serverInfo.url,
                 blockedTools: serverInfo.blockedTools,
                 metadata: safeMetadataConversion(serverInfo.metadata),
+                // HTTP transport-specific fields
+                headers: serverInfo.headers,
+                httpOptions: serverInfo.httpOptions,
+                retryConfig: serverInfo.retryConfig,
+                rateLimiting: serverInfo.rateLimiting,
             };
             const validation = this.validateConfig(tempConfig);
             if (!validation.isValid) {

package/dist/mcp/httpRateLimiter.d.ts

@@ -0,0 +1,152 @@
+/**
+ * HTTP Rate Limiter for MCP HTTP Transport
+ * Implements token bucket algorithm for rate limiting
+ * Provides fault tolerance and prevents server overload
+ */
+import type { RateLimitConfig, RateLimiterStats } from "../types/mcpTypes.js";
+/**
+ * Default rate limit configuration
+ * Provides sensible defaults for most MCP HTTP transport use cases
+ */
+export declare const DEFAULT_RATE_LIMIT_CONFIG: RateLimitConfig;
+/**
+ * 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 declare class HTTPRateLimiter {
+    private tokens;
+    private lastRefill;
+    private config;
+    private waitQueue;
+    private processingQueue;
+    constructor(config?: Partial<RateLimitConfig>);
+    /**
+     * Refill tokens based on elapsed time since last refill
+     * Tokens are added at the configured refillRate (tokens per second)
+     */
+    private refillTokens;
+    /**
+     * 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
+     */
+    acquire(): Promise<void>;
+    /**
+     * Process the wait queue, granting tokens as they become available
+     */
+    private processQueue;
+    /**
+     * Sleep helper function
+     */
+    private sleep;
+    /**
+     * Try to acquire a token without waiting
+     *
+     * @returns true if a token was acquired, false otherwise
+     */
+    tryAcquire(): boolean;
+    /**
+     * 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: Headers): number;
+    /**
+     * Get the number of remaining tokens
+     *
+     * @returns Current number of available tokens
+     */
+    getRemainingTokens(): number;
+    /**
+     * Reset the rate limiter to initial state
+     * Useful for testing or when server indicates rate limits have been reset
+     */
+    reset(): void;
+    /**
+     * Get current rate limiter statistics
+     */
+    getStats(): RateLimiterStats;
+    /**
+     * Update configuration dynamically
+     * Useful when server provides rate limit information
+     */
+    updateConfig(config: Partial<RateLimitConfig>): void;
+    /**
+     * Get current configuration
+     */
+    getConfig(): Readonly<RateLimitConfig>;
+}
+/**
+ * RateLimiterManager
+ * Manages multiple rate limiters for different servers
+ * Each server can have its own rate limiting configuration
+ */
+export declare class RateLimiterManager {
+    private limiters;
+    /**
+     * 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: string, config?: Partial<RateLimitConfig>): HTTPRateLimiter;
+    /**
+     * 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: string): boolean;
+    /**
+     * Remove a rate limiter for a server
+     *
+     * @param serverId - Unique identifier for the server
+     */
+    removeLimiter(serverId: string): void;
+    /**
+     * Get all server IDs with active rate limiters
+     *
+     * @returns Array of server IDs
+     */
+    getServerIds(): string[];
+    /**
+     * Get statistics for all rate limiters
+     *
+     * @returns Record of server IDs to their rate limiter statistics
+     */
+    getAllStats(): Record<string, RateLimiterStats>;
+    /**
+     * Reset all rate limiters
+     */
+    resetAll(): void;
+    /**
+     * Destroy all rate limiters and clean up resources
+     * This should be called during application shutdown
+     */
+    destroyAll(): void;
+    /**
+     * Get health summary for all rate limiters
+     */
+    getHealthSummary(): {
+        totalLimiters: number;
+        serversWithQueuedRequests: string[];
+        totalQueuedRequests: number;
+        averageTokensAvailable: number;
+    };
+}
+/**
+ * Global rate limiter manager instance
+ * Use this for application-wide rate limiting management
+ */
+export declare const globalRateLimiterManager: RateLimiterManager;