@1mcp/agent 0.13.1 → 0.15.0

package/README.md

@@ -58,31 +58,37 @@ npx -y @1mcp/agent --config ~/Library/Application\ Support/Claude/claude_desktop
 # Use stdio transport instead of SSE
 npx -y @1mcp/agent --transport stdio
 
+# Use external URL for reverse proxy setup (nginx, etc.)
+npx -y @1mcp/agent --external-url https://example.com
+
+# Configure trust proxy for reverse proxy setup
+npx -y @1mcp/agent --trust-proxy=192.168.1.1
+
 # Show all available options
 npx -y @1mcp/agent --help
 ```
 
 Available options:
 
-| Option (CLI)                 | Environment Variable               | Description                                           |  Default  | Deprecated? |
-| :--------------------------- | :--------------------------------- | :---------------------------------------------------- | :-------: | :---------: |
-| `--transport`, `-t`          | `ONE_MCP_TRANSPORT`                | Choose transport type ("stdio", "http", or "sse")     |  "http"   |             |
-| `--config`, `-c`             | `ONE_MCP_CONFIG`                   | Use a specific config file                            |           |             |
-| `--port`, `-P`               | `ONE_MCP_PORT`                     | Change HTTP port                                      |   3050    |             |
-| `--host`, `-H`               | `ONE_MCP_HOST`                     | Change HTTP host                                      | localhost |             |
-| `--tags`, `-g`               | `ONE_MCP_TAGS`                     | Filter servers by tags                                |           |             |
-| `--pagination`, `-p`         | `ONE_MCP_PAGINATION`               | Enable pagination for client/server lists (boolean)   |   false   |             |
-| `--auth`                     | `ONE_MCP_AUTH`                     | Enable authentication (OAuth 2.1)                     |   false   |     Yes     |
-| `--enable-auth`              | `ONE_MCP_ENABLE_AUTH`              | Enable authentication (OAuth 2.1)                     |   false   |             |
-| `--enable-scope-validation`  | `ONE_MCP_ENABLE_SCOPE_VALIDATION`  | Enable tag-based scope validation (boolean)           |   true    |             |
-| `--enable-enhanced-security` | `ONE_MCP_ENABLE_ENHANCED_SECURITY` | Enable enhanced security middleware (boolean)         |   false   |             |
-| `--session-ttl`              | `ONE_MCP_SESSION_TTL`              | Session expiry time in minutes (number)               |   1440    |             |
-| `--session-storage-path`     | `ONE_MCP_SESSION_STORAGE_PATH`     | Custom session storage directory path (string)        |           |             |
-| `--rate-limit-window`        | `ONE_MCP_RATE_LIMIT_WINDOW`        | OAuth rate limit window in minutes (number)           |    15     |             |
-| `--rate-limit-max`           | `ONE_MCP_RATE_LIMIT_MAX`           | Maximum requests per OAuth rate limit window (number) |    100    |             |
-| `--help`, `-h`               |                                    | Show help                                             |           |             |
-
-> 💡 **Note:** Deprecated options are provided for backward compatibility. Prefer using the non-deprecated options for new configurations.
+| Option (CLI)                 | Environment Variable               | Description                                                                   |  Default   |
+| :--------------------------- | :--------------------------------- | :---------------------------------------------------------------------------- | :--------: |
+| `--transport`, `-t`          | `ONE_MCP_TRANSPORT`                | Choose transport type ("stdio", "http", or "sse")                             |   "http"   |
+| `--config`, `-c`             | `ONE_MCP_CONFIG`                   | Use a specific config file                                                    |            |
+| `--port`, `-P`               | `ONE_MCP_PORT`                     | Change HTTP port                                                              |    3050    |
+| `--host`, `-H`               | `ONE_MCP_HOST`                     | Change HTTP host                                                              | localhost  |
+| `--external-url`, `-u`       | `ONE_MCP_EXTERNAL_URL`             | External URL for OAuth callbacks and public URLs (e.g., https://example.com)  |            |
+| `--trust-proxy`              | `ONE_MCP_TRUST_PROXY`              | Trust proxy configuration for client IP detection (boolean, IP, CIDR, preset) | "loopback" |
+| `--tags`, `-g`               | `ONE_MCP_TAGS`                     | Filter servers by tags                                                        |            |
+| `--pagination`, `-p`         | `ONE_MCP_PAGINATION`               | Enable pagination for client/server lists (boolean)                           |   false    |
+| `--auth`                     | `ONE_MCP_AUTH`                     | Enable authentication (OAuth 2.1) - **Deprecated**                            |   false    |
+| `--enable-auth`              | `ONE_MCP_ENABLE_AUTH`              | Enable authentication (OAuth 2.1)                                             |   false    |
+| `--enable-scope-validation`  | `ONE_MCP_ENABLE_SCOPE_VALIDATION`  | Enable tag-based scope validation (boolean)                                   |    true    |
+| `--enable-enhanced-security` | `ONE_MCP_ENABLE_ENHANCED_SECURITY` | Enable enhanced security middleware (boolean)                                 |   false    |
+| `--session-ttl`              | `ONE_MCP_SESSION_TTL`              | Session expiry time in minutes (number)                                       |    1440    |
+| `--session-storage-path`     | `ONE_MCP_SESSION_STORAGE_PATH`     | Custom session storage directory path (string)                                |            |
+| `--rate-limit-window`        | `ONE_MCP_RATE_LIMIT_WINDOW`        | OAuth rate limit window in minutes (number)                                   |     15     |
+| `--rate-limit-max`           | `ONE_MCP_RATE_LIMIT_MAX`           | Maximum requests per OAuth rate limit window (number)                         |    100     |
+| `--help`, `-h`               |                                    | Show help                                                                     |            |
 
 ## Docker
 
@@ -108,15 +114,39 @@ Available image tags:
 - `vX.Y.Z`: Specific version (e.g. `v1.0.0`)
 - `sha-<commit>`: Specific commit
 
-Example:
+Examples:
 
 ```bash
+# Custom port and tags
 docker run -p 3051:3051 \
   -e ONE_MCP_PORT=3051 \
   -e ONE_MCP_TAGS=network,filesystem \
   ghcr.io/1mcp-app/agent
+
+# With external URL for reverse proxy
+docker run -p 3050:3050 \
+  -e ONE_MCP_EXTERNAL_URL=https://mcp.example.com \
+  -e ONE_MCP_TRUST_PROXY=true \
+  ghcr.io/1mcp-app/agent
+```
+
+## Trust Proxy Configuration
+
+When running 1MCP behind a reverse proxy, configure trust proxy settings for proper client IP detection:
+
+```bash
+# Default (safe for local development)
+npx -y @1mcp/agent --trust-proxy=loopback
+
+# Behind reverse proxy
+npx -y @1mcp/agent --trust-proxy=192.168.1.1
+
+# Behind CDN/Cloudflare
+npx -y @1mcp/agent --trust-proxy=true
 ```
 
+See [docs/TRUST_PROXY.md](docs/TRUST_PROXY.md) for detailed configuration options, security considerations, and reverse proxy setup examples.
+
 ### Understanding Tags
 
 Tags help you control which MCP servers are available to different clients. Think of tags as labels that describe what each server can do.

package/build/constants.d.ts

@@ -9,7 +9,7 @@ export declare const MESSAGES_ENDPOINT = "/messages";
 export declare const STREAMABLE_HTTP_ENDPOINT = "/mcp";
 export declare const MCP_CONFIG_FILE = "mcp.json";
 export declare const MCP_SERVER_NAME = "1mcp";
-export declare const MCP_SERVER_VERSION = "0.13.1";
+export declare const MCP_SERVER_VERSION = "0.15.0";
 export declare const MCP_URI_SEPARATOR = "_1mcp_";
 export declare const CONFIG_DIR_NAME = "1mcp";
 export declare const DEFAULT_CONFIG: {

package/build/constants.js

@@ -11,7 +11,7 @@ export const STREAMABLE_HTTP_ENDPOINT = '/mcp';
 // MCP constants
 export const MCP_CONFIG_FILE = 'mcp.json';
 export const MCP_SERVER_NAME = '1mcp';
-export const MCP_SERVER_VERSION = '0.13.1';
+export const MCP_SERVER_VERSION = '0.15.0';
 export const MCP_URI_SEPARATOR = '_1mcp_';
 // Global config paths
 export const CONFIG_DIR_NAME = '1mcp';

package/build/core/client/clientManager.d.ts

@@ -1,43 +1,59 @@
 import { Client } from '@modelcontextprotocol/sdk/client/index.js';
-import { OutboundConnection, OutboundConnections, OperationOptions, InboundConnection, ServerCapability, AuthProviderTransport } from '../types/index.js';
-/**
- * Creates client instances for all transports with retry logic
- * @param transports Record of transport instances
- * @returns Record of client instances
- */
-export declare function createClients(transports: Record<string, AuthProviderTransport>): Promise<OutboundConnections>;
-/**
- * Gets a client by name with error handling
- * @param clients Record of client instances
- * @param clientName The name of the client to get
- * @returns The client instance
- * @throws ClientNotFoundError if the client is not found
- */
-export declare function getClient(clients: OutboundConnections, clientName: string): OutboundConnection;
-/**
- * Executes an operation with error handling and retry logic
- * @param operation The operation to execute
- * @param context The execution context (client info or server info)
- * @param options Operation options including timeout and retry settings
- * @returns The result of the operation
- */
-export declare function executeOperation<T>(operation: () => Promise<T>, contextName: string, options?: OperationOptions): Promise<T>;
-/**
- * Executes a client operation with error handling and retry logic
- * @param clients Record of client instances
- * @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
- */
-export declare function executeClientOperation<T>(clients: OutboundConnections, clientName: string, operation: (clientInfo: OutboundConnection) => Promise<T>, options?: OperationOptions, requiredCapability?: ServerCapability): Promise<T>;
-/**
- * Executes a server operation with error handling and retry logic
- * @param server The server to execute the operation on
- * @param operation The operation to execute
- * @param options Operation options including timeout and retry settings
- */
-export declare function executeServerOperation<T>(server: InboundConnection, operation: (server: InboundConnection) => Promise<T>, options?: OperationOptions): Promise<T>;
+import { OutboundConnection, OutboundConnections, OperationOptions, ServerCapability, AuthProviderTransport } from '../types/index.js';
+export declare class ClientManager {
+    private static instance;
+    private outboundConns;
+    private transports;
+    private connectionSemaphore;
+    private constructor();
+    static getOrCreateInstance(): ClientManager;
+    static get current(): ClientManager;
+    static resetInstance(): void;
+    /**
+     * Creates a new MCP client instance
+     * @returns A new Client instance
+     */
+    private createClient;
+    /**
+     * Creates a new MCP client instance for external use (e.g., OAuth testing)
+     * @returns A new Client instance
+     */
+    createClientInstance(): Client;
+    /**
+     * Creates client instances for all transports with retry logic
+     * @param transports Record of transport instances
+     * @returns Record of client instances
+     */
+    createClients(transports: Record<string, AuthProviderTransport>): Promise<OutboundConnections>;
+    /**
+     * 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
+     * @returns The connected client (may be a new instance after retries)
+     */
+    private connectWithRetry;
+    /**
+     * 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: string): OutboundConnection;
+    /**
+     * Gets all outbound connections
+     * @returns Map of all outbound connections
+     */
+    getClients(): OutboundConnections;
+    /**
+     * 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
+     */
+    executeClientOperation<T>(clientName: string, operation: (clientInfo: OutboundConnection) => Promise<T>, options?: OperationOptions, requiredCapability?: ServerCapability): Promise<T>;
+}
 /**
  * Custom error class for OAuth authorization required
  */

package/build/core/client/clientManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"clientManager.d.ts","sourceRoot":"","sources":["../../../src/core/client/clientManager.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,2CAA2C,CAAC;AAQnE,OAAO,EAEL,kBAAkB,EAClB,mBAAmB,EACnB,gBAAgB,EAChB,iBAAiB,EACjB,gBAAgB,EAChB,qBAAqB,EACtB,MAAM,mBAAmB,CAAC;AAG3B;;;;GAIG;AACH,wBAAsB,aAAa,CAAC,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,qBAAqB,CAAC,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAkEnH;AA4DD;;;;;;GAMG;AACH,wBAAgB,SAAS,CAAC,OAAO,EAAE,mBAAmB,EAAE,UAAU,EAAE,MAAM,GAAG,kBAAkB,CAM9F;AAED;;;;;;GAMG;AACH,wBAAsB,gBAAgB,CAAC,CAAC,EACtC,SAAS,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EAC3B,WAAW,EAAE,MAAM,EACnB,OAAO,GAAE,gBAAqB,GAC7B,OAAO,CAAC,CAAC,CAAC,CA2BZ;AAED;;;;;;;GAOG;AACH,wBAAsB,sBAAsB,CAAC,CAAC,EAC5C,OAAO,EAAE,mBAAmB,EAC5B,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,CAAC,UAAU,EAAE,kBAAkB,KAAK,OAAO,CAAC,CAAC,CAAC,EACzD,OAAO,GAAE,gBAAqB,EAC9B,kBAAkB,CAAC,EAAE,gBAAgB,GACpC,OAAO,CAAC,CAAC,CAAC,CAQZ;AAED;;;;;GAKG;AACH,wBAAsB,sBAAsB,CAAC,CAAC,EAC5C,MAAM,EAAE,iBAAiB,EACzB,SAAS,EAAE,CAAC,MAAM,EAAE,iBAAiB,KAAK,OAAO,CAAC,CAAC,CAAC,EACpD,OAAO,GAAE,gBAAqB,GAC7B,OAAO,CAAC,CAAC,CAAC,CAEZ;AAED;;GAEG;AACH,qBAAa,kBAAmB,SAAQ,KAAK;IAElC,UAAU,EAAE,MAAM;IAClB,MAAM,EAAE,MAAM;gBADd,UAAU,EAAE,MAAM,EAClB,MAAM,EAAE,MAAM;CAKxB"}
+{"version":3,"file":"clientManager.d.ts","sourceRoot":"","sources":["../../../src/core/client/clientManager.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,2CAA2C,CAAC;AAMnE,OAAO,EAEL,kBAAkB,EAClB,mBAAmB,EACnB,gBAAgB,EAChB,gBAAgB,EAChB,qBAAqB,EACtB,MAAM,mBAAmB,CAAC;AAI3B,qBAAa,aAAa;IACxB,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAgB;IACvC,OAAO,CAAC,aAAa,CAAkC;IACvD,OAAO,CAAC,UAAU,CAA6C;IAC/D,OAAO,CAAC,mBAAmB,CAAyC;IAEpE,OAAO;WAEO,mBAAmB,IAAI,aAAa;IAOlD,WAAkB,OAAO,IAAI,aAAa,CAEzC;WAGa,aAAa,IAAI,IAAI;IAInC;;;OAGG;IACH,OAAO,CAAC,YAAY;IAYpB;;;OAGG;IACI,oBAAoB,IAAI,MAAM;IAIrC;;;;OAIG;IACU,aAAa,CAAC,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,qBAAqB,CAAC,GAAG,OAAO,CAAC,mBAAmB,CAAC;IAyE3G;;;;;;OAMG;YACW,gBAAgB;IA+C9B;;;;;OAKG;IACI,SAAS,CAAC,UAAU,EAAE,MAAM,GAAG,kBAAkB;IAQxD;;;OAGG;IACI,UAAU,IAAI,mBAAmB;IAIxC;;;;;;OAMG;IACU,sBAAsB,CAAC,CAAC,EACnC,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,CAAC,UAAU,EAAE,kBAAkB,KAAK,OAAO,CAAC,CAAC,CAAC,EACzD,OAAO,GAAE,gBAAqB,EAC9B,kBAAkB,CAAC,EAAE,gBAAgB,GACpC,OAAO,CAAC,CAAC,CAAC;CAad;AAED;;GAEG;AACH,qBAAa,kBAAmB,SAAQ,KAAK;IAElC,UAAU,EAAE,MAAM;IAClB,MAAM,EAAE,MAAM;gBADd,UAAU,EAAE,MAAM,EAClB,MAAM,EAAE,MAAM;CAKxB"}

package/build/core/client/clientManager.js

@@ -1,197 +1,206 @@
-import { ErrorCode } from '@modelcontextprotocol/sdk/types.js';
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
 import { UnauthorizedError } from '@modelcontextprotocol/sdk/client/auth.js';
-import createClient from './clientFactory.js';
 import logger from '../../logger/logger.js';
-import { CONNECTION_RETRY, MCP_SERVER_NAME } from '../../constants.js';
-import { ClientConnectionError, ClientNotFoundError, MCPError, CapabilityError } from '../../utils/errorTypes.js';
+import { CONNECTION_RETRY, MCP_SERVER_NAME, MCP_SERVER_VERSION, MCP_CLIENT_CAPABILITIES } from '../../constants.js';
+import { ClientConnectionError, ClientNotFoundError, CapabilityError } from '../../utils/errorTypes.js';
 import { ClientStatus, } from '../types/index.js';
 import { AgentConfigManager } from '../server/agentConfig.js';
-/**
- * Creates client instances for all transports with retry logic
- * @param transports Record of transport instances
- * @returns Record of client instances
- */
-export async function createClients(transports) {
-    const clients = new Map();
-    for (const [name, transport] of Object.entries(transports)) {
-        logger.info(`Creating client for ${name}`);
-        try {
-            const client = await createClient();
-            // Connect with retry logic
-            const connectedClient = await connectWithRetry(client, transport, name);
-            clients.set(name, {
-                name,
-                transport,
-                client: connectedClient,
-                status: ClientStatus.Connected,
-                lastConnected: new Date(),
-            });
-            logger.info(`Client created for ${name}`);
-            connectedClient.onclose = () => {
-                const clientInfo = clients.get(name);
-                if (clientInfo) {
-                    clientInfo.status = ClientStatus.Disconnected;
-                }
-                logger.info(`Client ${name} disconnected`);
-            };
+import { executeOperation } from '../../utils/operationExecution.js';
+export class ClientManager {
+    static instance;
+    outboundConns = new Map();
+    transports = {};
+    connectionSemaphore = new Map();
+    constructor() { }
+    static getOrCreateInstance() {
+        if (!ClientManager.instance) {
+            ClientManager.instance = new ClientManager();
         }
-        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);
-                }
-                clients.set(name, {
+        return ClientManager.instance;
+    }
+    static get current() {
+        return ClientManager.instance;
+    }
+    // Test utility method to reset singleton state
+    static resetInstance() {
+        ClientManager.instance = undefined;
+    }
+    /**
+     * Creates a new MCP client instance
+     * @returns A new Client instance
+     */
+    createClient() {
+        return new Client({
+            name: MCP_SERVER_NAME,
+            version: MCP_SERVER_VERSION,
+        }, {
+            capabilities: MCP_CLIENT_CAPABILITIES,
+        });
+    }
+    /**
+     * Creates a new MCP client instance for external use (e.g., OAuth testing)
+     * @returns A new Client instance
+     */
+    createClientInstance() {
+        return this.createClient();
+    }
+    /**
+     * 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: error.client,
-                    status: ClientStatus.AwaitingOAuth,
-                    authorizationUrl,
-                    oauthStartTime: new Date(),
+                    client: connectedClient,
+                    status: ClientStatus.Connected,
+                    lastConnected: new Date(),
                 });
+                logger.info(`Client created for ${name}`);
+                connectedClient.onclose = () => {
+                    const clientInfo = this.outboundConns.get(name);
+                    if (clientInfo) {
+                        clientInfo.status = ClientStatus.Disconnected;
+                    }
+                    logger.info(`Client ${name} disconnected`);
+                };
+                connectedClient.onerror = (error) => {
+                    logger.error(`Client ${name} error: ${error}`);
+                };
             }
-            else {
-                logger.error(`Failed to create client for ${name}: ${error}`);
-                clients.set(name, {
-                    name,
-                    transport,
-                    client: await createClient(),
-                    status: ClientStatus.Error,
-                    lastError: error instanceof Error ? error : new Error(String(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)),
+                    });
+                }
             }
         }
+        return this.outboundConns;
     }
-    return clients;
-}
-/**
- * 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
- * @returns The connected client (may be a new instance after retries)
- */
-async function connectWithRetry(client, transport, name) {
-    let retryDelay = CONNECTION_RETRY.INITIAL_DELAY_MS;
-    let currentClient = client;
-    for (let i = 0; i < CONNECTION_RETRY.MAX_ATTEMPTS; i++) {
-        try {
-            await currentClient.connect(transport);
-            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 serverConfig = AgentConfigManager.getInstance().getConfig();
-                logger.info(`OAuth authorization required for ${name}. Visit http://localhost:${serverConfig.port}/oauth to authorize`);
-                // Throw special error that includes OAuth info
-                throw new OAuthRequiredError(name, currentClient);
+    /**
+     * 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
+     * @returns The connected client (may be a new instance after retries)
+     */
+    async connectWithRetry(client, transport, name) {
+        let retryDelay = CONNECTION_RETRY.INITIAL_DELAY_MS;
+        let currentClient = client;
+        for (let i = 0; i < CONNECTION_RETRY.MAX_ATTEMPTS; i++) {
+            try {
+                await currentClient.connect(transport);
+                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;
             }
-            // 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...`);
-                    await new Promise((resolve) => setTimeout(resolve, retryDelay));
-                    retryDelay *= 2; // Exponential backoff
-                    // Create a new client for retry to avoid "already started" errors
-                    currentClient = await createClient();
+            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 {
-                    throw new ClientConnectionError(name, error instanceof Error ? error : new Error(String(error)));
+                    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...`);
+                        await new Promise((resolve) => setTimeout(resolve, retryDelay));
+                        retryDelay *= 2; // Exponential backoff
+                        // Create a new client for retry to avoid "already started" errors
+                        currentClient = this.createClient();
+                    }
+                    else {
+                        throw new ClientConnectionError(name, 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'));
     }
-    // This should never be reached due to the throw in the else block above
-    throw new ClientConnectionError(name, new Error('Max retries exceeded'));
-}
-// OAuth authorization flow is now handled by the SDK's built-in implementation
-/**
- * Gets a client by name with error handling
- * @param clients Record of client instances
- * @param clientName The name of the client to get
- * @returns The client instance
- * @throws ClientNotFoundError if the client is not found
- */
-export function getClient(clients, clientName) {
-    const client = clients.get(clientName);
-    if (!client) {
-        throw new ClientNotFoundError(clientName);
-    }
-    return client;
-}
-/**
- * Executes an operation with error handling and retry logic
- * @param operation The operation to execute
- * @param context The execution context (client info or server info)
- * @param options Operation options including timeout and retry settings
- * @returns The result of the operation
- */
-export async function executeOperation(operation, contextName, options = {}) {
-    const { retryCount = 0, retryDelay = 1000 } = options;
-    let lastError;
-    for (let i = 0; i <= retryCount; i++) {
-        try {
-            return await operation();
-        }
-        catch (error) {
-            lastError = error instanceof Error ? error : new Error(String(error));
-            if (i < retryCount) {
-                logger.info(`Retrying operation ${operation.name} on ${contextName} after ${retryDelay}ms`);
-                await new Promise((resolve) => setTimeout(resolve, retryDelay));
-            }
+    /**
+     * 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) {
+            throw new ClientNotFoundError(clientName);
         }
+        return client;
     }
-    // If we get here, we've exhausted all retries
-    logger.error(`Operation failed on ${contextName} after ${retryCount + 1} attempts: ${lastError}`);
-    if (lastError instanceof MCPError) {
-        throw lastError;
+    /**
+     * Gets all outbound connections
+     * @returns Map of all outbound connections
+     */
+    getClients() {
+        return this.outboundConns;
     }
-    const mcpError = new MCPError(`Error executing operation on ${contextName}`, ErrorCode.InternalError, {
-        originalError: lastError,
-    });
-    throw mcpError;
-}
-/**
- * Executes a client operation with error handling and retry logic
- * @param clients Record of client instances
- * @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
- */
-export async function executeClientOperation(clients, clientName, operation, options = {}, requiredCapability) {
-    const clientInfo = getClient(clients, clientName);
-    if (requiredCapability && !clientInfo.capabilities?.[requiredCapability]) {
-        throw new CapabilityError(clientName, String(requiredCapability));
+    /**
+     * 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) {
+            throw new ClientConnectionError(clientName, new Error('Client not connected'));
+        }
+        if (requiredCapability && !outboundConn.capabilities?.[requiredCapability]) {
+            throw new CapabilityError(clientName, String(requiredCapability));
+        }
+        return executeOperation(() => operation(outboundConn), `client ${clientName}`, options);
     }
-    return executeOperation(() => operation(clientInfo), `client ${clientName}`, options);
-}
-/**
- * Executes a server operation with error handling and retry logic
- * @param server The server to execute the operation on
- * @param operation The operation to execute
- * @param options Operation options including timeout and retry settings
- */
-export async function executeServerOperation(server, operation, options = {}) {
-    return executeOperation(() => operation(server), 'server', options);
 }
 /**
  * Custom error class for OAuth authorization required