@mcp-ts/sdk 1.5.0 → 1.5.1

package/dist/server/index.mjs

@@ -1645,13 +1645,8 @@ var MCPClient = class _MCPClient {
       this.transportType = transportType;
       this.emitStateChange("CONNECTED");
       this.emitProgress("Connected successfully");
-      const existingSession = await storage.getSession(this.identity, this.sessionId);
-      const needsTransportUpdate = !existingSession || existingSession.transportType !== this.transportType;
-      const needsTtlPromotion = !existingSession || existingSession.active !== true;
-      if (needsTransportUpdate || needsTtlPromotion) {
-        console.log(`[MCPClient] Saving session ${this.sessionId} with 12hr TTL (connect success)`);
-        await this.saveSession(SESSION_TTL_SECONDS, true);
-      }
+      console.log(`[MCPClient] Saving session ${this.sessionId} with 12hr TTL (connect success)`);
+      await this.saveSession(SESSION_TTL_SECONDS, true);
     } catch (error) {
       if (error instanceof UnauthorizedError$1 || error instanceof Error && error.message.toLowerCase().includes("unauthorized")) {
         let authUrl = "";
@@ -1689,6 +1684,13 @@ var MCPClient = class _MCPClient {
       const errorMessage = error instanceof Error ? error.message : "Connection failed";
       this.emitError(errorMessage, "connection");
       this.emitStateChange("FAILED");
+      try {
+        const existingSession = await storage.getSession(this.identity, this.sessionId);
+        if (!existingSession || existingSession.active !== true) {
+          await storage.removeSession(this.identity, this.sessionId);
+        }
+      } catch {
+      }
       throw error;
     }
   }
@@ -1712,6 +1714,7 @@ var MCPClient = class _MCPClient {
     const transportsToTry = this.transportType ? [this.transportType] : ["streamable_http", "sse"];
     let lastError;
     let tokensExchanged = false;
+    let authenticatedStateEmitted = false;
     for (const currentType of transportsToTry) {
       const isLastAttempt = currentType === transportsToTry[transportsToTry.length - 1];
       try {
@@ -1723,8 +1726,10 @@ var MCPClient = class _MCPClient {
         } else {
           this.emitProgress(`Tokens already exchanged, skipping auth step for ${currentType}...`);
         }
-        this.transportType = currentType;
-        this.emitStateChange("AUTHENTICATED");
+        if (!authenticatedStateEmitted) {
+          this.emitStateChange("AUTHENTICATED");
+          authenticatedStateEmitted = true;
+        }
         this.emitProgress("Creating authenticated client...");
         this.client = new Client(
           {
@@ -1743,6 +1748,7 @@ var MCPClient = class _MCPClient {
         );
         this.emitStateChange("CONNECTING");
         await this.client.connect(this.transport);
+        this.transportType = currentType;
         this.emitStateChange("CONNECTED");
         console.log(`[MCPClient] Updating session ${this.sessionId} to 12hr TTL (OAuth complete)`);
         await this.saveSession(SESSION_TTL_SECONDS, true);
@@ -2609,9 +2615,23 @@ var SSEConnectionManager = class {
     if (existing) {
       return existing;
     }
+    const session = await storage.getSession(this.identity, sessionId);
+    if (!session) {
+      throw new Error("Session not found");
+    }
     const client = new MCPClient({
       identity: this.identity,
-      sessionId
+      sessionId,
+      // These fields are optional in MCPClient, but when rehydrating a known
+      // stored session on the server we pass them explicitly to preserve the
+      // original transport/connection metadata instead of relying on lazy
+      // reloading during initialize().
+      serverId: session.serverId,
+      serverName: session.serverName,
+      serverUrl: session.serverUrl,
+      callbackUrl: session.callbackUrl,
+      transportType: session.transportType,
+      headers: session.headers
     });
     client.onConnectionEvent((event) => this.emitConnectionEvent(event));
     client.onObservabilityEvent((event) => this.sendEvent(event));
@@ -2668,6 +2688,16 @@ var SSEConnectionManager = class {
       const client = new MCPClient({
         identity: this.identity,
         sessionId,
+        // These fields are optional in MCPClient, but when rehydrating a known
+        // stored session on the server we pass them explicitly to preserve the
+        // original transport/connection metadata instead of relying on lazy
+        // reloading during initialize().
+        serverId: session.serverId,
+        serverName: session.serverName,
+        serverUrl: session.serverUrl,
+        callbackUrl: session.callbackUrl,
+        transportType: session.transportType,
+        headers: session.headers,
         ...clientMetadata
       });
       client.onConnectionEvent((event) => this.emitConnectionEvent(event));
@@ -2700,7 +2730,21 @@ var SSEConnectionManager = class {
     try {
       const client = new MCPClient({
         identity: this.identity,
-        sessionId
+        sessionId,
+        // These fields are optional in MCPClient, but when rehydrating a known
+        // stored session on the server we pass them explicitly to preserve the
+        // original connection metadata instead of relying on lazy
+        // reloading during initialize().
+        serverId: session.serverId,
+        serverName: session.serverName,
+        serverUrl: session.serverUrl,
+        callbackUrl: session.callbackUrl,
+        // NOTE: transportType is intentionally omitted here.
+        // The session's stored transportType is a placeholder ('streamable_http')
+        // set before transport negotiation. Omitting it lets MCPClient auto-negotiate
+        // (try streamable_http → SSE fallback), which is critical for servers like
+        // Neon that only support SSE transport.
+        headers: session.headers
       });
       client.onConnectionEvent((event) => this.emitConnectionEvent(event));
       await client.finishAuth(code);