fix(retry): preserve uncapped Retry-After comparison in tools/index.ts

parseRetryAfter() caps its return value at 30s by default. tools/index.ts
compares the parsed Retry-After against a caller-configured maxDelayMs to
decide whether to skip a retry entirely -- capping before that comparison
silently defeats the skip check whenever maxDelayMs is configured above
30s, since a Retry-After between 30s and maxDelayMs would incorrectly look
"within limits" and get retried instead of skipped (caught by Cursor
Bugbot). Added an optional maxMs param (default unchanged) so tools/index.ts
can request the raw, uncapped value for its own comparison while
backoffWithJitter still clamps the actual sleep duration to maxDelayMs.
Added a regression test covering maxDelayMs > 30s.

Author: waleedlatif1

apps/sim/tools/index.test.ts

@@ -1896,6 +1896,28 @@ describe('MCP Tool Execution', () => {
       expect(result.success).toBe(false)
     })
 
+    it('skips retry when Retry-After exceeds a maxDelayMs configured above the 30s default cap', async () => {
+      global.fetch = Object.assign(
+        vi
+          .fn()
+          .mockResolvedValueOnce(
+            makeJsonResponse(429, { error: 'rate limited' }, { 'retry-after': '50' })
+          )
+          .mockResolvedValueOnce(makeJsonResponse(200, { ok: true })),
+        { preconnect: vi.fn() }
+      ) as typeof fetch
+
+      const result = await executeTool('http_request', {
+        url: '/api/test',
+        method: 'GET',
+        retries: 3,
+        retryMaxDelayMs: 40000,
+      })
+
+      expect(global.fetch).toHaveBeenCalledTimes(1)
+      expect(result.success).toBe(false)
+    })
+
     it('retries when Retry-After header is within maxDelayMs', async () => {
       global.fetch = Object.assign(
         vi

apps/sim/tools/index.ts

@@ -1495,7 +1495,10 @@ function shouldRetryWithoutReadingBody(
   if (!retryConfig || isLastAttempt || !isRetryableFailure(null, status)) {
     return false
   }
-  return (parseRetryAfter(headers.get('retry-after')) ?? 0) <= retryConfig.maxDelayMs
+  return (
+    (parseRetryAfter(headers.get('retry-after'), Number.POSITIVE_INFINITY) ?? 0) <=
+    retryConfig.maxDelayMs
+  )
 }
 
 /**
@@ -1741,7 +1744,10 @@ async function executeToolRequest(
         !response.ok &&
         isRetryableFailure(null, response.status)
       ) {
-        const retryAfterMs = parseRetryAfter(response.headers.get('retry-after'))
+        const retryAfterMs = parseRetryAfter(
+          response.headers.get('retry-after'),
+          Number.POSITIVE_INFINITY
+        )
         if (retryAfterMs !== null && retryAfterMs > retryConfig.maxDelayMs) {
           logger.warn(
             `[${requestId}] Retry-After (${retryAfterMs}ms) exceeds maxDelayMs (${retryConfig.maxDelayMs}ms), skipping retry`

packages/utils/src/retry.ts

@@ -32,28 +32,31 @@ export function backoffWithJitter(
   return exponential * (0.8 + jitter * 0.4)
 }
 
-/** Maximum `Retry-After` value honored: 30 s. Prevents a misconfigured upstream from stalling callers. */
+/** Default maximum `Retry-After` value honored: 30 s. Prevents a misconfigured upstream from stalling callers. */
 const RETRY_AFTER_MAX_MS = 30_000
 
 /**
  * Parses an HTTP `Retry-After` header (either delta-seconds or an HTTP-date)
- * into a millisecond delay, capped at 30 s.
+ * into a millisecond delay, capped at `maxMs` (default 30 s).
  * Returns `null` when the header is absent or unparseable so callers can fall
- * back to their own backoff.
+ * back to their own backoff. Pass the caller's own `maxDelayMs` as `maxMs` when
+ * that value needs to be compared against the parsed delay (e.g. to decide
+ * whether to skip a retry) — otherwise the default cap silently truncates the
+ * comparison.
  */
-export function parseRetryAfter(header: string | null): number | null {
+export function parseRetryAfter(header: string | null, maxMs = RETRY_AFTER_MAX_MS): number | null {
   if (!header) return null
   const trimmed = header.trim()
   if (trimmed.length === 0) return null
   const seconds = Number(trimmed)
   if (Number.isFinite(seconds) && seconds >= 0) {
-    return Math.min(Math.floor(seconds * 1000), RETRY_AFTER_MAX_MS)
+    return Math.min(Math.floor(seconds * 1000), maxMs)
   }
   const dateMs = Date.parse(trimmed)
   if (!Number.isNaN(dateMs)) {
     const delta = dateMs - Date.now()
     if (delta <= 0) return 0
-    return Math.min(delta, RETRY_AFTER_MAX_MS)
+    return Math.min(delta, maxMs)
   }
   return null
 }