@mcp-ts/sdk 2.5.0 → 2.5.2

package/dist/{tool-router-CS9l0w4a.d.ts → tool-router-C-Mw1_BQ.d.ts}

@@ -1,5 +1,5 @@
 import { Tool } from '@modelcontextprotocol/sdk/types.js';
-import { A as ToolClientProvider, T as ToolClient } from './types-DK_NGWd4.js';
+import { A as ToolClientProvider, T as ToolClient } from './types-6SmXege4.js';
 
 /**
  * ToolIndex — Lightweight in-memory search index for MCP tool discovery.

package/dist/{tool-router-CVLBaCwH.d.mts → tool-router-CsKVXbQB.d.mts}

@@ -1,5 +1,5 @@
 import { Tool } from '@modelcontextprotocol/sdk/types.js';
-import { A as ToolClientProvider, T as ToolClient } from './types-DK_NGWd4.mjs';
+import { A as ToolClientProvider, T as ToolClient } from './types-6SmXege4.mjs';
 
 /**
  * ToolIndex — Lightweight in-memory search index for MCP tool discovery.

package/dist/{types-DK_NGWd4.d.mts → types-6SmXege4.d.mts}

@@ -57,6 +57,7 @@ type McpConnectionEvent = {
     serverId: string;
     toolCount: number;
     tools: any[];
+    allTools?: any[];
     timestamp: number;
 } | {
     type: 'auth_required';
@@ -210,7 +211,7 @@ interface ToolPolicy {
     toolIds: string[];
     updatedAt: number;
 }
-type McpRpcMethod = 'connect' | 'disconnect' | 'listTools' | 'callTool' | 'listSessions' | 'getSession' | 'finishAuth' | 'listPrompts' | 'getPrompt' | 'listResources' | 'readResource' | 'setToolPolicy' | 'getToolPolicy';
+type McpRpcMethod = 'connect' | 'disconnect' | 'reconnect' | 'listTools' | 'callTool' | 'listSessions' | 'getSession' | 'finishAuth' | 'listPrompts' | 'getPrompt' | 'listResources' | 'readResource' | 'setToolPolicy' | 'getToolPolicy';
 interface McpRpcRequest {
     id: string;
     method: McpRpcMethod;
@@ -235,6 +236,7 @@ interface ConnectParams {
 interface DisconnectParams {
     sessionId: string;
 }
+type ReconnectParams = ConnectParams;
 interface SessionParams {
     sessionId: string;
 }
@@ -266,7 +268,7 @@ interface SetToolPolicyParams {
 interface GetToolPolicyParams {
     sessionId: string;
 }
-type McpRpcParams = ConnectParams | DisconnectParams | SessionParams | CallToolParams | GetPromptParams | ReadResourceParams | FinishAuthParams | SetToolPolicyParams | GetToolPolicyParams | undefined;
+type McpRpcParams = ConnectParams | DisconnectParams | ReconnectParams | SessionParams | CallToolParams | GetPromptParams | ReadResourceParams | FinishAuthParams | SetToolPolicyParams | GetToolPolicyParams | undefined;
 interface SessionInfo {
     sessionId: string;
     serverId?: string;

package/dist/{types-DK_NGWd4.d.ts → types-6SmXege4.d.ts}

@@ -57,6 +57,7 @@ type McpConnectionEvent = {
     serverId: string;
     toolCount: number;
     tools: any[];
+    allTools?: any[];
     timestamp: number;
 } | {
     type: 'auth_required';
@@ -210,7 +211,7 @@ interface ToolPolicy {
     toolIds: string[];
     updatedAt: number;
 }
-type McpRpcMethod = 'connect' | 'disconnect' | 'listTools' | 'callTool' | 'listSessions' | 'getSession' | 'finishAuth' | 'listPrompts' | 'getPrompt' | 'listResources' | 'readResource' | 'setToolPolicy' | 'getToolPolicy';
+type McpRpcMethod = 'connect' | 'disconnect' | 'reconnect' | 'listTools' | 'callTool' | 'listSessions' | 'getSession' | 'finishAuth' | 'listPrompts' | 'getPrompt' | 'listResources' | 'readResource' | 'setToolPolicy' | 'getToolPolicy';
 interface McpRpcRequest {
     id: string;
     method: McpRpcMethod;
@@ -235,6 +236,7 @@ interface ConnectParams {
 interface DisconnectParams {
     sessionId: string;
 }
+type ReconnectParams = ConnectParams;
 interface SessionParams {
     sessionId: string;
 }
@@ -266,7 +268,7 @@ interface SetToolPolicyParams {
 interface GetToolPolicyParams {
     sessionId: string;
 }
-type McpRpcParams = ConnectParams | DisconnectParams | SessionParams | CallToolParams | GetPromptParams | ReadResourceParams | FinishAuthParams | SetToolPolicyParams | GetToolPolicyParams | undefined;
+type McpRpcParams = ConnectParams | DisconnectParams | ReconnectParams | SessionParams | CallToolParams | GetPromptParams | ReadResourceParams | FinishAuthParams | SetToolPolicyParams | GetToolPolicyParams | undefined;
 interface SessionInfo {
     sessionId: string;
     serverId?: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mcp-ts/sdk",
-  "version": "2.5.0",
+  "version": "2.5.2",
   "publishConfig": {
     "access": "public"
   },
@@ -206,4 +206,4 @@
   "engines": {
     "node": ">=18.0.0"
   }
-}
+}

package/src/client/core/sse-client.ts

@@ -102,6 +102,10 @@ export class SSEClient {
     return this.sendRequest<DisconnectResult>('disconnect', { sessionId });
   }
 
+  async reconnectToServer(params: ConnectParams): Promise<ConnectResult> {
+    return this.sendRequest<ConnectResult>('reconnect', params);
+  }
+
   async setToolPolicy(
     sessionId: string,
     toolPolicy: Pick<ToolPolicy, 'mode'> & { toolIds?: string[] }

package/src/client/react/oauth-popup.tsx

@@ -135,7 +135,6 @@ export function createOAuthPopupRedirectHandler(
     openCenteredPopup(url, {
       ...options,
       onBlocked: options.onBlocked ?? ((blockedUrl) => {
-        window.alert('Popup blocked! Allow popups for this site to complete authentication.');
         window.location.href = blockedUrl;
       }),
     });
@@ -179,30 +178,26 @@ export function useMcpOAuthPopup<TConnection extends OAuthPopupConnectionLike>(
             : '';
       const targetSessionId = rawState ? parseOAuthState(rawState)?.sessionId || rawState : '';
 
-      if (popupWindow && targetSessionId) {
+      if (targetSessionId) {
         pendingPopupsRef.current.set(targetSessionId, { popupWindow, state: rawState });
       }
 
       if (!targetSessionId) {
-        if (popupWindow) {
-          postPopupResult(popupWindow, {
-            success: false,
-            error: 'Missing OAuth session identifier',
-          });
-        }
+        postPopupResult(popupWindow, {
+          success: false,
+          error: 'Missing OAuth session identifier',
+        });
         return;
       }
 
       const targetSession = connections.find((connection) => connection.sessionId === targetSessionId);
       if (!targetSession) {
-        if (popupWindow) {
-          postPopupResult(popupWindow, {
-            sessionId: targetSessionId,
-            state: rawState,
-            success: false,
-            error: 'OAuth session not found in the current client state',
-          });
-        }
+        postPopupResult(popupWindow, {
+          sessionId: targetSessionId,
+          state: rawState,
+          success: false,
+          error: 'OAuth session not found in the current client state',
+        });
         return;
       }
 
@@ -217,14 +212,12 @@ export function useMcpOAuthPopup<TConnection extends OAuthPopupConnectionLike>(
       } catch (error) {
         processingCodesRef.current.delete(codeKey);
         pendingPopupsRef.current.delete(targetSession.sessionId);
-        if (popupWindow) {
-          postPopupResult(popupWindow, {
-            sessionId: rawState,
-            state: rawState,
-            success: false,
-            error: error instanceof Error ? error.message : 'Failed to finish auth',
-          });
-        }
+        postPopupResult(popupWindow, {
+          sessionId: rawState,
+          state: rawState,
+          success: false,
+          error: error instanceof Error ? error.message : 'Failed to finish auth',
+        });
       }
     };
 

package/src/client/react/use-mcp.ts

@@ -371,7 +371,7 @@ export function useMcp(options: UseMcpOptions): McpClient {
           }
 
           return prev.map((c: McpConnection) =>
-            c.sessionId === event.sessionId ? { ...c, tools: event.tools, state: 'READY', updatedAt: new Date() } : c
+            c.sessionId === event.sessionId ? { ...c, tools: event.tools, allTools: (event as any).allTools, state: 'READY', updatedAt: new Date() } : c
           );
         }
 
@@ -516,24 +516,15 @@ export function useMcp(options: UseMcpOptions): McpClient {
         throw new Error('SSE client not initialized');
       }
 
-      // Find and disconnect existing session for the same server
-      const existing = connections.find(
-        (c: McpConnection) => c.serverId === params.serverId || c.serverUrl === params.serverUrl
-      );
-      if (existing) {
-        await clientRef.current.disconnectFromServer(existing.sessionId);
-        if (isMountedRef.current) {
-          setConnections((prev: McpConnection[]) =>
-            prev.filter((c: McpConnection) => c.sessionId !== existing.sessionId)
-          );
-        }
-      }
+      const result = await clientRef.current.reconnectToServer(params);
+
+      // The server emits connection events for the new session via SSE,
+      // so local state is kept in sync automatically. No manual removal
+      // of the old session or insertion of the new one needed here.
 
-      // Connect fresh
-      const result = await clientRef.current.connectToServer(params);
       return result.sessionId;
     },
-    [connections]
+    []
   );
 
   /**

package/src/client/vue/use-mcp.ts

@@ -84,6 +84,7 @@ export interface McpConnection {
     transport?: string;
     state: McpConnectionState;
     tools: ToolInfo[];
+    allTools?: ToolInfo[];
     authUrl?: string;
     error?: string;
     createdAt?: Date;
@@ -294,7 +295,7 @@ export function useMcp(options: UseMcpOptions): McpClient {
             case 'tools_discovered': {
                 const index = connections.value.findIndex((c) => c.sessionId === event.sessionId);
                 if (index !== -1) {
-                    connections.value[index] = { ...connections.value[index], tools: event.tools, state: 'READY', updatedAt: new Date() };
+                    connections.value[index] = { ...connections.value[index], tools: event.tools, allTools: (event as any).allTools, state: 'READY', updatedAt: new Date() };
                 }
                 break;
             }

package/src/server/handlers/sse-handler.ts

@@ -18,6 +18,7 @@ import type {
   McpRpcResponse,
   ConnectParams,
   DisconnectParams,
+  ReconnectParams,
   SessionParams,
   CallToolParams,
   GetPromptParams,
@@ -166,6 +167,10 @@ export class SSEConnectionManager {
           result = await this.connect(request.params as ConnectParams);
           break;
 
+        case 'reconnect':
+          result = await this.reconnect(request.params as ReconnectParams);
+          break;
+
         case 'disconnect':
           result = await this.disconnect(request.params as DisconnectParams);
           break;
@@ -363,6 +368,87 @@ export class SSEConnectionManager {
     }
   }
 
+  /**
+   * Reconnect to an MCP server — tears down the active client transport/connection
+   * and creates a fresh connection while reusing the existing session credentials in a single RPC call.
+   */
+  private async reconnect(params: ReconnectParams): Promise<ConnectResult> {
+    const { serverId: rawServerId, serverName, serverUrl, callbackUrl, transportType } = params;
+    const headers = normalizeHeaders(params.headers);
+
+    // Normalize serverId the same way connect() does
+    const serverId = rawServerId && rawServerId.length <= 12
+      ? rawServerId
+      : generateServerId();
+
+    // Find existing session for the same server to reuse its session ID
+    const existingSessions = await sessions.list(this.userId);
+    const duplicate = existingSessions.find(s =>
+      s.serverId === serverId || s.serverUrl === serverUrl
+    );
+
+    // Reuse the duplicate sessionId if present, otherwise generate a new one
+    const sessionId = duplicate ? duplicate.sessionId : await sessions.generateSessionId();
+
+    if (duplicate) {
+      // Disconnect any active in-memory client transport without deleting the database session
+      const existingClient = this.clients.get(duplicate.sessionId);
+      if (existingClient) {
+        await existingClient.disconnect();
+        this.clients.delete(duplicate.sessionId);
+      }
+    }
+
+    try {
+      const clientMetadata = await this.getResolvedClientMetadata();
+
+      // Create a new client instantiating the reused session ID (which preserves DCR credentials and tokens)
+      const client = new MCPClient({
+        userId: this.userId,
+        sessionId,
+        serverId,
+        serverName,
+        serverUrl,
+        callbackUrl,
+        transportType,
+        headers,
+        ...clientMetadata,
+      });
+
+      this.clients.set(sessionId, client);
+
+      client.onConnectionEvent((event) => {
+        this.emitConnectionEvent(event);
+      });
+
+      client.onObservabilityEvent((event) => {
+        this.sendEvent(event);
+      });
+
+      await client.connect();
+      await this.listPolicyFilteredTools(sessionId);
+
+      return { sessionId, success: true };
+    } catch (error) {
+      if (error instanceof UnauthorizedError) {
+        this.clients.delete(sessionId);
+        return { sessionId, success: true };
+      }
+
+      this.emitConnectionEvent({
+        type: 'error',
+        sessionId,
+        serverId,
+        error: error instanceof Error ? error.message : 'Connection failed',
+        errorType: 'connection',
+        timestamp: Date.now(),
+      });
+
+      this.clients.delete(sessionId);
+      throw error;
+    }
+  }
+
   /**
    * Disconnect from an MCP server
    */
@@ -422,6 +508,22 @@ export class SSEConnectionManager {
     return client;
   }
 
+  /**
+   * Fetches all tools from the remote MCP server and emits a `tools_discovered` event.
+   *
+   * Two lists are always published together:
+   * - `tools`    — policy-filtered list that agents are allowed to call.
+   * - `allTools` — the complete, unfiltered list used by the management UI so
+   *                that blocked tools still appear as checkboxes in the dialog.
+   *
+   * `fetchTools()` is called first (populates the in-memory cache), then
+   * `gateway.listTools()` re-uses that cache internally — so only one remote
+   * network round-trip is made regardless of how many callers follow.
+   *
+   * @param sessionId - The session whose tools should be discovered.
+   * @returns The session record and the policy-filtered tool list.
+   * @throws {Error} When the session does not exist in the store.
+   */
   private async listPolicyFilteredTools(sessionId: string): Promise<{ session: Session; result: ListToolsRpcResult }> {
     const session = await sessions.get(this.userId, sessionId);
     if (!session) {
@@ -429,6 +531,7 @@ export class SSEConnectionManager {
     }
 
     const client = await this.getOrCreateClient(sessionId);
+    const allTools = await client.fetchTools().catch(() => ({ tools: [] }));
     const gateway = createToolPolicyGateway(this.userId, sessionId, client);
     const result = await gateway.listTools();
 
@@ -438,13 +541,17 @@ export class SSEConnectionManager {
       serverId: session.serverId ?? 'unknown',
       toolCount: result.tools.length,
       tools: result.tools,
+      allTools: allTools.tools,
       timestamp: Date.now(),
     });
 
     return { session, result };
   }
+
   /**
-   * List tools from a session
+   * Returns the policy-filtered tool list for a session (agent-facing).
+   * Internally re-uses `listPolicyFilteredTools` which also emits a
+   * `tools_discovered` SSE event to keep client state up to date.
    */
   private async listTools(params: SessionParams): Promise<ListToolsRpcResult> {
     const { sessionId } = params;
@@ -485,7 +592,15 @@ export class SSEConnectionManager {
   }
 
   /**
-   * Update per-session tool access policy.
+   * Persists a new tool access policy for a session and broadcasts the updated
+   * filtered tool list to all connected browser clients via a `tools_discovered` event.
+   *
+   * Both `tools` (policy-filtered) and `allTools` (complete list) are emitted
+   * so the management UI can immediately reflect the new checkbox states without
+   * an additional round-trip to the server.
+   *
+   * @param params - Session ID and the new `{ mode, toolIds }` policy to apply.
+   * @throws {Error} When the session does not exist or the policy references unknown tool IDs.
    */
   private async setToolPolicy(params: SetToolPolicyParams): Promise<SetToolPolicyResult> {
     const { sessionId } = params;
@@ -508,6 +623,7 @@ export class SSEConnectionManager {
       serverId: session.serverId ?? 'unknown',
       toolCount: filteredTools.length,
       tools: filteredTools,
+      allTools: allTools.tools,
       timestamp: Date.now(),
     });
 
@@ -518,8 +634,10 @@ export class SSEConnectionManager {
       toolCount: filteredTools.length,
     };
   }
+
   /**
-   * Call a tool on the MCP server
+   * Proxies a tool invocation to the remote MCP server.
+   * Resolves the client for the given session and delegates to the tool router.
    */
   private async callTool(params: CallToolParams): Promise<CallToolResult> {
     const { sessionId, toolName, toolArgs } = params;

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

@@ -509,13 +509,20 @@ export class MCPClient {
   }
 
   /**
-   * Connects to the MCP server
-   * Automatically validates and refreshes OAuth tokens if needed
-   * Saves session to Redis on first successful connection
-   * @throws {UnauthorizedError} When OAuth authorization is required
-   * @throws {Error} When connection fails for other reasons
+   * Connects to the MCP server.
+   *
+   * Automatically validates and refreshes OAuth tokens if needed.
+   * Saves the session to Redis on first successful connection.
+   *
+   * The in-memory tools cache (`cachedTools`) is cleared at the start of every
+   * call so that a reconnection always fetches a fresh tool list from the remote
+   * server — even if the same `MCPClient` instance is reused.
+   *
+   * @throws {UnauthorizedError} When OAuth authorization is required.
+   * @throws {Error} When connection fails for other reasons.
    */
   async connect(): Promise<void> {
+    this.cachedTools = null;
     // Close any existing transport so we can negotiate a fresh session.
     // The SDK Client throws if asked to connect() while a transport is
     // already attached; close() detaches it cleanly so the same Client
@@ -782,18 +789,41 @@ export class MCPClient {
   }
 
   /**
-   * Lists all available tools from the connected MCP server without emitting discovery events.
-   * Gateways use this to apply policy before publishing tools to agents or UI state.
+   * In-memory cache for the remote server's full tools list.
+   *
+   * Populated on the first `fetchTools()` call and reused for the lifetime of
+   * the connection. Cleared to `null` at the start of `connect()` so that a
+   * reconnect always retrieves a fresh list, and also in `dispose()` to release
+   * the memory when the client is no longer needed.
+   */
+  private cachedTools: ListToolsResult | null = null;
+
+  /**
+   * Lists all available tools from the connected MCP server without emitting
+   * discovery events. The result is cached in memory for the lifetime of the
+   * connection — subsequent callers (e.g. `gateway.listTools()` running right
+   * after `fetchTools()`) pay zero extra network cost.
+   *
+   * Gateways use this to apply a tool-access policy before publishing the
+   * filtered list to agents or UI state.
+   *
+   * @returns The full `ListToolsResult` from the remote server.
+   * @throws {Error} When the client is not connected or the request times out.
    */
   async fetchTools(): Promise<ListToolsResult> {
+    if (this.cachedTools) {
+      return this.cachedTools;
+    }
     const request: ListToolsRequest = {
       method: 'tools/list',
       params: {},
     };
 
-    return await this.withRetry(() =>
+    const result = await this.withRetry(() =>
       this.client!.request(request, ListToolsResultSchema)
     );
+    this.cachedTools = result;
+    return result;
   }
 
   /**
@@ -1119,10 +1149,14 @@ export class MCPClient {
   }
 
   /**
-   * Dispose of all event emitters
-   * Call this when the client is no longer needed
+   * Disposes all event emitters and releases cached state.
+   *
+   * Clears `cachedTools` to free memory, and disposes the connection and
+   * observability event emitters so downstream listeners are unsubscribed.
+   * Call this when the client is permanently shut down (not just disconnected).
    */
   dispose(): void {
+    this.cachedTools = null;
     this._onConnectionEvent.dispose();
     this._onObservabilityEvent.dispose();
   }
@@ -1177,14 +1211,4 @@ export class MCPClient {
   getSessionId(): string {
     return this.sessionId;
   }
-
 }
-
-
-
-
-
-
-
-
-