@ai-sdk/mcp 2.0.3 → 2.0.5

package/package.json

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

package/src/tool/mcp-client.ts

@@ -3,6 +3,7 @@ import {
   asSchema,
   dynamicTool,
   jsonSchema,
+  retryWithExponentialBackoff,
   safeParseJSON,
   safeValidateTypes,
   tool,
@@ -66,6 +67,82 @@ import {
   type InitializeResult,
 } from './types';
 const CLIENT_VERSION = '1.0.0';
+const DEFAULT_MAX_TOOL_CALL_RETRIES = 0;
+
+const DEFAULT_RETRY_ERROR_CODES = [
+  'ConnectionRefused',
+  'ConnectionClosed',
+  'FailedToOpenSocket',
+  'ECONNRESET',
+  'ECONNREFUSED',
+  'ETIMEDOUT',
+  'EPIPE',
+];
+
+function getErrorStatusCode(error: unknown): number | undefined {
+  if (
+    error != null &&
+    typeof error === 'object' &&
+    'statusCode' in error &&
+    typeof error.statusCode === 'number'
+  ) {
+    return error.statusCode;
+  }
+
+  return undefined;
+}
+
+function getStringErrorCode(error: unknown): string | undefined {
+  if (
+    error != null &&
+    typeof error === 'object' &&
+    'code' in error &&
+    typeof error.code === 'string'
+  ) {
+    return error.code;
+  }
+
+  return undefined;
+}
+
+function isRetryableMCPToolCallError(error: unknown): boolean {
+  const statusCode = getErrorStatusCode(error);
+  if (statusCode != null) {
+    return (
+      statusCode === 408 ||
+      statusCode === 409 ||
+      statusCode === 429 ||
+      statusCode >= 500
+    );
+  }
+
+  if (MCPClientError.isInstance(error) && error.code != null) {
+    return false;
+  }
+
+  const errorCode = getStringErrorCode(error);
+  return errorCode != null && DEFAULT_RETRY_ERROR_CODES.includes(errorCode);
+}
+
+function prepareMaxRetries(maxRetries: number | undefined): number {
+  if (maxRetries == null) {
+    return DEFAULT_MAX_TOOL_CALL_RETRIES;
+  }
+
+  if (!Number.isInteger(maxRetries)) {
+    throw new MCPClientError({
+      message: 'maxRetries must be an integer',
+    });
+  }
+
+  if (maxRetries < 0) {
+    throw new MCPClientError({
+      message: 'maxRetries must be >= 0',
+    });
+  }
+
+  return maxRetries;
+}
 
 function mcpToModelOutput({
   output,
@@ -104,6 +181,15 @@ export interface MCPClientConfig {
   transport: MCPTransportConfig | MCPTransport;
   /** Optional callback for uncaught errors */
   onUncaughtError?: (error: unknown) => void;
+  /**
+   * Maximum number of retries for transient MCP tool call failures.
+   *
+   * Set to 0 to disable retries. Retries only apply to tools/call requests.
+   * JSON-RPC application errors, such as invalid params, are not retried.
+   *
+   * @default 0
+   */
+  maxRetries?: number;
   /**
    * Initialize result from a previous MCP session. When provided, the client
    * starts the transport and reuses this metadata without sending a new
@@ -248,6 +334,7 @@ export interface MCPClient {
 class DefaultMCPClient implements MCPClient {
   private transport: MCPTransport;
   private onUncaughtError?: (error: unknown) => void;
+  private maxRetries: number;
   private clientInfo: ClientConfiguration;
   private clientCapabilities: ClientCapabilities;
   private initialInitializeResult?: InitializeResult;
@@ -275,10 +362,12 @@ class DefaultMCPClient implements MCPClient {
     clientName = name ?? 'ai-sdk-mcp-client',
     version = CLIENT_VERSION,
     onUncaughtError,
+    maxRetries,
     capabilities,
     initialInitializeResult,
   }: MCPClientConfig) {
     this.onUncaughtError = onUncaughtError;
+    this.maxRetries = prepareMaxRetries(maxRetries);
     this.clientCapabilities = capabilities ?? {};
     this.initialInitializeResult = initialInitializeResult;
 
@@ -518,6 +607,29 @@ class DefaultMCPClient implements MCPClient {
     });
   }
 
+  private async callToolWithRetry({
+    options,
+    execute,
+  }: {
+    options?: RequestOptions;
+    execute: () => Promise<CallToolResult>;
+  }): Promise<CallToolResult> {
+    if (this.maxRetries === 0) {
+      return execute();
+    }
+
+    return retryWithExponentialBackoff({
+      maxRetries: this.maxRetries,
+      abortSignal: options?.signal,
+      shouldRetry: isRetryableMCPToolCallError,
+      createRetryError: ({ message, errors }) =>
+        new MCPClientError({
+          message,
+          cause: errors[errors.length - 1],
+        }),
+    })(execute);
+  }
+
   async callTool({
     name,
     arguments: args = {},
@@ -528,10 +640,17 @@ class DefaultMCPClient implements MCPClient {
     options?: RequestOptions;
   }): Promise<CallToolResult> {
     try {
-      return this.request({
-        request: { method: 'tools/call', params: { name, arguments: args } },
-        resultSchema: CallToolResultSchema,
+      return this.callToolWithRetry({
         options,
+        execute: () =>
+          this.request({
+            request: {
+              method: 'tools/call',
+              params: { name, arguments: args },
+            },
+            resultSchema: CallToolResultSchema,
+            options,
+          }),
       });
     } catch (error) {
       throw error;