@mcp-ts/sdk 2.5.0 → 2.5.1

package/dist/index.mjs

@@ -3458,6 +3458,9 @@ var SSEConnectionManager = class {
         case "connect":
           result = await this.connect(request.params);
           break;
+        case "reconnect":
+          result = await this.reconnect(request.params);
+          break;
         case "disconnect":
           result = await this.disconnect(request.params);
           break;
@@ -3600,6 +3603,66 @@ var SSEConnectionManager = class {
       throw error;
     }
   }
+  /**
+   * 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.
+   */
+  async reconnect(params) {
+    const { serverId: rawServerId, serverName, serverUrl, callbackUrl, transportType } = params;
+    const headers = normalizeHeaders(params.headers);
+    const serverId = rawServerId && rawServerId.length <= 12 ? rawServerId : generateServerId();
+    const existingSessions = await sessions.list(this.userId);
+    const duplicate = existingSessions.find(
+      (s) => s.serverId === serverId || s.serverUrl === serverUrl
+    );
+    const sessionId = duplicate ? duplicate.sessionId : await sessions.generateSessionId();
+    if (duplicate) {
+      const existingClient = this.clients.get(duplicate.sessionId);
+      if (existingClient) {
+        await existingClient.disconnect();
+        this.clients.delete(duplicate.sessionId);
+      }
+    }
+    try {
+      const clientMetadata = await this.getResolvedClientMetadata();
+      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
    */
@@ -4127,6 +4190,9 @@ var SSEClient = class {
   async disconnectFromServer(sessionId) {
     return this.sendRequest("disconnect", { sessionId });
   }
+  async reconnectToServer(params) {
+    return this.sendRequest("reconnect", params);
+  }
   async setToolPolicy(sessionId, toolPolicy) {
     return this.sendRequest("setToolPolicy", { sessionId, toolPolicy });
   }