@mcp-ts/sdk 2.5.2 → 2.6.0

package/src/server/mcp/oauth-client.ts

@@ -24,16 +24,19 @@ import {
   ReadResourceRequest,
   ReadResourceResult,
   ReadResourceResultSchema,
+  type Implementation,
 } from '@modelcontextprotocol/sdk/types.js';
 import { StorageOAuthClientProvider, type AgentsOAuthProvider } from './storage-oauth-provider.js';
 import { Emitter, type McpConnectionEvent, type McpObservabilityEvent, type McpConnectionState } from '../../shared/events.js';
 import { UnauthorizedError } from '../../shared/errors.js';
 import { sessions } from '../storage/index.js';
-import type { Session, SessionStatus } from '../storage/types.js';
+import type { Session, SessionStatus, SessionStore } from '../storage/types.js';
 import {
   MCP_CLIENT_NAME,
   MCP_CLIENT_VERSION,
 } from '../../shared/constants.js';
+import type { OAuthTokens } from '@modelcontextprotocol/sdk/shared/auth.js';
+import type { OAuthClientProvider } from '@modelcontextprotocol/sdk/client/auth.js';
 
 /**
  * Supported MCP transport types
@@ -71,6 +74,25 @@ export interface MCPOAuthClientOptions {
   clientUri?: string;
   logoUri?: string;
   policyUri?: string;
+  /**
+   * Credentials already loaded by the caller (e.g. via get({includeCredentials: true})).
+   * When provided, the StorageOAuthClientProvider uses these cached values to
+   * skip redundant DB reads for tokens() calls during reconnection.
+   */
+  cachedCredentials?: { tokens?: OAuthTokens };
+  /**
+   * When true, skips the redundant session-existence check in ensureSession().
+   * Set by callers that have already confirmed the session exists in storage
+   * (e.g. getOrCreateClient, getSession, finishAuth in sse-handler).
+   * Saves one round-trip per reconnection.
+   */
+  hasSession?: boolean;
+  /**
+   * Custom session store override. When provided, all storage operations
+   * (get/create/update/delete) use this store instead of the default global.
+   * Used for wrapping with DB observability or other decorators.
+   */
+  sessionStore?: SessionStore;
 }
 
 /**
@@ -80,26 +102,12 @@ export interface MCPOAuthClientOptions {
  */
 export class MCPClient {
   private client: Client;
-  public oauthProvider: AgentsOAuthProvider | null = null;
+  public oauthProvider: OAuthClientProvider | null = null;
   private transport: StreamableHTTPClientTransport | SSEClientTransport | null = null;
-  private userId: string;
-  private serverId?: string;
-  private sessionId: string;
-  private serverName?: string;
-  private transportType: TransportType | undefined;
-  private serverUrl: string | undefined;
-  private callbackUrl: string | undefined;
-  private onRedirect: ((url: string) => void) | undefined;
-  private clientId?: string;
-  private clientSecret?: string;
-  private headers?: Record<string, string>;
-  /** OAuth Client Metadata */
-  private clientName?: string;
-  private clientUri?: string;
-  private logoUri?: string;
-  private policyUri?: string;
+  private config!: MCPOAuthClientOptions;
   private createdAt?: number;
-
+  private _serverInfo: Implementation | undefined;
+  private _store!: SessionStore;
 
   /** Event emitters for connection lifecycle */
   private readonly _onConnectionEvent = new Emitter<McpConnectionEvent>();
@@ -116,21 +124,8 @@ export class MCPClient {
    * @param options - Client configuration options
    */
   constructor(options: MCPOAuthClientOptions) {
-    this.serverUrl = options.serverUrl;
-    this.serverName = options.serverName;
-    this.callbackUrl = options.callbackUrl;
-    this.onRedirect = options.onRedirect;
-    this.userId = options.userId;
-    this.serverId = options.serverId;
-    this.sessionId = options.sessionId;
-    this.transportType = options.transportType;
-    this.clientId = options.clientId;
-    this.clientSecret = options.clientSecret;
-    this.headers = options.headers;
-    this.clientName = options.clientName;
-    this.clientUri = options.clientUri;
-    this.logoUri = options.logoUri;
-    this.policyUri = options.policyUri;
+    this.config = { ...options };
+    this._store = options.sessionStore ?? sessions;
 
     this.client = new Client(
       {
@@ -149,6 +144,22 @@ export class MCPClient {
     );
   }
 
+  /** Shared session-shaped data for ensureSession and saveSession */
+  private get session() {
+    return {
+      sessionId: this.config.sessionId,
+      userId: this.config.userId,
+      serverId: this.config.serverId!,
+      serverName: this.config.serverName,
+      serverUrl: this.config.serverUrl!,
+      callbackUrl: this.config.callbackUrl!,
+      transportType: (this.config.transportType || 'streamable-http') as TransportType,
+      headers: this.config.headers,
+      createdAt: this.createdAt ?? Date.now(),
+      updatedAt: Date.now(),
+    };
+  }
+
   /**
    * Emit a connection state change event
    * @private
@@ -157,14 +168,14 @@ export class MCPClient {
     const previousState = this.currentState;
     this.currentState = newState;
 
-    if (!this.serverId) return;
+    if (!this.config.serverId) return;
 
     this._onConnectionEvent.fire({
       type: 'state_changed',
-      sessionId: this.sessionId,
-      serverId: this.serverId,
-      serverName: this.serverName || this.serverId,
-      serverUrl: this.serverUrl || '',
+      sessionId: this.config.sessionId,
+      serverId: this.config.serverId,
+      serverName: this.config.serverName || this.config.serverId,
+      serverUrl: this.config.serverUrl || '',
       createdAt: this.createdAt,
       state: newState,
       previousState,
@@ -176,8 +187,8 @@ export class MCPClient {
       level: 'info',
       message: `Connection state: ${previousState} → ${newState}`,
       displayMessage: `State changed to ${newState}`,
-      sessionId: this.sessionId,
-      serverId: this.serverId,
+      sessionId: this.config.sessionId,
+      serverId: this.config.serverId,
       payload: { previousState, newState },
       timestamp: Date.now(),
       id: nanoid(),
@@ -189,12 +200,12 @@ export class MCPClient {
    * @private
    */
   private emitError(error: string, errorType: 'connection' | 'auth' | 'validation' | 'unknown' = 'unknown'): void {
-    if (!this.serverId) return;
+    if (!this.config.serverId) return;
 
     this._onConnectionEvent.fire({
       type: 'error',
-      sessionId: this.sessionId,
-      serverId: this.serverId,
+      sessionId: this.config.sessionId,
+      serverId: this.config.serverId,
       error,
       errorType,
       timestamp: Date.now(),
@@ -205,8 +216,8 @@ export class MCPClient {
       level: 'error',
       message: error,
       displayMessage: error,
-      sessionId: this.sessionId,
-      serverId: this.serverId,
+      sessionId: this.config.sessionId,
+      serverId: this.config.serverId,
       payload: { errorType, error },
       timestamp: Date.now(),
       id: nanoid(),
@@ -218,12 +229,12 @@ export class MCPClient {
    * @private
    */
   private emitProgress(message: string): void {
-    if (!this.serverId) return;
+    if (!this.config.serverId) return;
 
     this._onConnectionEvent.fire({
       type: 'progress',
-      sessionId: this.sessionId,
-      serverId: this.serverId,
+      sessionId: this.config.sessionId,
+      serverId: this.config.serverId,
       message,
       timestamp: Date.now(),
     });
@@ -243,16 +254,16 @@ export class MCPClient {
    * @private
    */
   private getTransport(type: TransportType): StreamableHTTPClientTransport | SSEClientTransport {
-    if (!this.serverUrl) {
+    if (!this.config.serverUrl) {
       throw new Error('Server URL is required to create transport');
     }
 
-    const baseUrl = new URL(this.serverUrl);
-    const hasAuthorizationHeader = Object.keys(this.headers || {})
+    const baseUrl = new URL(this.config.serverUrl);
+    const hasAuthorizationHeader = Object.keys(this.config.headers || {})
       .some((key) => key.toLowerCase() === 'authorization');
-    const transportOptions = {
-      ...(!hasAuthorizationHeader && { authProvider: this.oauthProvider! }),
-      ...(this.headers && { requestInit: { headers: this.headers } }),
+    const transportOptions: Record<string, any> = {
+      ...(!hasAuthorizationHeader && { authProvider: this.oauthProvider }),
+      ...(this.config.headers && { requestInit: { headers: this.config.headers } }),
       /**
        * Custom fetch implementation to handle connection timeouts.
        * Observation: SDK 1.24.0+ connections may hang indefinitely in some environments.
@@ -296,96 +307,87 @@ export class MCPClient {
    * @private
    */
   private async ensureSession(): Promise<void> {
-    if (this.oauthProvider) {
-      return;
-    }
+    if (this.oauthProvider) return;
 
     this.emitStateChange('INITIALIZING');
     this.emitProgress('Loading session configuration...');
 
-    let existingSession: Session | null = null;
-
-    if (!this.serverUrl || !this.callbackUrl || !this.serverId) {
-      existingSession = await sessions.get(this.userId, this.sessionId);
+    if (!this.config.serverUrl || !this.config.callbackUrl || !this.config.serverId) {
+      const existingSession = await this._store.get(this.config.userId, this.config.sessionId);
       if (!existingSession) {
-        throw new Error(`Session not found: ${this.sessionId}`);
+        throw new Error(`Session not found: ${this.config.sessionId}`);
       }
 
-      this.serverUrl = this.serverUrl || existingSession.serverUrl;
-      this.callbackUrl = this.callbackUrl || existingSession.callbackUrl;
-      /**
-       * Do NOT load transportType from session if not explicitly provided.
-       * We want to re-negotiate (try streamable -> sse) on new connections if in "Auto" mode.
-       * this.transportType = this.transportType || sessionData.transportType; 
-       */
-      this.serverName = this.serverName || existingSession.serverName;
-      this.serverId = this.serverId || existingSession.serverId || 'unknown';
-      this.headers = this.headers || existingSession.headers;
+      this.config.serverUrl = this.config.serverUrl || existingSession.serverUrl;
+      this.config.callbackUrl = this.config.callbackUrl || existingSession.callbackUrl;
+      this.config.serverName = this.config.serverName || existingSession.serverName;
+      this.config.serverId = this.config.serverId || existingSession.serverId || 'unknown';
+      this.config.headers = this.config.headers || existingSession.headers;
       this.createdAt = existingSession.createdAt;
     }
 
-    if (!this.serverUrl || !this.callbackUrl || !this.serverId) {
+    if (!this.config.serverUrl || !this.config.callbackUrl || !this.config.serverId) {
       throw new Error('Missing required connection metadata');
     }
 
-    if (!this.oauthProvider) {
-      if (!this.serverId) {
-        throw new Error('serverId required for OAuth provider initialization');
-      }
-      this.oauthProvider = new StorageOAuthClientProvider({
-        userId: this.userId,
-        serverId: this.serverId,
-        sessionId: this.sessionId,
-        redirectUrl: this.callbackUrl!,
-        clientName: this.clientName,
-        clientUri: this.clientUri,
-        logoUri: this.logoUri,
-        policyUri: this.policyUri,
-        clientId: this.clientId,
-        clientSecret: this.clientSecret,
-        onRedirect: (redirectUrl: string) => {
-          if (this.onRedirect) {
-            this.onRedirect(redirectUrl);
-          }
+    this.oauthProvider = new StorageOAuthClientProvider({
+      userId: this.config.userId,
+      serverId: this.config.serverId!,
+      sessionId: this.config.sessionId,
+      redirectUrl: this.config.callbackUrl!,
+      clientName: this.config.clientName,
+      clientUri: this.config.clientUri,
+      logoUri: this.config.logoUri,
+      policyUri: this.config.policyUri,
+      clientId: this.config.clientId,
+      clientSecret: this.config.clientSecret,
+      cachedTokens: this.config.cachedCredentials?.tokens,
+      sessionStore: this._store,
+      onRedirect: (redirectUrl: string) => {
+        if (this.config.serverId) {
+          this._onConnectionEvent.fire({
+            type: 'auth_required',
+            sessionId: this.config.sessionId,
+            serverId: this.config.serverId,
+            authUrl: redirectUrl,
+            timestamp: Date.now(),
+          });
         }
-      });
-    }
+        if (this.config.onRedirect) {
+          this.config.onRedirect(redirectUrl);
+        }
+      },
+    });
 
-    // Create session in the session store if it doesn't exist yet
-    // This is needed BEFORE OAuth flow starts because the OAuth provider
-    // will call saveCodeVerifier() which requires the session to exist
-    if (existingSession === null) {
-      existingSession = await sessions.get(this.userId, this.sessionId);
-    }
-    if (!existingSession && this.serverId && this.serverUrl && this.callbackUrl) {
+    // Create session row BEFORE persisting credentials (FK constraint on mcp_credentials)
+    // When hasSession is set by the caller, the session is guaranteed
+    // to exist — skip the redundant round-trip.
+    const existingSession = this.config.hasSession ? {} as Session : await this._store.get(this.config.userId, this.config.sessionId);
+    if (!existingSession) {
       this.createdAt = Date.now();
       const updatedAt = this.createdAt;
       this._onObservabilityEvent.fire({
         type: 'mcp:client:session_created',
         level: 'info',
-        message: `Creating pending session ${this.sessionId} for connection setup`,
-        sessionId: this.sessionId,
-        serverId: this.serverId,
+        message: `Creating pending session ${this.config.sessionId} for connection setup`,
+        sessionId: this.config.sessionId,
+        serverId: this.config.serverId,
         timestamp: Date.now(),
         id: nanoid(),
       });
-      await sessions.create({
-        sessionId: this.sessionId,
-        userId: this.userId,
-        serverId: this.serverId,
-        serverName: this.serverName,
-        serverUrl: this.serverUrl,
-        callbackUrl: this.callbackUrl,
-        transportType: this.transportType || 'streamable-http',
-        headers: this.headers,
-        createdAt: this.createdAt,
+      await this._store.create({
+        ...this.session,
         updatedAt,
         status: 'pending',
       });
     }
-  }
-
 
+    // Only persist credentials on first connect. Existing sessions already have
+    // credentials from the initial connect — no DB read needed to verify.
+    if (!existingSession && this.oauthProvider instanceof StorageOAuthClientProvider) {
+        await this.oauthProvider.initializeCredentials();
+    }
+  }
 
   /**
    * Saves current session state to the session store
@@ -393,40 +395,15 @@ export class MCPClient {
    * @param status - Session lifecycle status used by storage cleanup
    * @private
    */
-  private async saveSession(
-    status: SessionStatus = 'active',
-    existingSession?: Session | null
-  ): Promise<void> {
-    if (!this.sessionId || !this.serverId || !this.serverUrl || !this.callbackUrl) {
+  private async saveSession(status: SessionStatus = 'active'): Promise<void> {
+    if (!this.config.sessionId || !this.config.serverId || !this.config.serverUrl || !this.config.callbackUrl) {
       return;
     }
 
-    const sessionData = {
-      sessionId: this.sessionId,
-      userId: this.userId,
-      serverId: this.serverId,
-      serverName: this.serverName,
-      serverUrl: this.serverUrl,
-      callbackUrl: this.callbackUrl,
-      transportType: (this.transportType || 'streamable-http') as TransportType,
-      headers: this.headers,
-      createdAt: this.createdAt || Date.now(),
-      updatedAt: Date.now(),
+    await this._store.update(this.config.userId, this.config.sessionId, {
+      ...this.session,
       status,
-    };
-    if (status === 'active') {
-      (sessionData as typeof sessionData & { authUrl: null }).authUrl = null;
-    }
-
-    // Try to update first, create if doesn't exist
-    if (existingSession === undefined) {
-      existingSession = await sessions.get(this.userId, this.sessionId);
-    }
-    if (existingSession) {
-      await sessions.update(this.userId, this.sessionId, sessionData);
-    } else {
-      await sessions.create(sessionData);
-    }
+    });
   }
 
   /**
@@ -435,7 +412,7 @@ export class MCPClient {
    */
   private async deleteTransientSession(): Promise<void> {
     try {
-      await sessions.delete(this.userId, this.sessionId);
+      await this._store.delete(this.config.userId, this.config.sessionId);
     } catch {
       // Best effort only: preserve the original connection/auth error.
     }
@@ -451,8 +428,8 @@ export class MCPClient {
      * If exact transport type is known, only try that.
      * Otherwise (auto mode), try streamable_http first, then sse.
      */
-    const transportsToTry: TransportType[] = this.transportType
-      ? [this.transportType]
+    const transportsToTry: TransportType[] = this.config.transportType
+      ? [this.config.transportType]
       : ['streamable-http', 'sse'];
 
     let lastError: unknown;
@@ -469,6 +446,9 @@ export class MCPClient {
         /** Race connection against timeout */
         await this.client!.connect(transport);
 
+        /** Capture server metadata from the initialize response */
+        this._serverInfo = this.client.getServerVersion();
+
         /** Success! Return the type that worked */
         return { transportType: currentType };
 
@@ -494,8 +474,8 @@ export class MCPClient {
         this._onObservabilityEvent.fire({
           level: 'warn',
           message: `Transport ${currentType} failed, falling back`,
-          sessionId: this.sessionId,
-          serverId: this.serverId,
+          sessionId: this.config.sessionId,
+          serverId: this.config.serverId,
           metadata: {
             failedTransport: currentType,
             error: errorMessage
@@ -550,7 +530,7 @@ export class MCPClient {
       const { transportType } = await this.tryConnect();
 
       /** Update transport type to the one that actually worked */
-      this.transportType = transportType;
+      this.config.transportType = transportType;
 
       this.emitStateChange('CONNECTED');
       this.emitProgress('Connected successfully');
@@ -560,9 +540,9 @@ export class MCPClient {
       this._onObservabilityEvent.fire({
         type: 'mcp:client:session_saved',
         level: 'info',
-        message: `Saving active session ${this.sessionId} (connect success)`,
-        sessionId: this.sessionId,
-        serverId: this.serverId,
+        message: `Saving active session ${this.config.sessionId} (connect success)`,
+        sessionId: this.config.sessionId,
+        serverId: this.config.serverId,
         timestamp: Date.now(),
         id: nanoid(),
       });
@@ -576,9 +556,8 @@ export class MCPClient {
         /** Set when the SDK calls redirectToAuthorization on the OAuth provider */
         let authUrl = '';
         if (this.oauthProvider) {
-          authUrl = (this.oauthProvider.authUrl || '').trim();
+          authUrl = ((this.oauthProvider as any).authUrl || '').trim();
         }
-
         /**
          * 401 without a usable URL means metadata/DCR failed or the server never started
          * an interactive OAuth flow — not recoverable as "pending OAuth".
@@ -606,25 +585,25 @@ export class MCPClient {
         this._onObservabilityEvent.fire({
           type: 'mcp:client:session_saved',
           level: 'info',
-          message: `Saving pending OAuth session ${this.sessionId}`,
-          sessionId: this.sessionId,
-          serverId: this.serverId,
+          message: `Saving pending OAuth session ${this.config.sessionId}`,
+          sessionId: this.config.sessionId,
+          serverId: this.config.serverId,
           timestamp: Date.now(),
           id: nanoid(),
         });
         await this.saveSession('pending');
 
-        if (this.serverId) {
+        if (this.config.serverId) {
           this._onConnectionEvent.fire({
             type: 'auth_required',
-            sessionId: this.sessionId,
-            serverId: this.serverId,
+            sessionId: this.config.sessionId,
+            serverId: this.config.serverId,
             authUrl,
             timestamp: Date.now(),
           });
 
-          if (authUrl && this.onRedirect) {
-            this.onRedirect(authUrl);
+          if (authUrl && this.config.onRedirect) {
+            this.config.onRedirect(authUrl);
           }
         }
 
@@ -639,9 +618,9 @@ export class MCPClient {
       // Remove transient sessions that failed before becoming restorable.
       // Existing active sessions may still hold usable credentials for reconnect.
       try {
-        const existingSession = await sessions.get(this.userId, this.sessionId);
+        const existingSession = await this._store.get(this.config.userId, this.config.sessionId);
         if (!existingSession || existingSession.status !== 'active') {
-          await sessions.delete(this.userId, this.sessionId);
+          await this._store.delete(this.config.userId, this.config.sessionId);
         }
       } catch {
         // Best effort only: preserve the original connection error.
@@ -673,23 +652,22 @@ export class MCPClient {
     }
 
     if (state) {
-      const stateCheck = await this.oauthProvider.checkState(state);
-      if (!stateCheck.valid) {
-        const error = stateCheck.error || 'Invalid OAuth state';
-        this.emitError(error, 'auth');
+      try {
+        await (this.oauthProvider as AgentsOAuthProvider).consumeState(state);
+      } catch (error) {
+        const msg = error instanceof Error ? error.message : 'Invalid OAuth state';
+        this.emitError(msg, 'auth');
         this.emitStateChange('FAILED');
-        throw new Error(error);
+        throw error;
       }
-
-      await this.oauthProvider.consumeState(state);
     }
 
     /**
      * Determine which transports to try for finishing auth
      * If transportType is set, use only that. Otherwise try streamable_http then sse.
      */
-    const transportsToTry: TransportType[] = this.transportType
-      ? [this.transportType]
+    const transportsToTry: TransportType[] = this.config.transportType
+      ? [this.config.transportType]
       : ['streamable-http', 'sse'];
 
     let lastError: unknown;
@@ -728,16 +706,19 @@ export class MCPClient {
 
         await this.client.connect(this.transport);
 
+        /** Capture server metadata from the initialize response */
+        this._serverInfo = this.client.getServerVersion();
+
         /** Connection succeeded — lock in the transport type */
-        this.transportType = currentType;
+        this.config.transportType = currentType;
 
         this.emitStateChange('CONNECTED');
         this._onObservabilityEvent.fire({
           type: 'mcp:client:session_saved',
           level: 'info',
-          message: `Saving active session ${this.sessionId} (OAuth complete)`,
-          sessionId: this.sessionId,
-          serverId: this.serverId,
+          message: `Saving active session ${this.config.sessionId} (OAuth complete)`,
+          sessionId: this.config.sessionId,
+          serverId: this.config.serverId,
           timestamp: Date.now(),
           id: nanoid(),
         });
@@ -837,11 +818,11 @@ export class MCPClient {
     try {
       const result = await this.fetchTools();
 
-      if (this.serverId) {
+      if (this.config.serverId) {
         this._onConnectionEvent.fire({
           type: 'tools_discovered',
-          sessionId: this.sessionId,
-          serverId: this.serverId,
+          sessionId: this.config.sessionId,
+          serverId: this.config.serverId,
           toolCount: result.tools.length,
           tools: result.tools,
           timestamp: Date.now(),
@@ -885,8 +866,8 @@ export class MCPClient {
         level: 'info',
         message: `Tool ${toolName} called successfully`,
         displayMessage: `Called tool ${toolName}`,
-        sessionId: this.sessionId,
-        serverId: this.serverId,
+        sessionId: this.config.sessionId,
+        serverId: this.config.serverId,
         payload: {
           toolName,
           args: toolArgs,
@@ -904,8 +885,8 @@ export class MCPClient {
         level: 'error',
         message: errorMessage,
         displayMessage: `Failed to call tool ${toolName}`,
-        sessionId: this.sessionId,
-        serverId: this.serverId,
+        sessionId: this.config.sessionId,
+        serverId: this.config.serverId,
         payload: {
           errorType: 'tool_execution',
           error: errorMessage,
@@ -1070,8 +1051,8 @@ export class MCPClient {
         type: 'mcp:client:error',
         level: 'warn',
         message: 'Initialization failed during clearSession',
-        sessionId: this.sessionId,
-        serverId: this.serverId,
+        sessionId: this.config.sessionId,
+        serverId: this.config.serverId,
         payload: { error: String(error) },
         timestamp: Date.now(),
         id: nanoid(),
@@ -1082,7 +1063,7 @@ export class MCPClient {
       await (this.oauthProvider as any).invalidateCredentials('all');
     }
 
-    await sessions.delete(this.userId, this.sessionId);
+    await this._store.delete(this.config.userId, this.config.sessionId);
     await this.disconnect();
   }
 
@@ -1125,20 +1106,20 @@ export class MCPClient {
     this.transport = null;
 
     // Emit disconnected event
-    if (this.serverId) {
+    if (this.config.serverId) {
       this._onConnectionEvent.fire({
         type: 'disconnected',
-        sessionId: this.sessionId,
-        serverId: this.serverId,
+        sessionId: this.config.sessionId,
+        serverId: this.config.serverId,
         timestamp: Date.now(),
       });
 
       this._onObservabilityEvent.fire({
         type: 'mcp:client:disconnect',
         level: 'info',
-        message: `Disconnected from ${this.serverId}`,
-        sessionId: this.sessionId,
-        serverId: this.serverId,
+        message: `Disconnected from ${this.config.serverId}`,
+        sessionId: this.config.sessionId,
+        serverId: this.config.serverId,
         payload: {},
         timestamp: Date.now(),
         id: nanoid(),
@@ -1166,7 +1147,7 @@ export class MCPClient {
    * @returns Server URL or empty string if not set
    */
   getServerUrl(): string {
-    return this.serverUrl || '';
+    return this.config.serverUrl || '';
   }
 
   /**
@@ -1174,7 +1155,7 @@ export class MCPClient {
    * @returns Callback URL or empty string if not set
    */
   getCallbackUrl(): string {
-    return this.callbackUrl || '';
+    return this.config.callbackUrl || '';
   }
 
   /**
@@ -1182,18 +1163,29 @@ export class MCPClient {
    * @returns Transport type (defaults to 'streamable-http')
    */
   getTransportType(): TransportType {
-    return this.transportType || 'streamable-http';
+    return this.config.transportType || 'streamable-http';
+  }
+
+  /**
+   * Gets the full server metadata from the MCP initialize response.
+   * Includes name, version, icons, title, description, and website URL.
+   * Returns undefined if the client hasn't connected yet.
+   */
+  getServerInfo(): Implementation | undefined {
+    return this._serverInfo;
   }
 
   /**
-   * Gets the human-readable server name
+   * Gets the human-readable server name.
+   * Prefers the server's reported title/name from the initialize response,
+   * falling back to the name provided at construction or session metadata.
    * @returns Server name or undefined
    */
   getServerName(): string | undefined {
     // Temporarily avoid deriving serverName from serverVersion metadata.
     // const info = (this.client as any)?.getServerVersion();
-    // return info?.title ?? info?.name ?? this.serverName;
-    return this.serverName;
+    // return info?.title ?? info?.name ?? this.config.serverName;
+    return this.config.serverName;
   }
 
   /**
@@ -1201,7 +1193,7 @@ export class MCPClient {
    * @returns Server ID or undefined
    */
   getServerId(): string | undefined {
-    return this.serverId;
+    return this.config.serverId;
   }
 
   /**
@@ -1209,6 +1201,6 @@ export class MCPClient {
    * @returns Session ID
    */
   getSessionId(): string {
-    return this.sessionId;
+    return this.config.sessionId;
   }
 }