@1mcp/agent 0.28.1 → 0.29.0-beta2

package/build/core/client/clientManager.js

@@ -1,22 +1,29 @@
-import { UnauthorizedError } from '@modelcontextprotocol/sdk/client/auth.js';
-import { Client } from '@modelcontextprotocol/sdk/client/index.js';
-import { SSEClientTransport } from '@modelcontextprotocol/sdk/client/sse.js';
-import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
-import { CONNECTION_RETRY, MCP_CLIENT_CAPABILITIES, MCP_SERVER_NAME, MCP_SERVER_VERSION } from '../../constants.js';
-import { AgentConfigManager } from '../../core/server/agentConfig.js';
 import { ClientStatus, } from '../../core/types/index.js';
-import { CustomJsonSchemaValidator } from '../../core/validation/CustomJsonSchemaValidator.js';
 import logger, { debugIf } from '../../logger/logger.js';
 import { CapabilityError, ClientConnectionError, ClientNotFoundError } from '../../utils/core/errorTypes.js';
 import { executeOperation } from '../../utils/core/operationExecution.js';
-import { getConnectionTimeout } from '../../utils/core/timeoutUtils.js';
+import { ClientFactory } from './clientFactory.js';
+import { ConnectionHandler } from './connectionHandler.js';
+import { OAuthFlowHandler } from './oauthFlowHandler.js';
+import { TransportRecreator } from './transportRecreator.js';
+import { OAuthRequiredError } from './types.js';
+export { OAuthRequiredError };
 export class ClientManager {
     static instance;
     outboundConns = new Map();
     transports = {};
     connectionSemaphore = new Map();
     instructionAggregator;
-    constructor() { }
+    clientFactory;
+    connectionHandler;
+    oauthFlowHandler;
+    transportRecreator;
+    constructor() {
+        this.clientFactory = new ClientFactory();
+        this.connectionHandler = new ConnectionHandler();
+        this.oauthFlowHandler = new OAuthFlowHandler();
+        this.transportRecreator = new TransportRecreator();
+    }
     static getOrCreateInstance() {
         if (!ClientManager.instance) {
             ClientManager.instance = new ClientManager();
@@ -26,31 +33,19 @@ export class ClientManager {
     static get current() {
         return ClientManager.instance;
     }
-    // Test utility method to reset singleton state
     static resetInstance() {
         ClientManager.instance = undefined;
     }
-    /**
-     * Set the instruction aggregator instance
-     * @param aggregator The instruction aggregator to use
-     */
     setInstructionAggregator(aggregator) {
         this.instructionAggregator = aggregator;
     }
-    /**
-     * Extract and cache instructions from a connected client
-     * @param name The client name
-     * @param client The connected client instance
-     */
     extractAndCacheInstructions(name, client) {
         try {
             const instructions = client.getInstructions();
-            // Update the connection info with instructions
             const connectionInfo = this.outboundConns.get(name);
             if (connectionInfo) {
                 connectionInfo.instructions = instructions;
             }
-            // Update the instruction aggregator if available
             if (this.instructionAggregator) {
                 this.instructionAggregator.setInstructions(name, instructions);
             }
@@ -68,207 +63,71 @@ export class ClientManager {
             logger.warn(`Failed to extract instructions from ${name}: ${error}`);
         }
     }
-    /**
-     * Creates a new MCP client instance
-     * @returns A new Client instance
-     */
-    createClient() {
-        // Create custom validator instance for each client
-        const customValidator = new CustomJsonSchemaValidator();
-        return new Client({
-            name: MCP_SERVER_NAME,
-            version: MCP_SERVER_VERSION,
-        }, {
-            capabilities: MCP_CLIENT_CAPABILITIES,
-            jsonSchemaValidator: customValidator,
-            debouncedNotificationMethods: [
-                'notifications/tools/list_changed',
-                'notifications/resources/list_changed',
-                'notifications/prompts/list_changed',
-            ],
-        });
-    }
-    /**
-     * Creates a new MCP client instance for external use (e.g., OAuth testing)
-     * @returns A new Client instance
-     */
-    createClientInstance() {
-        return this.createClient();
+    setupConnectionHandlers(name, client) {
+        client.onclose = () => {
+            const clientInfo = this.outboundConns.get(name);
+            if (clientInfo) {
+                clientInfo.status = ClientStatus.Disconnected;
+            }
+            this.instructionAggregator?.removeServer(name);
+            logger.info(`Client ${name} disconnected`);
+        };
+        client.onerror = (error) => {
+            logger.error(`Client ${name} error: ${error}`);
+        };
     }
-    /**
-     * Creates client instances for all transports with retry logic
-     * @param transports Record of transport instances
-     * @returns Record of client instances
-     */
     async createClients(transports) {
         this.transports = transports;
         this.outboundConns.clear();
         for (const [name, transport] of Object.entries(transports)) {
-            logger.info(`Creating client for ${name}`);
-            try {
-                const client = this.createClient();
-                // Connect with retry logic
-                const connectedClient = await this.connectWithRetry(client, transport, name);
-                this.outboundConns.set(name, {
-                    name,
-                    transport,
-                    client: connectedClient,
-                    status: ClientStatus.Connected,
-                    lastConnected: new Date(),
-                });
-                logger.info(`Client created for ${name}`);
-                // Extract and cache instructions after successful connection
-                this.extractAndCacheInstructions(name, connectedClient);
-                connectedClient.onclose = () => {
-                    const clientInfo = this.outboundConns.get(name);
-                    if (clientInfo) {
-                        clientInfo.status = ClientStatus.Disconnected;
-                    }
-                    // Remove instructions from aggregator when client disconnects
-                    if (this.instructionAggregator) {
-                        this.instructionAggregator.removeServer(name);
-                    }
-                    logger.info(`Client ${name} disconnected`);
-                };
-                connectedClient.onerror = (error) => {
-                    logger.error(`Client ${name} error: ${error}`);
-                };
-            }
-            catch (error) {
-                if (error instanceof OAuthRequiredError) {
-                    // Handle OAuth required - set client to AwaitingOAuth status
-                    logger.info(`OAuth authorization required for ${name}`);
-                    // Try to get authorization URL from OAuth provider
-                    let authorizationUrl;
-                    try {
-                        // Extract OAuth provider from transport if available
-                        const oauthProvider = transport.oauthProvider;
-                        if (oauthProvider && typeof oauthProvider.getAuthorizationUrl === 'function') {
-                            authorizationUrl = oauthProvider.getAuthorizationUrl();
-                        }
-                    }
-                    catch (urlError) {
-                        logger.warn(`Could not extract authorization URL for ${name}:`, urlError);
-                    }
-                    this.outboundConns.set(name, {
-                        name,
-                        transport,
-                        client: error.client,
-                        status: ClientStatus.AwaitingOAuth,
-                        authorizationUrl,
-                        oauthStartTime: new Date(),
-                    });
-                }
-                else {
-                    logger.error(`Failed to create client for ${name}: ${error}`);
-                    this.outboundConns.set(name, {
-                        name,
-                        transport,
-                        client: this.createClient(),
-                        status: ClientStatus.Error,
-                        lastError: error instanceof Error ? error : new Error(String(error)),
-                    });
-                }
-            }
+            await this.createClient(name, transport);
         }
         return this.outboundConns;
     }
-    /**
-     * Connects a client to its transport with retry logic and OAuth support
-     * @param client The client to connect
-     * @param transport The transport to connect to
-     * @param name The name of the client for logging
-     * @param abortSignal Optional abort signal to cancel the operation
-     * @returns The connected client (may be a new instance after retries)
-     */
-    async connectWithRetry(client, transport, name, abortSignal) {
-        let retryDelay = CONNECTION_RETRY.INITIAL_DELAY_MS;
-        let currentClient = client;
-        let currentTransport = transport;
-        for (let i = 0; i < CONNECTION_RETRY.MAX_ATTEMPTS; i++) {
-            try {
-                // Check if operation was aborted before each attempt
-                if (abortSignal?.aborted) {
-                    throw new Error(`Connection aborted: ${abortSignal.reason || 'Request cancelled'}`);
-                }
-                // Connect with timeout from transport config
-                // Priority: connectionTimeout > timeout (deprecated fallback)
-                const authTransport = currentTransport;
-                const timeout = getConnectionTimeout(authTransport);
-                await currentClient.connect(currentTransport, timeout ? { timeout } : undefined);
-                const sv = await currentClient.getServerVersion();
-                if (sv?.name === MCP_SERVER_NAME) {
-                    throw new ClientConnectionError(name, new Error('Aborted to prevent circular dependency'));
-                }
-                logger.info(`Successfully connected to ${name} with server ${sv?.name} version ${sv?.version}`);
-                return currentClient;
-            }
-            catch (error) {
-                // Handle OAuth authorization flow (managed by SDK)
-                if (error instanceof UnauthorizedError) {
-                    const configManager = AgentConfigManager.getInstance();
-                    logger.info(`OAuth authorization required for ${name}. Visit ${configManager.getUrl()}/oauth to authorize`);
-                    // Throw special error that includes OAuth info
-                    throw new OAuthRequiredError(name, currentClient);
-                }
-                // Handle other connection errors
-                else {
-                    const errorMessage = error instanceof Error ? error.message : String(error);
-                    logger.error(`Failed to connect to ${name}: ${errorMessage}`);
-                    if (i < CONNECTION_RETRY.MAX_ATTEMPTS - 1) {
-                        logger.info(`Retrying in ${retryDelay}ms...`);
-                        // Clean up failed transport
-                        try {
-                            await currentTransport.close();
-                        }
-                        catch (closeError) {
-                            debugIf(() => ({ message: `Error closing transport during retry: ${closeError}` }));
-                        }
-                        // Implement cancellable delay
-                        await new Promise((resolve, reject) => {
-                            const timeoutId = setTimeout(resolve, retryDelay);
-                            if (abortSignal) {
-                                const abortHandler = () => {
-                                    clearTimeout(timeoutId);
-                                    reject(new Error(`Connection retry aborted: ${abortSignal.reason || 'Request cancelled'}`));
-                                };
-                                if (abortSignal.aborted) {
-                                    clearTimeout(timeoutId);
-                                    reject(new Error(`Connection retry aborted: ${abortSignal.reason || 'Request cancelled'}`));
-                                }
-                                else {
-                                    abortSignal.addEventListener('abort', abortHandler, { once: true });
-                                }
-                            }
-                        });
-                        retryDelay *= 2; // Exponential backoff
-                        // For HTTP/SSE transports, we need to recreate both client and transport
-                        // because these transports cannot be restarted once started
-                        if (currentTransport instanceof StreamableHTTPClientTransport ||
-                            currentTransport instanceof SSEClientTransport) {
-                            currentTransport = this.recreateHttpTransport(currentTransport);
-                            currentClient = this.createClient();
-                        }
-                        else {
-                            // For STDIO transports, we can reuse the transport but need a new client
-                            currentClient = this.createClient();
-                        }
-                    }
-                    else {
-                        throw new ClientConnectionError(name, error instanceof Error ? error : new Error(String(error)));
-                    }
-                }
-            }
+    async createClient(name, transport) {
+        logger.info(`Creating client for ${name}`);
+        try {
+            const client = this.clientFactory.createClient();
+            const connectedClient = await this.connectionHandler.connectWithRetry(client, transport, name, undefined, (t) => this.transportRecreator.recreateHttpTransport(t));
+            this.outboundConns.set(name, {
+                name,
+                transport,
+                client: connectedClient,
+                status: ClientStatus.Connected,
+                lastConnected: new Date(),
+            });
+            logger.info(`Client created for ${name}`);
+            this.extractAndCacheInstructions(name, connectedClient);
+            this.setupConnectionHandlers(name, connectedClient);
+        }
+        catch (error) {
+            this.handleClientCreationError(name, transport, error);
+        }
+    }
+    handleClientCreationError(name, transport, error) {
+        if (error instanceof OAuthRequiredError) {
+            logger.info(`OAuth authorization required for ${name}`);
+            const authorizationUrl = this.oauthFlowHandler.extractAuthorizationUrl(transport);
+            this.outboundConns.set(name, {
+                name,
+                transport,
+                client: error.client,
+                status: ClientStatus.AwaitingOAuth,
+                authorizationUrl,
+                oauthStartTime: new Date(),
+            });
+        }
+        else {
+            logger.error(`Failed to create client for ${name}: ${error}`);
+            this.outboundConns.set(name, {
+                name,
+                transport,
+                client: this.clientFactory.createClient(),
+                status: ClientStatus.Error,
+                lastError: error instanceof Error ? error : new Error(String(error)),
+            });
         }
-        // This should never be reached due to the throw in the else block above
-        throw new ClientConnectionError(name, new Error('Max retries exceeded'));
     }
-    /**
-     * Gets a client by name with error handling
-     * @param clientName The name of the client to get
-     * @returns The client instance
-     * @throws ClientNotFoundError if the client is not found
-     */
     getClient(clientName) {
         const client = this.outboundConns.get(clientName);
         if (!client) {
@@ -276,32 +135,18 @@ export class ClientManager {
         }
         return client;
     }
-    /**
-     * Gets all outbound connections
-     * @returns Map of all outbound connections
-     */
     getClients() {
         return this.outboundConns;
     }
-    /**
-     * Creates a single client for async loading (used by McpLoadingManager)
-     * @param name The name of the client
-     * @param transport The transport to connect to
-     * @param abortSignal Optional AbortSignal to cancel the operation
-     * @returns Promise that resolves when client is connected
-     */
     async createSingleClient(name, transport, abortSignal) {
-        // Prevent concurrent creation of the same client
         const existingPromise = this.connectionSemaphore.get(name);
         if (existingPromise) {
             await existingPromise;
             return;
         }
-        // Check if operation was aborted before starting
         if (abortSignal?.aborted) {
             throw new Error(`Operation aborted: ${abortSignal.reason || 'Request cancelled'}`);
         }
-        // Create connection promise
         const connectionPromise = this.createSingleClientInternal(name, transport, abortSignal);
         this.connectionSemaphore.set(name, connectionPromise);
         try {
@@ -311,21 +156,15 @@ export class ClientManager {
             this.connectionSemaphore.delete(name);
         }
     }
-    /**
-     * Internal method to create and connect a single client
-     */
     async createSingleClientInternal(name, transport, abortSignal) {
         logger.info(`Creating client for ${name}`);
-        // Store transport reference
         this.transports[name] = transport;
         try {
-            // Check if operation was aborted
             if (abortSignal?.aborted) {
                 throw new Error(`Operation aborted: ${abortSignal.reason || 'Request cancelled'}`);
             }
-            const client = this.createClient();
-            // Connect with retry logic
-            const connectedClient = await this.connectWithRetry(client, transport, name, abortSignal);
+            const client = this.clientFactory.createClient();
+            const connectedClient = await this.connectionHandler.connectWithRetry(client, transport, name, abortSignal, (t) => this.transportRecreator.recreateHttpTransport(t));
             this.outboundConns.set(name, {
                 name,
                 transport,
@@ -334,190 +173,63 @@ export class ClientManager {
                 lastConnected: new Date(),
             });
             logger.info(`Client created for ${name}`);
-            // Extract and cache instructions after successful connection
             this.extractAndCacheInstructions(name, connectedClient);
-            connectedClient.onclose = () => {
-                const clientInfo = this.outboundConns.get(name);
-                if (clientInfo) {
-                    clientInfo.status = ClientStatus.Disconnected;
-                }
-                // Remove instructions from aggregator when client disconnects
-                if (this.instructionAggregator) {
-                    this.instructionAggregator.removeServer(name);
-                }
-                logger.info(`Client ${name} disconnected`);
-            };
-            connectedClient.onerror = (error) => {
-                logger.error(`Client ${name} error: ${error}`);
-            };
+            this.setupConnectionHandlers(name, connectedClient);
         }
         catch (error) {
-            if (error instanceof OAuthRequiredError) {
-                // Handle OAuth required - set client to AwaitingOAuth status
-                logger.info(`OAuth authorization required for ${name}`);
-                // Try to get authorization URL from OAuth provider
-                let authorizationUrl;
-                try {
-                    // Extract OAuth provider from transport if available
-                    const oauthProvider = transport.oauthProvider;
-                    if (oauthProvider && typeof oauthProvider.getAuthorizationUrl === 'function') {
-                        authorizationUrl = oauthProvider.getAuthorizationUrl();
-                    }
-                }
-                catch (urlError) {
-                    logger.warn(`Could not extract authorization URL for ${name}:`, urlError);
-                }
-                this.outboundConns.set(name, {
-                    name,
-                    transport,
-                    client: error.client,
-                    status: ClientStatus.AwaitingOAuth,
-                    authorizationUrl,
-                    oauthStartTime: new Date(),
-                });
-                // Re-throw OAuth error for loading manager to handle
-                throw error;
-            }
-            else {
-                logger.error(`Failed to create client for ${name}: ${error}`);
-                this.outboundConns.set(name, {
-                    name,
-                    transport,
-                    client: this.createClient(),
-                    status: ClientStatus.Error,
-                    lastError: error instanceof Error ? error : new Error(String(error)),
-                });
-                // Re-throw error for loading manager to handle
-                throw error;
-            }
+            this.handleSingleClientError(name, transport, error);
+            throw error;
+        }
+    }
+    handleSingleClientError(name, transport, error) {
+        if (error instanceof OAuthRequiredError) {
+            logger.info(`OAuth authorization required for ${name}`);
+            const authorizationUrl = this.oauthFlowHandler.extractAuthorizationUrl(transport);
+            this.outboundConns.set(name, {
+                name,
+                transport,
+                client: error.client,
+                status: ClientStatus.AwaitingOAuth,
+                authorizationUrl,
+                oauthStartTime: new Date(),
+            });
+        }
+        else {
+            logger.error(`Failed to create client for ${name}: ${error}`);
+            this.outboundConns.set(name, {
+                name,
+                transport,
+                client: this.clientFactory.createClient(),
+                status: ClientStatus.Error,
+                lastError: error instanceof Error ? error : new Error(String(error)),
+            });
         }
     }
-    /**
-     * Initialize clients storage without connecting (for async loading)
-     * @param transports Record of transport instances
-     * @returns Empty connections map (to be populated by async loading)
-     */
     initializeClientsAsync(transports) {
         this.transports = transports;
         this.outboundConns.clear();
         logger.info(`Initialized client storage for ${Object.keys(transports).length} transports`);
         return this.outboundConns;
     }
-    /**
-     * Get transport by name (used by loading manager for retries)
-     * @param name The transport name
-     * @returns The transport instance or undefined
-     */
     getTransport(name) {
         return this.transports[name];
     }
-    /**
-     * Get all transport names
-     * @returns Array of transport names
-     */
     getTransportNames() {
         return Object.keys(this.transports);
     }
-    /**
-     * Recreates an HTTP or SSE transport with the same configuration
-     * This is necessary because HTTP transports cannot be restarted once started
-     * @param transport The original transport to recreate
-     * @returns A new transport instance with the same configuration
-     */
-    recreateHttpTransport(transport) {
-        // Type guard for HTTP-based transports
-        if (!(transport instanceof StreamableHTTPClientTransport) && !(transport instanceof SSEClientTransport)) {
-            throw new Error('Transport recreation only supported for HTTP and SSE transports');
-        }
-        const transportUrl = transport._url;
-        // Get OAuth provider from AuthProviderTransport
-        const authTransport = transport;
-        const oauthProvider = authTransport.oauthProvider;
-        // Create new transport based on original type
-        let newTransport;
-        if (transport instanceof StreamableHTTPClientTransport) {
-            const httpTransport = new StreamableHTTPClientTransport(transportUrl, {
-                authProvider: oauthProvider,
-            });
-            newTransport = httpTransport;
-        }
-        else {
-            const sseTransport = new SSEClientTransport(transportUrl, {
-                authProvider: oauthProvider,
-            });
-            newTransport = sseTransport;
-        }
-        // Copy transport properties from AuthProviderTransport
-        newTransport.oauthProvider = oauthProvider;
-        newTransport.connectionTimeout = authTransport.connectionTimeout;
-        newTransport.requestTimeout = authTransport.requestTimeout;
-        newTransport.timeout = authTransport.timeout; // Keep for backward compatibility
-        newTransport.tags = authTransport.tags;
-        return newTransport;
-    }
-    /**
-     * Complete OAuth flow and reconnect client with fresh transport
-     * This recreates both transport and client since HTTP transports cannot be restarted
-     * @param serverName The name of the server to reconnect
-     * @param authorizationCode The OAuth authorization code from the callback
-     * @throws ClientNotFoundError if the client is not found
-     * @throws Error if transport does not support OAuth or reconnection fails
-     */
     async completeOAuthAndReconnect(serverName, authorizationCode) {
         const clientInfo = this.outboundConns.get(serverName);
         if (!clientInfo) {
             throw new ClientNotFoundError(serverName);
         }
-        // Type guard for OAuth-capable transports
-        const transport = clientInfo.transport;
-        if (!(transport instanceof StreamableHTTPClientTransport) && !(transport instanceof SSEClientTransport)) {
-            throw new Error(`Transport for ${serverName} does not support OAuth (requires HTTP or SSE transport)`);
-        }
-        logger.info(`Completing OAuth and reconnecting ${serverName}...`);
-        try {
-            // 1. Complete OAuth flow
-            await transport.finishAuth(authorizationCode);
-            // 2. Close old transport
-            await transport.close();
-            // 3. Create new transport using helper
-            const newTransport = this.recreateHttpTransport(transport);
-            // 4. Create and connect new client with timeout
-            // Priority: connectionTimeout > timeout (deprecated fallback)
-            const newClient = this.createClient();
-            const timeout = getConnectionTimeout(newTransport);
-            await newClient.connect(newTransport, timeout ? { timeout } : undefined);
-            // 5. Discover capabilities
-            const capabilities = newClient.getServerCapabilities();
-            // 6. Cache instructions
-            this.extractAndCacheInstructions(serverName, newClient);
-            // 7. Update connection info (create new object to handle readonly properties)
-            const updatedInfo = {
-                name: serverName,
-                transport: newTransport,
-                client: newClient,
-                status: ClientStatus.Connected,
-                lastConnected: new Date(),
-                capabilities,
-                instructions: clientInfo.instructions, // Preserve existing instructions if any
-                lastError: undefined,
-            };
-            this.outboundConns.set(serverName, updatedInfo);
-            // 8. Update transports map
-            this.transports[serverName] = newTransport;
-            logger.info(`OAuth reconnection completed successfully for ${serverName}`);
-        }
-        catch (error) {
-            logger.error(`OAuth reconnection failed for ${serverName}:`, error);
-            throw error;
-        }
+        const oldTransport = clientInfo.transport;
+        const newTransport = this.transportRecreator.recreateHttpTransport(oldTransport, serverName);
+        const updatedInfo = await this.oauthFlowHandler.completeOAuthAndReconnect(serverName, oldTransport, newTransport, authorizationCode, clientInfo);
+        this.outboundConns.set(serverName, updatedInfo);
+        this.transports[serverName] = newTransport;
+        this.extractAndCacheInstructions(serverName, updatedInfo.client);
+        this.setupConnectionHandlers(serverName, updatedInfo.client);
     }
-    /**
-     * Executes a client operation with error handling and retry logic
-     * @param clientName The name of the client to use
-     * @param operation The operation to execute
-     * @param options Operation options including timeout and retry settings
-     * @param requiredCapability The capability required for this operation
-     */
     async executeClientOperation(clientName, operation, options = {}, requiredCapability) {
         const outboundConn = this.getClient(clientName);
         if (outboundConn.status !== ClientStatus.Connected || !outboundConn.client.transport) {
@@ -528,10 +240,12 @@ export class ClientManager {
         }
         return executeOperation(() => operation(outboundConn), `client ${clientName}`, options);
     }
-    /**
-     * Remove a client and close its transport
-     * @param name The name of the client to remove
-     */
+    createClientInstance() {
+        return this.clientFactory.createClientInstance();
+    }
+    createPooledClientInstance() {
+        return this.clientFactory.createPooledClientInstance();
+    }
     async removeClient(name) {
         const clientInfo = this.outboundConns.get(name);
         if (!clientInfo) {
@@ -539,7 +253,6 @@ export class ClientManager {
         }
         logger.info(`Removing client ${name}...`);
         try {
-            // Close transport if connected
             if (clientInfo.transport) {
                 try {
                     await clientInfo.transport.close();
@@ -548,13 +261,9 @@ export class ClientManager {
                     logger.warn(`Error closing transport for ${name}: ${error}`);
                 }
             }
-            // Remove from collections
             this.outboundConns.delete(name);
             delete this.transports[name];
-            // Remove from instruction aggregator
-            if (this.instructionAggregator) {
-                this.instructionAggregator.removeServer(name);
-            }
+            this.instructionAggregator?.removeServer(name);
             logger.info(`Client ${name} removed successfully`);
         }
         catch (error) {
@@ -563,17 +272,5 @@ export class ClientManager {
         }
     }
 }
-/**
- * Custom error class for OAuth authorization required
- */
-export class OAuthRequiredError extends Error {
-    serverName;
-    client;
-    constructor(serverName, client) {
-        super(`OAuth authorization required for ${serverName}`);
-        this.serverName = serverName;
-        this.client = client;
-        this.name = 'OAuthRequiredError';
-    }
-}
+export default ClientManager;
 //# sourceMappingURL=clientManager.js.map