@trigger.dev/core 0.0.0-v3-prerelease-20240703161020 → 0.0.0-v3-prerelease-20240705100038

package/dist/v3/workers/index.js

@@ -138,7 +138,10 @@ var SemanticInternalAttributes = {
   LINK_TITLE: "$link.title",
   IDEMPOTENCY_KEY: "ctx.run.idempotencyKey",
   USAGE_DURATION_MS: "$usage.durationMs",
-  USAGE_COST_IN_CENTS: "$usage.costInCents"
+  USAGE_COST_IN_CENTS: "$usage.costInCents",
+  RATE_LIMIT_LIMIT: "response.rateLimit.limit",
+  RATE_LIMIT_REMAINING: "response.rateLimit.remaining",
+  RATE_LIMIT_RESET: "response.rateLimit.reset"
 };
 
 // src/v3/utils/flattenAttributes.ts
@@ -370,7 +373,7 @@ function getEnvVar(name) {
 __name(getEnvVar, "getEnvVar");
 
 // package.json
-var version = "0.0.0-v3-prerelease-20240703161020";
+var version = "0.0.0-v3-prerelease-20240705100038";
 
 // src/v3/otel/tracingSDK.ts
 var _a;
@@ -621,6 +624,7 @@ var TaskRun = zod.z.object({
   createdAt: zod.z.coerce.date(),
   startedAt: zod.z.coerce.date().default(() => /* @__PURE__ */ new Date()),
   idempotencyKey: zod.z.string().optional(),
+  maxAttempts: zod.z.number().optional(),
   durationMs: zod.z.number().default(0),
   costInCents: zod.z.number().default(0),
   baseCostInCents: zod.z.number().default(0)
@@ -988,7 +992,8 @@ var TriggerTaskRequestBody = zod.z.object({
     test: zod.z.boolean().optional(),
     payloadType: zod.z.string().optional(),
     delay: zod.z.string().or(zod.z.coerce.date()).optional(),
-    ttl: zod.z.string().or(zod.z.number().nonnegative().int()).optional()
+    ttl: zod.z.string().or(zod.z.number().nonnegative().int()).optional(),
+    maxAttempts: zod.z.number().int().optional()
   }).optional()
 });
 var TriggerTaskResponse = zod.z.object({
@@ -1318,10 +1323,34 @@ var EnvironmentVariable = zod.z.object({
 });
 var EnvironmentVariables = zod.z.array(EnvironmentVariable);
 
+// src/v3/utils/retries.ts
+var defaultRetryOptions = {
+  maxAttempts: 3,
+  factor: 2,
+  minTimeoutInMs: 1e3,
+  maxTimeoutInMs: 6e4,
+  randomize: true
+};
+function calculateNextRetryDelay(options, attempt) {
+  const opts = {
+    ...defaultRetryOptions,
+    ...options
+  };
+  if (attempt >= opts.maxAttempts) {
+    return;
+  }
+  const { factor, minTimeoutInMs, maxTimeoutInMs, randomize } = opts;
+  const random = randomize ? Math.random() + 1 : 1;
+  const timeout = Math.min(maxTimeoutInMs, random * minTimeoutInMs * Math.pow(factor, attempt - 1));
+  return Math.round(timeout);
+}
+__name(calculateNextRetryDelay, "calculateNextRetryDelay");
+
 // src/v3/apiClient/errors.ts
 var _ApiError = class _ApiError extends Error {
   constructor(status, error, message, headers) {
     super(`${_ApiError.makeMessage(status, error, message)}`);
+    this.name = "TriggerApiError";
     this.status = status;
     this.headers = headers;
     const data = error;
@@ -1442,6 +1471,16 @@ var _RateLimitError = class _RateLimitError extends ApiError {
     super(...arguments);
     __publicField(this, "status", 429);
   }
+  get millisecondsUntilReset() {
+    const resetAtUnixEpochMs = (this.headers ?? {})["x-ratelimit-reset"];
+    if (typeof resetAtUnixEpochMs === "string") {
+      const resetAtUnixEpoch = parseInt(resetAtUnixEpochMs, 10);
+      if (isNaN(resetAtUnixEpoch)) {
+        return;
+      }
+      return Math.max(resetAtUnixEpoch - Date.now() + Math.floor(Math.random() * 2e3), 0);
+    }
+  }
 };
 __name(_RateLimitError, "RateLimitError");
 var RateLimitError = _RateLimitError;
@@ -1456,28 +1495,11 @@ function castToError(err) {
 }
 __name(castToError, "castToError");
 
-// src/v3/utils/retries.ts
-var defaultRetryOptions = {
-  maxAttempts: 3,
-  factor: 2,
-  minTimeoutInMs: 1e3,
-  maxTimeoutInMs: 6e4,
-  randomize: true
-};
-function calculateNextRetryDelay(options, attempt) {
-  const opts = {
-    ...defaultRetryOptions,
-    ...options
-  };
-  if (attempt >= opts.maxAttempts) {
-    return;
-  }
-  const { factor, minTimeoutInMs, maxTimeoutInMs, randomize } = opts;
-  const random = randomize ? Math.random() + 1 : 1;
-  const timeout = Math.min(maxTimeoutInMs, random * minTimeoutInMs * Math.pow(factor, attempt - 1));
-  return Math.round(timeout);
+// src/v3/utils/styleAttributes.ts
+function accessoryAttributes(accessory) {
+  return flattenAttributes(accessory, SemanticInternalAttributes.STYLE_ACCESSORY);
 }
-__name(calculateNextRetryDelay, "calculateNextRetryDelay");
+__name(accessoryAttributes, "accessoryAttributes");
 
 // src/v3/apiClient/pagination.ts
 var _CursorPage = class _CursorPage {
@@ -1637,16 +1659,43 @@ function zodfetchOffsetLimitPage(schema, url, params, requestInit, options) {
   return new OffsetLimitPagePromise(fetchResult, schema, url, params, requestInit, options);
 }
 __name(zodfetchOffsetLimitPage, "zodfetchOffsetLimitPage");
-async function _doZodFetch(schema, url, requestInit, options, attempt = 1) {
+async function traceZodFetch(params, callback) {
+  if (!params.options?.tracer) {
+    return callback();
+  }
+  const url = new URL(params.url);
+  const method = params.requestInit?.method ?? "GET";
+  const name = params.options.name ?? `${method} ${url.pathname}`;
+  return await params.options.tracer.startActiveSpan(name, async (span) => {
+    return await callback(span);
+  }, {
+    attributes: {
+      [SemanticInternalAttributes.STYLE_ICON]: params.options?.icon ?? "api",
+      ...params.options.attributes
+    }
+  });
+}
+__name(traceZodFetch, "traceZodFetch");
+async function _doZodFetch(schema, url, requestInit, options) {
+  const $requestInit = await requestInit;
+  return traceZodFetch({
+    url,
+    requestInit: $requestInit,
+    options
+  }, async (span) => {
+    return await _doZodFetchWithRetries(schema, url, $requestInit, options);
+  });
+}
+__name(_doZodFetch, "_doZodFetch");
+async function _doZodFetchWithRetries(schema, url, requestInit, options, attempt = 1) {
   try {
-    const $requestInit = await requestInit;
-    const response = await fetch(url, requestInitWithCache($requestInit));
+    const response = await fetch(url, requestInitWithCache(requestInit));
     const responseHeaders = createResponseHeaders(response.headers);
     if (!response.ok) {
       const retryResult = shouldRetry(response, attempt, options?.retry);
       if (retryResult.retry) {
-        await new Promise((resolve) => setTimeout(resolve, retryResult.delay));
-        return await _doZodFetch(schema, url, requestInit, options, attempt + 1);
+        await waitForRetry(url, attempt + 1, retryResult.delay, options, requestInit, response);
+        return await _doZodFetchWithRetries(schema, url, requestInit, options, attempt + 1);
       } else {
         const errText = await response.text().catch((e) => castToError2(e).message);
         const errJSON = safeJsonParse(errText);
@@ -1674,8 +1723,8 @@ async function _doZodFetch(schema, url, requestInit, options, attempt = 1) {
       };
       const delay = calculateNextRetryDelay(retry, attempt);
       if (delay) {
-        await new Promise((resolve) => setTimeout(resolve, delay));
-        return await _doZodFetch(schema, url, requestInit, options, attempt + 1);
+        await waitForRetry(url, attempt + 1, delay, options, requestInit);
+        return await _doZodFetchWithRetries(schema, url, requestInit, options, attempt + 1);
       }
     }
     throw new ApiConnectionError({
@@ -1683,7 +1732,7 @@ async function _doZodFetch(schema, url, requestInit, options, attempt = 1) {
     });
   }
 }
-__name(_doZodFetch, "_doZodFetch");
+__name(_doZodFetchWithRetries, "_doZodFetchWithRetries");
 function castToError2(err) {
   if (err instanceof Error)
     return err;
@@ -1720,8 +1769,25 @@ function shouldRetry(response, attempt, retryOptions) {
     return shouldRetryForOptions();
   if (response.status === 409)
     return shouldRetryForOptions();
-  if (response.status === 429)
+  if (response.status === 429) {
+    if (attempt >= (typeof retryOptions?.maxAttempts === "number" ? retryOptions?.maxAttempts : 3)) {
+      return {
+        retry: false
+      };
+    }
+    const resetAtUnixEpochMs = response.headers.get("x-ratelimit-reset");
+    if (resetAtUnixEpochMs) {
+      const resetAtUnixEpoch = parseInt(resetAtUnixEpochMs, 10);
+      const delay = resetAtUnixEpoch - Date.now() + Math.floor(Math.random() * 1e3);
+      if (delay > 0) {
+        return {
+          retry: true,
+          delay
+        };
+      }
+    }
     return shouldRetryForOptions();
+  }
   if (response.status >= 500)
     return shouldRetryForOptions();
   return {
@@ -1884,9 +1950,32 @@ fetchPage_fn2 = /* @__PURE__ */ __name(function(params1) {
 }, "#fetchPage");
 __name(_OffsetLimitPagePromise, "OffsetLimitPagePromise");
 var OffsetLimitPagePromise = _OffsetLimitPagePromise;
+async function waitForRetry(url, attempt, delay, options, requestInit, response) {
+  if (options?.tracer) {
+    const method = requestInit?.method ?? "GET";
+    return options.tracer.startActiveSpan(response ? `wait after ${response.status}` : `wait after error`, async (span) => {
+      await new Promise((resolve) => setTimeout(resolve, delay));
+    }, {
+      attributes: {
+        [SemanticInternalAttributes.STYLE_ICON]: "wait",
+        ...accessoryAttributes({
+          items: [
+            {
+              text: `retrying ${options?.name ?? method.toUpperCase()} in ${delay}ms`,
+              variant: "normal"
+            }
+          ],
+          style: "codepath"
+        })
+      }
+    });
+  }
+  await new Promise((resolve) => setTimeout(resolve, delay));
+}
+__name(waitForRetry, "waitForRetry");
 
 // src/v3/apiClient/index.ts
-var zodFetchOptions = {
+var DEFAULT_ZOD_FETCH_OPTIONS = {
   retry: {
     maxAttempts: 3,
     minTimeoutInMs: 1e3,
@@ -1897,17 +1986,18 @@ var zodFetchOptions = {
 };
 var _getHeaders, getHeaders_fn;
 var _ApiClient = class _ApiClient {
-  constructor(baseUrl, accessToken) {
+  constructor(baseUrl, accessToken, requestOptions = {}) {
     __privateAdd(this, _getHeaders);
     this.accessToken = accessToken;
     this.baseUrl = baseUrl.replace(/\/$/, "");
+    this.defaultRequestOptions = mergeRequestOptions(DEFAULT_ZOD_FETCH_OPTIONS, requestOptions);
   }
-  async getRunResult(runId) {
+  async getRunResult(runId, requestOptions) {
     try {
       return await zodfetch(TaskRunExecutionResult, `${this.baseUrl}/api/v1/runs/${runId}/result`, {
         method: "GET",
         headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
-      }, zodFetchOptions);
+      }, mergeRequestOptions(this.defaultRequestOptions, requestOptions));
     } catch (error) {
       if (error instanceof ApiError) {
         if (error.status === 404) {
@@ -1917,47 +2007,47 @@ var _ApiClient = class _ApiClient {
       throw error;
     }
   }
-  async getBatchResults(batchId) {
+  async getBatchResults(batchId, requestOptions) {
     return await zodfetch(BatchTaskRunExecutionResult, `${this.baseUrl}/api/v1/batches/${batchId}/results`, {
       method: "GET",
       headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
-    }, zodFetchOptions);
+    }, mergeRequestOptions(this.defaultRequestOptions, requestOptions));
   }
-  triggerTask(taskId, body, options) {
+  triggerTask(taskId, body, options, requestOptions) {
     const encodedTaskId = encodeURIComponent(taskId);
     return zodfetch(TriggerTaskResponse, `${this.baseUrl}/api/v1/tasks/${encodedTaskId}/trigger`, {
       method: "POST",
       headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, options?.spanParentAsLink ?? false),
       body: JSON.stringify(body)
-    }, zodFetchOptions);
+    }, mergeRequestOptions(this.defaultRequestOptions, requestOptions));
   }
-  batchTriggerTask(taskId, body, options) {
+  batchTriggerTask(taskId, body, options, requestOptions) {
     const encodedTaskId = encodeURIComponent(taskId);
     return zodfetch(BatchTriggerTaskResponse, `${this.baseUrl}/api/v1/tasks/${encodedTaskId}/batch`, {
       method: "POST",
       headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, options?.spanParentAsLink ?? false),
       body: JSON.stringify(body)
-    }, zodFetchOptions);
+    }, mergeRequestOptions(this.defaultRequestOptions, requestOptions));
   }
-  createUploadPayloadUrl(filename) {
+  createUploadPayloadUrl(filename, requestOptions) {
     return zodfetch(CreateUploadPayloadUrlResponseBody, `${this.baseUrl}/api/v1/packets/${filename}`, {
       method: "PUT",
       headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
-    }, zodFetchOptions);
+    }, mergeRequestOptions(this.defaultRequestOptions, requestOptions));
   }
-  getPayloadUrl(filename) {
+  getPayloadUrl(filename, requestOptions) {
     return zodfetch(CreateUploadPayloadUrlResponseBody, `${this.baseUrl}/api/v1/packets/${filename}`, {
       method: "GET",
       headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
-    }, zodFetchOptions);
+    }, mergeRequestOptions(this.defaultRequestOptions, requestOptions));
   }
-  retrieveRun(runId) {
+  retrieveRun(runId, requestOptions) {
     return zodfetch(RetrieveRunResponse, `${this.baseUrl}/api/v3/runs/${runId}`, {
       method: "GET",
       headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
-    }, zodFetchOptions);
+    }, mergeRequestOptions(this.defaultRequestOptions, requestOptions));
   }
-  listRuns(query) {
+  listRuns(query, requestOptions) {
     const searchParams = createSearchQueryForListRuns(query);
     return zodfetchCursorPage(ListRunResponseItem, `${this.baseUrl}/api/v1/runs`, {
       query: searchParams,
@@ -1967,9 +2057,9 @@ var _ApiClient = class _ApiClient {
     }, {
       method: "GET",
       headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
-    }, zodFetchOptions);
+    }, mergeRequestOptions(this.defaultRequestOptions, requestOptions));
   }
-  listProjectRuns(projectRef, query) {
+  listProjectRuns(projectRef, query, requestOptions) {
     const searchParams = createSearchQueryForListRuns(query);
     if (query?.env) {
       searchParams.append("filter[env]", Array.isArray(query.env) ? query.env.join(",") : query.env);
@@ -1982,35 +2072,35 @@ var _ApiClient = class _ApiClient {
     }, {
       method: "GET",
       headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
-    }, zodFetchOptions);
+    }, mergeRequestOptions(this.defaultRequestOptions, requestOptions));
   }
-  replayRun(runId) {
+  replayRun(runId, requestOptions) {
     return zodfetch(ReplayRunResponse, `${this.baseUrl}/api/v1/runs/${runId}/replay`, {
       method: "POST",
       headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
-    }, zodFetchOptions);
+    }, mergeRequestOptions(this.defaultRequestOptions, requestOptions));
   }
-  cancelRun(runId) {
+  cancelRun(runId, requestOptions) {
     return zodfetch(CanceledRunResponse, `${this.baseUrl}/api/v2/runs/${runId}/cancel`, {
       method: "POST",
       headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
-    }, zodFetchOptions);
+    }, mergeRequestOptions(this.defaultRequestOptions, requestOptions));
   }
-  rescheduleRun(runId, body) {
+  rescheduleRun(runId, body, requestOptions) {
     return zodfetch(RetrieveRunResponse, `${this.baseUrl}/api/v1/runs/${runId}/reschedule`, {
       method: "POST",
       headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false),
       body: JSON.stringify(body)
-    }, zodFetchOptions);
+    }, mergeRequestOptions(this.defaultRequestOptions, requestOptions));
   }
-  createSchedule(options) {
+  createSchedule(options, requestOptions) {
     return zodfetch(ScheduleObject, `${this.baseUrl}/api/v1/schedules`, {
       method: "POST",
       headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false),
       body: JSON.stringify(options)
-    });
+    }, mergeRequestOptions(this.defaultRequestOptions, requestOptions));
   }
-  listSchedules(options) {
+  listSchedules(options, requestOptions) {
     const searchParams = new URLSearchParams();
     if (options?.page) {
       searchParams.append("page", options.page.toString());
@@ -2024,77 +2114,77 @@ var _ApiClient = class _ApiClient {
     }, {
       method: "GET",
       headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
-    });
+    }, mergeRequestOptions(this.defaultRequestOptions, requestOptions));
   }
-  retrieveSchedule(scheduleId) {
+  retrieveSchedule(scheduleId, requestOptions) {
     return zodfetch(ScheduleObject, `${this.baseUrl}/api/v1/schedules/${scheduleId}`, {
       method: "GET",
       headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
-    });
+    }, mergeRequestOptions(this.defaultRequestOptions, requestOptions));
   }
-  updateSchedule(scheduleId, options) {
+  updateSchedule(scheduleId, options, requestOptions) {
     return zodfetch(ScheduleObject, `${this.baseUrl}/api/v1/schedules/${scheduleId}`, {
       method: "PUT",
       headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false),
       body: JSON.stringify(options)
-    });
+    }, mergeRequestOptions(this.defaultRequestOptions, requestOptions));
   }
-  deactivateSchedule(scheduleId) {
+  deactivateSchedule(scheduleId, requestOptions) {
     return zodfetch(ScheduleObject, `${this.baseUrl}/api/v1/schedules/${scheduleId}/deactivate`, {
       method: "POST",
       headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
-    });
+    }, mergeRequestOptions(this.defaultRequestOptions, requestOptions));
   }
-  activateSchedule(scheduleId) {
+  activateSchedule(scheduleId, requestOptions) {
     return zodfetch(ScheduleObject, `${this.baseUrl}/api/v1/schedules/${scheduleId}/activate`, {
       method: "POST",
       headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
-    });
+    }, mergeRequestOptions(this.defaultRequestOptions, requestOptions));
   }
-  deleteSchedule(scheduleId) {
+  deleteSchedule(scheduleId, requestOptions) {
     return zodfetch(DeletedScheduleObject, `${this.baseUrl}/api/v1/schedules/${scheduleId}`, {
       method: "DELETE",
       headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
-    });
+    }, mergeRequestOptions(this.defaultRequestOptions, requestOptions));
   }
-  listEnvVars(projectRef, slug) {
+  listEnvVars(projectRef, slug, requestOptions) {
     return zodfetch(EnvironmentVariables, `${this.baseUrl}/api/v1/projects/${projectRef}/envvars/${slug}`, {
       method: "GET",
       headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
-    });
+    }, mergeRequestOptions(this.defaultRequestOptions, requestOptions));
   }
-  importEnvVars(projectRef, slug, body) {
+  importEnvVars(projectRef, slug, body, requestOptions) {
     return zodfetch(EnvironmentVariableResponseBody, `${this.baseUrl}/api/v1/projects/${projectRef}/envvars/${slug}/import`, {
       method: "POST",
       headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false),
       body: JSON.stringify(body)
-    });
+    }, mergeRequestOptions(this.defaultRequestOptions, requestOptions));
   }
-  retrieveEnvVar(projectRef, slug, key) {
+  retrieveEnvVar(projectRef, slug, key, requestOptions) {
     return zodfetch(EnvironmentVariableValue, `${this.baseUrl}/api/v1/projects/${projectRef}/envvars/${slug}/${key}`, {
       method: "GET",
       headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
-    });
+    }, mergeRequestOptions(this.defaultRequestOptions, requestOptions));
   }
-  createEnvVar(projectRef, slug, body) {
+  createEnvVar(projectRef, slug, body, requestOptions) {
     return zodfetch(EnvironmentVariableResponseBody, `${this.baseUrl}/api/v1/projects/${projectRef}/envvars/${slug}`, {
       method: "POST",
       headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false),
       body: JSON.stringify(body)
-    });
+    }, mergeRequestOptions(this.defaultRequestOptions, requestOptions));
   }
-  updateEnvVar(projectRef, slug, key, body) {
+  updateEnvVar(projectRef, slug, key, body, requestOptions) {
     return zodfetch(EnvironmentVariableResponseBody, `${this.baseUrl}/api/v1/projects/${projectRef}/envvars/${slug}/${key}`, {
       method: "PUT",
       headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false),
       body: JSON.stringify(body)
-    });
+    }, mergeRequestOptions(this.defaultRequestOptions, requestOptions));
   }
-  deleteEnvVar(projectRef, slug, key) {
+  deleteEnvVar(projectRef, slug, key, requestOptions) {
     return zodfetch(EnvironmentVariableResponseBody, `${this.baseUrl}/api/v1/projects/${projectRef}/envvars/${slug}/${key}`, {
       method: "DELETE",
       headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
-    });
+    }, mergeRequestOptions(this.defaultRequestOptions, requestOptions));
   }
 };
 _getHeaders = new WeakSet();
@@ -2149,6 +2239,20 @@ function createSearchQueryForListRuns(query) {
   return searchParams;
 }
 __name(createSearchQueryForListRuns, "createSearchQueryForListRuns");
+function mergeRequestOptions(defaultOptions, options) {
+  if (!options) {
+    return defaultOptions;
+  }
+  return {
+    ...defaultOptions,
+    ...options,
+    retry: {
+      ...defaultOptions.retry,
+      ...options.retry
+    }
+  };
+}
+__name(mergeRequestOptions, "mergeRequestOptions");
 
 // src/v3/apiClientManager/index.ts
 var API_NAME2 = "api-client";
@@ -2413,12 +2517,6 @@ async function loadSuperJSON() {
 }
 __name(loadSuperJSON, "loadSuperJSON");
 
-// src/v3/utils/styleAttributes.ts
-function accessoryAttributes(accessory) {
-  return flattenAttributes(accessory, SemanticInternalAttributes.STYLE_ACCESSORY);
-}
-__name(accessoryAttributes, "accessoryAttributes");
-
 // src/v3/workers/taskExecutor.ts
 var _callRun, callRun_fn, _callInitFunctions, callInitFunctions_fn, _callConfigInit, callConfigInit_fn, _callOnSuccessFunctions, callOnSuccessFunctions_fn, _callOnSuccessFunction, callOnSuccessFunction_fn, _callOnFailureFunctions, callOnFailureFunctions_fn, _callOnFailureFunction, callOnFailureFunction_fn, _callOnStartFunctions, callOnStartFunctions_fn, _callOnStartFunction, callOnStartFunction_fn, _callTaskCleanup, callTaskCleanup_fn, _handleError, handleError_fn;
 var _TaskExecutor = class _TaskExecutor {
@@ -2695,7 +2793,19 @@ handleError_fn = /* @__PURE__ */ __name(async function(execution, error2, payloa
       status: "noop"
     };
   }
-  const delay = calculateNextRetryDelay(retry, execution.attempt.number);
+  if (error2 instanceof Error && error2.name === "AbortTaskRunError") {
+    return {
+      status: "skipped"
+    };
+  }
+  if (execution.run.maxAttempts) {
+    retry.maxAttempts = Math.max(execution.run.maxAttempts, 1);
+  }
+  let delay = calculateNextRetryDelay(retry, execution.attempt.number);
+  if (delay && error2 instanceof Error && error2.name === "TriggerApiError" && error2.status === 429) {
+    const rateLimitError = error2;
+    delay = rateLimitError.millisecondsUntilReset;
+  }
   if (execution.environment.type === "DEVELOPMENT" && typeof retriesConfig?.enabledInDev === "boolean" && !retriesConfig.enabledInDev) {
     return {
       status: "skipped"