@trigger.dev/sdk 3.0.0-beta.26 → 3.0.0-beta.28

package/dist/v3/index.js

@@ -1,8 +1,8 @@
 'use strict';
 
+var v3 = require('@trigger.dev/core/v3');
 var api = require('@opentelemetry/api');
 var semanticConventions = require('@opentelemetry/semantic-conventions');
-var v3 = require('@trigger.dev/core/v3');
 var node_async_hooks = require('node:async_hooks');
 
 var __defProp = Object.defineProperty;
@@ -18,921 +18,932 @@ var __publicField = (obj, key, value) => {
 };
 
 // package.json
-var version = "3.0.0-beta.26";
+var version = "3.0.0-beta.28";
+
+// src/v3/tracer.ts
 var tracer = new v3.TriggerTracer({
   name: "@trigger.dev/sdk",
   version
 });
 
-// src/v3/shared.ts
-function queue(options) {
-  return options;
-}
-__name(queue, "queue");
-function createTask(params) {
-  const task3 = {
-    id: params.id,
-    trigger: async (payload, options) => {
-      const apiClient = v3.apiClientManager.client;
-      if (!apiClient) {
-        throw apiClientMissingError();
+// src/v3/cache.ts
+var _InMemoryCache = class _InMemoryCache {
+  constructor() {
+    __publicField(this, "_cache", /* @__PURE__ */ new Map());
+  }
+  get(key) {
+    return this._cache.get(key);
+  }
+  set(key, value) {
+    this._cache.set(key, value);
+    return void 0;
+  }
+  delete(key) {
+    this._cache.delete(key);
+    return void 0;
+  }
+};
+__name(_InMemoryCache, "InMemoryCache");
+var InMemoryCache = _InMemoryCache;
+function createCache(store) {
+  return /* @__PURE__ */ __name(function cache(cacheKey, fn) {
+    return tracer.startActiveSpan("cache", async (span) => {
+      span.setAttribute("cache.key", cacheKey);
+      span.setAttribute(v3.SemanticInternalAttributes.STYLE_ICON, "device-sd-card");
+      const cacheEntry = await store.get(cacheKey);
+      if (cacheEntry) {
+        span.updateName(`cache.hit ${cacheKey}`);
+        return cacheEntry.value;
       }
-      const taskMetadata = v3.taskCatalog.getTaskMetadata(params.id);
-      const payloadPacket = await v3.stringifyIO(payload);
-      const handle = await tracer.startActiveSpan(taskMetadata ? "Trigger" : `${params.id} trigger()`, async (span) => {
-        const response = await apiClient.triggerTask(params.id, {
-          payload: payloadPacket.data,
-          options: {
-            queue: params.queue,
-            concurrencyKey: options?.concurrencyKey,
-            test: v3.taskContext.ctx?.run.isTest,
-            payloadType: payloadPacket.dataType,
-            idempotencyKey: options?.idempotencyKey
-          }
-        }, {
-          spanParentAsLink: true
-        });
-        span.setAttribute("messaging.message.id", response.id);
-        return response;
+      span.updateName(`cache.miss ${cacheKey}`);
+      const value = await tracer.startActiveSpan("cache.getFreshValue", async (span2) => {
+        return await fn();
       }, {
-        kind: api.SpanKind.PRODUCER,
         attributes: {
-          [semanticConventions.SEMATTRS_MESSAGING_OPERATION]: "publish",
-          [v3.SemanticInternalAttributes.STYLE_ICON]: "trigger",
-          ["messaging.client_id"]: v3.taskContext.worker?.id,
-          [semanticConventions.SEMATTRS_MESSAGING_DESTINATION]: params.queue?.name ?? params.id,
-          [semanticConventions.SEMATTRS_MESSAGING_SYSTEM]: "trigger.dev",
-          ...taskMetadata ? v3.accessoryAttributes({
-            items: [
-              {
-                text: `${taskMetadata.exportName}.trigger()`,
-                variant: "normal"
-              }
-            ],
-            style: "codepath"
-          }) : {}
+          "cache.key": cacheKey,
+          [v3.SemanticInternalAttributes.STYLE_ICON]: "device-sd-card"
         }
       });
-      return handle;
-    },
-    batchTrigger: async (items) => {
-      const apiClient = v3.apiClientManager.client;
-      if (!apiClient) {
-        throw apiClientMissingError();
-      }
-      const taskMetadata = v3.taskCatalog.getTaskMetadata(params.id);
-      const response = await tracer.startActiveSpan(taskMetadata ? "Batch trigger" : `${params.id} batchTrigger()`, async (span) => {
-        const response2 = await apiClient.batchTriggerTask(params.id, {
-          items: await Promise.all(items.map(async (item) => {
-            const payloadPacket = await v3.stringifyIO(item.payload);
-            return {
-              payload: payloadPacket.data,
-              options: {
-                queue: item.options?.queue ?? params.queue,
-                concurrencyKey: item.options?.concurrencyKey,
-                test: v3.taskContext.ctx?.run.isTest,
-                payloadType: payloadPacket.dataType,
-                idempotencyKey: item.options?.idempotencyKey
-              }
-            };
-          }))
-        }, {
-          spanParentAsLink: true
+      await tracer.startActiveSpan("cache.set", async (span2) => {
+        await store.set(cacheKey, {
+          value,
+          metadata: {
+            createdTime: Date.now()
+          }
         });
-        span.setAttribute("messaging.message.id", response2.batchId);
-        return response2;
       }, {
-        kind: api.SpanKind.PRODUCER,
         attributes: {
-          [semanticConventions.SEMATTRS_MESSAGING_OPERATION]: "publish",
-          ["messaging.batch.message_count"]: items.length,
-          ["messaging.client_id"]: v3.taskContext.worker?.id,
-          [semanticConventions.SEMATTRS_MESSAGING_DESTINATION]: params.queue?.name ?? params.id,
-          [semanticConventions.SEMATTRS_MESSAGING_SYSTEM]: "trigger.dev",
-          [v3.SemanticInternalAttributes.STYLE_ICON]: "trigger",
-          ...taskMetadata ? v3.accessoryAttributes({
+          "cache.key": cacheKey,
+          [v3.SemanticInternalAttributes.STYLE_ICON]: "device-sd-card"
+        }
+      });
+      return value;
+    });
+  }, "cache");
+}
+__name(createCache, "createCache");
+function onThrow(fn, options) {
+  const opts = {
+    ...v3.defaultRetryOptions,
+    ...options
+  };
+  return tracer.startActiveSpan(`retry.onThrow()`, async (span) => {
+    let attempt = 1;
+    while (attempt <= opts.maxAttempts) {
+      const innerSpan = tracer.startSpan("retry.fn()", {
+        attributes: {
+          [v3.SemanticInternalAttributes.STYLE_ICON]: "function",
+          ...v3.accessoryAttributes({
             items: [
               {
-                text: `${taskMetadata.exportName}.batchTrigger()`,
+                text: `${attempt}/${opts.maxAttempts}`,
                 variant: "normal"
               }
             ],
             style: "codepath"
-          }) : {}
+          })
         }
       });
-      return response;
-    },
-    triggerAndWait: async (payload, options) => {
-      const ctx = v3.taskContext.ctx;
-      if (!ctx) {
-        throw new Error("triggerAndWait can only be used from inside a task.run()");
-      }
-      const apiClient = v3.apiClientManager.client;
-      if (!apiClient) {
-        throw apiClientMissingError();
-      }
-      const taskMetadata = v3.taskCatalog.getTaskMetadata(params.id);
-      const payloadPacket = await v3.stringifyIO(payload);
-      return await tracer.startActiveSpan(taskMetadata ? "Trigger" : `${params.id} triggerAndWait()`, async (span) => {
-        const response = await apiClient.triggerTask(params.id, {
-          payload: payloadPacket.data,
-          options: {
-            dependentAttempt: ctx.attempt.id,
-            lockToVersion: v3.taskContext.worker?.version,
-            queue: params.queue,
-            concurrencyKey: options?.concurrencyKey,
-            test: v3.taskContext.ctx?.run.isTest,
-            payloadType: payloadPacket.dataType,
-            idempotencyKey: options?.idempotencyKey
-          }
+      const contextWithSpanSet = api.trace.setSpan(api.context.active(), innerSpan);
+      try {
+        const result = await api.context.with(contextWithSpanSet, async () => {
+          return fn({
+            attempt,
+            maxAttempts: opts.maxAttempts
+          });
         });
-        span.setAttribute("messaging.message.id", response.id);
-        if (options?.idempotencyKey) {
-          const result2 = await apiClient.getRunResult(response.id);
-          if (result2) {
-            v3.logger.log(`Result reused from previous task run with idempotency key '${options.idempotencyKey}'.`, {
-              runId: response.id,
-              idempotencyKey: options.idempotencyKey
-            });
-            return await handleTaskRunExecutionResult(result2);
-          }
+        innerSpan.end();
+        return result;
+      } catch (e) {
+        if (e instanceof Error || typeof e === "string") {
+          innerSpan.recordException(e);
+        } else {
+          innerSpan.recordException(String(e));
         }
-        const result = await v3.runtime.waitForTask({
-          id: response.id,
-          ctx
+        innerSpan.setStatus({
+          code: api.SpanStatusCode.ERROR
         });
-        return await handleTaskRunExecutionResult(result);
-      }, {
-        kind: api.SpanKind.PRODUCER,
-        attributes: {
-          [v3.SemanticInternalAttributes.STYLE_ICON]: "trigger",
-          [semanticConventions.SEMATTRS_MESSAGING_OPERATION]: "publish",
-          ["messaging.client_id"]: v3.taskContext.worker?.id,
-          [semanticConventions.SEMATTRS_MESSAGING_DESTINATION]: params.queue?.name ?? params.id,
-          [semanticConventions.SEMATTRS_MESSAGING_SYSTEM]: "trigger.dev",
-          ...taskMetadata ? v3.accessoryAttributes({
-            items: [
-              {
-                text: `${taskMetadata.exportName}.triggerAndWait()`,
-                variant: "normal"
-              }
-            ],
-            style: "codepath"
-          }) : {}
+        const nextRetryDelay = v3.calculateNextRetryDelay(opts, attempt);
+        if (!nextRetryDelay) {
+          innerSpan.end();
+          throw e;
         }
-      });
-    },
-    batchTriggerAndWait: async (items) => {
-      const ctx = v3.taskContext.ctx;
-      if (!ctx) {
-        throw new Error("batchTriggerAndWait can only be used from inside a task.run()");
-      }
-      const apiClient = v3.apiClientManager.client;
-      if (!apiClient) {
-        throw apiClientMissingError();
+        innerSpan.setAttribute(v3.SemanticInternalAttributes.RETRY_AT, new Date(Date.now() + nextRetryDelay).toISOString());
+        innerSpan.setAttribute(v3.SemanticInternalAttributes.RETRY_COUNT, attempt);
+        innerSpan.setAttribute(v3.SemanticInternalAttributes.RETRY_DELAY, `${nextRetryDelay}ms`);
+        innerSpan.end();
+        await v3.runtime.waitForDuration(nextRetryDelay);
+      } finally {
+        attempt++;
       }
-      const taskMetadata = v3.taskCatalog.getTaskMetadata(params.id);
-      return await tracer.startActiveSpan(taskMetadata ? "Batch trigger" : `${params.id} batchTriggerAndWait()`, async (span) => {
-        const response = await apiClient.batchTriggerTask(params.id, {
-          items: await Promise.all(items.map(async (item) => {
-            const payloadPacket = await v3.stringifyIO(item.payload);
-            return {
-              payload: payloadPacket.data,
-              options: {
-                lockToVersion: v3.taskContext.worker?.version,
-                queue: item.options?.queue ?? params.queue,
-                concurrencyKey: item.options?.concurrencyKey,
-                test: v3.taskContext.ctx?.run.isTest,
-                payloadType: payloadPacket.dataType,
-                idempotencyKey: item.options?.idempotencyKey
-              }
-            };
-          })),
-          dependentAttempt: ctx.attempt.id
-        });
-        span.setAttribute("messaging.message.id", response.batchId);
-        const getBatchResults = /* @__PURE__ */ __name(async () => {
-          const hasIdempotencyKey = items.some((item) => item.options?.idempotencyKey);
-          if (hasIdempotencyKey) {
-            const results = await apiClient.getBatchResults(response.batchId);
-            if (results) {
-              return results;
-            }
+    }
+    throw new Error("Max attempts reached");
+  }, {
+    attributes: {
+      [v3.SemanticInternalAttributes.STYLE_ICON]: "arrow-capsule"
+    }
+  });
+}
+__name(onThrow, "onThrow");
+var normalizeUrlFromInput = /* @__PURE__ */ __name((input) => {
+  if (typeof input === "string") {
+    return new URL(input);
+  }
+  if (input instanceof URL) {
+    return input;
+  }
+  return new URL(input.url);
+}, "normalizeUrlFromInput");
+var normalizeHttpMethod = /* @__PURE__ */ __name((input, init) => {
+  if (typeof input === "string" || input instanceof URL) {
+    return (init?.method || "GET").toUpperCase();
+  }
+  return (input.method ?? init?.method ?? "GET").toUpperCase();
+}, "normalizeHttpMethod");
+var fetchHttpHandlerStorage = new node_async_hooks.AsyncLocalStorage();
+var fetchWithInterceptors = /* @__PURE__ */ __name(async (input, init) => {
+  const handlers = fetchHttpHandlerStorage.getStore();
+  if (handlers) {
+    try {
+      const { getResponse } = await import('msw');
+      const request = new Request(input, init);
+      const response = await getResponse(handlers, request);
+      if (response) {
+        return response;
+      }
+    } catch (e) {
+      return fetch(input, init);
+    }
+  }
+  return fetch(input, init);
+}, "fetchWithInterceptors");
+var _a;
+var FetchErrorWithSpan = (_a = class extends Error {
+  constructor(originalError, span) {
+    super("Fetch error");
+    this.originalError = originalError;
+    this.span = span;
+  }
+}, __name(_a, "FetchErrorWithSpan"), _a);
+var MAX_ATTEMPTS = 10;
+async function retryFetch(input, init) {
+  return tracer.startActiveSpan("retry.fetch()", async (span) => {
+    let attempt = 1;
+    while (true) {
+      try {
+        const abortController = new AbortController();
+        const timeoutId = init?.timeoutInMs ? setTimeout(() => {
+          abortController.abort();
+        }, init?.timeoutInMs) : void 0;
+        init?.signal?.addEventListener("abort", () => {
+          abortController.abort();
+        });
+        const [response, span2] = await doFetchRequest(input, {
+          ...init ?? {},
+          signal: abortController.signal
+        }, attempt);
+        if (timeoutId) {
+          clearTimeout(timeoutId);
+        }
+        if (response.ok) {
+          span2.setAttributes(createFetchResponseAttributes(response));
+          span2.end();
+          return response;
+        }
+        const nextRetry = await calculateRetryDelayForResponse(resolveDefaults(init?.retry, "byStatus", v3.defaultFetchRetryOptions.byStatus), response, attempt);
+        if (!nextRetry) {
+          span2.setAttributes(createFetchResponseAttributes(response));
+          span2.end();
+          return response;
+        }
+        if (attempt >= MAX_ATTEMPTS) {
+          span2.setAttributes(createFetchResponseAttributes(response));
+          span2.end();
+          return response;
+        }
+        if (nextRetry.type === "delay") {
+          span2.setAttribute(v3.SemanticInternalAttributes.RETRY_AT, new Date(Date.now() + nextRetry.value).toISOString());
+          span2.setAttribute(v3.SemanticInternalAttributes.RETRY_COUNT, attempt);
+          span2.setAttribute(v3.SemanticInternalAttributes.RETRY_DELAY, `${nextRetry.value}ms`);
+          span2.end();
+          await v3.runtime.waitForDuration(nextRetry.value);
+        } else {
+          const now = Date.now();
+          const nextRetryDate = new Date(nextRetry.value);
+          const isInFuture = nextRetryDate.getTime() > now;
+          span2.setAttribute(v3.SemanticInternalAttributes.RETRY_AT, new Date(nextRetry.value).toISOString());
+          span2.setAttribute(v3.SemanticInternalAttributes.RETRY_COUNT, attempt);
+          if (isInFuture) {
+            span2.setAttribute(v3.SemanticInternalAttributes.RETRY_DELAY, `${nextRetry.value - now}ms`);
           }
-          return {
-            id: response.batchId,
-            items: []
-          };
-        }, "getBatchResults");
-        const existingResults = await getBatchResults();
-        const incompleteRuns = response.runs.filter((runId) => !existingResults.items.some((item) => item.id === runId));
-        if (incompleteRuns.length === 0) {
-          v3.logger.log(`Results reused from previous task runs because of the provided idempotency keys.`);
-          const runs3 = await handleBatchTaskRunExecutionResult(existingResults.items);
-          return {
-            id: existingResults.id,
-            runs: runs3
-          };
+          span2.end();
+          await v3.runtime.waitUntil(new Date(nextRetry.value));
         }
-        const result = await v3.runtime.waitForBatch({
-          id: response.batchId,
-          runs: incompleteRuns,
-          ctx
-        });
-        const combinedItems = [];
-        for (const runId of response.runs) {
-          const existingItem = existingResults.items.find((item) => item.id === runId);
-          if (existingItem) {
-            combinedItems.push(existingItem);
-          } else {
-            const newItem = result.items.find((item) => item.id === runId);
-            if (newItem) {
-              combinedItems.push(newItem);
+      } catch (e) {
+        if (e instanceof FetchErrorWithSpan && e.originalError instanceof Error) {
+          if (e.originalError.name === "AbortError") {
+            const nextRetryDelay = v3.calculateNextRetryDelay(resolveDefaults(init?.retry, "timeout", v3.defaultFetchRetryOptions.timeout), attempt);
+            if (!nextRetryDelay) {
+              e.span.end();
+              throw e;
             }
+            if (attempt >= MAX_ATTEMPTS) {
+              e.span.end();
+              throw e;
+            }
+            e.span.setAttribute(v3.SemanticInternalAttributes.RETRY_AT, new Date(Date.now() + nextRetryDelay).toISOString());
+            e.span.setAttribute(v3.SemanticInternalAttributes.RETRY_COUNT, attempt);
+            e.span.setAttribute(v3.SemanticInternalAttributes.RETRY_DELAY, `${nextRetryDelay}ms`);
+            e.span.end();
+            await v3.runtime.waitForDuration(nextRetryDelay);
+            continue;
+          } else if (e.originalError.name === "TypeError" && "cause" in e.originalError && e.originalError.cause instanceof Error) {
+            const nextRetryDelay = v3.calculateNextRetryDelay(resolveDefaults(init?.retry, "connectionError", v3.defaultFetchRetryOptions.connectionError), attempt);
+            if (!nextRetryDelay) {
+              e.span.end();
+              throw e;
+            }
+            if (attempt >= MAX_ATTEMPTS) {
+              e.span.end();
+              throw e;
+            }
+            e.span.setAttribute(v3.SemanticInternalAttributes.RETRY_AT, new Date(Date.now() + nextRetryDelay).toISOString());
+            e.span.setAttribute(v3.SemanticInternalAttributes.RETRY_COUNT, attempt);
+            e.span.setAttribute(v3.SemanticInternalAttributes.RETRY_DELAY, `${nextRetryDelay}ms`);
+            e.span.end();
+            await v3.runtime.waitForDuration(nextRetryDelay);
+            continue;
           }
         }
-        const runs2 = await handleBatchTaskRunExecutionResult(combinedItems);
-        return {
-          id: result.id,
-          runs: runs2
-        };
-      }, {
-        kind: api.SpanKind.PRODUCER,
-        attributes: {
-          [semanticConventions.SEMATTRS_MESSAGING_OPERATION]: "publish",
-          ["messaging.batch.message_count"]: items.length,
-          ["messaging.client_id"]: v3.taskContext.worker?.id,
-          [semanticConventions.SEMATTRS_MESSAGING_DESTINATION]: params.queue?.name ?? params.id,
-          [semanticConventions.SEMATTRS_MESSAGING_SYSTEM]: "trigger.dev",
-          [v3.SemanticInternalAttributes.STYLE_ICON]: "trigger",
-          ...taskMetadata ? v3.accessoryAttributes({
-            items: [
-              {
-                text: `${taskMetadata.exportName}.batchTriggerAndWait()`,
-                variant: "normal"
-              }
-            ],
-            style: "codepath"
-          }) : {}
+        if (e instanceof FetchErrorWithSpan) {
+          e.span.end();
         }
-      });
+        throw e;
+      } finally {
+        attempt++;
+      }
     }
-  };
-  v3.taskCatalog.registerTaskMetadata({
-    id: params.id,
-    packageVersion: version,
-    queue: params.queue,
-    retry: params.retry ? {
-      ...v3.defaultRetryOptions,
-      ...params.retry
-    } : void 0,
-    machine: params.machine,
-    fns: {
-      run: params.run,
-      init: params.init,
-      cleanup: params.cleanup,
-      middleware: params.middleware,
-      handleError: params.handleError,
-      onSuccess: params.onSuccess,
-      onFailure: params.onFailure,
-      onStart: params.onStart
+  }, {
+    attributes: {
+      [v3.SemanticInternalAttributes.STYLE_ICON]: "arrow-capsule",
+      ...createFetchAttributes(input, init),
+      ...createFetchRetryOptionsAttributes(init?.retry)
     }
   });
-  return task3;
 }
-__name(createTask, "createTask");
-async function handleBatchTaskRunExecutionResult(items) {
-  const someObjectStoreOutputs = items.some((item) => item.ok && item.outputType === "application/store");
-  if (!someObjectStoreOutputs) {
-    const results = await Promise.all(items.map(async (item) => {
-      return await handleTaskRunExecutionResult(item);
-    }));
-    return results;
-  }
-  return await tracer.startActiveSpan("store.downloadPayloads", async (span) => {
-    const results = await Promise.all(items.map(async (item) => {
-      return await handleTaskRunExecutionResult(item);
-    }));
-    return results;
-  }, {
-    kind: api.SpanKind.INTERNAL,
-    [v3.SemanticInternalAttributes.STYLE_ICON]: "cloud-download"
+__name(retryFetch, "retryFetch");
+var doFetchRequest = /* @__PURE__ */ __name(async (input, init, attemptCount = 0) => {
+  const httpMethod = normalizeHttpMethod(input, init);
+  const span = tracer.startSpan(`HTTP ${httpMethod}`, {
+    attributes: {
+      [v3.SemanticInternalAttributes.STYLE_ICON]: "world",
+      ...attemptCount > 1 ? {
+        ["http.request.resend_count"]: attemptCount - 1
+      } : {},
+      ...createFetchAttributes(input, init)
+    }
   });
-}
-__name(handleBatchTaskRunExecutionResult, "handleBatchTaskRunExecutionResult");
-async function handleTaskRunExecutionResult(execution) {
-  if (execution.ok) {
-    const outputPacket = {
-      data: execution.output,
-      dataType: execution.outputType
-    };
-    const importedPacket = await v3.conditionallyImportPacket(outputPacket, tracer);
-    return {
-      ok: true,
-      id: execution.id,
-      output: await v3.parsePacket(importedPacket)
-    };
-  } else {
-    return {
-      ok: false,
-      id: execution.id,
-      error: v3.createErrorTaskError(execution.error)
-    };
-  }
-}
-__name(handleTaskRunExecutionResult, "handleTaskRunExecutionResult");
-function apiClientMissingError() {
-  const hasBaseUrl = !!v3.apiClientManager.baseURL;
-  const hasAccessToken = !!v3.apiClientManager.accessToken;
-  if (!hasBaseUrl && !hasAccessToken) {
-    return `You need to set the TRIGGER_API_URL and TRIGGER_SECRET_KEY environment variables.`;
-  } else if (!hasBaseUrl) {
-    return `You need to set the TRIGGER_API_URL environment variable.`;
-  } else if (!hasAccessToken) {
-    return `You need to set the TRIGGER_SECRET_KEY environment variable.`;
-  }
-  return `Unknown error`;
-}
-__name(apiClientMissingError, "apiClientMissingError");
-
-// src/v3/tasks.ts
-function task(options) {
-  return createTask(options);
-}
-__name(task, "task");
-var wait = {
-  for: async (options) => {
-    return tracer.startActiveSpan(`wait.for()`, async (span) => {
-      const durationInMs = calculateDurationInMs(options);
-      await v3.runtime.waitForDuration(durationInMs);
-    }, {
-      attributes: {
-        [v3.SemanticInternalAttributes.STYLE_ICON]: "wait",
-        ...v3.accessoryAttributes({
-          items: [
-            {
-              text: nameForWaitOptions(options),
-              variant: "normal"
-            }
-          ],
-          style: "codepath"
-        })
+  try {
+    const response = await fetchWithInterceptors(input, {
+      ...init,
+      headers: {
+        ...init?.headers,
+        "x-retry-count": attemptCount.toString()
       }
     });
-  },
-  until: async (options) => {
-    return tracer.startActiveSpan(`wait.until()`, async (span) => {
-      const start = Date.now();
-      if (options.throwIfInThePast && options.date < /* @__PURE__ */ new Date()) {
-        throw new Error("Date is in the past");
-      }
-      const durationInMs = options.date.getTime() - start;
-      await v3.runtime.waitForDuration(durationInMs);
-    }, {
-      attributes: {
-        [v3.SemanticInternalAttributes.STYLE_ICON]: "wait",
-        ...v3.accessoryAttributes({
-          items: [
-            {
-              text: options.date.toISOString(),
-              variant: "normal"
-            }
-          ],
-          style: "codepath"
-        })
-      }
+    span.setAttributes(createFetchResponseAttributes(response));
+    if (!response.ok) {
+      span.recordException(`${response.status}: ${response.statusText}`);
+      span.setStatus({
+        code: api.SpanStatusCode.ERROR,
+        message: `${response.status}: ${response.statusText}`
+      });
+    }
+    return [
+      response,
+      span
+    ];
+  } catch (e) {
+    if (typeof e === "string" || e instanceof Error) {
+      span.recordException(e);
+    }
+    span.setStatus({
+      code: api.SpanStatusCode.ERROR
     });
+    span.setAttribute(semanticConventions.SEMATTRS_HTTP_STATUS_CODE, 0);
+    span.setAttribute("http.status_text", "This operation was aborted.");
+    throw new FetchErrorWithSpan(e, span);
   }
-};
-function nameForWaitOptions(options) {
-  if ("seconds" in options) {
-    return options.seconds === 1 ? `1 second` : `${options.seconds} seconds`;
-  }
-  if ("minutes" in options) {
-    return options.minutes === 1 ? `1 minute` : `${options.minutes} minutes`;
-  }
-  if ("hours" in options) {
-    return options.hours === 1 ? `1 hour` : `${options.hours} hours`;
-  }
-  if ("days" in options) {
-    return options.days === 1 ? `1 day` : `${options.days} days`;
-  }
-  if ("weeks" in options) {
-    return options.weeks === 1 ? `1 week` : `${options.weeks} weeks`;
-  }
-  if ("months" in options) {
-    return options.months === 1 ? `1 month` : `${options.months} months`;
-  }
-  if ("years" in options) {
-    return options.years === 1 ? `1 year` : `${options.years} years`;
+}, "doFetchRequest");
+var calculateRetryDelayForResponse = /* @__PURE__ */ __name(async (retry2, response, attemptCount) => {
+  if (!retry2) {
+    return;
   }
-  return "NaN";
-}
-__name(nameForWaitOptions, "nameForWaitOptions");
-function calculateDurationInMs(options) {
-  if ("seconds" in options) {
-    return options.seconds * 1e3;
+  const strategy = await getRetryStrategyForResponse(response, retry2);
+  if (!strategy) {
+    return;
   }
-  if ("minutes" in options) {
-    return options.minutes * 1e3 * 60;
+  switch (strategy.strategy) {
+    case "backoff": {
+      const value = v3.calculateNextRetryDelay({
+        ...v3.defaultRetryOptions,
+        ...strategy
+      }, attemptCount);
+      if (value) {
+        return {
+          type: "delay",
+          value
+        };
+      }
+      break;
+    }
+    case "headers": {
+      const resetAt = response.headers.get(strategy.resetHeader);
+      if (typeof resetAt === "string") {
+        const resetTimestamp = v3.calculateResetAt(resetAt, strategy.resetFormat ?? "unix_timestamp_in_ms");
+        if (resetTimestamp) {
+          return {
+            type: "timestamp",
+            value: resetTimestamp
+          };
+        }
+      }
+      break;
+    }
   }
-  if ("hours" in options) {
-    return options.hours * 1e3 * 60 * 60;
+}, "calculateRetryDelayForResponse");
+var getRetryStrategyForResponse = /* @__PURE__ */ __name(async (response, retry2) => {
+  const statusCodes = Object.keys(retry2);
+  const clonedResponse = response.clone();
+  for (let i = 0; i < statusCodes.length; i++) {
+    const statusRange = statusCodes[i];
+    const strategy = retry2[statusRange];
+    if (isStatusCodeInRange(response.status, statusRange)) {
+      if (strategy.bodyFilter) {
+        const body = safeJsonParse(await clonedResponse.text());
+        if (!body) {
+          continue;
+        }
+        if (v3.eventFilterMatches(body, strategy.bodyFilter)) {
+          return strategy;
+        } else {
+          continue;
+        }
+      }
+      return strategy;
+    }
   }
-  if ("days" in options) {
-    return options.days * 1e3 * 60 * 60 * 24;
+}, "getRetryStrategyForResponse");
+var isStatusCodeInRange = /* @__PURE__ */ __name((statusCode, statusRange) => {
+  if (statusRange === "all") {
+    return true;
   }
-  if ("weeks" in options) {
-    return options.weeks * 1e3 * 60 * 60 * 24 * 7;
+  if (statusRange.includes(",")) {
+    const statusCodes = statusRange.split(",").map((s) => s.trim());
+    return statusCodes.some((s) => isStatusCodeInRange(statusCode, s));
   }
-  if ("months" in options) {
-    return options.months * 1e3 * 60 * 60 * 24 * 30;
+  const [start, end] = statusRange.split("-");
+  if (end) {
+    return statusCode >= parseInt(start, 10) && statusCode <= parseInt(end, 10);
   }
-  if ("years" in options) {
-    return options.years * 1e3 * 60 * 60 * 24 * 365;
+  if (start.endsWith("xx")) {
+    const prefix = start.slice(0, -2);
+    const statusCodePrefix = Math.floor(statusCode / 100).toString();
+    return statusCodePrefix === prefix;
   }
-  throw new Error("Invalid options");
-}
-__name(calculateDurationInMs, "calculateDurationInMs");
-var _InMemoryCache = class _InMemoryCache {
-  constructor() {
-    __publicField(this, "_cache", /* @__PURE__ */ new Map());
+  const statusCodeString = statusCode.toString();
+  const rangePrefix = start.slice(0, -1);
+  if (start.endsWith("x") && statusCodeString.startsWith(rangePrefix)) {
+    return true;
   }
-  get(key) {
-    return this._cache.get(key);
+  return statusCode === parseInt(start, 10);
+}, "isStatusCodeInRange");
+var createAttributesFromHeaders = /* @__PURE__ */ __name((headers) => {
+  const attributes = {};
+  const normalizedHeaderKey = /* @__PURE__ */ __name((key) => {
+    return key.toLowerCase();
+  }, "normalizedHeaderKey");
+  headers.forEach((value, key) => {
+    attributes[`http.response.header.${normalizedHeaderKey(key)}`] = value;
+  });
+  return attributes;
+}, "createAttributesFromHeaders");
+var safeJsonParse = /* @__PURE__ */ __name((json) => {
+  try {
+    return JSON.parse(json);
+  } catch (e) {
+    return null;
   }
-  set(key, value) {
-    this._cache.set(key, value);
-    return void 0;
+}, "safeJsonParse");
+var interceptFetch = /* @__PURE__ */ __name((...handlers) => {
+  return {
+    run: async (fn) => {
+      const current = fetchHttpHandlerStorage.getStore();
+      if (current) {
+        current.push(...handlers);
+        return fn();
+      } else {
+        return fetchHttpHandlerStorage.run(handlers, fn);
+      }
+    }
+  };
+}, "interceptFetch");
+var resolveDefaults = /* @__PURE__ */ __name((obj, key, defaults) => {
+  if (!obj) {
+    return defaults;
   }
-  delete(key) {
-    this._cache.delete(key);
-    return void 0;
+  if (obj[key] === void 0 || obj[key] === null) {
+    return defaults;
   }
-};
-__name(_InMemoryCache, "InMemoryCache");
-var InMemoryCache = _InMemoryCache;
-function createCache(store) {
-  return /* @__PURE__ */ __name(function cache(cacheKey, fn) {
-    return tracer.startActiveSpan("cache", async (span) => {
-      span.setAttribute("cache.key", cacheKey);
-      span.setAttribute(v3.SemanticInternalAttributes.STYLE_ICON, "device-sd-card");
-      const cacheEntry = await store.get(cacheKey);
-      if (cacheEntry) {
-        span.updateName(`cache.hit ${cacheKey}`);
-        return cacheEntry.value;
-      }
-      span.updateName(`cache.miss ${cacheKey}`);
-      const value = await tracer.startActiveSpan("cache.getFreshValue", async (span2) => {
-        return await fn();
-      }, {
-        attributes: {
-          "cache.key": cacheKey,
-          [v3.SemanticInternalAttributes.STYLE_ICON]: "device-sd-card"
+  return obj[key];
+}, "resolveDefaults");
+var createFetchAttributes = /* @__PURE__ */ __name((input, init) => {
+  const url = normalizeUrlFromInput(input);
+  const httpMethod = normalizeHttpMethod(input, init);
+  return {
+    [semanticConventions.SEMATTRS_HTTP_METHOD]: httpMethod,
+    [semanticConventions.SEMATTRS_HTTP_URL]: url.href,
+    [semanticConventions.SEMATTRS_HTTP_HOST]: url.hostname,
+    ["server.host"]: url.hostname,
+    ["server.port"]: url.port,
+    [semanticConventions.SEMATTRS_HTTP_SCHEME]: url.protocol.replace(":", ""),
+    ...v3.accessoryAttributes({
+      items: [
+        {
+          text: url.hostname,
+          variant: "normal"
         }
-      });
-      await tracer.startActiveSpan("cache.set", async (span2) => {
-        await store.set(cacheKey, {
-          value,
-          metadata: {
-            createdTime: Date.now()
+      ],
+      style: "codepath"
+    })
+  };
+}, "createFetchAttributes");
+var createFetchResponseAttributes = /* @__PURE__ */ __name((response) => {
+  return {
+    [semanticConventions.SEMATTRS_HTTP_STATUS_CODE]: response.status,
+    "http.status_text": response.statusText,
+    [semanticConventions.SEMATTRS_HTTP_RESPONSE_CONTENT_LENGTH]: response.headers.get("content-length") || "0",
+    ...createAttributesFromHeaders(response.headers)
+  };
+}, "createFetchResponseAttributes");
+var createFetchRetryOptionsAttributes = /* @__PURE__ */ __name((retry2) => {
+  const byStatus = resolveDefaults(retry2, "byStatus", v3.defaultFetchRetryOptions.byStatus);
+  const connectionError = resolveDefaults(retry2, "connectionError", v3.defaultFetchRetryOptions.connectionError);
+  const timeout = resolveDefaults(retry2, "timeout", v3.defaultFetchRetryOptions.timeout);
+  return {
+    ...v3.flattenAttributes(byStatus, "retry.byStatus"),
+    ...v3.flattenAttributes(connectionError, "retry.connectionError"),
+    ...v3.flattenAttributes(timeout, "retry.timeout")
+  };
+}, "createFetchRetryOptionsAttributes");
+var retry = {
+  onThrow,
+  fetch: retryFetch,
+  interceptFetch
+};
+function queue(options) {
+  return options;
+}
+__name(queue, "queue");
+function createTask(params) {
+  const task3 = {
+    id: params.id,
+    trigger: async (payload, options) => {
+      const apiClient = v3.apiClientManager.client;
+      if (!apiClient) {
+        throw apiClientMissingError();
+      }
+      const taskMetadata = v3.taskCatalog.getTaskMetadata(params.id);
+      const payloadPacket = await v3.stringifyIO(payload);
+      const handle = await tracer.startActiveSpan(taskMetadata ? "Trigger" : `${params.id} trigger()`, async (span) => {
+        const response = await apiClient.triggerTask(params.id, {
+          payload: payloadPacket.data,
+          options: {
+            queue: params.queue,
+            concurrencyKey: options?.concurrencyKey,
+            test: v3.taskContext.ctx?.run.isTest,
+            payloadType: payloadPacket.dataType,
+            idempotencyKey: options?.idempotencyKey
           }
+        }, {
+          spanParentAsLink: true
         });
+        span.setAttribute("messaging.message.id", response.id);
+        return response;
       }, {
+        kind: api.SpanKind.PRODUCER,
         attributes: {
-          "cache.key": cacheKey,
-          [v3.SemanticInternalAttributes.STYLE_ICON]: "device-sd-card"
+          [semanticConventions.SEMATTRS_MESSAGING_OPERATION]: "publish",
+          [v3.SemanticInternalAttributes.STYLE_ICON]: "trigger",
+          ["messaging.client_id"]: v3.taskContext.worker?.id,
+          [semanticConventions.SEMATTRS_MESSAGING_DESTINATION]: params.queue?.name ?? params.id,
+          [semanticConventions.SEMATTRS_MESSAGING_SYSTEM]: "trigger.dev",
+          ...taskMetadata ? v3.accessoryAttributes({
+            items: [
+              {
+                text: `${taskMetadata.exportName}.trigger()`,
+                variant: "normal"
+              }
+            ],
+            style: "codepath"
+          }) : {}
         }
       });
-      return value;
-    });
-  }, "cache");
-}
-__name(createCache, "createCache");
-function onThrow(fn, options) {
-  const opts = {
-    ...v3.defaultRetryOptions,
-    ...options
-  };
-  return tracer.startActiveSpan(`retry.onThrow()`, async (span) => {
-    let attempt = 1;
-    while (attempt <= opts.maxAttempts) {
-      const innerSpan = tracer.startSpan("retry.fn()", {
+      return handle;
+    },
+    batchTrigger: async (items) => {
+      const apiClient = v3.apiClientManager.client;
+      if (!apiClient) {
+        throw apiClientMissingError();
+      }
+      const taskMetadata = v3.taskCatalog.getTaskMetadata(params.id);
+      const response = await tracer.startActiveSpan(taskMetadata ? "Batch trigger" : `${params.id} batchTrigger()`, async (span) => {
+        const response2 = await apiClient.batchTriggerTask(params.id, {
+          items: await Promise.all(items.map(async (item) => {
+            const payloadPacket = await v3.stringifyIO(item.payload);
+            return {
+              payload: payloadPacket.data,
+              options: {
+                queue: item.options?.queue ?? params.queue,
+                concurrencyKey: item.options?.concurrencyKey,
+                test: v3.taskContext.ctx?.run.isTest,
+                payloadType: payloadPacket.dataType,
+                idempotencyKey: item.options?.idempotencyKey
+              }
+            };
+          }))
+        }, {
+          spanParentAsLink: true
+        });
+        span.setAttribute("messaging.message.id", response2.batchId);
+        return response2;
+      }, {
+        kind: api.SpanKind.PRODUCER,
         attributes: {
-          [v3.SemanticInternalAttributes.STYLE_ICON]: "function",
-          ...v3.accessoryAttributes({
+          [semanticConventions.SEMATTRS_MESSAGING_OPERATION]: "publish",
+          ["messaging.batch.message_count"]: items.length,
+          ["messaging.client_id"]: v3.taskContext.worker?.id,
+          [semanticConventions.SEMATTRS_MESSAGING_DESTINATION]: params.queue?.name ?? params.id,
+          [semanticConventions.SEMATTRS_MESSAGING_SYSTEM]: "trigger.dev",
+          [v3.SemanticInternalAttributes.STYLE_ICON]: "trigger",
+          ...taskMetadata ? v3.accessoryAttributes({
             items: [
               {
-                text: `${attempt}/${opts.maxAttempts}`,
+                text: `${taskMetadata.exportName}.batchTrigger()`,
                 variant: "normal"
               }
             ],
             style: "codepath"
-          })
+          }) : {}
         }
       });
-      const contextWithSpanSet = api.trace.setSpan(api.context.active(), innerSpan);
-      try {
-        const result = await api.context.with(contextWithSpanSet, async () => {
-          return fn({
-            attempt,
-            maxAttempts: opts.maxAttempts
-          });
-        });
-        innerSpan.end();
-        return result;
-      } catch (e) {
-        if (e instanceof Error || typeof e === "string") {
-          innerSpan.recordException(e);
-        } else {
-          innerSpan.recordException(String(e));
-        }
-        innerSpan.setStatus({
-          code: api.SpanStatusCode.ERROR
-        });
-        const nextRetryDelay = v3.calculateNextRetryDelay(opts, attempt);
-        if (!nextRetryDelay) {
-          innerSpan.end();
-          throw e;
-        }
-        innerSpan.setAttribute(v3.SemanticInternalAttributes.RETRY_AT, new Date(Date.now() + nextRetryDelay).toISOString());
-        innerSpan.setAttribute(v3.SemanticInternalAttributes.RETRY_COUNT, attempt);
-        innerSpan.setAttribute(v3.SemanticInternalAttributes.RETRY_DELAY, `${nextRetryDelay}ms`);
-        innerSpan.end();
-        await v3.runtime.waitForDuration(nextRetryDelay);
-      } finally {
-        attempt++;
+      return response;
+    },
+    triggerAndWait: async (payload, options) => {
+      const ctx = v3.taskContext.ctx;
+      if (!ctx) {
+        throw new Error("triggerAndWait can only be used from inside a task.run()");
       }
-    }
-    throw new Error("Max attempts reached");
-  }, {
-    attributes: {
-      [v3.SemanticInternalAttributes.STYLE_ICON]: "arrow-capsule"
-    }
-  });
-}
-__name(onThrow, "onThrow");
-var normalizeUrlFromInput = /* @__PURE__ */ __name((input) => {
-  if (typeof input === "string") {
-    return new URL(input);
-  }
-  if (input instanceof URL) {
-    return input;
-  }
-  return new URL(input.url);
-}, "normalizeUrlFromInput");
-var normalizeHttpMethod = /* @__PURE__ */ __name((input, init) => {
-  if (typeof input === "string" || input instanceof URL) {
-    return (init?.method || "GET").toUpperCase();
-  }
-  return (input.method ?? init?.method ?? "GET").toUpperCase();
-}, "normalizeHttpMethod");
-var fetchHttpHandlerStorage = new node_async_hooks.AsyncLocalStorage();
-var fetchWithInterceptors = /* @__PURE__ */ __name(async (input, init) => {
-  const handlers = fetchHttpHandlerStorage.getStore();
-  if (handlers) {
-    try {
-      const { getResponse } = await import('msw');
-      const request = new Request(input, init);
-      const response = await getResponse(handlers, request);
-      if (response) {
-        return response;
+      const apiClient = v3.apiClientManager.client;
+      if (!apiClient) {
+        throw apiClientMissingError();
       }
-    } catch (e) {
-      return fetch(input, init);
-    }
-  }
-  return fetch(input, init);
-}, "fetchWithInterceptors");
-var _a;
-var FetchErrorWithSpan = (_a = class extends Error {
-  constructor(originalError, span) {
-    super("Fetch error");
-    this.originalError = originalError;
-    this.span = span;
-  }
-}, __name(_a, "FetchErrorWithSpan"), _a);
-var MAX_ATTEMPTS = 10;
-async function retryFetch(input, init) {
-  return tracer.startActiveSpan("retry.fetch()", async (span) => {
-    let attempt = 1;
-    while (true) {
-      try {
-        const abortController = new AbortController();
-        const timeoutId = init?.timeoutInMs ? setTimeout(() => {
-          abortController.abort();
-        }, init?.timeoutInMs) : void 0;
-        init?.signal?.addEventListener("abort", () => {
-          abortController.abort();
+      const taskMetadata = v3.taskCatalog.getTaskMetadata(params.id);
+      const payloadPacket = await v3.stringifyIO(payload);
+      return await tracer.startActiveSpan(taskMetadata ? "Trigger" : `${params.id} triggerAndWait()`, async (span) => {
+        const response = await apiClient.triggerTask(params.id, {
+          payload: payloadPacket.data,
+          options: {
+            dependentAttempt: ctx.attempt.id,
+            lockToVersion: v3.taskContext.worker?.version,
+            queue: params.queue,
+            concurrencyKey: options?.concurrencyKey,
+            test: v3.taskContext.ctx?.run.isTest,
+            payloadType: payloadPacket.dataType,
+            idempotencyKey: options?.idempotencyKey
+          }
         });
-        const [response, span2] = await doFetchRequest(input, {
-          ...init ?? {},
-          signal: abortController.signal
-        }, attempt);
-        if (timeoutId) {
-          clearTimeout(timeoutId);
-        }
-        if (response.ok) {
-          span2.setAttributes(createFetchResponseAttributes(response));
-          span2.end();
-          return response;
-        }
-        const nextRetry = await calculateRetryDelayForResponse(resolveDefaults(init?.retry, "byStatus", v3.defaultFetchRetryOptions.byStatus), response, attempt);
-        if (!nextRetry) {
-          span2.setAttributes(createFetchResponseAttributes(response));
-          span2.end();
-          return response;
+        span.setAttribute("messaging.message.id", response.id);
+        if (options?.idempotencyKey) {
+          const result2 = await apiClient.getRunResult(response.id);
+          if (result2) {
+            v3.logger.log(`Result reused from previous task run with idempotency key '${options.idempotencyKey}'.`, {
+              runId: response.id,
+              idempotencyKey: options.idempotencyKey
+            });
+            return await handleTaskRunExecutionResult(result2);
+          }
         }
-        if (attempt >= MAX_ATTEMPTS) {
-          span2.setAttributes(createFetchResponseAttributes(response));
-          span2.end();
-          return response;
+        const result = await v3.runtime.waitForTask({
+          id: response.id,
+          ctx
+        });
+        return await handleTaskRunExecutionResult(result);
+      }, {
+        kind: api.SpanKind.PRODUCER,
+        attributes: {
+          [v3.SemanticInternalAttributes.STYLE_ICON]: "trigger",
+          [semanticConventions.SEMATTRS_MESSAGING_OPERATION]: "publish",
+          ["messaging.client_id"]: v3.taskContext.worker?.id,
+          [semanticConventions.SEMATTRS_MESSAGING_DESTINATION]: params.queue?.name ?? params.id,
+          [semanticConventions.SEMATTRS_MESSAGING_SYSTEM]: "trigger.dev",
+          ...taskMetadata ? v3.accessoryAttributes({
+            items: [
+              {
+                text: `${taskMetadata.exportName}.triggerAndWait()`,
+                variant: "normal"
+              }
+            ],
+            style: "codepath"
+          }) : {}
         }
-        if (nextRetry.type === "delay") {
-          span2.setAttribute(v3.SemanticInternalAttributes.RETRY_AT, new Date(Date.now() + nextRetry.value).toISOString());
-          span2.setAttribute(v3.SemanticInternalAttributes.RETRY_COUNT, attempt);
-          span2.setAttribute(v3.SemanticInternalAttributes.RETRY_DELAY, `${nextRetry.value}ms`);
-          span2.end();
-          await v3.runtime.waitForDuration(nextRetry.value);
-        } else {
-          const now = Date.now();
-          const nextRetryDate = new Date(nextRetry.value);
-          const isInFuture = nextRetryDate.getTime() > now;
-          span2.setAttribute(v3.SemanticInternalAttributes.RETRY_AT, new Date(nextRetry.value).toISOString());
-          span2.setAttribute(v3.SemanticInternalAttributes.RETRY_COUNT, attempt);
-          if (isInFuture) {
-            span2.setAttribute(v3.SemanticInternalAttributes.RETRY_DELAY, `${nextRetry.value - now}ms`);
+      });
+    },
+    batchTriggerAndWait: async (items) => {
+      const ctx = v3.taskContext.ctx;
+      if (!ctx) {
+        throw new Error("batchTriggerAndWait can only be used from inside a task.run()");
+      }
+      const apiClient = v3.apiClientManager.client;
+      if (!apiClient) {
+        throw apiClientMissingError();
+      }
+      const taskMetadata = v3.taskCatalog.getTaskMetadata(params.id);
+      return await tracer.startActiveSpan(taskMetadata ? "Batch trigger" : `${params.id} batchTriggerAndWait()`, async (span) => {
+        const response = await apiClient.batchTriggerTask(params.id, {
+          items: await Promise.all(items.map(async (item) => {
+            const payloadPacket = await v3.stringifyIO(item.payload);
+            return {
+              payload: payloadPacket.data,
+              options: {
+                lockToVersion: v3.taskContext.worker?.version,
+                queue: item.options?.queue ?? params.queue,
+                concurrencyKey: item.options?.concurrencyKey,
+                test: v3.taskContext.ctx?.run.isTest,
+                payloadType: payloadPacket.dataType,
+                idempotencyKey: item.options?.idempotencyKey
+              }
+            };
+          })),
+          dependentAttempt: ctx.attempt.id
+        });
+        span.setAttribute("messaging.message.id", response.batchId);
+        const getBatchResults = /* @__PURE__ */ __name(async () => {
+          const hasIdempotencyKey = items.some((item) => item.options?.idempotencyKey);
+          if (hasIdempotencyKey) {
+            const results = await apiClient.getBatchResults(response.batchId);
+            if (results) {
+              return results;
+            }
           }
-          span2.end();
-          await v3.runtime.waitUntil(new Date(nextRetry.value));
+          return {
+            id: response.batchId,
+            items: []
+          };
+        }, "getBatchResults");
+        const existingResults = await getBatchResults();
+        const incompleteRuns = response.runs.filter((runId) => !existingResults.items.some((item) => item.id === runId));
+        if (incompleteRuns.length === 0) {
+          v3.logger.log(`Results reused from previous task runs because of the provided idempotency keys.`);
+          const runs3 = await handleBatchTaskRunExecutionResult(existingResults.items);
+          return {
+            id: existingResults.id,
+            runs: runs3
+          };
         }
-      } catch (e) {
-        if (e instanceof FetchErrorWithSpan && e.originalError instanceof Error) {
-          if (e.originalError.name === "AbortError") {
-            const nextRetryDelay = v3.calculateNextRetryDelay(resolveDefaults(init?.retry, "timeout", v3.defaultFetchRetryOptions.timeout), attempt);
-            if (!nextRetryDelay) {
-              e.span.end();
-              throw e;
-            }
-            if (attempt >= MAX_ATTEMPTS) {
-              e.span.end();
-              throw e;
-            }
-            e.span.setAttribute(v3.SemanticInternalAttributes.RETRY_AT, new Date(Date.now() + nextRetryDelay).toISOString());
-            e.span.setAttribute(v3.SemanticInternalAttributes.RETRY_COUNT, attempt);
-            e.span.setAttribute(v3.SemanticInternalAttributes.RETRY_DELAY, `${nextRetryDelay}ms`);
-            e.span.end();
-            await v3.runtime.waitForDuration(nextRetryDelay);
-            continue;
-          } else if (e.originalError.name === "TypeError" && "cause" in e.originalError && e.originalError.cause instanceof Error) {
-            const nextRetryDelay = v3.calculateNextRetryDelay(resolveDefaults(init?.retry, "connectionError", v3.defaultFetchRetryOptions.connectionError), attempt);
-            if (!nextRetryDelay) {
-              e.span.end();
-              throw e;
-            }
-            if (attempt >= MAX_ATTEMPTS) {
-              e.span.end();
-              throw e;
+        const result = await v3.runtime.waitForBatch({
+          id: response.batchId,
+          runs: incompleteRuns,
+          ctx
+        });
+        const combinedItems = [];
+        for (const runId of response.runs) {
+          const existingItem = existingResults.items.find((item) => item.id === runId);
+          if (existingItem) {
+            combinedItems.push(existingItem);
+          } else {
+            const newItem = result.items.find((item) => item.id === runId);
+            if (newItem) {
+              combinedItems.push(newItem);
             }
-            e.span.setAttribute(v3.SemanticInternalAttributes.RETRY_AT, new Date(Date.now() + nextRetryDelay).toISOString());
-            e.span.setAttribute(v3.SemanticInternalAttributes.RETRY_COUNT, attempt);
-            e.span.setAttribute(v3.SemanticInternalAttributes.RETRY_DELAY, `${nextRetryDelay}ms`);
-            e.span.end();
-            await v3.runtime.waitForDuration(nextRetryDelay);
-            continue;
           }
         }
-        if (e instanceof FetchErrorWithSpan) {
-          e.span.end();
+        const runs2 = await handleBatchTaskRunExecutionResult(combinedItems);
+        return {
+          id: result.id,
+          runs: runs2
+        };
+      }, {
+        kind: api.SpanKind.PRODUCER,
+        attributes: {
+          [semanticConventions.SEMATTRS_MESSAGING_OPERATION]: "publish",
+          ["messaging.batch.message_count"]: items.length,
+          ["messaging.client_id"]: v3.taskContext.worker?.id,
+          [semanticConventions.SEMATTRS_MESSAGING_DESTINATION]: params.queue?.name ?? params.id,
+          [semanticConventions.SEMATTRS_MESSAGING_SYSTEM]: "trigger.dev",
+          [v3.SemanticInternalAttributes.STYLE_ICON]: "trigger",
+          ...taskMetadata ? v3.accessoryAttributes({
+            items: [
+              {
+                text: `${taskMetadata.exportName}.batchTriggerAndWait()`,
+                variant: "normal"
+              }
+            ],
+            style: "codepath"
+          }) : {}
         }
-        throw e;
-      } finally {
-        attempt++;
-      }
+      });
     }
-  }, {
-    attributes: {
-      [v3.SemanticInternalAttributes.STYLE_ICON]: "arrow-capsule",
-      ...createFetchAttributes(input, init),
-      ...createFetchRetryOptionsAttributes(init?.retry)
+  };
+  v3.taskCatalog.registerTaskMetadata({
+    id: params.id,
+    packageVersion: version,
+    queue: params.queue,
+    retry: params.retry ? {
+      ...v3.defaultRetryOptions,
+      ...params.retry
+    } : void 0,
+    machine: params.machine,
+    fns: {
+      run: params.run,
+      init: params.init,
+      cleanup: params.cleanup,
+      middleware: params.middleware,
+      handleError: params.handleError,
+      onSuccess: params.onSuccess,
+      onFailure: params.onFailure,
+      onStart: params.onStart
     }
   });
+  return task3;
 }
-__name(retryFetch, "retryFetch");
-var doFetchRequest = /* @__PURE__ */ __name(async (input, init, attemptCount = 0) => {
-  const httpMethod = normalizeHttpMethod(input, init);
-  const span = tracer.startSpan(`HTTP ${httpMethod}`, {
-    attributes: {
-      [v3.SemanticInternalAttributes.STYLE_ICON]: "world",
-      ...attemptCount > 1 ? {
-        ["http.request.resend_count"]: attemptCount - 1
-      } : {},
-      ...createFetchAttributes(input, init)
-    }
+__name(createTask, "createTask");
+async function handleBatchTaskRunExecutionResult(items) {
+  const someObjectStoreOutputs = items.some((item) => item.ok && item.outputType === "application/store");
+  if (!someObjectStoreOutputs) {
+    const results = await Promise.all(items.map(async (item) => {
+      return await handleTaskRunExecutionResult(item);
+    }));
+    return results;
+  }
+  return await tracer.startActiveSpan("store.downloadPayloads", async (span) => {
+    const results = await Promise.all(items.map(async (item) => {
+      return await handleTaskRunExecutionResult(item);
+    }));
+    return results;
+  }, {
+    kind: api.SpanKind.INTERNAL,
+    [v3.SemanticInternalAttributes.STYLE_ICON]: "cloud-download"
   });
-  try {
-    const response = await fetchWithInterceptors(input, {
-      ...init,
-      headers: {
-        ...init?.headers,
-        "x-retry-count": attemptCount.toString()
+}
+__name(handleBatchTaskRunExecutionResult, "handleBatchTaskRunExecutionResult");
+async function handleTaskRunExecutionResult(execution) {
+  if (execution.ok) {
+    const outputPacket = {
+      data: execution.output,
+      dataType: execution.outputType
+    };
+    const importedPacket = await v3.conditionallyImportPacket(outputPacket, tracer);
+    return {
+      ok: true,
+      id: execution.id,
+      output: await v3.parsePacket(importedPacket)
+    };
+  } else {
+    return {
+      ok: false,
+      id: execution.id,
+      error: v3.createErrorTaskError(execution.error)
+    };
+  }
+}
+__name(handleTaskRunExecutionResult, "handleTaskRunExecutionResult");
+function apiClientMissingError() {
+  const hasBaseUrl = !!v3.apiClientManager.baseURL;
+  const hasAccessToken = !!v3.apiClientManager.accessToken;
+  if (!hasBaseUrl && !hasAccessToken) {
+    return `You need to set the TRIGGER_API_URL and TRIGGER_SECRET_KEY environment variables.`;
+  } else if (!hasBaseUrl) {
+    return `You need to set the TRIGGER_API_URL environment variable.`;
+  } else if (!hasAccessToken) {
+    return `You need to set the TRIGGER_SECRET_KEY environment variable.`;
+  }
+  return `Unknown error`;
+}
+__name(apiClientMissingError, "apiClientMissingError");
+
+// src/v3/tasks.ts
+function task(options) {
+  return createTask(options);
+}
+__name(task, "task");
+var wait = {
+  for: async (options) => {
+    return tracer.startActiveSpan(`wait.for()`, async (span) => {
+      const durationInMs = calculateDurationInMs(options);
+      await v3.runtime.waitForDuration(durationInMs);
+    }, {
+      attributes: {
+        [v3.SemanticInternalAttributes.STYLE_ICON]: "wait",
+        ...v3.accessoryAttributes({
+          items: [
+            {
+              text: nameForWaitOptions(options),
+              variant: "normal"
+            }
+          ],
+          style: "codepath"
+        })
       }
     });
-    span.setAttributes(createFetchResponseAttributes(response));
-    if (!response.ok) {
-      span.recordException(`${response.status}: ${response.statusText}`);
-      span.setStatus({
-        code: api.SpanStatusCode.ERROR,
-        message: `${response.status}: ${response.statusText}`
-      });
-    }
-    return [
-      response,
-      span
-    ];
-  } catch (e) {
-    if (typeof e === "string" || e instanceof Error) {
-      span.recordException(e);
-    }
-    span.setStatus({
-      code: api.SpanStatusCode.ERROR
+  },
+  until: async (options) => {
+    return tracer.startActiveSpan(`wait.until()`, async (span) => {
+      const start = Date.now();
+      if (options.throwIfInThePast && options.date < /* @__PURE__ */ new Date()) {
+        throw new Error("Date is in the past");
+      }
+      const durationInMs = options.date.getTime() - start;
+      await v3.runtime.waitForDuration(durationInMs);
+    }, {
+      attributes: {
+        [v3.SemanticInternalAttributes.STYLE_ICON]: "wait",
+        ...v3.accessoryAttributes({
+          items: [
+            {
+              text: options.date.toISOString(),
+              variant: "normal"
+            }
+          ],
+          style: "codepath"
+        })
+      }
     });
-    span.setAttribute(semanticConventions.SEMATTRS_HTTP_STATUS_CODE, 0);
-    span.setAttribute("http.status_text", "This operation was aborted.");
-    throw new FetchErrorWithSpan(e, span);
   }
-}, "doFetchRequest");
-var calculateRetryDelayForResponse = /* @__PURE__ */ __name(async (retry2, response, attemptCount) => {
-  if (!retry2) {
-    return;
+};
+function nameForWaitOptions(options) {
+  if ("seconds" in options) {
+    return options.seconds === 1 ? `1 second` : `${options.seconds} seconds`;
   }
-  const strategy = await getRetryStrategyForResponse(response, retry2);
-  if (!strategy) {
-    return;
+  if ("minutes" in options) {
+    return options.minutes === 1 ? `1 minute` : `${options.minutes} minutes`;
   }
-  switch (strategy.strategy) {
-    case "backoff": {
-      const value = v3.calculateNextRetryDelay({
-        ...v3.defaultRetryOptions,
-        ...strategy
-      }, attemptCount);
-      if (value) {
-        return {
-          type: "delay",
-          value
-        };
-      }
-      break;
-    }
-    case "headers": {
-      const resetAt = response.headers.get(strategy.resetHeader);
-      if (typeof resetAt === "string") {
-        const resetTimestamp = v3.calculateResetAt(resetAt, strategy.resetFormat ?? "unix_timestamp_in_ms");
-        if (resetTimestamp) {
-          return {
-            type: "timestamp",
-            value: resetTimestamp
-          };
-        }
-      }
-      break;
-    }
+  if ("hours" in options) {
+    return options.hours === 1 ? `1 hour` : `${options.hours} hours`;
   }
-}, "calculateRetryDelayForResponse");
-var getRetryStrategyForResponse = /* @__PURE__ */ __name(async (response, retry2) => {
-  const statusCodes = Object.keys(retry2);
-  const clonedResponse = response.clone();
-  for (let i = 0; i < statusCodes.length; i++) {
-    const statusRange = statusCodes[i];
-    const strategy = retry2[statusRange];
-    if (isStatusCodeInRange(response.status, statusRange)) {
-      if (strategy.bodyFilter) {
-        const body = safeJsonParse(await clonedResponse.text());
-        if (!body) {
-          continue;
-        }
-        if (v3.eventFilterMatches(body, strategy.bodyFilter)) {
-          return strategy;
-        } else {
-          continue;
-        }
-      }
-      return strategy;
-    }
+  if ("days" in options) {
+    return options.days === 1 ? `1 day` : `${options.days} days`;
   }
-}, "getRetryStrategyForResponse");
-var isStatusCodeInRange = /* @__PURE__ */ __name((statusCode, statusRange) => {
-  if (statusRange === "all") {
-    return true;
+  if ("weeks" in options) {
+    return options.weeks === 1 ? `1 week` : `${options.weeks} weeks`;
   }
-  if (statusRange.includes(",")) {
-    const statusCodes = statusRange.split(",").map((s) => s.trim());
-    return statusCodes.some((s) => isStatusCodeInRange(statusCode, s));
+  if ("months" in options) {
+    return options.months === 1 ? `1 month` : `${options.months} months`;
   }
-  const [start, end] = statusRange.split("-");
-  if (end) {
-    return statusCode >= parseInt(start, 10) && statusCode <= parseInt(end, 10);
+  if ("years" in options) {
+    return options.years === 1 ? `1 year` : `${options.years} years`;
   }
-  if (start.endsWith("xx")) {
-    const prefix = start.slice(0, -2);
-    const statusCodePrefix = Math.floor(statusCode / 100).toString();
-    return statusCodePrefix === prefix;
+  return "NaN";
+}
+__name(nameForWaitOptions, "nameForWaitOptions");
+function calculateDurationInMs(options) {
+  if ("seconds" in options) {
+    return options.seconds * 1e3;
   }
-  const statusCodeString = statusCode.toString();
-  const rangePrefix = start.slice(0, -1);
-  if (start.endsWith("x") && statusCodeString.startsWith(rangePrefix)) {
-    return true;
+  if ("minutes" in options) {
+    return options.minutes * 1e3 * 60;
   }
-  return statusCode === parseInt(start, 10);
-}, "isStatusCodeInRange");
-var createAttributesFromHeaders = /* @__PURE__ */ __name((headers) => {
-  const attributes = {};
-  const normalizedHeaderKey = /* @__PURE__ */ __name((key) => {
-    return key.toLowerCase();
-  }, "normalizedHeaderKey");
-  headers.forEach((value, key) => {
-    attributes[`http.response.header.${normalizedHeaderKey(key)}`] = value;
-  });
-  return attributes;
-}, "createAttributesFromHeaders");
-var safeJsonParse = /* @__PURE__ */ __name((json) => {
-  try {
-    return JSON.parse(json);
-  } catch (e) {
-    return null;
+  if ("hours" in options) {
+    return options.hours * 1e3 * 60 * 60;
   }
-}, "safeJsonParse");
-var interceptFetch = /* @__PURE__ */ __name((...handlers) => {
-  return {
-    run: async (fn) => {
-      const current = fetchHttpHandlerStorage.getStore();
-      if (current) {
-        current.push(...handlers);
-        return fn();
-      } else {
-        return fetchHttpHandlerStorage.run(handlers, fn);
-      }
-    }
-  };
-}, "interceptFetch");
-var resolveDefaults = /* @__PURE__ */ __name((obj, key, defaults) => {
-  if (!obj) {
-    return defaults;
+  if ("days" in options) {
+    return options.days * 1e3 * 60 * 60 * 24;
   }
-  if (obj[key] === void 0 || obj[key] === null) {
-    return defaults;
+  if ("weeks" in options) {
+    return options.weeks * 1e3 * 60 * 60 * 24 * 7;
   }
-  return obj[key];
-}, "resolveDefaults");
-var createFetchAttributes = /* @__PURE__ */ __name((input, init) => {
-  const url = normalizeUrlFromInput(input);
-  const httpMethod = normalizeHttpMethod(input, init);
-  return {
-    [semanticConventions.SEMATTRS_HTTP_METHOD]: httpMethod,
-    [semanticConventions.SEMATTRS_HTTP_URL]: url.href,
-    [semanticConventions.SEMATTRS_HTTP_HOST]: url.hostname,
-    ["server.host"]: url.hostname,
-    ["server.port"]: url.port,
-    [semanticConventions.SEMATTRS_HTTP_SCHEME]: url.protocol.replace(":", ""),
-    ...v3.accessoryAttributes({
-      items: [
-        {
-          text: url.hostname,
-          variant: "normal"
-        }
-      ],
-      style: "codepath"
-    })
-  };
-}, "createFetchAttributes");
-var createFetchResponseAttributes = /* @__PURE__ */ __name((response) => {
-  return {
-    [semanticConventions.SEMATTRS_HTTP_STATUS_CODE]: response.status,
-    "http.status_text": response.statusText,
-    [semanticConventions.SEMATTRS_HTTP_RESPONSE_CONTENT_LENGTH]: response.headers.get("content-length") || "0",
-    ...createAttributesFromHeaders(response.headers)
-  };
-}, "createFetchResponseAttributes");
-var createFetchRetryOptionsAttributes = /* @__PURE__ */ __name((retry2) => {
-  const byStatus = resolveDefaults(retry2, "byStatus", v3.defaultFetchRetryOptions.byStatus);
-  const connectionError = resolveDefaults(retry2, "connectionError", v3.defaultFetchRetryOptions.connectionError);
-  const timeout = resolveDefaults(retry2, "timeout", v3.defaultFetchRetryOptions.timeout);
-  return {
-    ...v3.flattenAttributes(byStatus, "retry.byStatus"),
-    ...v3.flattenAttributes(connectionError, "retry.connectionError"),
-    ...v3.flattenAttributes(timeout, "retry.timeout")
-  };
-}, "createFetchRetryOptionsAttributes");
-var retry = {
-  onThrow,
-  fetch: retryFetch,
-  interceptFetch
-};
+  if ("months" in options) {
+    return options.months * 1e3 * 60 * 60 * 24 * 30;
+  }
+  if ("years" in options) {
+    return options.years * 1e3 * 60 * 60 * 24 * 365;
+  }
+  throw new Error("Invalid options");
+}
+__name(calculateDurationInMs, "calculateDurationInMs");
 var runs = {
   replay: replayRun,
-  cancel: cancelRun
+  cancel: cancelRun,
+  retrieve: retrieveRun
 };
+async function retrieveRun(runId) {
+  const apiClient = v3.apiClientManager.client;
+  if (!apiClient) {
+    throw apiClientMissingError();
+  }
+  return await apiClient.retrieveRun(runId);
+}
+__name(retrieveRun, "retrieveRun");
 async function replayRun(runId) {
   const apiClient = v3.apiClientManager.client;
   if (!apiClient) {
@@ -1027,6 +1038,12 @@ async function list(options) {
 }
 __name(list, "list");
 
+// src/v3/index.ts
+function configure(options) {
+  v3.apiClientManager.setGlobalAPIClientConfiguration(options);
+}
+__name(configure, "configure");
+
 Object.defineProperty(exports, 'APIError', {
   enumerable: true,
   get: function () { return v3.APIError; }
@@ -1068,6 +1085,7 @@ Object.defineProperty(exports, 'logger', {
   get: function () { return v3.logger; }
 });
 exports.InMemoryCache = InMemoryCache;
+exports.configure = configure;
 exports.createCache = createCache;
 exports.queue = queue;
 exports.retry = retry;