@ai-sdk/mcp 2.0.72 → 2.0.73

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/mcp",
-  "version": "2.0.72",
+  "version": "2.0.73",
   "type": "module",
   "license": "Apache-2.0",
   "sideEffects": false,

package/src/index.ts

@@ -48,7 +48,8 @@ export {
 export { MCPClientError } from './error/mcp-client-error';
 export type { ManagedMCPClient as Experimental_ManagedMCPClient } from './tool/mcp-client';
 export type {
-  MCPEventsAdapter as Experimental_MCPEventsAdapter,
+  MCPEventOperations as Experimental_MCPEventOperations,
+  MCPEventAdapter as Experimental_MCPEventAdapter,
   ManagedSubscribeInput as Experimental_ManagedSubscribeInput,
   ManagedSubscription as Experimental_ManagedSubscription,
   ManagedMCPEvents as Experimental_ManagedMCPEvents,

package/src/tool/mcp-client.ts

@@ -16,8 +16,9 @@ import type { z } from 'zod/v4';
 import { createMCPEvents } from './mcp-events';
 import {
   createManagedMCPEvents,
+  validateMCPEventOperations,
   type ManagedMCPEvents,
-  type MCPEventsAdapter,
+  type MCPEventAdapter,
 } from './mcp-events-adapter';
 import type { MCPEvents, MCPEventsConfig } from './mcp-event-types';
 import { MCPClientError } from '../error/mcp-client-error';
@@ -301,7 +302,9 @@ export type ManagedMCPClient = Omit<MCPClient, 'experimental_events'> & {
 
 export function createMCPClient(
   config: MCPClientConfig & {
-    experimental_events: { adapter: MCPEventsAdapter };
+    experimental_events: {
+      adapter: MCPEventAdapter;
+    };
   },
 ): Promise<ManagedMCPClient>;
 export function createMCPClient(
@@ -486,6 +489,24 @@ class DefaultMCPClient implements Omit<MCPClient, 'experimental_events'> {
           'Configure experimental_events with either an adapter or a store, not both. Managed adapters own argument validation.',
       });
     }
+    if (
+      events?.adapter !== undefined &&
+      typeof events.adapter?.createAdapter !== 'function'
+    ) {
+      throw new MCPClientError({
+        message:
+          'experimental_events.adapter must implement createAdapter. Wrap bound operations with { createAdapter: () => operations }.',
+      });
+    }
+    const operations = events?.adapter?.createAdapter({
+      transport: isCustomMcpTransport(transportConfig)
+        ? { type: 'custom' }
+        : { type: transportConfig.type, url: transportConfig.url },
+    });
+    if (events?.adapter !== undefined) {
+      validateMCPEventOperations(operations);
+    }
+
     this.onUncaughtError = onUncaughtError;
     this.maxRetries = prepareMaxRetries(maxRetries);
     this.clientCapabilities = capabilities ?? {};
@@ -527,8 +548,8 @@ class DefaultMCPClient implements Omit<MCPClient, 'experimental_events'> {
       store: events?.store,
       validateArguments: events?.validateArguments,
     });
-    this.experimental_events = events?.adapter
-      ? createManagedMCPEvents(events.adapter, directEvents.list)
+    this.experimental_events = operations
+      ? createManagedMCPEvents(operations, directEvents.list)
       : directEvents;
   }
 

package/src/tool/mcp-event-types.ts

@@ -1,5 +1,5 @@
 import type { JSONObject } from '@ai-sdk/provider';
-import type { MCPEventsAdapter } from './mcp-events-adapter';
+import type { MCPEventAdapter } from './mcp-events-adapter';
 import { z } from 'zod/v4';
 import { ResultSchema, type RequestOptions } from './types';
 
@@ -112,7 +112,7 @@ export type MCPEventsConfig =
       }) => void | PromiseLike<void>;
     }
   | {
-      adapter: MCPEventsAdapter;
+      adapter: MCPEventAdapter;
       store?: never;
       validateArguments?: never;
     };

package/src/tool/mcp-events-adapter.ts

@@ -1,4 +1,5 @@
 import type { JSONObject } from '@ai-sdk/provider';
+import { MCPClientError } from '../error/mcp-client-error';
 import type { MCPEvents } from './mcp-event-types';
 import type { RequestOptions } from './types';
 
@@ -39,7 +40,7 @@ export type ManagedSubscribeInput = {
  * Implementations must honor request options and preserve actionable errors.
  * Cancelling a request does not cancel an already accepted remote subscription.
  */
-export interface MCPEventsAdapter {
+export interface MCPEventOperations {
   subscribe(input: ManagedSubscribeInput): Promise<ManagedSubscription>;
 
   getSubscription(input: {
@@ -63,20 +64,69 @@ export interface MCPEventsAdapter {
   }): Promise<ManagedSubscription>;
 }
 
+/**
+ * Creates bound subscription operations once per client, before the transport starts.
+ * Receives transport metadata, not credentials or a live transport instance.
+ * HTTP/SSE URLs are the configured endpoints, not resolved redirect targets.
+ * Custom transports have no standard URL and receive only their type.
+ */
+export interface MCPEventAdapter {
+  createAdapter(context: {
+    transport: { type: 'http' | 'sse'; url: string } | { type: 'custom' };
+  }): MCPEventOperations;
+}
+
+/** Validate JavaScript integrations before opening the MCP transport. */
+export function validateMCPEventOperations(
+  operations: unknown,
+): asserts operations is MCPEventOperations {
+  if (
+    operations != null &&
+    (typeof operations === 'object' || typeof operations === 'function') &&
+    'then' in operations &&
+    typeof operations.then === 'function'
+  ) {
+    // Consume a rejected async factory result so the configuration error does
+    // not also cause an unhandled rejection. Async factories are not supported.
+    void Promise.resolve(operations).catch(() => {});
+    throw new MCPClientError({
+      message:
+        'experimental_events.adapter.createAdapter() must return operations synchronously. Promise and thenable results are not supported.',
+    });
+  }
+  if (
+    typeof operations !== 'object' ||
+    operations === null ||
+    !('subscribe' in operations) ||
+    typeof operations.subscribe !== 'function' ||
+    !('getSubscription' in operations) ||
+    typeof operations.getSubscription !== 'function' ||
+    !('listSubscriptions' in operations) ||
+    typeof operations.listSubscriptions !== 'function' ||
+    !('unsubscribe' in operations) ||
+    typeof operations.unsubscribe !== 'function'
+  ) {
+    throw new MCPClientError({
+      message:
+        'experimental_events.adapter.createAdapter() must return an object implementing subscribe, getSubscription, listSubscriptions, and unsubscribe.',
+    });
+  }
+}
+
 /** Catalog discovery uses MCP; all subscription operations use the adapter. */
-export interface ManagedMCPEvents extends MCPEventsAdapter {
+export interface ManagedMCPEvents extends MCPEventOperations {
   list: MCPEvents['list'];
 }
 
 export function createManagedMCPEvents(
-  adapter: MCPEventsAdapter,
+  operations: MCPEventOperations,
   list: MCPEvents['list'],
 ): ManagedMCPEvents {
   return {
     list,
-    subscribe: input => adapter.subscribe(input),
-    getSubscription: input => adapter.getSubscription(input),
-    listSubscriptions: input => adapter.listSubscriptions(input),
-    unsubscribe: input => adapter.unsubscribe(input),
+    subscribe: input => operations.subscribe(input),
+    getSubscription: input => operations.getSubscription(input),
+    listSubscriptions: input => operations.listSubscriptions(input),
+    unsubscribe: input => operations.unsubscribe(input),
   };
 }