@zapier/zapier-sdk 0.103.0 → 0.104.0

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @zapier/zapier-sdk
 
+## 0.104.0
+
+### Minor Changes
+
+- 1ec9410: SDK HTTP requests now automatically retry HTTP 500, 502, 503, and 504 responses for idempotent methods; HTTP 429 responses continue to retry for any method. All retryable responses share the budget set by `maxNetworkRetries`, with exponential backoff capped by `maxNetworkRetryDelaySeconds`; set `maxNetworkRetries: 0` to disable retries. Callers that pass a custom `sendHttpRequest` transport to `createZapierApi` remain responsible for its retry behavior.
+
+### Patch Changes
+
+- Updated dependencies [1ec9410]
+- Updated dependencies [1ec9410]
+  - @zapier/kitcore@0.19.0
+
 ## 0.103.0
 
 ### Minor Changes

package/README.md

@@ -376,8 +376,8 @@ The `createZapierSdk(...)` factory function is the main entry point for the SDK.
 | `debug`                          | `boolean`                  | ❌       | —       | —                           | Enable debug logging.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
 | `baseUrl`                        | `string`                   | ❌       | —       | —                           | Base URL for Zapier API endpoints.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
 | `trackingBaseUrl`                | `string`                   | ❌       | —       | —                           | Base URL for Zapier tracking endpoints.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
-| `maxNetworkRetries`              | `number`                   | ❌       | —       | —                           | Max retries for rate-limited requests (default: 3).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
-| `maxNetworkRetryDelaySeconds`    | `number`                   | ❌       | —       | —                           | Max delay in seconds to wait for a rate-limit retry (default: 60).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
+| `maxNetworkRetries`              | `number`                   | ❌       | —       | —                           | Max retries for rate-limited and server-error responses (default: 3).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
+| `maxNetworkRetryDelaySeconds`    | `number`                   | ❌       | —       | —                           | Max delay in seconds to wait between network retries (default: 60).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
 | `maxConcurrentRequests`          | `number, literal`          | ❌       | —       | —                           | Max concurrent in-flight HTTP requests (default: 200, max: 10000).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
 | `approvalTimeoutSeconds`         | `number`                   | ❌       | —       | —                           | Timeout in seconds for approval polling. Default: 600 (10 min).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
 | `maxApprovalRetries`             | `number`                   | ❌       | —       | —                           | Maximum number of sequential approval rounds per request (one per gating policy) before giving up. Default: 2.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |

package/dist/{chunk-JJHKZ4XK.mjs → chunk-CJKNVBRZ.mjs}

@@ -1,6 +1,6 @@
 import { __require } from './chunk-Y6FXYEAI.mjs';
 import { z } from 'zod';
-import { withPositional, declareOptionalProperty, defineProperty, createDeprecationLogger, createAsyncContext, definePlugin, sendHttpRequestPlugin, declareProperty, defineMethod, coreOptionsPluginRef, createValidator, defineFormatter, declareMethod, defineResolver, concatLists, openEnum, defineHook, getRegistryPlugin, paginate, toSnakeCase, isCoreError, toTitleCase, createSdk, CORE_ERROR_SYMBOL, CoreErrorCode, CORE_SIGNAL_SYMBOL, isCoreSignal, CORE_OPTIONS_ID } from '@zapier/kitcore';
+import { withPositional, declareOptionalProperty, defineProperty, createDeprecationLogger, createAsyncContext, definePlugin, sendHttpRequestPlugin, retryHttpRequestPlugin, declareProperty, defineMethod, coreOptionsPluginRef, createValidator, defineFormatter, declareMethod, defineResolver, concatLists, openEnum, defineHook, getRegistryPlugin, paginate, toSnakeCase, isCoreError, toTitleCase, createSdk, RETRY_HTTP_REQUEST_OPTIONS_ID, CORE_ERROR_SYMBOL, CoreErrorCode, CORE_SIGNAL_SYMBOL, isCoreSignal, CORE_OPTIONS_ID } from '@zapier/kitcore';
 export { CONTEXT, CORE_ERROR_SYMBOL, CORE_OPTIONS_ID, CORE_SIGNAL_SYMBOL, CoreCancelledSignal, CoreDisposeError, CoreErrorCode, CoreSignal, addPlugin, composePlugins, createController, createCorePlugin, createFunction, createPaginatedFunction, createPaginatedPluginMethod, createPluginMethod, createPluginStack, createSdk, declareMethod, declareOptionalProperty, declarePlugin, declareProperty, defineFormatter, defineLegacyMerge, defineMethod, defineMethodOverride, defineOverride, definePlugin, defineProperty, defineResolver, disposeSdk, fromFunctionPlugin, getContext, getCoreErrorCause, getCoreErrorCode, getNegatable, getRegistryPlugin, isCoreCancelledSignal, isCoreError, isCoreSignal, isPositional, omitExports, resolvePlugin, runInMethodScope, runWithTelemetryContext, selectExports, toSnakeCase, toTitleCase } from '@zapier/kitcore';
 import { buildHttpRequestContext, buildActionRunContext } from '@zapier/policy-context';
 import { ListAppsQuerySchema, AppItemSchema as AppItemSchema$1 } from '@zapier/zapier-sdk-core/v0/schemas/apps';
@@ -705,7 +705,6 @@ function createDebugFetch(options) {
 // src/utils/retry-utils.ts
 var MAX_CONSECUTIVE_ERRORS = 3;
 var BASE_ERROR_BACKOFF_MILLISECONDS = 1e3;
-var BASE_EXPONENTIAL_BACKOFF_MILLISECONDS = 1e3;
 var JITTER_FACTOR = 0.5;
 function calculateErrorBackoffMs(baseInterval, errorCount) {
   const jitter = Math.random() * JITTER_FACTOR * baseInterval;
@@ -716,11 +715,6 @@ function calculateErrorBackoffMs(baseInterval, errorCount) {
   );
   return Math.floor(baseInterval + jitter + errorBackoff);
 }
-function calculateExponentialBackoffMs(attempt, baseDelayMs = BASE_EXPONENTIAL_BACKOFF_MILLISECONDS) {
-  const baseDelay = baseDelayMs * Math.pow(2, attempt - 1);
-  const jitter = Math.random() * JITTER_FACTOR * baseDelay;
-  return Math.floor(baseDelay + jitter);
-}
 function sleep(ms, signal) {
   if (!signal) {
     return new Promise((resolve2) => setTimeout(resolve2, ms));
@@ -1075,7 +1069,114 @@ var sdkOptionsPluginRef = declareOptionalProperty({
   id: SDK_OPTIONS_ID
 });
 
+// src/api/rate-limit.ts
+var EPOCH_THRESHOLD_SECONDS = 1e9;
+function parseRateLimitHeaders(response) {
+  const info = {};
+  const retryAfter = response.headers.get("retry-after");
+  if (retryAfter) {
+    const seconds = parseInt(retryAfter, 10);
+    if (!isNaN(seconds)) {
+      info.retryAfterMs = Math.max(0, seconds * 1e3);
+    } else {
+      const date = Date.parse(retryAfter);
+      if (!isNaN(date)) {
+        info.retryAfterMs = Math.max(0, date - Date.now());
+      }
+    }
+  }
+  const reset = response.headers.get("x-ratelimit-reset");
+  if (reset) {
+    const resetValue = parseInt(reset, 10);
+    if (!isNaN(resetValue)) {
+      const isEpoch = resetValue >= EPOCH_THRESHOLD_SECONDS;
+      info.resetMs = isEpoch ? resetValue * 1e3 : Date.now() + resetValue * 1e3;
+      if (info.retryAfterMs === void 0) {
+        info.retryAfterMs = isEpoch ? Math.max(0, info.resetMs - Date.now()) : Math.max(0, resetValue * 1e3);
+      }
+    }
+  }
+  const limit = response.headers.get("x-ratelimit-limit");
+  if (limit) {
+    const limitNum = parseInt(limit, 10);
+    if (!isNaN(limitNum)) {
+      info.limit = limitNum;
+    }
+  }
+  const remaining = response.headers.get("x-ratelimit-remaining");
+  if (remaining) {
+    const remainingNum = parseInt(remaining, 10);
+    if (!isNaN(remainingNum)) {
+      info.remaining = remainingNum;
+    }
+  }
+  return info;
+}
+
+// src/utils/type-guard-utils.ts
+function isPlainObject(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+function isPromiseLike(value) {
+  return (typeof value === "object" || typeof value === "function") && value !== null && "then" in value && typeof value.then === "function";
+}
+
+// src/plugins/transport/retry-events.ts
+var retryCounts = /* @__PURE__ */ new WeakMap();
+function retriesFor(request) {
+  return retryCounts.get(request) ?? 0;
+}
+function createRetryObserver({
+  onEvent,
+  maxNetworkRetries
+}) {
+  return ({ request, attemptNumber, delayMilliseconds, response }) => {
+    retryCounts.set(request, attemptNumber);
+    if (!onEvent || response?.status !== 429) return;
+    const observed = onEvent({
+      type: "api:rate_limit_retry",
+      payload: {
+        retry: attemptNumber,
+        maxNetworkRetries,
+        delayMs: delayMilliseconds,
+        path: request.url,
+        method: request.method ?? "GET",
+        rateLimit: parseRateLimitHeaders(response)
+      },
+      timestamp: Date.now()
+    });
+    if (isPromiseLike(observed)) {
+      void Promise.resolve(observed).catch(() => {
+      });
+    }
+  };
+}
+
 // src/plugins/transport/options.ts
+var RETRYABLE_STATUSES = [429, 500, 502, 503, 504];
+var NON_IDEMPOTENT_RETRYABLE_STATUSES = [429];
+function resolveRetryHttpRequestOptions({
+  maxNetworkRetries,
+  maxNetworkRetryDelayMilliseconds,
+  onEvent
+}) {
+  const retries = maxNetworkRetries ?? ZAPIER_MAX_NETWORK_RETRIES;
+  return {
+    maxAttempts: retries + 1,
+    maxDelayMilliseconds: maxNetworkRetryDelayMilliseconds ?? ZAPIER_MAX_NETWORK_RETRY_DELAY_MILLISECONDS,
+    retryStatuses: RETRYABLE_STATUSES,
+    nonIdempotentRetryStatuses: NON_IDEMPOTENT_RETRYABLE_STATUSES,
+    onRetry: createRetryObserver({ onEvent, maxNetworkRetries: retries })
+  };
+}
+function resolveNetworkRetryDelayMilliseconds({
+  maxNetworkRetryDelaySeconds,
+  maxNetworkRetryDelayMs
+}) {
+  return maxNetworkRetryDelaySeconds != null ? maxNetworkRetryDelaySeconds * 1e3 : maxNetworkRetryDelayMs;
+}
 function resolveTransportFetch({
   fetch: customFetch,
   debug = false
@@ -1103,15 +1204,29 @@ var httpFetchPlugin = defineProperty({
 // src/plugins/transport/standalone.ts
 function createZapierSendHttpRequest({
   fetch: customFetch,
-  debug
+  debug,
+  maxNetworkRetries,
+  maxNetworkRetryDelayMilliseconds,
+  onEvent
 }) {
   const sdk = createSdk(
     definePlugin({
       name: "zapierStandaloneHttpTransport",
-      imports: [sendHttpRequestPlugin, httpFetchPlugin],
+      imports: [sendHttpRequestPlugin, retryHttpRequestPlugin, httpFetchPlugin],
       exports: [sendHttpRequestPlugin]
     }),
-    { configuration: { [SDK_OPTIONS_ID]: { fetch: customFetch, debug } } }
+    {
+      configuration: {
+        [SDK_OPTIONS_ID]: { fetch: customFetch, debug },
+        // Filled by configuration rather than the graph's property plugin: the
+        // caller here holds client-shaped ms options, not SDK options.
+        [RETRY_HTTP_REQUEST_OPTIONS_ID]: resolveRetryHttpRequestOptions({
+          maxNetworkRetries,
+          maxNetworkRetryDelayMilliseconds,
+          onEvent
+        })
+      }
+    }
   );
   return sdk.sendHttpRequest;
 }
@@ -1769,13 +1884,6 @@ async function invalidateCredentialsToken(options) {
     });
   }
 }
-
-// src/utils/type-guard-utils.ts
-function isPlainObject(value) {
-  if (typeof value !== "object" || value === null) return false;
-  const proto = Object.getPrototypeOf(value);
-  return proto === Object.prototype || proto === null;
-}
 var callerContext = createAsyncContext();
 function runWithCallerContext(context, fn) {
   let parent;
@@ -2021,9 +2129,6 @@ function sniffDeprecationNotice({
     }
   }
 }
-function isPromiseLike(value) {
-  return (typeof value === "object" || typeof value === "function") && value !== null && "then" in value && typeof value.then === "function";
-}
 function parseDeprecationDate(value) {
   if (!value) return void 0;
   const match = /^@(-?\d+)$/.exec(value.trim());
@@ -2552,7 +2657,7 @@ function logRouteOverride({
 }
 
 // src/sdk-version.ts
-var SDK_VERSION = (typeof process !== "undefined" && process.env ? "0.103.0" : void 0) || "unknown";
+var SDK_VERSION = (typeof process !== "undefined" && process.env ? "0.104.0" : void 0) || "unknown";
 
 // src/utils/open-url.ts
 var nodePrefix = "node:";
@@ -2668,7 +2773,6 @@ var PollApprovalResponseSchema = z.object({
   approval_url: z.string().optional()
 });
 var APPROVAL_MAX_POLLING_INTERVAL_MILLISECONDS = 5e3;
-var EPOCH_THRESHOLD_SECONDS = 1e9;
 function validateSdkPath(path) {
   if (!path.startsWith("/") || path.startsWith("//")) {
     throw new ZapierValidationError(
@@ -2676,57 +2780,17 @@ function validateSdkPath(path) {
     );
   }
 }
-function parseRateLimitHeaders(response) {
-  const info = {};
-  const retryAfter = response.headers.get("retry-after");
-  if (retryAfter) {
-    const seconds = parseInt(retryAfter, 10);
-    if (!isNaN(seconds)) {
-      info.retryAfterMs = seconds * 1e3;
-    } else {
-      const date = Date.parse(retryAfter);
-      if (!isNaN(date)) {
-        info.retryAfterMs = Math.max(0, date - Date.now());
-      }
-    }
-  }
-  const reset = response.headers.get("x-ratelimit-reset");
-  if (reset) {
-    const resetValue = parseInt(reset, 10);
-    if (!isNaN(resetValue)) {
-      const isEpoch = resetValue >= EPOCH_THRESHOLD_SECONDS;
-      info.resetMs = isEpoch ? resetValue * 1e3 : Date.now() + resetValue * 1e3;
-      if (info.retryAfterMs === void 0) {
-        info.retryAfterMs = isEpoch ? Math.max(0, info.resetMs - Date.now()) : Math.max(0, resetValue * 1e3);
-      }
-    }
-  }
-  const limit = response.headers.get("x-ratelimit-limit");
-  if (limit) {
-    const limitNum = parseInt(limit, 10);
-    if (!isNaN(limitNum)) {
-      info.limit = limitNum;
-    }
-  }
-  const remaining = response.headers.get("x-ratelimit-remaining");
-  if (remaining) {
-    const remainingNum = parseInt(remaining, 10);
-    if (!isNaN(remainingNum)) {
-      info.remaining = remainingNum;
-    }
-  }
-  return info;
-}
 var ZapierApiClient = class {
   constructor(options) {
     this.options = options;
     /**
      * Perform a request against an already-resolved URL.
      *
-     * Does auth, header merging, and 429 retry — all the cross-cutting
-     * concerns that every Zapier-bound HTTP call needs. Callers that have a
-     * path (e.g. `/relay/...`) should use `rawFetch` instead, which does
-     * path → URL resolution and delegates here.
+     * Does auth and header merging, and converts a terminal 429 into
+     * `ZapierRateLimitError` — the cross-cutting concerns that every
+     * Zapier-bound HTTP call needs and that the transport does not own. Callers
+     * that have a path (e.g. `/relay/...`) should use `rawFetch` instead, which
+     * does path → URL resolution and delegates here.
      *
      * Exposed as a separate helper so call sites with a server-supplied
      * absolute URL (e.g. an approval poll URL) can still share the same
@@ -2760,47 +2824,30 @@ var ZapierApiClient = class {
         resource: _resource,
         ...wireInit
       } = fetchInit;
-      let retries = 0;
-      while (true) {
-        const response = await this.options.sendHttpRequest({
-          ...wireInit,
-          // Set the resolved URL and merged headers after the spread so caller
-          // values cannot override them.
-          url,
-          headers: Object.fromEntries(mergedHeaders)
-        });
-        if (response.status !== 429) {
-          return response;
-        }
-        const rateLimitInfo = parseRateLimitHeaders(response);
-        const delayMs = rateLimitInfo.retryAfterMs ?? calculateExponentialBackoffMs(retries + 1);
-        if (delayMs > this.maxNetworkRetryDelayMilliseconds || retries >= this.maxNetworkRetries) {
-          throw new ZapierRateLimitError(
-            await this.readRateLimitErrorMessage(response),
-            {
-              statusCode: 429,
-              rateLimit: rateLimitInfo,
-              retries
-            }
-          );
-        }
-        retries++;
-        this.emitEvent("api:rate_limit_retry", {
-          retry: retries,
-          maxNetworkRetries: this.maxNetworkRetries,
-          delayMs,
-          path: url,
-          method: init?.method ?? "GET",
-          rateLimit: rateLimitInfo
-        });
-        await sleep(delayMs, init?.signal ?? void 0);
+      const request = {
+        ...wireInit,
+        url,
+        headers: Object.fromEntries(mergedHeaders)
+      };
+      const response = await this.options.sendHttpRequest(request);
+      if (response.status !== 429) {
+        return response;
       }
+      throw new ZapierRateLimitError(
+        await this.readRateLimitErrorMessage(response),
+        {
+          statusCode: 429,
+          rateLimit: parseRateLimitHeaders(response),
+          retries: retriesFor(request)
+        }
+      );
     };
     /**
      * Wrap an outbound HTTP call with the concurrency semaphore. Used by both
      * `rawFetch` (path-based) and the approval-poll path (absolute URL); each
-     * caller acquires per-attempt, so 429 retry sleep is held but the gap
-     * between approval polls and the human-approval wait are not.
+     * caller acquires per request, so the transport's retry sleeps are held
+     * inside the permit but the gap between approval polls and the
+     * human-approval wait are not.
      *
      * The release is registered in a finally that wraps the entire post-
      * acquire flow — including the `wait_end` event emission — so a throwing
@@ -3050,8 +3097,6 @@ var ZapierApiClient = class {
         signal: options.signal
       });
     };
-    this.maxNetworkRetries = options.maxNetworkRetries ?? ZAPIER_MAX_NETWORK_RETRIES;
-    this.maxNetworkRetryDelayMilliseconds = options.maxNetworkRetryDelayMilliseconds ?? options.maxNetworkRetryDelayMs ?? ZAPIER_MAX_NETWORK_RETRY_DELAY_MILLISECONDS;
     const requested = options.maxConcurrentRequests;
     const limit = requested === void 0 || Number.isNaN(requested) ? ZAPIER_MAX_CONCURRENT_REQUESTS : requested;
     if (limit !== Infinity && (!Number.isInteger(limit) || limit < 1 || limit > MAX_CONCURRENCY_LIMIT)) {
@@ -3807,7 +3852,13 @@ var createZapierApi = (options) => {
     fetch: debugFetch,
     // Built from the caller's own `fetch`, not `debugFetch`: the pipeline wraps
     // for debug itself, and passing the wrapped one would log twice.
-    sendHttpRequest: options.sendHttpRequest ?? createZapierSendHttpRequest({ fetch: options.fetch, debug }),
+    sendHttpRequest: options.sendHttpRequest ?? createZapierSendHttpRequest({
+      fetch: options.fetch,
+      debug,
+      onEvent: options.onEvent,
+      maxNetworkRetries: options.maxNetworkRetries,
+      maxNetworkRetryDelayMilliseconds: options.maxNetworkRetryDelayMilliseconds ?? options.maxNetworkRetryDelayMs
+    }),
     debugLog,
     routingOptions
   });
@@ -3846,10 +3897,30 @@ function getOrCreateApiClient(config) {
     callerPackage
   });
 }
+var retryHttpRequestOptionsPlugin = defineProperty({
+  namespace: "kitcore",
+  name: "retryHttpRequestOptions",
+  imports: [sdkOptionsPluginRef],
+  setup: ({ imports }) => resolveRetryHttpRequestOptions({
+    maxNetworkRetries: imports.sdkOptions?.maxNetworkRetries,
+    maxNetworkRetryDelayMilliseconds: resolveNetworkRetryDelayMilliseconds(
+      imports.sdkOptions ?? {}
+    ),
+    onEvent: imports.sdkOptions?.onEvent
+  }),
+  get: ({ state }) => state
+});
+
+// src/plugins/transport/index.ts
 var zapierHttpTransportPlugin = definePlugin({
   namespace: "zapier",
   name: "httpTransport",
-  imports: [sendHttpRequestPlugin, httpFetchPlugin],
+  imports: [
+    sendHttpRequestPlugin,
+    retryHttpRequestPlugin,
+    retryHttpRequestOptionsPlugin,
+    httpFetchPlugin
+  ],
   exports: [sendHttpRequestPlugin]
 });
 
@@ -3909,7 +3980,10 @@ var apiPlugin = defineProperty({
       fetch: customFetch,
       onEvent,
       maxNetworkRetries,
-      maxNetworkRetryDelayMilliseconds: (maxNetworkRetryDelaySeconds != null ? maxNetworkRetryDelaySeconds * 1e3 : maxNetworkRetryDelayMs) ?? ZAPIER_MAX_NETWORK_RETRY_DELAY_MILLISECONDS,
+      maxNetworkRetryDelayMilliseconds: resolveNetworkRetryDelayMilliseconds({
+        maxNetworkRetryDelaySeconds,
+        maxNetworkRetryDelayMs
+      }) ?? ZAPIER_MAX_NETWORK_RETRY_DELAY_MILLISECONDS,
       maxConcurrentRequests,
       approvalTimeoutMilliseconds: approvalTimeoutSeconds != null ? approvalTimeoutSeconds * 1e3 : approvalTimeoutMs,
       maxApprovalRetries,
@@ -12314,17 +12388,20 @@ var BaseSdkOptionsSchema = z.object({
   routeOverrides: z.record(z.string(), z.string()).optional().describe("Maps SDK route prefixes to direct origins.").meta({ internal: true }),
   trackingBaseUrl: z.string().optional().describe("Base URL for Zapier tracking endpoints.").meta({ valueHint: "url" }),
   /**
-   * Maximum number of retries for rate-limited requests (429 responses).
+   * Maximum number of retries for rate-limited requests (429 responses) and,
+   * on idempotent methods, retryable server errors (500, 502, 503, 504).
    * Set to 0 to disable retries. Default is 3.
    */
-  maxNetworkRetries: z.number().optional().describe("Max retries for rate-limited requests (default: 3).").meta({ valueHint: "count" }),
+  maxNetworkRetries: z.number().optional().describe(
+    "Max retries for rate-limited and server-error responses (default: 3)."
+  ).meta({ valueHint: "count" }),
   /**
-   * Maximum delay in seconds to wait for a rate-limit retry.
+   * Maximum delay in seconds to wait between network retries.
    * If the server requests a longer delay, the request fails immediately.
    * Default is 60 (60 seconds).
    */
   maxNetworkRetryDelaySeconds: z.number().optional().describe(
-    "Max delay in seconds to wait for a rate-limit retry (default: 60)."
+    "Max delay in seconds to wait between network retries (default: 60)."
   ).meta({ valueHint: "seconds" }),
   /** @deprecated Use `maxNetworkRetryDelaySeconds` instead. */
   maxNetworkRetryDelayMs: z.number().optional().describe("Max delay in ms to wait for retry (default: 60000).").meta({ valueHint: "ms", deprecated: true }),