@ai-sdk/mcp 2.0.7 → 2.0.8

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # @ai-sdk/mcp
 
+## 2.0.8
+
+### Patch Changes
+
+- 3e6e955: Reject in-flight MCP requests when their abort signal fires and remove the pending response handler.
+- eebd14b: Prevent streamable HTTP MCP background SSE disconnects from surfacing as unhandled promise rejections.
+
 ## 2.0.7
 
 ### Patch Changes

package/dist/index.js

@@ -1635,7 +1635,7 @@ var HttpMCPTransport = class {
       });
     }
     this.abortController = new AbortController();
-    void this.openInboundSse();
+    this.startInboundSse();
   }
   async close() {
     var _a3, _b3, _c;
@@ -1693,7 +1693,7 @@ var HttpMCPTransport = class {
         }
         if (response.status === 202) {
           if (!this.inboundSseConnection) {
-            void this.openInboundSse();
+            this.startInboundSse();
           }
           return;
         }
@@ -1769,7 +1769,13 @@ var HttpMCPTransport = class {
               (_c2 = this.onerror) == null ? void 0 : _c2.call(this, error2);
             }
           };
-          processEvents();
+          void processEvents().catch((error2) => {
+            var _a4;
+            if (error2 instanceof Error && error2.name === "AbortError") {
+              return;
+            }
+            (_a4 = this.onerror) == null ? void 0 : _a4.call(this, error2);
+          });
           return;
         }
         const error = new MCPClientError({
@@ -1811,12 +1817,21 @@ var HttpMCPTransport = class {
     }
     const delay = this.getNextReconnectionDelay(this.inboundReconnectAttempts);
     this.inboundReconnectAttempts += 1;
-    setTimeout(async () => {
+    setTimeout(() => {
       var _a4;
       if ((_a4 = this.abortController) == null ? void 0 : _a4.signal.aborted) return;
-      await this.openInboundSse(false, this.lastInboundEventId);
+      this.startInboundSse(false, this.lastInboundEventId);
     }, delay);
   }
+  startInboundSse(triedAuth = false, resumeToken) {
+    void this.openInboundSse(triedAuth, resumeToken).catch((error) => {
+      var _a3;
+      if (error instanceof Error && error.name === "AbortError") {
+        return;
+      }
+      (_a3 = this.onerror) == null ? void 0 : _a3.call(this, error);
+    });
+  }
   // Open optional inbound SSE stream; best-effort and resumable
   async openInboundSse(triedAuth = false, resumeToken) {
     var _a3, _b3, _c, _d, _e, _f;
@@ -1903,10 +1918,27 @@ var HttpMCPTransport = class {
         }
       };
       this.inboundSseConnection = {
-        close: () => reader.cancel()
+        close: () => {
+          void reader.cancel().catch((error) => {
+            var _a4;
+            if (error instanceof Error && error.name === "AbortError") {
+              return;
+            }
+            (_a4 = this.onerror) == null ? void 0 : _a4.call(this, error);
+          });
+        }
       };
       this.inboundReconnectAttempts = 0;
-      processEvents();
+      void processEvents().catch((error) => {
+        var _a4, _b4;
+        if (error instanceof Error && error.name === "AbortError") {
+          return;
+        }
+        (_a4 = this.onerror) == null ? void 0 : _a4.call(this, error);
+        if (!((_b4 = this.abortController) == null ? void 0 : _b4.signal.aborted)) {
+          this.scheduleInboundSseReconnection();
+        }
+      });
     } catch (error) {
       if (error instanceof Error && error.name === "AbortError") {
         return;
@@ -2306,35 +2338,49 @@ var DefaultMCPClient = class {
         jsonrpc: "2.0",
         id: messageId
       };
+      const rejectWithAbortError = () => {
+        reject(
+          new MCPClientError({
+            message: "Request was aborted",
+            cause: signal == null ? void 0 : signal.reason
+          })
+        );
+      };
       const cleanup = () => {
         this.responseHandlers.delete(messageId);
+        signal == null ? void 0 : signal.removeEventListener("abort", onAbort);
+      };
+      const rejectAndCleanup = (error) => {
+        cleanup();
+        reject(error);
+      };
+      const onAbort = () => {
+        cleanup();
+        rejectWithAbortError();
       };
       this.responseHandlers.set(messageId, (response) => {
         if (signal == null ? void 0 : signal.aborted) {
-          return reject(
-            new MCPClientError({
-              message: "Request was aborted",
-              cause: signal.reason
-            })
-          );
+          cleanup();
+          return rejectWithAbortError();
         }
         if (response instanceof Error) {
-          return reject(response);
+          return rejectAndCleanup(response);
         }
         try {
           const result = resultSchema.parse(response.result);
+          cleanup();
           resolve(result);
         } catch (error) {
           const parseError = new MCPClientError({
             message: "Failed to parse server response",
             cause: error
           });
-          reject(parseError);
+          rejectAndCleanup(parseError);
         }
       });
+      signal == null ? void 0 : signal.addEventListener("abort", onAbort, { once: true });
       this.transport.send(jsonrpcRequest).catch((error) => {
-        cleanup();
-        reject(error);
+        rejectAndCleanup(error);
       });
     });
   }