@ai-sdk/mcp 2.0.4 → 2.0.5

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # @ai-sdk/mcp
 
+## 2.0.5
+
+### Patch Changes
+
+- 8c616f0: feat(mcp): add maxRetries option for failed mcp tool calls
+- Updated dependencies [8c616f0]
+  - @ai-sdk/provider-utils@5.0.3
+
 ## 2.0.4
 
 ### Patch Changes

package/dist/index.d.ts

@@ -600,6 +600,15 @@ 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

package/dist/index.js

@@ -3,6 +3,7 @@ import {
   asSchema,
   dynamicTool,
   jsonSchema,
+  retryWithExponentialBackoff,
   safeParseJSON,
   safeValidateTypes,
   tool
@@ -2042,6 +2043,55 @@ async function readMCPAppResource({
 
 // src/tool/mcp-client.ts
 var CLIENT_VERSION = "1.0.0";
+var DEFAULT_MAX_TOOL_CALL_RETRIES = 0;
+var DEFAULT_RETRY_ERROR_CODES = [
+  "ConnectionRefused",
+  "ConnectionClosed",
+  "FailedToOpenSocket",
+  "ECONNRESET",
+  "ECONNREFUSED",
+  "ETIMEDOUT",
+  "EPIPE"
+];
+function getErrorStatusCode(error) {
+  if (error != null && typeof error === "object" && "statusCode" in error && typeof error.statusCode === "number") {
+    return error.statusCode;
+  }
+  return void 0;
+}
+function getStringErrorCode(error) {
+  if (error != null && typeof error === "object" && "code" in error && typeof error.code === "string") {
+    return error.code;
+  }
+  return void 0;
+}
+function isRetryableMCPToolCallError(error) {
+  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) {
+  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
 }) {
@@ -2078,6 +2128,7 @@ var DefaultMCPClient = class {
     clientName = name3 != null ? name3 : "ai-sdk-mcp-client",
     version = CLIENT_VERSION,
     onUncaughtError,
+    maxRetries,
     capabilities,
     initialInitializeResult
   }) {
@@ -2092,6 +2143,7 @@ var DefaultMCPClient = class {
     };
     this.isClosed = true;
     this.onUncaughtError = onUncaughtError;
+    this.maxRetries = prepareMaxRetries(maxRetries);
     this.clientCapabilities = capabilities != null ? capabilities : {};
     this.initialInitializeResult = initialInitializeResult;
     if (isCustomMcpTransport(transportConfig)) {
@@ -2295,16 +2347,39 @@ var DefaultMCPClient = class {
       options
     });
   }
+  async callToolWithRetry({
+    options,
+    execute
+  }) {
+    if (this.maxRetries === 0) {
+      return execute();
+    }
+    return retryWithExponentialBackoff({
+      maxRetries: this.maxRetries,
+      abortSignal: options == null ? void 0 : options.signal,
+      shouldRetry: isRetryableMCPToolCallError,
+      createRetryError: ({ message, errors }) => new MCPClientError({
+        message,
+        cause: errors[errors.length - 1]
+      })
+    })(execute);
+  }
   async callTool({
     name: name3,
     arguments: args = {},
     options
   }) {
     try {
-      return this.request({
-        request: { method: "tools/call", params: { name: name3, arguments: args } },
-        resultSchema: CallToolResultSchema,
-        options
+      return this.callToolWithRetry({
+        options,
+        execute: () => this.request({
+          request: {
+            method: "tools/call",
+            params: { name: name3, arguments: args }
+          },
+          resultSchema: CallToolResultSchema,
+          options
+        })
       });
     } catch (error) {
       throw error;