@trigger.dev/sdk 3.0.0-beta.5 → 3.0.0-beta.50

package/dist/index.mjs

@@ -258,7 +258,7 @@ __name(_Job, "Job");
 var Job = _Job;
 
 // package.json
-var version = "3.0.0-beta.5";
+var version = "3.0.0-beta.50";
 
 // src/errors.ts
 var _ResumeWithTaskError = class _ResumeWithTaskError {
@@ -318,6 +318,13 @@ var _AutoYieldWithCompletedTaskExecutionError = class _AutoYieldWithCompletedTas
 };
 __name(_AutoYieldWithCompletedTaskExecutionError, "AutoYieldWithCompletedTaskExecutionError");
 var AutoYieldWithCompletedTaskExecutionError = _AutoYieldWithCompletedTaskExecutionError;
+var _AutoYieldRateLimitError = class _AutoYieldRateLimitError {
+  constructor(resetAtTimestamp) {
+    this.resetAtTimestamp = resetAtTimestamp;
+  }
+};
+__name(_AutoYieldRateLimitError, "AutoYieldRateLimitError");
+var AutoYieldRateLimitError = _AutoYieldRateLimitError;
 var _ParsedPayloadSchemaError = class _ParsedPayloadSchemaError {
   constructor(schemaErrors) {
     this.schemaErrors = schemaErrors;
@@ -326,7 +333,7 @@ var _ParsedPayloadSchemaError = class _ParsedPayloadSchemaError {
 __name(_ParsedPayloadSchemaError, "ParsedPayloadSchemaError");
 var ParsedPayloadSchemaError = _ParsedPayloadSchemaError;
 function isTriggerError(err) {
-  return err instanceof ResumeWithTaskError || err instanceof RetryWithTaskError || err instanceof CanceledWithTaskError || err instanceof YieldExecutionError || err instanceof AutoYieldExecutionError || err instanceof AutoYieldWithCompletedTaskExecutionError || err instanceof ResumeWithParallelTaskError;
+  return err instanceof ResumeWithTaskError || err instanceof RetryWithTaskError || err instanceof CanceledWithTaskError || err instanceof YieldExecutionError || err instanceof AutoYieldExecutionError || err instanceof AutoYieldWithCompletedTaskExecutionError || err instanceof AutoYieldRateLimitError || err instanceof ResumeWithParallelTaskError;
 }
 __name(isTriggerError, "isTriggerError");
 var _ErrorWithTask = class _ErrorWithTask extends Error {
@@ -569,10 +576,12 @@ var _JSONOutputSerializer = class _JSONOutputSerializer {
 };
 __name(_JSONOutputSerializer, "JSONOutputSerializer");
 var JSONOutputSerializer = _JSONOutputSerializer;
-var _addToCachedTasks, addToCachedTasks_fn, _detectAutoYield, detectAutoYield_fn, _forceYield, forceYield_fn, _getTimeElapsed, getTimeElapsed_fn, _getRemainingTimeInMillis, getRemainingTimeInMillis_fn;
+var _addToCachedTasks, addToCachedTasks_fn, _doRunTask, doRunTask_fn, _doCompleteTask, doCompleteTask_fn, _detectAutoYield, detectAutoYield_fn, _forceYield, forceYield_fn, _getTimeElapsed, getTimeElapsed_fn, _getRemainingTimeInMillis, getRemainingTimeInMillis_fn;
 var _IO = class _IO {
   constructor(options) {
     __privateAdd(this, _addToCachedTasks);
+    __privateAdd(this, _doRunTask);
+    __privateAdd(this, _doCompleteTask);
     __privateAdd(this, _detectAutoYield);
     __privateAdd(this, _forceYield);
     __privateAdd(this, _getTimeElapsed);
@@ -1432,15 +1441,17 @@ var _IO = class _IO {
       ...options ?? {},
       parseOutput: void 0
     };
-    const response = await this._apiClient.runTask(this._id, {
+    const response = await __privateMethod(this, _doRunTask, doRunTask_fn).call(this, {
       idempotencyKey,
       displayKey: typeof cacheKey === "string" ? cacheKey : void 0,
       noop: false,
       ...runOptions ?? {},
       parentId
-    }, {
-      cachedTasksCursor: this._cachedTasksCursor
     });
+    if (!response) {
+      __privateMethod(this, _forceYield, forceYield_fn).call(this, "failed_task_run");
+      throw new Error("Failed to run task");
+    }
     const task = response.version === API_VERSIONS.LAZY_LOADED_CACHED_TASKS ? response.body.task : response.body;
     if (task.forceYield) {
       this._logger.debug("Forcing yield after run task", {
@@ -1506,10 +1517,14 @@ var _IO = class _IO {
           task
         });
         __privateMethod(this, _detectAutoYield, detectAutoYield_fn).call(this, "before_complete_task", 500, task, output);
-        const completedTask = await this._apiClient.completeTask(this._id, task.id, {
+        const completedTask = await __privateMethod(this, _doCompleteTask, doCompleteTask_fn).call(this, task.id, {
           output,
           properties: task.outputProperties ?? void 0
         });
+        if (!completedTask) {
+          __privateMethod(this, _forceYield, forceYield_fn).call(this, "before_complete_task", task, output);
+          throw new Error("Failed to complete task");
+        }
         if (completedTask.forceYield) {
           this._logger.debug("Forcing yield after task completed", {
             idempotencyKey
@@ -1646,12 +1661,36 @@ _addToCachedTasks = new WeakSet();
 addToCachedTasks_fn = /* @__PURE__ */ __name(function(task) {
   this._cachedTasks.set(task.idempotencyKey, task);
 }, "#addToCachedTasks");
+_doRunTask = new WeakSet();
+doRunTask_fn = /* @__PURE__ */ __name(async function(task1) {
+  try {
+    return await this._apiClient.runTask(this._id, task1, {
+      cachedTasksCursor: this._cachedTasksCursor
+    });
+  } catch (error) {
+    if (error instanceof AutoYieldRateLimitError) {
+      this._logger.debug("AutoYieldRateLimitError", {
+        error
+      });
+      throw error;
+    }
+    return;
+  }
+}, "#doRunTask");
+_doCompleteTask = new WeakSet();
+doCompleteTask_fn = /* @__PURE__ */ __name(async function(id, task2) {
+  try {
+    return await this._apiClient.completeTask(this._id, id, task2);
+  } catch (error) {
+    return;
+  }
+}, "#doCompleteTask");
 _detectAutoYield = new WeakSet();
-detectAutoYield_fn = /* @__PURE__ */ __name(function(location, threshold = 1500, task1, output) {
+detectAutoYield_fn = /* @__PURE__ */ __name(function(location, threshold = 1500, task3, output) {
   const timeRemaining = __privateMethod(this, _getRemainingTimeInMillis, getRemainingTimeInMillis_fn).call(this);
   if (timeRemaining && timeRemaining < threshold) {
-    if (task1) {
-      throw new AutoYieldWithCompletedTaskExecutionError(task1.id, task1.outputProperties ?? [], {
+    if (task3) {
+      throw new AutoYieldWithCompletedTaskExecutionError(task3.id, task3.outputProperties ?? [], {
         location,
         timeRemaining,
         timeElapsed: __privateMethod(this, _getTimeElapsed, getTimeElapsed_fn).call(this)
@@ -1662,10 +1701,18 @@ detectAutoYield_fn = /* @__PURE__ */ __name(function(location, threshold = 1500,
   }
 }, "#detectAutoYield");
 _forceYield = new WeakSet();
-forceYield_fn = /* @__PURE__ */ __name(function(location1) {
+forceYield_fn = /* @__PURE__ */ __name(function(location1, task4, output1) {
   const timeRemaining = __privateMethod(this, _getRemainingTimeInMillis, getRemainingTimeInMillis_fn).call(this);
   if (timeRemaining) {
-    throw new AutoYieldExecutionError(location1, timeRemaining, __privateMethod(this, _getTimeElapsed, getTimeElapsed_fn).call(this));
+    if (task4) {
+      throw new AutoYieldWithCompletedTaskExecutionError(task4.id, task4.outputProperties ?? [], {
+        location: location1,
+        timeRemaining,
+        timeElapsed: __privateMethod(this, _getTimeElapsed, getTimeElapsed_fn).call(this)
+      }, output1);
+    } else {
+      throw new AutoYieldExecutionError(location1, timeRemaining, __privateMethod(this, _getTimeElapsed, getTimeElapsed_fn).call(this));
+    }
   }
 }, "#forceYield");
 _getTimeElapsed = new WeakSet();
@@ -1835,6 +1882,18 @@ __name(_KeyValueStoreClient, "KeyValueStoreClient");
 var KeyValueStoreClient = _KeyValueStoreClient;
 
 // src/apiClient.ts
+var _UnknownVersionError = class _UnknownVersionError extends Error {
+  constructor(version2) {
+    super(`Unknown version ${version2}`);
+  }
+};
+__name(_UnknownVersionError, "UnknownVersionError");
+var UnknownVersionError = _UnknownVersionError;
+var MAX_RETRIES = 8;
+var EXPONENT_FACTOR = 2;
+var MIN_DELAY_IN_MS = 80;
+var MAX_DELAY_IN_MS = 2e3;
+var JITTER_IN_MS = 50;
 var _apiUrl, _options, _logger, _storeClient, _queryKeyValueStore, queryKeyValueStore_fn, _apiKey, apiKey_fn;
 var _ApiClient = class _ApiClient {
   constructor(options) {
@@ -1877,10 +1936,8 @@ var _ApiClient = class _ApiClient {
   }
   async runTask(runId, task, options = {}) {
     const apiKey = await __privateMethod(this, _apiKey, apiKey_fn).call(this);
-    __privateGet(this, _logger).debug("Running Task", {
-      task
-    });
-    return await zodfetchWithVersions({
+    __privateGet(this, _logger).debug(`[ApiClient] runTask ${task.displayKey}`);
+    return await zodfetchWithVersions(__privateGet(this, _logger), {
       [API_VERSIONS.LAZY_LOADED_CACHED_TASKS]: RunTaskResponseWithCachedTasksBodySchema
     }, ServerTaskSchema, `${__privateGet(this, _apiUrl)}/api/v1/runs/${runId}/tasks`, {
       method: "POST",
@@ -2315,39 +2372,91 @@ function getApiKey(key) {
   };
 }
 __name(getApiKey, "getApiKey");
-async function zodfetchWithVersions(versionedSchemaMap, unversionedSchema, url, requestInit, options, retryCount = 0) {
-  const response = await fetch(url, requestInitWithCache(requestInit));
-  if ((!requestInit || requestInit.method === "GET") && response.status === 404 && options?.optional) {
-    return;
-  }
-  if (response.status >= 400 && response.status < 500) {
-    const body = await response.json();
-    throw new Error(body.error);
-  }
-  if (response.status >= 500 && retryCount < 6) {
-    const delay = exponentialBackoff(retryCount + 1, 2, 50, 1150, 50);
-    await new Promise((resolve) => setTimeout(resolve, delay));
-    return zodfetchWithVersions(versionedSchemaMap, unversionedSchema, url, requestInit, options, retryCount + 1);
-  }
-  if (response.status !== 200) {
-    throw new Error(options?.errorMessage ?? `Failed to fetch ${url}, got status code ${response.status}`);
-  }
-  const jsonBody = await response.json();
-  const version2 = response.headers.get("trigger-version");
-  if (!version2) {
+async function zodfetchWithVersions(logger, versionedSchemaMap, unversionedSchema, url, requestInit, options, retryCount = 0) {
+  try {
+    const fullRequestInit = requestInitWithCache(requestInit);
+    const response = await fetch(url, fullRequestInit);
+    logger.debug(`[ApiClient] zodfetchWithVersions ${url} (attempt ${retryCount + 1})`, {
+      url,
+      retryCount,
+      requestHeaders: fullRequestInit?.headers,
+      responseHeaders: Object.fromEntries(response.headers.entries())
+    });
+    if ((!requestInit || requestInit.method === "GET") && response.status === 404 && options?.optional) {
+      return;
+    }
+    if (response.status === 429) {
+      const retryAfter = response.headers.get("x-ratelimit-reset");
+      if (retryAfter) {
+        throw new AutoYieldRateLimitError(parseInt(retryAfter));
+      }
+    }
+    if (response.status >= 400 && response.status < 500) {
+      const rawBody = await safeResponseText(response);
+      const body = safeJsonParse(rawBody);
+      logger.error(`[ApiClient] zodfetchWithVersions failed with ${response.status}`, {
+        url,
+        retryCount,
+        requestHeaders: fullRequestInit?.headers,
+        responseHeaders: Object.fromEntries(response.headers.entries()),
+        status: response.status,
+        rawBody
+      });
+      if (body && body.error) {
+        throw new Error(body.error);
+      } else {
+        throw new Error(rawBody);
+      }
+    }
+    if (response.status >= 500 && retryCount < MAX_RETRIES) {
+      const delay = exponentialBackoff(retryCount + 1);
+      await new Promise((resolve) => setTimeout(resolve, delay));
+      return zodfetchWithVersions(logger, versionedSchemaMap, unversionedSchema, url, requestInit, options, retryCount + 1);
+    }
+    if (response.status !== 200) {
+      const rawBody = await safeResponseText(response);
+      logger.error(`[ApiClient] zodfetchWithVersions failed with ${response.status}`, {
+        url,
+        retryCount,
+        requestHeaders: fullRequestInit?.headers,
+        responseHeaders: Object.fromEntries(response.headers.entries()),
+        status: response.status,
+        rawBody
+      });
+      throw new Error(options?.errorMessage ?? `Failed to fetch ${url}, got status code ${response.status}`);
+    }
+    const jsonBody = await response.json();
+    const version2 = response.headers.get("trigger-version");
+    if (!version2) {
+      return {
+        version: "unversioned",
+        body: unversionedSchema.parse(jsonBody)
+      };
+    }
+    const versionedSchema = versionedSchemaMap[version2];
+    if (!versionedSchema) {
+      throw new UnknownVersionError(version2);
+    }
     return {
-      version: "unversioned",
-      body: unversionedSchema.parse(jsonBody)
+      version: version2,
+      body: versionedSchema.parse(jsonBody)
     };
+  } catch (error) {
+    if (error instanceof UnknownVersionError || error instanceof AutoYieldRateLimitError) {
+      throw error;
+    }
+    logger.error(`[ApiClient] zodfetchWithVersions failed with a connection error`, {
+      url,
+      retryCount,
+      error
+    });
+    if (retryCount < MAX_RETRIES) {
+      const delay = exponentialBackoff(retryCount + 1);
+      await new Promise((resolve) => setTimeout(resolve, delay));
+      return zodfetchWithVersions(logger, versionedSchemaMap, unversionedSchema, url, requestInit, options, retryCount + 1);
+    }
+    throw error;
   }
-  const versionedSchema = versionedSchemaMap[version2];
-  if (!versionedSchema) {
-    throw new Error(`Unknown version ${version2}`);
-  }
-  return {
-    version: version2,
-    body: versionedSchema.parse(jsonBody)
-  };
 }
 __name(zodfetchWithVersions, "zodfetchWithVersions");
 function requestInitWithCache(requestInit) {
@@ -2369,8 +2478,8 @@ async function fetchHead(url, requestInitWithoutMethod, retryCount = 0) {
     method: "HEAD"
   };
   const response = await fetch(url, requestInitWithCache(requestInit));
-  if (response.status >= 500 && retryCount < 6) {
-    const delay = exponentialBackoff(retryCount + 1, 2, 50, 1150, 50);
+  if (response.status >= 500 && retryCount < MAX_RETRIES) {
+    const delay = exponentialBackoff(retryCount + 1);
     await new Promise((resolve) => setTimeout(resolve, delay));
     return fetchHead(url, requestInitWithoutMethod, retryCount + 1);
   }
@@ -2378,32 +2487,66 @@ async function fetchHead(url, requestInitWithoutMethod, retryCount = 0) {
 }
 __name(fetchHead, "fetchHead");
 async function zodfetch(schema, url, requestInit, options, retryCount = 0) {
-  const response = await fetch(url, requestInitWithCache(requestInit));
-  if ((!requestInit || requestInit.method === "GET") && response.status === 404 && options?.optional) {
-    return;
-  }
-  if (response.status >= 400 && response.status < 500) {
-    const body = await response.json();
-    throw new Error(body.error);
-  }
-  if (response.status >= 500 && retryCount < 6) {
-    const delay = exponentialBackoff(retryCount + 1, 2, 50, 1150, 50);
-    await new Promise((resolve) => setTimeout(resolve, delay));
-    return zodfetch(schema, url, requestInit, options, retryCount + 1);
-  }
-  if (response.status !== 200) {
-    throw new Error(options?.errorMessage ?? `Failed to fetch ${url}, got status code ${response.status}`);
+  try {
+    const response = await fetch(url, requestInitWithCache(requestInit));
+    if ((!requestInit || requestInit.method === "GET") && response.status === 404 && options?.optional) {
+      return;
+    }
+    if (response.status === 429) {
+      const retryAfter = response.headers.get("x-ratelimit-reset");
+      if (retryAfter) {
+        throw new AutoYieldRateLimitError(parseInt(retryAfter));
+      }
+    }
+    if (response.status >= 400 && response.status < 500) {
+      const body = await response.json();
+      throw new Error(body.error);
+    }
+    if (response.status >= 500 && retryCount < MAX_RETRIES) {
+      const delay = exponentialBackoff(retryCount + 1);
+      await new Promise((resolve) => setTimeout(resolve, delay));
+      return zodfetch(schema, url, requestInit, options, retryCount + 1);
+    }
+    if (response.status !== 200) {
+      throw new Error(options?.errorMessage ?? `Failed to fetch ${url}, got status code ${response.status}`);
+    }
+    const jsonBody = await response.json();
+    return schema.parse(jsonBody);
+  } catch (error) {
+    if (error instanceof AutoYieldRateLimitError) {
+      throw error;
+    }
+    if (retryCount < MAX_RETRIES) {
+      const delay = exponentialBackoff(retryCount + 1);
+      await new Promise((resolve) => setTimeout(resolve, delay));
+      return zodfetch(schema, url, requestInit, options, retryCount + 1);
+    }
+    throw error;
   }
-  const jsonBody = await response.json();
-  return schema.parse(jsonBody);
 }
 __name(zodfetch, "zodfetch");
-function exponentialBackoff(retryCount, exponential, minDelay, maxDelay, jitter) {
-  const delay = Math.min(Math.pow(exponential, retryCount) * minDelay, maxDelay);
-  const jitterValue = Math.random() * jitter;
+function exponentialBackoff(retryCount) {
+  const delay = Math.min(Math.pow(EXPONENT_FACTOR, retryCount) * MIN_DELAY_IN_MS, MAX_DELAY_IN_MS);
+  const jitterValue = Math.random() * JITTER_IN_MS;
   return delay + jitterValue;
 }
 __name(exponentialBackoff, "exponentialBackoff");
+function safeJsonParse(rawBody) {
+  try {
+    return JSON.parse(rawBody);
+  } catch (error) {
+    return;
+  }
+}
+__name(safeJsonParse, "safeJsonParse");
+async function safeResponseText(response) {
+  try {
+    return await response.text();
+  } catch (error) {
+    return "";
+  }
+}
+__name(safeResponseText, "safeResponseText");
 
 // src/concurrencyLimit.ts
 var _ConcurrencyLimit = class _ConcurrencyLimit {
@@ -3019,11 +3162,14 @@ var _TriggerClient = class _TriggerClient {
     __publicField(this, "on", __privateGet(this, _eventEmitter).on.bind(__privateGet(this, _eventEmitter)));
     this.id = options.id;
     __privateSet(this, _options4, options);
-    __privateSet(this, _client2, new ApiClient(__privateGet(this, _options4)));
     __privateSet(this, _internalLogger, new Logger("trigger.dev", __privateGet(this, _options4).verbose ? "debug" : "log", [
       "output",
       "noopTasksSet"
     ]));
+    __privateSet(this, _client2, new ApiClient({
+      logLevel: __privateGet(this, _options4).verbose ? "debug" : "log",
+      ...__privateGet(this, _options4)
+    }));
     __privateSet(this, _envStore, new KeyValueStore(__privateGet(this, _client2)));
   }
   async handleRequest(request, timeOrigin = performance.now()) {
@@ -3850,6 +3996,12 @@ convertErrorToExecutionResponse_fn = /* @__PURE__ */ __name(function(error, body
       }
     };
   }
+  if (error instanceof AutoYieldRateLimitError) {
+    return {
+      status: "AUTO_YIELD_RATE_LIMIT",
+      reset: error.resetAtTimestamp
+    };
+  }
   if (error instanceof YieldExecutionError) {
     return {
       status: "YIELD_EXECUTION",