@juspay/neurolink 8.28.0 → 8.30.0

package/dist/lib/mcp/mcpClientFactory.js

@@ -1,15 +1,20 @@
 /**
  * MCP Client Factory
  * Creates and manages MCP clients for external servers
- * Supports stdio, SSE, and WebSocket transports
+ * Supports stdio, SSE, WebSocket, and HTTP transports
+ * Enhanced with retry, rate limiting, and OAuth 2.1 support
  */
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
 import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
 import { WebSocketClientTransport } from "@modelcontextprotocol/sdk/client/websocket.js";
-import { spawn, ChildProcess } from "child_process";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { spawn } from "child_process";
 import { mcpLogger } from "../utils/logger.js";
 import { globalCircuitBreakerManager } from "./mcpCircuitBreaker.js";
+import { withHTTPRetry, DEFAULT_HTTP_RETRY_CONFIG, } from "./httpRetryHandler.js";
+import { globalRateLimiterManager } from "./httpRateLimiter.js";
+import { NeuroLinkOAuthProvider, InMemoryTokenStorage } from "./auth/index.js";
 /**
  * MCPClientFactory
  * Factory class for creating MCP clients with different transports
@@ -27,6 +32,7 @@ export class MCPClientFactory {
     };
     /**
      * Create an MCP client for the given server configuration
+     * Enhanced with retry logic, rate limiting, and circuit breaker protection
      */
     static async createClient(config, timeout = 10000) {
         const startTime = Date.now();
@@ -34,17 +40,56 @@ export class MCPClientFactory {
             mcpLogger.info(`[MCPClientFactory] Creating client for ${config.id}`, {
                 transport: config.transport,
                 command: config.command,
+                hasRetryConfig: !!config.retryConfig,
+                hasRateLimiting: !!config.rateLimiting,
+                hasAuth: !!config.auth,
             });
+            // Acquire rate limit token if rate limiting is configured for HTTP transport
+            if ((config.transport === "http" || config.transport === "sse") &&
+                config.rateLimiting) {
+                const rateLimiter = globalRateLimiterManager.getLimiter(config.id, {
+                    requestsPerWindow: config.rateLimiting.requestsPerMinute ?? 60,
+                    windowMs: 60000,
+                    maxBurst: config.rateLimiting.maxBurst ?? 10,
+                    useTokenBucket: config.rateLimiting.useTokenBucket ?? true,
+                    refillRate: (config.rateLimiting.requestsPerMinute ?? 60) / 60,
+                });
+                await rateLimiter.acquire();
+                mcpLogger.debug(`[MCPClientFactory] Rate limit token acquired for ${config.id}`);
+            }
             // Create circuit breaker for this server
             const circuitBreaker = globalCircuitBreakerManager.getBreaker(`mcp-client-${config.id}`, {
                 failureThreshold: 3,
                 resetTimeout: 30000,
                 operationTimeout: timeout,
             });
-            // Create client with circuit breaker protection
-            const result = await circuitBreaker.execute(async () => {
-                return await this.createClientInternal(config, timeout);
-            });
+            // Define the client creation operation
+            const createClientOperation = async () => {
+                return await circuitBreaker.execute(async () => {
+                    return await this.createClientInternal(config, timeout);
+                });
+            };
+            // Wrap with retry logic if retry config is provided for HTTP transport
+            let result;
+            if ((config.transport === "http" || config.transport === "sse") &&
+                config.retryConfig) {
+                mcpLogger.debug(`[MCPClientFactory] Using retry logic for ${config.id}`, {
+                    maxAttempts: config.retryConfig.maxAttempts ??
+                        DEFAULT_HTTP_RETRY_CONFIG.maxAttempts,
+                });
+                result = await withHTTPRetry(createClientOperation, {
+                    maxAttempts: config.retryConfig.maxAttempts ??
+                        DEFAULT_HTTP_RETRY_CONFIG.maxAttempts,
+                    initialDelay: config.retryConfig.initialDelay ??
+                        DEFAULT_HTTP_RETRY_CONFIG.initialDelay,
+                    maxDelay: config.retryConfig.maxDelay ?? DEFAULT_HTTP_RETRY_CONFIG.maxDelay,
+                    backoffMultiplier: config.retryConfig.backoffMultiplier ??
+                        DEFAULT_HTTP_RETRY_CONFIG.backoffMultiplier,
+                });
+            }
+            else {
+                result = await createClientOperation();
+            }
             mcpLogger.info(`[MCPClientFactory] Client created successfully for ${config.id}`, {
                 duration: Date.now() - startTime,
                 capabilities: result.capabilities,
@@ -122,6 +167,8 @@ export class MCPClientFactory {
                 return this.createSSETransport(config);
             case "websocket":
                 return this.createWebSocketTransport(config);
+            case "http":
+                return this.createHTTPTransport(config);
             default:
                 throw new Error(`Unsupported transport type: ${config.transport}`);
         }
@@ -244,6 +291,153 @@ export class MCPClientFactory {
             throw new Error(`Invalid WebSocket URL: ${error instanceof Error ? error.message : String(error)}`);
         }
     }
+    /**
+     * Create HTTP transport (Streamable HTTP)
+     * Enhanced with OAuth 2.1, rate limiting, and configurable timeouts
+     */
+    static async createHTTPTransport(config) {
+        if (!config.url) {
+            throw new Error("URL is required for HTTP transport");
+        }
+        // Extract HTTP options with defaults
+        const httpOptions = {
+            connectionTimeout: config.httpOptions?.connectionTimeout ?? 30000,
+            requestTimeout: config.httpOptions?.requestTimeout ?? 60000,
+            idleTimeout: config.httpOptions?.idleTimeout ?? 120000,
+            keepAliveTimeout: config.httpOptions?.keepAliveTimeout ?? 30000,
+        };
+        mcpLogger.debug(`[MCPClientFactory] Creating HTTP transport for ${config.id}`, {
+            url: config.url,
+            hasHeaders: !!config.headers,
+            hasAuth: !!config.auth,
+            authType: config.auth?.type,
+            httpOptions,
+        });
+        try {
+            const url = new URL(config.url);
+            // Set up OAuth provider if configured
+            const oauthProvider = await this.setupAuthProvider(config);
+            // Build headers including authentication
+            const headers = {
+                ...(config.headers ?? {}),
+            };
+            // Add authentication headers based on auth type
+            if (config.auth) {
+                const authHeader = await this.getAuthorizationHeader(config, oauthProvider);
+                if (authHeader) {
+                    headers["Authorization"] = authHeader;
+                }
+            }
+            // Create custom fetch wrapper with timeout and rate limiting support
+            const fetchWithEnhancements = this.createEnhancedFetch(config, httpOptions.requestTimeout, oauthProvider);
+            // Create request init with custom headers
+            const requestInit = {
+                headers: Object.keys(headers).length > 0 ? headers : undefined,
+            };
+            const transport = new StreamableHTTPClientTransport(url, {
+                requestInit,
+                fetch: fetchWithEnhancements,
+            });
+            return { transport };
+        }
+        catch (error) {
+            throw new Error(`Invalid HTTP URL: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    /**
+     * Create a fetch wrapper with timeout support
+     */
+    static createFetchWithTimeout(timeoutMs) {
+        return async (input, init) => {
+            const controller = new AbortController();
+            const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+            try {
+                return await fetch(input, { ...init, signal: controller.signal });
+            }
+            finally {
+                clearTimeout(timeoutId);
+            }
+        };
+    }
+    /**
+     * Create an enhanced fetch function with timeout and optional retry
+     */
+    static createEnhancedFetch(config, timeoutMs, oauthProvider) {
+        const fetchWithTimeout = this.createFetchWithTimeout(timeoutMs);
+        return async (input, init) => {
+            // If OAuth is configured, ensure we have valid tokens
+            if (oauthProvider && config.auth?.type === "oauth2") {
+                try {
+                    const authHeader = await oauthProvider.getAuthorizationHeader(config.id);
+                    if (authHeader) {
+                        const existingHeaders = init?.headers ?? {};
+                        const headers = new Headers(existingHeaders);
+                        headers.set("Authorization", authHeader);
+                        init = {
+                            ...init,
+                            headers,
+                        };
+                    }
+                }
+                catch (error) {
+                    mcpLogger.warn(`[MCPClientFactory] OAuth token refresh failed for ${config.id}:`, error instanceof Error ? error.message : String(error));
+                    // Continue without auth - let the request fail naturally
+                }
+            }
+            return fetchWithTimeout(input, init);
+        };
+    }
+    /**
+     * Set up OAuth provider if configured
+     */
+    static async setupAuthProvider(config) {
+        if (config.auth?.type === "oauth2" && config.auth.oauth) {
+            const tokenStorage = new InMemoryTokenStorage();
+            const oauthConfig = {
+                clientId: config.auth.oauth.clientId,
+                clientSecret: config.auth.oauth.clientSecret,
+                authorizationUrl: config.auth.oauth.authorizationUrl,
+                tokenUrl: config.auth.oauth.tokenUrl,
+                redirectUrl: config.auth.oauth.redirectUrl,
+                scope: config.auth.oauth.scope,
+                usePKCE: config.auth.oauth.usePKCE ?? true,
+            };
+            const provider = new NeuroLinkOAuthProvider(oauthConfig, tokenStorage);
+            mcpLogger.debug(`[MCPClientFactory] OAuth provider created for ${config.id}`, {
+                clientId: oauthConfig.clientId,
+                usePKCE: oauthConfig.usePKCE,
+            });
+            return provider;
+        }
+        return undefined;
+    }
+    /**
+     * Get authorization header based on auth configuration
+     */
+    static async getAuthorizationHeader(config, oauthProvider) {
+        if (!config.auth) {
+            return undefined;
+        }
+        switch (config.auth.type) {
+            case "oauth2":
+                if (oauthProvider) {
+                    const header = await oauthProvider.getAuthorizationHeader(config.id);
+                    return header ?? undefined;
+                }
+                return undefined;
+            case "bearer":
+                if (config.auth.token) {
+                    return `Bearer ${config.auth.token}`;
+                }
+                return undefined;
+            case "api-key":
+                // API key is typically sent as a custom header, not Authorization
+                // But if needed, we can return it here
+                return undefined;
+            default:
+                return undefined;
+        }
+    }
     /**
      * Perform MCP handshake and get server capabilities
      */
@@ -427,11 +621,13 @@ export class MCPClientFactory {
         if (!config.transport) {
             errors.push("Transport is required");
         }
-        if (!["stdio", "sse", "websocket"].includes(config.transport)) {
-            errors.push("Transport must be stdio, sse, or websocket");
+        if (!["stdio", "sse", "websocket", "http"].includes(config.transport)) {
+            errors.push("Transport must be stdio, sse, websocket, or http");
         }
         // Transport-specific validation
-        if (config.transport === "sse" || config.transport === "websocket") {
+        if (config.transport === "sse" ||
+            config.transport === "websocket" ||
+            config.transport === "http") {
             if (!config.url) {
                 errors.push(`URL is required for ${config.transport} transport`);
             }
@@ -458,7 +654,7 @@ export class MCPClientFactory {
      * Get supported transport types
      */
     static getSupportedTransports() {
-        return ["stdio", "sse", "websocket"];
+        return ["stdio", "sse", "websocket", "http"];
     }
     /**
      * Get default client capabilities

package/dist/lib/mcp/toolRegistry.d.ts

@@ -5,7 +5,7 @@
 import type { MCPServerInfo } from "../types/mcpTypes.js";
 import type { ToolImplementation, ToolInfo, ExecutionContext } from "../types/tools.js";
 import { MCPRegistry } from "./registry.js";
-import type { HITLManager } from "../hitl/hitlManager.js";
+import type { HITLManager } from "../types/hitlTypes.js";
 export declare class MCPToolRegistry extends MCPRegistry {
     private tools;
     private toolImplementations;
@@ -141,4 +141,3 @@ export declare class MCPToolRegistry extends MCPRegistry {
 }
 export declare const toolRegistry: MCPToolRegistry;
 export declare const defaultToolRegistry: MCPToolRegistry;
-export type { ToolInfo } from "../types/tools.js";

package/dist/lib/mcp/toolRegistry.js

@@ -100,14 +100,12 @@ export class MCPToolRegistry extends MCPRegistry {
         }
         registryLogger.debug(`Auto-registered ${Object.keys(directAgentTools).length} direct tools`);
     }
-    async registerServer(serverInfoOrId, serverConfigOrContext, context) {
+    async registerServer(serverInfoOrId, _serverConfigOrContext, _context) {
         // Handle both signatures for backward compatibility
         let serverInfo;
-        let _finalContext;
         if (typeof serverInfoOrId === "string") {
             // Legacy signature: registerServer(serverId, serverConfig, context)
             const serverId = serverInfoOrId;
-            _finalContext = context;
             // Convert legacy call to MCPServerInfo format using smart defaults
             serverInfo = createMCPServerInfo({
                 id: serverId,
@@ -119,7 +117,6 @@ export class MCPToolRegistry extends MCPRegistry {
         else {
             // New signature: registerServer(serverInfo, context)
             serverInfo = serverInfoOrId;
-            _finalContext = serverConfigOrContext;
         }
         const serverId = serverInfo.id;
         // Use MCPServerInfo.tools array directly - ZERO conversions!
@@ -231,7 +228,6 @@ export class MCPToolRegistry extends MCPRegistry {
     async executeTool(toolName, args, context) {
         const startTime = Date.now();
         try {
-            registryLogger.info(`🔧 [TOOL_EXECUTION] Starting execution: ${toolName}`);
             registryLogger.info(`🔧 [TOOL_EXECUTION] Starting execution: ${toolName}`, { args, context });
             // Try to find the tool by fully-qualified name first
             let tool = this.tools.get(toolName);

package/dist/lib/neurolink.js

@@ -1362,6 +1362,7 @@ Current user's request: ${currentInput}`;
                     }
                     : undefined,
                 audio: textResult.audio,
+                video: textResult.video,
             };
             if (this.conversationMemoryConfig?.conversationMemory?.mem0Enabled &&
                 options.context?.userId &&
@@ -1662,6 +1663,7 @@ Current user's request: ${currentInput}`;
                 enhancedWithTools: Boolean(hasToolExecutions), // Mark as enhanced if tools were actually used
                 availableTools: transformToolsForMCP(transformToolsToExpectedFormat(availableTools)),
                 audio: result.audio,
+                video: result.video,
                 // Include analytics and evaluation from BaseProvider
                 analytics: result.analytics,
                 evaluation: result.evaluation,
@@ -1755,6 +1757,7 @@ Current user's request: ${currentInput}`;
                     analytics: result.analytics,
                     evaluation: result.evaluation,
                     audio: result.audio,
+                    video: result.video,
                 };
             }
             catch (error) {

package/dist/lib/providers/amazonBedrock.js

@@ -474,7 +474,10 @@ export class AmazonBedrockProvider extends BaseProvider {
                     }
                 }
                 else if (result.error) {
-                    throw new Error(result.error.message || "Tool execution failed");
+                    const errorMessage = typeof result.error === "string"
+                        ? result.error
+                        : result.error.message || "Tool execution failed";
+                    throw new Error(errorMessage);
                 }
             }
             // Fallback for non-ToolResult return types

package/dist/lib/providers/ollama.js

@@ -1194,7 +1194,10 @@ export class OllamaProvider extends BaseProvider {
                     }
                 }
                 else if (result.error) {
-                    throw new Error(result.error.message || "Tool execution failed");
+                    const errorMessage = typeof result.error === "string"
+                        ? result.error
+                        : result.error.message || "Tool execution failed";
+                    throw new Error(errorMessage);
                 }
             }
             // Fallback for non-ToolResult return types

package/dist/lib/sdk/toolRegistration.d.ts

@@ -3,9 +3,8 @@
  * Simple interface for developers to register custom tools
  */
 import { z } from "zod";
-import { logger } from "../utils/logger.js";
 import type { MCPServerInfo, MCPServerCategory } from "../types/mcpTypes.js";
-import type { ToolArgs, ToolContext as CoreToolContext, ToolResult, SimpleTool as CoreSimpleTool, ZodUnknownSchema } from "../types/tools.js";
+import type { ToolArgs, SimpleTool as CoreSimpleTool, ZodUnknownSchema, SDKToolContext } from "../types/tools.js";
 import type { JsonValue } from "../types/common.js";
 /**
  * Enhanced validation configuration
@@ -21,30 +20,9 @@ declare const VALIDATION_CONFIG: {
 };
 /**
  * Context provided to tools during execution
- * Extends the core ToolContext with SDK-specific features
+ * Type alias for backward compatibility
  */
-export interface ToolContext extends CoreToolContext {
-    /**
-     * Current session ID
-     */
-    sessionId: string;
-    /**
-     * AI provider being used
-     */
-    provider?: string;
-    /**
-     * Model being used
-     */
-    model?: string;
-    /**
-     * Call another tool
-     */
-    callTool?: (name: string, params: ToolArgs) => Promise<ToolResult>;
-    /**
-     * Logger instance
-     */
-    logger: typeof logger;
-}
+export type ToolContext = SDKToolContext;
 /**
  * Simple tool interface for SDK users
  * Extends the core SimpleTool with specific types

package/dist/lib/types/cli.d.ts

@@ -582,139 +582,139 @@ export type CLIMCPServerConfig = {
  * OpenAI setup configuration types
  */
 export declare namespace OpenAISetup {
-    interface SetupOptions {
+    type SetupOptions = {
         checkOnly?: boolean;
         interactive?: boolean;
-    }
-    interface SetupArgv {
+    };
+    type SetupArgv = {
         check?: boolean;
         nonInteractive?: boolean;
-    }
-    interface Config {
+    };
+    type Config = {
         apiKey?: string;
         organization?: string;
         model?: string;
         isReconfiguring?: boolean;
-    }
+    };
 }
 /**
  * Anthropic setup configuration types
  */
 export declare namespace AnthropicSetup {
-    interface SetupOptions {
+    type SetupOptions = {
         checkOnly?: boolean;
         interactive?: boolean;
-    }
-    interface SetupArgv {
+    };
+    type SetupArgv = {
         check?: boolean;
         nonInteractive?: boolean;
-    }
-    interface Config {
+    };
+    type Config = {
         apiKey?: string;
         model?: string;
         isReconfiguring?: boolean;
-    }
+    };
 }
 /**
  * Google AI setup configuration types
  */
 export declare namespace GoogleAISetup {
-    interface SetupOptions {
+    type SetupOptions = {
         checkOnly?: boolean;
         interactive?: boolean;
-    }
-    interface SetupArgv {
+    };
+    type SetupArgv = {
         check?: boolean;
         nonInteractive?: boolean;
-    }
-    interface Config {
+    };
+    type Config = {
         apiKey?: string;
         model?: string;
         isReconfiguring?: boolean;
-    }
+    };
 }
 /**
  * Azure setup configuration types
  */
 export declare namespace AzureSetup {
-    interface SetupOptions {
+    type SetupOptions = {
         checkOnly?: boolean;
         interactive?: boolean;
-    }
-    interface SetupArgv {
+    };
+    type SetupArgv = {
         check?: boolean;
         nonInteractive?: boolean;
-    }
-    interface Config {
+    };
+    type Config = {
         apiKey?: string;
         endpoint?: string;
         deploymentName?: string;
         apiVersion?: string;
         model?: string;
         isReconfiguring?: boolean;
-    }
+    };
 }
 /**
  * AWS Bedrock setup configuration types
  */
 export declare namespace BedrockSetup {
-    interface SetupOptions {
+    type SetupOptions = {
         checkOnly?: boolean;
         interactive?: boolean;
-    }
-    interface SetupArgv {
+    };
+    type SetupArgv = {
         check?: boolean;
         nonInteractive?: boolean;
-    }
-    interface ConfigData {
+    };
+    type ConfigData = {
         region?: string;
         accessKeyId?: string;
         secretAccessKey?: string;
         model?: string;
-    }
-    interface ConfigStatus {
+    };
+    type ConfigStatus = {
         hasCredentials: boolean;
         hasRegion: boolean;
         hasModel: boolean;
         isReconfiguring?: boolean;
-    }
+    };
 }
 /**
  * GCP/Vertex AI setup configuration types
  */
 export declare namespace GCPSetup {
-    interface SetupOptions {
+    type SetupOptions = {
         checkOnly?: boolean;
         interactive?: boolean;
-    }
-    interface SetupArgv {
+    };
+    type SetupArgv = {
         check?: boolean;
         nonInteractive?: boolean;
-    }
-    interface AuthMethodStatus {
+    };
+    type AuthMethodStatus = {
         hasServiceAccount: boolean;
         hasGcloudAuth: boolean;
         hasApplicationDefault: boolean;
         preferredMethod?: "service-account" | "gcloud" | "adc";
-    }
+    };
 }
 /**
  * Hugging Face setup configuration types
  */
 export declare namespace HuggingFaceSetup {
-    interface SetupArgs {
+    type SetupArgs = {
         check?: boolean;
         nonInteractive?: boolean;
         help?: boolean;
-    }
+    };
 }
 /**
  * Mistral setup configuration types
  */
 export declare namespace MistralSetup {
-    interface SetupArgs {
+    type SetupArgs = {
         check?: boolean;
         nonInteractive?: boolean;
         help?: boolean;
-    }
+    };
 }

package/dist/lib/types/externalMcp.d.ts

@@ -8,9 +8,10 @@ import type { ChildProcess } from "child_process";
 import type { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import type { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
 /**
- * Supported MCP transport protocols
+ * Supported MCP transport protocols - imported from mcpTypes.js (canonical definition)
  */
-export type MCPTransportType = "stdio" | "sse" | "websocket";
+import type { MCPTransportType } from "./mcpTypes.js";
+export type { MCPTransportType } from "./mcpTypes.js";
 /**
  * External MCP server configuration for process spawning
  */
@@ -35,8 +36,10 @@ export type ExternalMCPServerConfig = {
     autoRestart?: boolean;
     /** Working directory for the process */
     cwd?: string;
-    /** URL for SSE/WebSocket transports */
+    /** URL for SSE/WebSocket/HTTP transports */
     url?: string;
+    /** HTTP headers for authentication and configuration (HTTP/SSE/WebSocket) */
+    headers?: Record<string, string>;
     /** List of tool names to block/blacklist from this server */
     blockedTools?: string[];
     /** Additional metadata */
@@ -288,3 +291,52 @@ export type ExternalMCPManagerConfig = {
     /** Log level for external MCP operations */
     logLevel?: "debug" | "info" | "warn" | "error";
 };
+/**
+ * Extended MCPServerInfo with runtime state for external servers
+ * Represents the transition towards zero-conversion architecture by combining
+ * configuration fields from MCPServerInfo with runtime-only state needed for
+ * active server management (process handles, clients, metrics, etc.)
+ */
+export type RuntimeMCPServerInfo = import("./mcpTypes.js").MCPServerInfo & {
+    /** Child process handle (for stdio transport, null for HTTP transports) */
+    process: import("child_process").ChildProcess | null;
+    /** MCP client instance for communication */
+    client: Client | null;
+    /** Transport instance (renamed from 'transport' to avoid conflict with MCPServerInfo.transport) */
+    transportInstance: Transport | null;
+    /** Last error message if any */
+    lastError?: string;
+    /** When the server was started */
+    startTime?: Date;
+    /** When the server was last seen healthy */
+    lastHealthCheck?: Date;
+    /** Number of reconnection attempts */
+    reconnectAttempts: number;
+    /** Maximum reconnection attempts before giving up */
+    maxReconnectAttempts: number;
+    /** Server capabilities reported during MCP handshake */
+    capabilities?: Record<string, JsonValue>;
+    /** Health monitoring timer */
+    healthTimer?: NodeJS.Timeout;
+    /** Restart backoff timer */
+    restartTimer?: NodeJS.Timeout;
+    /** Performance metrics for this server */
+    metrics: {
+        totalConnections: number;
+        totalDisconnections: number;
+        totalErrors: number;
+        totalToolCalls: number;
+        averageResponseTime: number;
+        lastResponseTime: number;
+    };
+    /** Legacy compatibility - maintain tools map for now */
+    toolsMap: Map<string, ExternalMCPToolInfo>;
+    /** Cached tools array for ZERO conversion - MCP format */
+    toolsArray?: Array<{
+        name: string;
+        description: string;
+        inputSchema?: object;
+    }>;
+    /** Compatibility field for existing code - stores MCPServerInfo config */
+    config: import("./mcpTypes.js").MCPServerInfo;
+};