@ai-sdk/mcp 2.0.6 → 2.0.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/mcp",
-  "version": "2.0.6",
+  "version": "2.0.8",
   "type": "module",
   "license": "Apache-2.0",
   "sideEffects": false,
@@ -32,8 +32,8 @@
   },
   "dependencies": {
     "pkce-challenge": "^5.0.1",
-    "@ai-sdk/provider": "4.0.1",
-    "@ai-sdk/provider-utils": "5.0.4"
+    "@ai-sdk/provider": "4.0.2",
+    "@ai-sdk/provider-utils": "5.0.5"
   },
   "devDependencies": {
     "@types/node": "22.19.19",

package/src/tool/mcp-client.ts

@@ -556,39 +556,57 @@ class DefaultMCPClient implements MCPClient {
         id: messageId,
       };
 
+      const rejectWithAbortError = () => {
+        reject(
+          new MCPClientError({
+            message: 'Request was aborted',
+            cause: signal?.reason,
+          }),
+        );
+      };
+
       const cleanup = () => {
         this.responseHandlers.delete(messageId);
+        signal?.removeEventListener('abort', onAbort);
+      };
+
+      const rejectAndCleanup = (error: unknown) => {
+        cleanup();
+        reject(error);
+      };
+
+      const onAbort = () => {
+        cleanup();
+        rejectWithAbortError();
       };
 
       this.responseHandlers.set(messageId, response => {
         if (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?.addEventListener('abort', onAbort, { once: true });
+
       this.transport.send(jsonrpcRequest).catch(error => {
-        cleanup();
-        reject(error);
+        rejectAndCleanup(error);
       });
     });
   }

package/src/tool/mcp-http-transport.ts

@@ -186,7 +186,7 @@ export class HttpMCPTransport implements MCPTransport {
     }
     this.abortController = new AbortController();
 
-    void this.openInboundSse();
+    this.startInboundSse();
   }
 
   async close(): Promise<void> {
@@ -260,7 +260,7 @@ export class HttpMCPTransport implements MCPTransport {
           // If inbound SSE was not available earlier (e.g. 405 before init), try again now
           // Do not await to avoid blocking send()
           if (!this.inboundSseConnection) {
-            void this.openInboundSse();
+            this.startInboundSse();
           }
           return;
         }
@@ -355,7 +355,12 @@ export class HttpMCPTransport implements MCPTransport {
             }
           };
 
-          processEvents();
+          void processEvents().catch(error => {
+            if (error instanceof Error && error.name === 'AbortError') {
+              return;
+            }
+            this.onerror?.(error);
+          });
           return;
         }
 
@@ -400,12 +405,24 @@ export class HttpMCPTransport implements MCPTransport {
 
     const delay = this.getNextReconnectionDelay(this.inboundReconnectAttempts);
     this.inboundReconnectAttempts += 1;
-    setTimeout(async () => {
+    setTimeout(() => {
       if (this.abortController?.signal.aborted) return;
-      await this.openInboundSse(false, this.lastInboundEventId);
+      this.startInboundSse(false, this.lastInboundEventId);
     }, delay);
   }
 
+  private startInboundSse(
+    triedAuth: boolean = false,
+    resumeToken?: string,
+  ): void {
+    void this.openInboundSse(triedAuth, resumeToken).catch(error => {
+      if (error instanceof Error && error.name === 'AbortError') {
+        return;
+      }
+      this.onerror?.(error);
+    });
+  }
+
   // Open optional inbound SSE stream; best-effort and resumable
   private async openInboundSse(
     triedAuth: boolean = false,
@@ -510,10 +527,25 @@ export class HttpMCPTransport implements MCPTransport {
       };
 
       this.inboundSseConnection = {
-        close: () => reader.cancel(),
+        close: () => {
+          void reader.cancel().catch(error => {
+            if (error instanceof Error && error.name === 'AbortError') {
+              return;
+            }
+            this.onerror?.(error);
+          });
+        },
       };
       this.inboundReconnectAttempts = 0;
-      processEvents();
+      void processEvents().catch(error => {
+        if (error instanceof Error && error.name === 'AbortError') {
+          return;
+        }
+        this.onerror?.(error);
+        if (!this.abortController?.signal.aborted) {
+          this.scheduleInboundSseReconnection();
+        }
+      });
     } catch (error) {
       if (error instanceof Error && error.name === 'AbortError') {
         return;