@trigger.dev/sdk 3.0.0-beta.46 → 3.0.0-beta.48

package/dist/v3/index.js

@@ -10,8 +10,8 @@ var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
+  for (var name2 in all)
+    __defProp(target, name2, { get: all[name2], enumerable: true });
 };
 var __publicField = (obj, key, value) => {
   __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
@@ -19,7 +19,7 @@ var __publicField = (obj, key, value) => {
 };
 
 // package.json
-var version = "3.0.0-beta.46";
+var version = "3.0.0-beta.48";
 
 // src/v3/tracer.ts
 var tracer = new v3.TriggerTracer({
@@ -124,6 +124,10 @@ function onThrow(fn, options) {
         innerSpan.setStatus({
           code: api.SpanStatusCode.ERROR
         });
+        if (e instanceof Error && e.name === "AbortTaskRunError") {
+          innerSpan.end();
+          throw e;
+        }
         const nextRetryDelay = v3.calculateNextRetryDelay(opts, attempt);
         if (!nextRetryDelay) {
           innerSpan.end();
@@ -510,63 +514,231 @@ var runs = {
   reschedule: rescheduleRun,
   poll
 };
-function listRuns(paramsOrProjectRef, params) {
+function listRuns(paramsOrProjectRef, paramsOrOptions, requestOptions) {
   const apiClient = v3.apiClientManager.client;
   if (!apiClient) {
     throw apiClientMissingError();
   }
+  const $requestOptions = listRunsRequestOptions(paramsOrProjectRef, paramsOrOptions, requestOptions);
   if (typeof paramsOrProjectRef === "string") {
-    return apiClient.listProjectRuns(paramsOrProjectRef, params);
+    if (v3.isRequestOptions(paramsOrOptions)) {
+      return apiClient.listProjectRuns(paramsOrProjectRef, {}, $requestOptions);
+    } else {
+      return apiClient.listProjectRuns(paramsOrProjectRef, paramsOrOptions, $requestOptions);
+    }
   }
-  return apiClient.listRuns(params);
+  return apiClient.listRuns(paramsOrProjectRef, $requestOptions);
 }
 __name(listRuns, "listRuns");
-function retrieveRun(runId) {
+function listRunsRequestOptions(paramsOrProjectRef, paramsOrOptions, requestOptions) {
+  if (typeof paramsOrProjectRef === "string") {
+    if (v3.isRequestOptions(paramsOrOptions)) {
+      return v3.mergeRequestOptions({
+        tracer,
+        name: "runs.list()",
+        icon: "runs",
+        attributes: {
+          projectRef: paramsOrProjectRef,
+          ...v3.accessoryAttributes({
+            items: [
+              {
+                text: paramsOrProjectRef,
+                variant: "normal"
+              }
+            ],
+            style: "codepath"
+          })
+        }
+      }, paramsOrOptions);
+    } else {
+      return v3.mergeRequestOptions({
+        tracer,
+        name: "runs.list()",
+        icon: "runs",
+        attributes: {
+          projectRef: paramsOrProjectRef,
+          ...v3.flattenAttributes(paramsOrOptions, "queryParams"),
+          ...v3.accessoryAttributes({
+            items: [
+              {
+                text: paramsOrProjectRef,
+                variant: "normal"
+              }
+            ],
+            style: "codepath"
+          })
+        }
+      }, requestOptions);
+    }
+  }
+  return v3.mergeRequestOptions({
+    tracer,
+    name: "runs.list()",
+    icon: "runs",
+    attributes: {
+      ...v3.flattenAttributes(paramsOrProjectRef, "queryParams")
+    }
+  }, v3.isRequestOptions(paramsOrOptions) ? paramsOrOptions : requestOptions);
+}
+__name(listRunsRequestOptions, "listRunsRequestOptions");
+function retrieveRun(runId, requestOptions) {
   const apiClient = v3.apiClientManager.client;
   if (!apiClient) {
     throw apiClientMissingError();
   }
+  const $requestOptions = v3.mergeRequestOptions({
+    tracer,
+    name: "runs.retrieve()",
+    icon: "runs",
+    attributes: {
+      runId: typeof runId === "string" ? runId : runId.id,
+      ...v3.accessoryAttributes({
+        items: [
+          {
+            text: typeof runId === "string" ? runId : runId.id,
+            variant: "normal"
+          }
+        ],
+        style: "codepath"
+      })
+    }
+  }, requestOptions);
   if (typeof runId === "string") {
-    return apiClient.retrieveRun(runId);
+    return apiClient.retrieveRun(runId, $requestOptions);
   } else {
-    return apiClient.retrieveRun(runId.id);
+    return apiClient.retrieveRun(runId.id, $requestOptions);
   }
 }
 __name(retrieveRun, "retrieveRun");
-function replayRun(runId) {
+function replayRun(runId, requestOptions) {
   const apiClient = v3.apiClientManager.client;
   if (!apiClient) {
     throw apiClientMissingError();
   }
-  return apiClient.replayRun(runId);
+  const $requestOptions = v3.mergeRequestOptions({
+    tracer,
+    name: "runs.replay()",
+    icon: "runs",
+    attributes: {
+      runId,
+      ...v3.accessoryAttributes({
+        items: [
+          {
+            text: runId,
+            variant: "normal"
+          }
+        ],
+        style: "codepath"
+      })
+    }
+  }, requestOptions);
+  return apiClient.replayRun(runId, $requestOptions);
 }
 __name(replayRun, "replayRun");
-function cancelRun(runId) {
+function cancelRun(runId, requestOptions) {
   const apiClient = v3.apiClientManager.client;
   if (!apiClient) {
     throw apiClientMissingError();
   }
-  return apiClient.cancelRun(runId);
+  const $requestOptions = v3.mergeRequestOptions({
+    tracer,
+    name: "runs.cancel()",
+    icon: "runs",
+    attributes: {
+      runId,
+      ...v3.accessoryAttributes({
+        items: [
+          {
+            text: runId,
+            variant: "normal"
+          }
+        ],
+        style: "codepath"
+      })
+    }
+  }, requestOptions);
+  return apiClient.cancelRun(runId, $requestOptions);
 }
 __name(cancelRun, "cancelRun");
-function rescheduleRun(runId, body) {
+function rescheduleRun(runId, body, requestOptions) {
   const apiClient = v3.apiClientManager.client;
   if (!apiClient) {
     throw apiClientMissingError();
   }
-  return apiClient.rescheduleRun(runId, body);
+  const $requestOptions = v3.mergeRequestOptions({
+    tracer,
+    name: "runs.reschedule()",
+    icon: "runs",
+    attributes: {
+      runId,
+      ...v3.accessoryAttributes({
+        items: [
+          {
+            text: runId,
+            variant: "normal"
+          }
+        ],
+        style: "codepath"
+      })
+    }
+  }, requestOptions);
+  return apiClient.rescheduleRun(runId, body, $requestOptions);
 }
 __name(rescheduleRun, "rescheduleRun");
-async function poll(handle, options) {
-  while (true) {
-    const run = await runs.retrieve(handle);
+var MAX_POLL_ATTEMPTS = 500;
+async function poll(handle, options, requestOptions) {
+  let attempts = 0;
+  while (attempts++ < MAX_POLL_ATTEMPTS) {
+    const run = await runs.retrieve(handle, requestOptions);
     if (run.isCompleted) {
       return run;
     }
     await new Promise((resolve) => setTimeout(resolve, options?.pollIntervalMs ?? 1e3));
   }
+  throw new Error(`Run ${handle} did not complete after ${MAX_POLL_ATTEMPTS} attempts`);
 }
 __name(poll, "poll");
+var idempotencyKeys = {
+  create: createIdempotencyKey
+};
+function isIdempotencyKey(value) {
+  return typeof value === "string" && value.length === 64;
+}
+__name(isIdempotencyKey, "isIdempotencyKey");
+async function createIdempotencyKey(key, options) {
+  const idempotencyKey = await generateIdempotencyKey([
+    ...Array.isArray(key) ? key : [
+      key
+    ]
+  ].concat(injectScope(options?.scope ?? "run")));
+  return idempotencyKey;
+}
+__name(createIdempotencyKey, "createIdempotencyKey");
+function injectScope(scope) {
+  switch (scope) {
+    case "run": {
+      if (v3.taskContext?.ctx) {
+        return [
+          v3.taskContext.ctx.run.id
+        ];
+      }
+    }
+    case "attempt": {
+      if (v3.taskContext?.ctx) {
+        return [
+          v3.taskContext.ctx.attempt.id
+        ];
+      }
+    }
+  }
+  return [];
+}
+__name(injectScope, "injectScope");
+async function generateIdempotencyKey(keyMaterial) {
+  const hash = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(keyMaterial.join("-")));
+  return Array.from(new Uint8Array(hash)).map((byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+__name(generateIdempotencyKey, "generateIdempotencyKey");
 
 // src/v3/shared.ts
 function queue(options) {
@@ -583,40 +755,41 @@ function createTask(params) {
       }
       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: options?.queue ?? params.queue,
-            concurrencyKey: options?.concurrencyKey,
-            test: v3.taskContext.ctx?.run.isTest,
-            payloadType: payloadPacket.dataType,
-            idempotencyKey: options?.idempotencyKey,
-            delay: options?.delay,
-            ttl: options?.ttl
-          }
-        }, {
-          spanParentAsLink: true
-        });
-        span.setAttribute("messaging.message.id", response.id);
-        return response;
+      const handle = await apiClient.triggerTask(params.id, {
+        payload: payloadPacket.data,
+        options: {
+          queue: options?.queue ?? params.queue,
+          concurrencyKey: options?.concurrencyKey,
+          test: v3.taskContext.ctx?.run.isTest,
+          payloadType: payloadPacket.dataType,
+          idempotencyKey: await makeKey(options?.idempotencyKey),
+          delay: options?.delay,
+          ttl: options?.ttl,
+          maxAttempts: options?.maxAttempts
+        }
       }, {
-        kind: api.SpanKind.PRODUCER,
+        spanParentAsLink: true
+      }, {
+        name: taskMetadata ? `${taskMetadata.exportName}.trigger()` : `trigger()`,
+        tracer,
+        icon: "trigger",
         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({
+          ...v3.accessoryAttributes({
             items: [
               {
-                text: `${taskMetadata.exportName}.trigger()`,
+                text: params.id,
                 variant: "normal"
               }
             ],
             style: "codepath"
-          }) : {}
+          })
+        },
+        onResponseBody: (body, span) => {
+          body && typeof body === "object" && !Array.isArray(body) && "id" in body && typeof body.id === "string" && span.setAttribute("messaging.message.id", body.id);
         }
       });
       return handle;
@@ -627,55 +800,53 @@ function createTask(params) {
         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,
-                delay: item.options?.delay,
-                ttl: item.options?.ttl
-              }
-            };
-          }))
-        }, {
-          spanParentAsLink: true
-        });
-        span.setAttribute("messaging.message.id", response2.batchId);
-        const handle = {
-          batchId: response2.batchId,
-          runs: response2.runs.map((id) => ({
-            id
-          }))
-        };
-        return handle;
+      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: {
+              queue: item.options?.queue ?? params.queue,
+              concurrencyKey: item.options?.concurrencyKey,
+              test: v3.taskContext.ctx?.run.isTest,
+              payloadType: payloadPacket.dataType,
+              idempotencyKey: await makeKey(item.options?.idempotencyKey),
+              delay: item.options?.delay,
+              ttl: item.options?.ttl,
+              maxAttempts: item.options?.maxAttempts
+            }
+          };
+        }))
       }, {
-        kind: api.SpanKind.PRODUCER,
+        spanParentAsLink: true
+      }, {
+        name: taskMetadata ? `${taskMetadata.exportName}.batchTrigger()` : `batchTrigger()`,
+        icon: "trigger",
+        tracer,
         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({
+          ...v3.accessoryAttributes({
             items: [
               {
-                text: `${taskMetadata.exportName}.batchTrigger()`,
+                text: params.id,
                 variant: "normal"
               }
             ],
             style: "codepath"
-          }) : {}
+          })
         }
       });
-      return response;
+      const handle = {
+        batchId: response.batchId,
+        runs: response.runs.map((id) => ({
+          id
+        }))
+      };
+      return handle;
     },
     triggerAndWait: async (payload, options) => {
       const ctx = v3.taskContext.ctx;
@@ -688,7 +859,7 @@ function createTask(params) {
       }
       const taskMetadata = v3.taskCatalog.getTaskMetadata(params.id);
       const payloadPacket = await v3.stringifyIO(payload);
-      return await tracer.startActiveSpan(taskMetadata ? "Trigger" : `${params.id} triggerAndWait()`, async (span) => {
+      return await tracer.startActiveSpan(taskMetadata ? `${taskMetadata.exportName}.triggerAndWait()` : `triggerAndWait()`, async (span) => {
         const response = await apiClient.triggerTask(params.id, {
           payload: payloadPacket.data,
           options: {
@@ -698,9 +869,10 @@ function createTask(params) {
             concurrencyKey: options?.concurrencyKey,
             test: v3.taskContext.ctx?.run.isTest,
             payloadType: payloadPacket.dataType,
-            idempotencyKey: options?.idempotencyKey,
+            idempotencyKey: await makeKey(options?.idempotencyKey),
             delay: options?.delay,
-            ttl: options?.ttl
+            ttl: options?.ttl,
+            maxAttempts: options?.maxAttempts
           }
         });
         span.setAttribute("messaging.message.id", response.id);
@@ -727,15 +899,15 @@ function createTask(params) {
           ["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({
+          ...v3.accessoryAttributes({
             items: [
               {
-                text: `${taskMetadata.exportName}.triggerAndWait()`,
+                text: params.id,
                 variant: "normal"
               }
             ],
             style: "codepath"
-          }) : {}
+          })
         }
       });
     },
@@ -749,7 +921,7 @@ function createTask(params) {
         throw apiClientMissingError();
       }
       const taskMetadata = v3.taskCatalog.getTaskMetadata(params.id);
-      return await tracer.startActiveSpan(taskMetadata ? "Batch trigger" : `${params.id} batchTriggerAndWait()`, async (span) => {
+      return await tracer.startActiveSpan(taskMetadata ? `${taskMetadata.exportName}.batchTriggerAndWait()` : `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);
@@ -761,9 +933,10 @@ function createTask(params) {
                 concurrencyKey: item.options?.concurrencyKey,
                 test: v3.taskContext.ctx?.run.isTest,
                 payloadType: payloadPacket.dataType,
-                idempotencyKey: item.options?.idempotencyKey,
+                idempotencyKey: await makeKey(item.options?.idempotencyKey),
                 delay: item.options?.delay,
-                ttl: item.options?.ttl
+                ttl: item.options?.ttl,
+                maxAttempts: item.options?.maxAttempts
               }
             };
           })),
@@ -824,15 +997,15 @@ function createTask(params) {
           [semanticConventions.SEMATTRS_MESSAGING_DESTINATION]: params.queue?.name ?? params.id,
           [semanticConventions.SEMATTRS_MESSAGING_SYSTEM]: "trigger.dev",
           [v3.SemanticInternalAttributes.STYLE_ICON]: "trigger",
-          ...taskMetadata ? v3.accessoryAttributes({
+          ...v3.accessoryAttributes({
             items: [
               {
-                text: `${taskMetadata.exportName}.batchTriggerAndWait()`,
+                text: params.id,
                 variant: "normal"
               }
             ],
             style: "codepath"
-          }) : {}
+          })
         }
       });
     }
@@ -860,7 +1033,7 @@ function createTask(params) {
   return task3;
 }
 __name(createTask, "createTask");
-async function trigger(id, payload, options) {
+async function trigger(id, payload, options, requestOptions) {
   const apiClient = v3.apiClientManager.client;
   if (!apiClient) {
     throw apiClientMissingError();
@@ -873,20 +1046,108 @@ async function trigger(id, payload, options) {
       concurrencyKey: options?.concurrencyKey,
       test: v3.taskContext.ctx?.run.isTest,
       payloadType: payloadPacket.dataType,
-      idempotencyKey: options?.idempotencyKey,
+      idempotencyKey: await makeKey(options?.idempotencyKey),
       delay: options?.delay,
-      ttl: options?.ttl
+      ttl: options?.ttl,
+      maxAttempts: options?.maxAttempts
     }
+  }, {
+    spanParentAsLink: true
+  }, {
+    name: `tasks.trigger()`,
+    tracer,
+    icon: "trigger",
+    attributes: {
+      [semanticConventions.SEMATTRS_MESSAGING_OPERATION]: "publish",
+      ["messaging.client_id"]: v3.taskContext.worker?.id,
+      [semanticConventions.SEMATTRS_MESSAGING_SYSTEM]: "trigger.dev",
+      ...v3.accessoryAttributes({
+        items: [
+          {
+            text: id,
+            variant: "normal"
+          }
+        ],
+        style: "codepath"
+      })
+    },
+    onResponseBody: (body, span) => {
+      body && typeof body === "object" && !Array.isArray(body) && "id" in body && typeof body.id === "string" && span.setAttribute("messaging.message.id", body.id);
+    },
+    ...requestOptions
   });
   return handle;
 }
 __name(trigger, "trigger");
-async function triggerAndPoll(id, payload, options) {
-  const handle = await trigger(id, payload, options);
-  return runs.poll(handle);
+async function triggerAndWait(id, payload, options, requestOptions) {
+  const ctx = v3.taskContext.ctx;
+  if (!ctx) {
+    throw new Error("tasks.triggerAndWait can only be used from inside a task.run()");
+  }
+  const apiClient = v3.apiClientManager.client;
+  if (!apiClient) {
+    throw apiClientMissingError();
+  }
+  const payloadPacket = await v3.stringifyIO(payload);
+  return await tracer.startActiveSpan("tasks.triggerAndWait()", async (span) => {
+    const response = await apiClient.triggerTask(id, {
+      payload: payloadPacket.data,
+      options: {
+        dependentAttempt: ctx.attempt.id,
+        lockToVersion: v3.taskContext.worker?.version,
+        queue: options?.queue,
+        concurrencyKey: options?.concurrencyKey,
+        test: v3.taskContext.ctx?.run.isTest,
+        payloadType: payloadPacket.dataType,
+        idempotencyKey: await makeKey(options?.idempotencyKey),
+        delay: options?.delay,
+        ttl: options?.ttl,
+        maxAttempts: options?.maxAttempts
+      }
+    }, {}, requestOptions);
+    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);
+      }
+    }
+    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]: id,
+      [semanticConventions.SEMATTRS_MESSAGING_SYSTEM]: "trigger.dev",
+      ...v3.accessoryAttributes({
+        items: [
+          {
+            text: id,
+            variant: "normal"
+          }
+        ],
+        style: "codepath"
+      })
+    }
+  });
+}
+__name(triggerAndWait, "triggerAndWait");
+async function triggerAndPoll(id, payload, options, requestOptions) {
+  const handle = await trigger(id, payload, options, requestOptions);
+  return runs.poll(handle, options, requestOptions);
 }
 __name(triggerAndPoll, "triggerAndPoll");
-async function batchTrigger(id, items) {
+async function batchTrigger(id, items, requestOptions) {
   const apiClient = v3.apiClientManager.client;
   if (!apiClient) {
     throw apiClientMissingError();
@@ -901,12 +1162,34 @@ async function batchTrigger(id, items) {
           concurrencyKey: item.options?.concurrencyKey,
           test: v3.taskContext.ctx?.run.isTest,
           payloadType: payloadPacket.dataType,
-          idempotencyKey: item.options?.idempotencyKey,
+          idempotencyKey: await makeKey(item.options?.idempotencyKey),
           delay: item.options?.delay,
-          ttl: item.options?.ttl
+          ttl: item.options?.ttl,
+          maxAttempts: item.options?.maxAttempts
         }
       };
     }))
+  }, {
+    spanParentAsLink: true
+  }, {
+    name: `tasks.batchTrigger()`,
+    tracer,
+    icon: "trigger",
+    attributes: {
+      [semanticConventions.SEMATTRS_MESSAGING_OPERATION]: "publish",
+      ["messaging.client_id"]: v3.taskContext.worker?.id,
+      [semanticConventions.SEMATTRS_MESSAGING_SYSTEM]: "trigger.dev",
+      ...v3.accessoryAttributes({
+        items: [
+          {
+            text: id,
+            variant: "normal"
+          }
+        ],
+        style: "codepath"
+      })
+    },
+    ...requestOptions
   });
   const handle = {
     batchId: response.batchId,
@@ -970,6 +1253,18 @@ function apiClientMissingError() {
   return `Unknown error`;
 }
 __name(apiClientMissingError, "apiClientMissingError");
+async function makeKey(idempotencyKey) {
+  if (!idempotencyKey) {
+    return;
+  }
+  if (isIdempotencyKey(idempotencyKey)) {
+    return idempotencyKey;
+  }
+  return await idempotencyKeys.create(idempotencyKey, {
+    scope: "global"
+  });
+}
+__name(makeKey, "makeKey");
 
 // src/v3/tasks.ts
 function task(options) {
@@ -979,7 +1274,8 @@ __name(task, "task");
 var tasks = {
   trigger,
   triggerAndPoll,
-  batchTrigger
+  batchTrigger,
+  triggerAndWait
 };
 var wait = {
   for: async (options) => {
@@ -1207,60 +1503,166 @@ function task2(params) {
   return task3;
 }
 __name(task2, "task");
-function create(options) {
+function create(options, requestOptions) {
   const apiClient = v3.apiClientManager.client;
   if (!apiClient) {
     throw apiClientMissingError();
   }
-  return apiClient.createSchedule(options);
+  const $requestOptions = v3.mergeRequestOptions({
+    tracer,
+    name: "schedules.create()",
+    icon: "clock",
+    attributes: {
+      ...v3.accessoryAttributes({
+        items: [
+          {
+            text: options.cron,
+            variant: "normal"
+          }
+        ],
+        style: "codepath"
+      })
+    }
+  }, requestOptions);
+  return apiClient.createSchedule(options, $requestOptions);
 }
 __name(create, "create");
-function retrieve(scheduleId) {
+function retrieve(scheduleId, requestOptions) {
   const apiClient = v3.apiClientManager.client;
   if (!apiClient) {
     throw apiClientMissingError();
   }
-  return apiClient.retrieveSchedule(scheduleId);
+  const $requestOptions = v3.mergeRequestOptions({
+    tracer,
+    name: "schedules.retrieve()",
+    icon: "clock",
+    attributes: {
+      scheduleId,
+      ...v3.accessoryAttributes({
+        items: [
+          {
+            text: scheduleId,
+            variant: "normal"
+          }
+        ],
+        style: "codepath"
+      })
+    }
+  }, requestOptions);
+  return apiClient.retrieveSchedule(scheduleId, $requestOptions);
 }
 __name(retrieve, "retrieve");
-function update(scheduleId, options) {
+function update(scheduleId, options, requestOptions) {
   const apiClient = v3.apiClientManager.client;
   if (!apiClient) {
     throw apiClientMissingError();
   }
-  return apiClient.updateSchedule(scheduleId, options);
+  const $requestOptions = v3.mergeRequestOptions({
+    tracer,
+    name: "schedules.update()",
+    icon: "clock",
+    attributes: {
+      scheduleId,
+      ...v3.accessoryAttributes({
+        items: [
+          {
+            text: scheduleId,
+            variant: "normal"
+          }
+        ],
+        style: "codepath"
+      })
+    }
+  }, requestOptions);
+  return apiClient.updateSchedule(scheduleId, options, $requestOptions);
 }
 __name(update, "update");
-function del(scheduleId) {
+function del(scheduleId, requestOptions) {
   const apiClient = v3.apiClientManager.client;
   if (!apiClient) {
     throw apiClientMissingError();
   }
-  return apiClient.deleteSchedule(scheduleId);
+  const $requestOptions = v3.mergeRequestOptions({
+    tracer,
+    name: "schedules.delete()",
+    icon: "clock",
+    attributes: {
+      scheduleId,
+      ...v3.accessoryAttributes({
+        items: [
+          {
+            text: scheduleId,
+            variant: "normal"
+          }
+        ],
+        style: "codepath"
+      })
+    }
+  }, requestOptions);
+  return apiClient.deleteSchedule(scheduleId, $requestOptions);
 }
 __name(del, "del");
-function deactivate(scheduleId) {
+function deactivate(scheduleId, requestOptions) {
   const apiClient = v3.apiClientManager.client;
   if (!apiClient) {
     throw apiClientMissingError();
   }
-  return apiClient.deactivateSchedule(scheduleId);
+  const $requestOptions = v3.mergeRequestOptions({
+    tracer,
+    name: "schedules.deactivate()",
+    icon: "clock",
+    attributes: {
+      scheduleId,
+      ...v3.accessoryAttributes({
+        items: [
+          {
+            text: scheduleId,
+            variant: "normal"
+          }
+        ],
+        style: "codepath"
+      })
+    }
+  }, requestOptions);
+  return apiClient.deactivateSchedule(scheduleId, $requestOptions);
 }
 __name(deactivate, "deactivate");
-function activate(scheduleId) {
+function activate(scheduleId, requestOptions) {
   const apiClient = v3.apiClientManager.client;
   if (!apiClient) {
     throw apiClientMissingError();
   }
-  return apiClient.activateSchedule(scheduleId);
+  const $requestOptions = v3.mergeRequestOptions({
+    tracer,
+    name: "schedules.activate()",
+    icon: "clock",
+    attributes: {
+      scheduleId,
+      ...v3.accessoryAttributes({
+        items: [
+          {
+            text: scheduleId,
+            variant: "normal"
+          }
+        ],
+        style: "codepath"
+      })
+    }
+  }, requestOptions);
+  return apiClient.activateSchedule(scheduleId, $requestOptions);
 }
 __name(activate, "activate");
-function list(options) {
+function list(options, requestOptions) {
   const apiClient = v3.apiClientManager.client;
   if (!apiClient) {
     throw apiClientMissingError();
   }
-  return apiClient.listSchedules(options);
+  const $requestOptions = v3.mergeRequestOptions({
+    tracer,
+    name: "schedules.list()",
+    icon: "clock"
+  }, requestOptions);
+  return apiClient.listSchedules(options, $requestOptions);
 }
 __name(list, "list");
 function timezones(options) {
@@ -1287,14 +1689,15 @@ __export(envvars_exports, {
   update: () => update2,
   upload: () => upload
 });
-function upload(projectRefOrParams, slug, params) {
+function upload(projectRefOrParams, slugOrRequestOptions, params, requestOptions) {
   let $projectRef;
   let $params;
   let $slug;
+  const $requestOptions = overloadRequestOptions("upload", slugOrRequestOptions, requestOptions);
   if (v3.taskContext.ctx) {
     if (typeof projectRefOrParams === "string") {
       $projectRef = projectRefOrParams;
-      $slug = slug ?? v3.taskContext.ctx.environment.slug;
+      $slug = typeof slugOrRequestOptions === "string" ? slugOrRequestOptions : v3.taskContext.ctx.environment.slug;
       if (!params) {
         throw new Error("params is required");
       }
@@ -1308,47 +1711,54 @@ function upload(projectRefOrParams, slug, params) {
     if (typeof projectRefOrParams !== "string") {
       throw new Error("projectRef is required");
     }
-    if (!slug) {
+    if (!slugOrRequestOptions || typeof slugOrRequestOptions !== "string") {
       throw new Error("slug is required");
     }
     if (!params) {
       throw new Error("params is required");
     }
     $projectRef = projectRefOrParams;
-    $slug = slug;
+    $slug = slugOrRequestOptions;
     $params = params;
   }
   const apiClient = v3.apiClientManager.client;
   if (!apiClient) {
     throw apiClientMissingError();
   }
-  return apiClient.importEnvVars($projectRef, $slug, $params);
+  return apiClient.importEnvVars($projectRef, $slug, $params, $requestOptions);
 }
 __name(upload, "upload");
-function list2(projectRef, slug) {
-  const $projectRef = projectRef ?? v3.taskContext.ctx?.project.ref;
+function list2(projectRefOrRequestOptions, slug, requestOptions) {
+  const $projectRef = !v3.isRequestOptions(projectRefOrRequestOptions) ? projectRefOrRequestOptions : v3.taskContext.ctx?.project.ref;
   const $slug = slug ?? v3.taskContext.ctx?.environment.slug;
+  let $requestOptions = v3.isRequestOptions(projectRefOrRequestOptions) ? projectRefOrRequestOptions : requestOptions;
   if (!$projectRef) {
     throw new Error("projectRef is required");
   }
   if (!$slug) {
     throw new Error("slug is required");
   }
+  $requestOptions = v3.mergeRequestOptions({
+    tracer,
+    name: "envvars.list()",
+    icon: "id-badge"
+  }, $requestOptions);
   const apiClient = v3.apiClientManager.client;
   if (!apiClient) {
     throw apiClientMissingError();
   }
-  return apiClient.listEnvVars($projectRef, $slug);
+  return apiClient.listEnvVars($projectRef, $slug, $requestOptions);
 }
 __name(list2, "list");
-function create2(projectRefOrParams, slug, params) {
+function create2(projectRefOrParams, slugOrRequestOptions, params, requestOptions) {
   let $projectRef;
   let $slug;
   let $params;
+  const $requestOptions = overloadRequestOptions("create", slugOrRequestOptions, requestOptions);
   if (v3.taskContext.ctx) {
     if (typeof projectRefOrParams === "string") {
       $projectRef = projectRefOrParams;
-      $slug = slug ?? v3.taskContext.ctx.environment.slug;
+      $slug = typeof slugOrRequestOptions === "string" ? slugOrRequestOptions : v3.taskContext.ctx.environment.slug;
       if (!params) {
         throw new Error("params is required");
       }
@@ -1362,31 +1772,32 @@ function create2(projectRefOrParams, slug, params) {
     if (typeof projectRefOrParams !== "string") {
       throw new Error("projectRef is required");
     }
-    if (!slug) {
+    if (!slugOrRequestOptions || typeof slugOrRequestOptions !== "string") {
       throw new Error("slug is required");
     }
     if (!params) {
       throw new Error("params is required");
     }
     $projectRef = projectRefOrParams;
-    $slug = slug;
+    $slug = slugOrRequestOptions;
     $params = params;
   }
   const apiClient = v3.apiClientManager.client;
   if (!apiClient) {
     throw apiClientMissingError();
   }
-  return apiClient.createEnvVar($projectRef, $slug, $params);
+  return apiClient.createEnvVar($projectRef, $slug, $params, $requestOptions);
 }
 __name(create2, "create");
-function retrieve2(projectRefOrName, slug, name) {
+function retrieve2(projectRefOrName, slugOrRequestOptions, name1, requestOptions) {
   let $projectRef;
   let $slug;
   let $name;
-  if (typeof name === "string") {
+  const $requestOptions = overloadRequestOptions("retrieve", slugOrRequestOptions, requestOptions);
+  if (typeof name1 === "string") {
     $projectRef = projectRefOrName;
-    $slug = slug;
-    $name = name;
+    $slug = typeof slugOrRequestOptions === "string" ? slugOrRequestOptions : v3.taskContext.ctx?.environment.slug;
+    $name = name1;
   } else {
     $projectRef = v3.taskContext.ctx?.project.ref;
     $slug = v3.taskContext.ctx?.environment.slug;
@@ -1402,17 +1813,18 @@ function retrieve2(projectRefOrName, slug, name) {
   if (!apiClient) {
     throw apiClientMissingError();
   }
-  return apiClient.retrieveEnvVar($projectRef, $slug, $name);
+  return apiClient.retrieveEnvVar($projectRef, $slug, $name, $requestOptions);
 }
 __name(retrieve2, "retrieve");
-function del2(projectRefOrName, slug, name) {
+function del2(projectRefOrName, slugOrRequestOptions, name1, requestOptions) {
   let $projectRef;
   let $slug;
   let $name;
-  if (typeof name === "string") {
+  const $requestOptions = overloadRequestOptions("del", slugOrRequestOptions, requestOptions);
+  if (typeof name1 === "string") {
     $projectRef = projectRefOrName;
-    $slug = slug;
-    $name = name;
+    $slug = typeof slugOrRequestOptions === "string" ? slugOrRequestOptions : v3.taskContext.ctx?.environment.slug;
+    $name = name1;
   } else {
     $projectRef = v3.taskContext.ctx?.project.ref;
     $slug = v3.taskContext.ctx?.environment.slug;
@@ -1428,19 +1840,20 @@ function del2(projectRefOrName, slug, name) {
   if (!apiClient) {
     throw apiClientMissingError();
   }
-  return apiClient.deleteEnvVar($projectRef, $slug, $name);
+  return apiClient.deleteEnvVar($projectRef, $slug, $name, $requestOptions);
 }
 __name(del2, "del");
-function update2(projectRefOrName, slugOrParams, name, params) {
+function update2(projectRefOrName, slugOrParams, nameOrRequestOptions, params, requestOptions) {
   let $projectRef;
   let $slug;
   let $name;
   let $params;
+  const $requestOptions = overloadRequestOptions("update", nameOrRequestOptions, requestOptions);
   if (v3.taskContext.ctx) {
     if (typeof slugOrParams === "string") {
       $projectRef = slugOrParams;
       $slug = slugOrParams ?? v3.taskContext.ctx.environment.slug;
-      $name = name;
+      $name = typeof nameOrRequestOptions === "string" ? nameOrRequestOptions : v3.taskContext.ctx.environment.slug;
       if (!params) {
         throw new Error("params is required");
       }
@@ -1470,9 +1883,25 @@ function update2(projectRefOrName, slugOrParams, name, params) {
   if (!apiClient) {
     throw apiClientMissingError();
   }
-  return apiClient.updateEnvVar($projectRef, $slug, $name, $params);
+  return apiClient.updateEnvVar($projectRef, $slug, $name, $params, $requestOptions);
 }
 __name(update2, "update");
+function overloadRequestOptions(name1, slugOrRequestOptions, requestOptions) {
+  if (v3.isRequestOptions(slugOrRequestOptions)) {
+    return v3.mergeRequestOptions({
+      tracer,
+      name: `envvars.${name1}()`,
+      icon: "id-badge"
+    }, slugOrRequestOptions);
+  } else {
+    return v3.mergeRequestOptions({
+      tracer,
+      name: `envvars.${name1}()`,
+      icon: "id-badge"
+    }, requestOptions);
+  }
+}
+__name(overloadRequestOptions, "overloadRequestOptions");
 
 // src/v3/index.ts
 function configure(options) {
@@ -1480,6 +1909,10 @@ function configure(options) {
 }
 __name(configure, "configure");
 
+Object.defineProperty(exports, "AbortTaskRunError", {
+  enumerable: true,
+  get: function () { return v3.AbortTaskRunError; }
+});
 Object.defineProperty(exports, "ApiError", {
   enumerable: true,
   get: function () { return v3.ApiError; }
@@ -1524,6 +1957,8 @@ exports.InMemoryCache = InMemoryCache;
 exports.configure = configure;
 exports.createCache = createCache;
 exports.envvars = envvars_exports;
+exports.idempotencyKeys = idempotencyKeys;
+exports.isIdempotencyKey = isIdempotencyKey;
 exports.queue = queue;
 exports.retry = retry;
 exports.runs = runs;