@trigger.dev/core 3.0.0-beta.45 → 3.0.0-beta.47

package/dist/v3/index.js

@@ -33,7 +33,7 @@ var __privateMethod = (obj, member, method) => {
 };
 
 // package.json
-var version = "3.0.0-beta.45";
+var version = "3.0.0-beta.47";
 var dependencies = {
   "@google-cloud/precise-date": "^4.0.0",
   "@opentelemetry/api": "^1.8.0",
@@ -48,7 +48,7 @@ var dependencies = {
   "@opentelemetry/sdk-trace-node": "^1.22.0",
   "@opentelemetry/semantic-conventions": "^1.22.0",
   "humanize-duration": "^3.27.3",
-  "socket.io-client": "4.7.4",
+  "socket.io-client": "4.7.5",
   superjson: "^2.2.1",
   ulidx: "^2.2.1",
   zod: "3.22.3",
@@ -167,6 +167,7 @@ var TaskRun = zod.z.object({
   createdAt: zod.z.coerce.date(),
   startedAt: zod.z.coerce.date().default(() => /* @__PURE__ */ new Date()),
   idempotencyKey: zod.z.string().optional(),
+  maxAttempts: zod.z.number().optional(),
   durationMs: zod.z.number().default(0),
   costInCents: zod.z.number().default(0),
   baseCostInCents: zod.z.number().default(0)
@@ -458,6 +459,7 @@ var WaitReason = zod.z.enum([
 ]);
 var TaskRunExecutionLazyAttemptPayload = zod.z.object({
   runId: zod.z.string(),
+  attemptCount: zod.z.number().optional(),
   messageId: zod.z.string(),
   isTest: zod.z.boolean(),
   traceContext: zod.z.record(zod.z.unknown()),
@@ -484,6 +486,14 @@ var ImageDetailsMetadata = zod.z.object({
   contentHash: zod.z.string(),
   imageTag: zod.z.string()
 });
+var _AbortTaskRunError = class _AbortTaskRunError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "AbortTaskRunError";
+  }
+};
+__name(_AbortTaskRunError, "AbortTaskRunError");
+var AbortTaskRunError = _AbortTaskRunError;
 function parseError(error) {
   if (error instanceof Error) {
     return {
@@ -564,6 +574,39 @@ function createJsonErrorObject(error) {
   }
 }
 __name(createJsonErrorObject, "createJsonErrorObject");
+function sanitizeError(error) {
+  switch (error.type) {
+    case "BUILT_IN_ERROR": {
+      return {
+        type: "BUILT_IN_ERROR",
+        message: error.message?.replace(/\0/g, ""),
+        name: error.name?.replace(/\0/g, ""),
+        stackTrace: error.stackTrace?.replace(/\0/g, "")
+      };
+    }
+    case "STRING_ERROR": {
+      return {
+        type: "STRING_ERROR",
+        raw: error.raw.replace(/\0/g, "")
+      };
+    }
+    case "CUSTOM_ERROR": {
+      return {
+        type: "CUSTOM_ERROR",
+        raw: error.raw.replace(/\0/g, "")
+      };
+    }
+    case "INTERNAL_ERROR": {
+      return {
+        type: "INTERNAL_ERROR",
+        code: error.code,
+        message: error.message?.replace(/\0/g, ""),
+        stackTrace: error.stackTrace?.replace(/\0/g, "")
+      };
+    }
+  }
+}
+__name(sanitizeError, "sanitizeError");
 function correctErrorStackTrace(stackTrace, projectDir, options) {
   const [errorLine, ...traceLines] = stackTrace.split("\n");
   return [
@@ -679,7 +722,8 @@ var TriggerTaskRequestBody = zod.z.object({
     test: zod.z.boolean().optional(),
     payloadType: zod.z.string().optional(),
     delay: zod.z.string().or(zod.z.coerce.date()).optional(),
-    ttl: zod.z.string().or(zod.z.number().nonnegative().int()).optional()
+    ttl: zod.z.string().or(zod.z.number().nonnegative().int()).optional(),
+    maxAttempts: zod.z.number().int().optional()
   }).optional()
 });
 var TriggerTaskResponse = zod.z.object({
@@ -1192,47 +1236,15 @@ var ProdChildToWorkerMessages = {
       id: zod.z.string()
     })
   },
-  TASK_RUN_HEARTBEAT: {
-    message: zod.z.object({
-      version: zod.z.literal("v1").default("v1"),
-      id: zod.z.string()
-    })
-  },
   READY_TO_DISPOSE: {
     message: zod.z.undefined()
   },
-  READY_FOR_CHECKPOINT: {
-    message: zod.z.object({
-      version: zod.z.literal("v1").default("v1")
-    })
-  },
-  CANCEL_CHECKPOINT: {
-    message: zod.z.discriminatedUnion("version", [
-      zod.z.object({
-        version: zod.z.literal("v1")
-      }),
-      zod.z.object({
-        version: zod.z.literal("v2"),
-        reason: WaitReason.optional()
-      })
-    ]).default({
-      version: "v1"
-    }),
-    callback: zod.z.object({
-      // TODO: Figure out how best to handle callback schema parsing in zod IPC
-      version: zod.z.literal("v2"),
-      checkpointCanceled: zod.z.boolean(),
-      reason: WaitReason.optional()
-    })
-  },
   WAIT_FOR_DURATION: {
     message: zod.z.object({
       version: zod.z.literal("v1").default("v1"),
       ms: zod.z.number(),
-      now: zod.z.number()
-    }),
-    callback: zod.z.object({
-      willCheckpointAndRestore: zod.z.boolean()
+      now: zod.z.number(),
+      waitThresholdInMs: zod.z.number()
     })
   },
   WAIT_FOR_TASK: {
@@ -1435,6 +1447,7 @@ var CoordinatorToPlatformMessages = {
       })
     ])
   },
+  // Deprecated: Only workers without lazy attempt support will use this
   READY_FOR_EXECUTION: {
     message: zod.z.object({
       version: zod.z.literal("v1").default("v1"),
@@ -1598,6 +1611,12 @@ var PlatformToCoordinatorMessages = {
       version: zod.z.literal("v1").default("v1"),
       runId: zod.z.string()
     })
+  },
+  DYNAMIC_CONFIG: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      checkpointThresholdInMs: zod.z.number()
+    })
   }
 };
 var ClientToSharedQueueMessages = {
@@ -1643,10 +1662,9 @@ var IndexTasksMessage = zod.z.object({
   packageVersion: zod.z.string()
 });
 var ProdWorkerToCoordinatorMessages = {
-  LOG: {
+  TEST: {
     message: zod.z.object({
-      version: zod.z.literal("v1").default("v1"),
-      text: zod.z.string()
+      version: zod.z.literal("v1").default("v1")
     }),
     callback: zod.z.void()
   },
@@ -1669,6 +1687,7 @@ var ProdWorkerToCoordinatorMessages = {
       })
     ])
   },
+  // Deprecated: Only workers without lazy attempt support will use this
   READY_FOR_EXECUTION: {
     message: zod.z.object({
       version: zod.z.literal("v1").default("v1"),
@@ -1755,7 +1774,10 @@ var ProdWorkerToCoordinatorMessages = {
   },
   WAIT_FOR_TASK: {
     message: zod.z.object({
-      version: zod.z.literal("v1").default("v1"),
+      version: zod.z.enum([
+        "v1",
+        "v2"
+      ]).default("v1"),
       friendlyId: zod.z.string(),
       // This is the attempt that is waiting
       attemptFriendlyId: zod.z.string()
@@ -1766,7 +1788,10 @@ var ProdWorkerToCoordinatorMessages = {
   },
   WAIT_FOR_BATCH: {
     message: zod.z.object({
-      version: zod.z.literal("v1").default("v1"),
+      version: zod.z.enum([
+        "v1",
+        "v2"
+      ]).default("v1"),
       batchFriendlyId: zod.z.string(),
       runFriendlyIds: zod.z.string().array(),
       // This is the attempt that is waiting
@@ -1813,6 +1838,12 @@ var ProdWorkerToCoordinatorMessages = {
         stack: zod.z.string().optional()
       })
     })
+  },
+  SET_STATE: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      attemptFriendlyId: zod.z.string().optional()
+    })
   }
 };
 var CoordinatorToProdWorkerMessages = {
@@ -1830,6 +1861,7 @@ var CoordinatorToProdWorkerMessages = {
       attemptId: zod.z.string()
     })
   },
+  // Deprecated: Only workers without lazy attempt support will use this
   EXECUTE_TASK_RUN: {
     message: zod.z.object({
       version: zod.z.literal("v1").default("v1"),
@@ -1876,6 +1908,9 @@ var ProdWorkerSocketData = zod.z.object({
   deploymentId: zod.z.string(),
   deploymentVersion: zod.z.string()
 });
+var CoordinatorSocketData = zod.z.object({
+  supportsDynamicConfig: zod.z.string().optional()
+});
 var PRIMARY_VARIANT = "primary";
 var Variant = zod.z.enum([
   PRIMARY_VARIANT
@@ -2152,7 +2187,10 @@ var SemanticInternalAttributes = {
   LINK_TITLE: "$link.title",
   IDEMPOTENCY_KEY: "ctx.run.idempotencyKey",
   USAGE_DURATION_MS: "$usage.durationMs",
-  USAGE_COST_IN_CENTS: "$usage.costInCents"
+  USAGE_COST_IN_CENTS: "$usage.costInCents",
+  RATE_LIMIT_LIMIT: "response.rateLimit.limit",
+  RATE_LIMIT_REMAINING: "response.rateLimit.remaining",
+  RATE_LIMIT_RESET: "response.rateLimit.reset"
 };
 
 // src/v3/taskContext/index.ts
@@ -2242,10 +2280,118 @@ var TaskContextAPI = _TaskContextAPI;
 // src/v3/task-context-api.ts
 var taskContext = TaskContextAPI.getInstance();
 
+// src/retry.ts
+function calculateResetAt(resets, format, now = /* @__PURE__ */ new Date()) {
+  if (!resets)
+    return;
+  switch (format) {
+    case "iso_8601_duration_openai_variant": {
+      return calculateISO8601DurationOpenAIVariantResetAt(resets, now);
+    }
+    case "iso_8601": {
+      return calculateISO8601ResetAt(resets, now);
+    }
+    case "unix_timestamp": {
+      return calculateUnixTimestampResetAt(resets, now);
+    }
+    case "unix_timestamp_in_ms": {
+      return calculateUnixTimestampInMsResetAt(resets, now);
+    }
+  }
+}
+__name(calculateResetAt, "calculateResetAt");
+function calculateUnixTimestampResetAt(resets, now = /* @__PURE__ */ new Date()) {
+  if (!resets)
+    return void 0;
+  const resetAt = parseInt(resets, 10);
+  if (isNaN(resetAt))
+    return void 0;
+  return new Date(resetAt * 1e3);
+}
+__name(calculateUnixTimestampResetAt, "calculateUnixTimestampResetAt");
+function calculateUnixTimestampInMsResetAt(resets, now = /* @__PURE__ */ new Date()) {
+  if (!resets)
+    return void 0;
+  const resetAt = parseInt(resets, 10);
+  if (isNaN(resetAt))
+    return void 0;
+  return new Date(resetAt);
+}
+__name(calculateUnixTimestampInMsResetAt, "calculateUnixTimestampInMsResetAt");
+function calculateISO8601ResetAt(resets, now = /* @__PURE__ */ new Date()) {
+  if (!resets)
+    return void 0;
+  const resetAt = new Date(resets);
+  if (isNaN(resetAt.getTime()))
+    return void 0;
+  return resetAt;
+}
+__name(calculateISO8601ResetAt, "calculateISO8601ResetAt");
+function calculateISO8601DurationOpenAIVariantResetAt(resets, now = /* @__PURE__ */ new Date()) {
+  if (!resets)
+    return void 0;
+  const pattern = /^(?:(\d+)d)?(?:(\d+)h)?(?:(\d+)m)?(?:(\d+(?:\.\d+)?)s)?(?:(\d+)ms)?$/;
+  const match = resets.match(pattern);
+  if (!match)
+    return void 0;
+  const days = parseInt(match[1], 10) || 0;
+  const hours = parseInt(match[2], 10) || 0;
+  const minutes = parseInt(match[3], 10) || 0;
+  const seconds = parseFloat(match[4]) || 0;
+  const milliseconds = parseInt(match[5], 10) || 0;
+  const resetAt = new Date(now);
+  resetAt.setDate(resetAt.getDate() + days);
+  resetAt.setHours(resetAt.getHours() + hours);
+  resetAt.setMinutes(resetAt.getMinutes() + minutes);
+  resetAt.setSeconds(resetAt.getSeconds() + Math.floor(seconds));
+  resetAt.setMilliseconds(resetAt.getMilliseconds() + (seconds - Math.floor(seconds)) * 1e3 + milliseconds);
+  return resetAt;
+}
+__name(calculateISO8601DurationOpenAIVariantResetAt, "calculateISO8601DurationOpenAIVariantResetAt");
+
+// src/v3/utils/retries.ts
+var defaultRetryOptions = {
+  maxAttempts: 3,
+  factor: 2,
+  minTimeoutInMs: 1e3,
+  maxTimeoutInMs: 6e4,
+  randomize: true
+};
+var defaultFetchRetryOptions = {
+  byStatus: {
+    "429,408,409,5xx": {
+      strategy: "backoff",
+      ...defaultRetryOptions
+    }
+  },
+  connectionError: defaultRetryOptions,
+  timeout: defaultRetryOptions
+};
+function calculateNextRetryDelay(options, attempt) {
+  const opts = {
+    ...defaultRetryOptions,
+    ...options
+  };
+  if (attempt >= opts.maxAttempts) {
+    return;
+  }
+  const { factor, minTimeoutInMs, maxTimeoutInMs, randomize } = opts;
+  const random = randomize ? Math.random() + 1 : 1;
+  const timeout = Math.min(maxTimeoutInMs, random * minTimeoutInMs * Math.pow(factor, attempt - 1));
+  return Math.round(timeout);
+}
+__name(calculateNextRetryDelay, "calculateNextRetryDelay");
+function calculateResetAt2(resets, format, now = Date.now()) {
+  const resetAt = calculateResetAt(resets, format, new Date(now));
+  return resetAt?.getTime();
+}
+__name(calculateResetAt2, "calculateResetAt");
+
 // src/v3/apiClient/errors.ts
 var _ApiError = class _ApiError extends Error {
   constructor(status, error, message, headers) {
     super(`${_ApiError.makeMessage(status, error, message)}`);
+    this.name = "TriggerApiError";
     this.status = status;
     this.headers = headers;
     const data = error;
@@ -2366,6 +2512,16 @@ var _RateLimitError = class _RateLimitError extends ApiError {
     super(...arguments);
     __publicField(this, "status", 429);
   }
+  get millisecondsUntilReset() {
+    const resetAtUnixEpochMs = (this.headers ?? {})["x-ratelimit-reset"];
+    if (typeof resetAtUnixEpochMs === "string") {
+      const resetAtUnixEpoch = parseInt(resetAtUnixEpochMs, 10);
+      if (isNaN(resetAtUnixEpoch)) {
+        return;
+      }
+      return Math.max(resetAtUnixEpoch - Date.now() + Math.floor(Math.random() * 2e3), 0);
+    }
+  }
 };
 __name(_RateLimitError, "RateLimitError");
 var RateLimitError = _RateLimitError;
@@ -2380,112 +2536,131 @@ function castToError(err) {
 }
 __name(castToError, "castToError");
 
-// src/retry.ts
-function calculateResetAt(resets, format, now = /* @__PURE__ */ new Date()) {
-  if (!resets)
-    return;
-  switch (format) {
-    case "iso_8601_duration_openai_variant": {
-      return calculateISO8601DurationOpenAIVariantResetAt(resets, now);
-    }
-    case "iso_8601": {
-      return calculateISO8601ResetAt(resets, now);
-    }
-    case "unix_timestamp": {
-      return calculateUnixTimestampResetAt(resets, now);
-    }
-    case "unix_timestamp_in_ms": {
-      return calculateUnixTimestampInMsResetAt(resets, now);
+// src/v3/utils/flattenAttributes.ts
+var NULL_SENTINEL = "$@null((";
+function flattenAttributes(obj, prefix) {
+  const result = {};
+  if (obj === void 0) {
+    return result;
+  }
+  if (obj === null) {
+    result[prefix || ""] = NULL_SENTINEL;
+    return result;
+  }
+  if (typeof obj === "string") {
+    result[prefix || ""] = obj;
+    return result;
+  }
+  if (typeof obj === "number") {
+    result[prefix || ""] = obj;
+    return result;
+  }
+  if (typeof obj === "boolean") {
+    result[prefix || ""] = obj;
+    return result;
+  }
+  for (const [key, value] of Object.entries(obj)) {
+    const newPrefix = `${prefix ? `${prefix}.` : ""}${Array.isArray(obj) ? `[${key}]` : key}`;
+    if (Array.isArray(value)) {
+      for (let i = 0; i < value.length; i++) {
+        if (typeof value[i] === "object" && value[i] !== null) {
+          Object.assign(result, flattenAttributes(value[i], `${newPrefix}.[${i}]`));
+        } else {
+          if (value[i] === null) {
+            result[`${newPrefix}.[${i}]`] = NULL_SENTINEL;
+          } else {
+            result[`${newPrefix}.[${i}]`] = value[i];
+          }
+        }
+      }
+    } else if (isRecord(value)) {
+      Object.assign(result, flattenAttributes(value, newPrefix));
+    } else {
+      if (typeof value === "number" || typeof value === "string" || typeof value === "boolean") {
+        result[newPrefix] = value;
+      } else if (value === null) {
+        result[newPrefix] = NULL_SENTINEL;
+      }
     }
   }
+  return result;
 }
-__name(calculateResetAt, "calculateResetAt");
-function calculateUnixTimestampResetAt(resets, now = /* @__PURE__ */ new Date()) {
-  if (!resets)
-    return void 0;
-  const resetAt = parseInt(resets, 10);
-  if (isNaN(resetAt))
-    return void 0;
-  return new Date(resetAt * 1e3);
+__name(flattenAttributes, "flattenAttributes");
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
 }
-__name(calculateUnixTimestampResetAt, "calculateUnixTimestampResetAt");
-function calculateUnixTimestampInMsResetAt(resets, now = /* @__PURE__ */ new Date()) {
-  if (!resets)
-    return void 0;
-  const resetAt = parseInt(resets, 10);
-  if (isNaN(resetAt))
-    return void 0;
-  return new Date(resetAt);
-}
-__name(calculateUnixTimestampInMsResetAt, "calculateUnixTimestampInMsResetAt");
-function calculateISO8601ResetAt(resets, now = /* @__PURE__ */ new Date()) {
-  if (!resets)
-    return void 0;
-  const resetAt = new Date(resets);
-  if (isNaN(resetAt.getTime()))
-    return void 0;
-  return resetAt;
+__name(isRecord, "isRecord");
+function unflattenAttributes(obj) {
+  if (typeof obj !== "object" || obj === null || Array.isArray(obj)) {
+    return obj;
+  }
+  if (typeof obj === "object" && obj !== null && Object.keys(obj).length === 1 && Object.keys(obj)[0] === "") {
+    return rehydrateNull(obj[""]);
+  }
+  if (Object.keys(obj).length === 0) {
+    return;
+  }
+  const result = {};
+  for (const [key, value] of Object.entries(obj)) {
+    const parts = key.split(".").reduce((acc, part) => {
+      if (part.includes("[")) {
+        const subparts = part.split(/\[|\]/).filter((p) => p !== "");
+        acc.push(...subparts);
+      } else {
+        acc.push(part);
+      }
+      return acc;
+    }, []);
+    let current = result;
+    for (let i = 0; i < parts.length - 1; i++) {
+      const part = parts[i];
+      const nextPart = parts[i + 1];
+      const isArray = /^\d+$/.test(nextPart);
+      if (isArray && !Array.isArray(current[part])) {
+        current[part] = [];
+      } else if (!isArray && current[part] === void 0) {
+        current[part] = {};
+      }
+      current = current[part];
+    }
+    const lastPart = parts[parts.length - 1];
+    current[lastPart] = rehydrateNull(value);
+  }
+  if (Object.keys(result).every((k) => /^\d+$/.test(k))) {
+    const maxIndex = Math.max(...Object.keys(result).map((k) => parseInt(k)));
+    const arrayResult = Array(maxIndex + 1);
+    for (const key in result) {
+      arrayResult[parseInt(key)] = result[key];
+    }
+    return arrayResult;
+  }
+  return result;
 }
-__name(calculateISO8601ResetAt, "calculateISO8601ResetAt");
-function calculateISO8601DurationOpenAIVariantResetAt(resets, now = /* @__PURE__ */ new Date()) {
-  if (!resets)
-    return void 0;
-  const pattern = /^(?:(\d+)d)?(?:(\d+)h)?(?:(\d+)m)?(?:(\d+(?:\.\d+)?)s)?(?:(\d+)ms)?$/;
-  const match = resets.match(pattern);
-  if (!match)
-    return void 0;
-  const days = parseInt(match[1], 10) || 0;
-  const hours = parseInt(match[2], 10) || 0;
-  const minutes = parseInt(match[3], 10) || 0;
-  const seconds = parseFloat(match[4]) || 0;
-  const milliseconds = parseInt(match[5], 10) || 0;
-  const resetAt = new Date(now);
-  resetAt.setDate(resetAt.getDate() + days);
-  resetAt.setHours(resetAt.getHours() + hours);
-  resetAt.setMinutes(resetAt.getMinutes() + minutes);
-  resetAt.setSeconds(resetAt.getSeconds() + Math.floor(seconds));
-  resetAt.setMilliseconds(resetAt.getMilliseconds() + (seconds - Math.floor(seconds)) * 1e3 + milliseconds);
-  return resetAt;
+__name(unflattenAttributes, "unflattenAttributes");
+function primitiveValueOrflattenedAttributes(obj, prefix) {
+  if (typeof obj === "string" || typeof obj === "number" || typeof obj === "boolean" || obj === null || obj === void 0) {
+    return obj;
+  }
+  const attributes = flattenAttributes(obj, prefix);
+  if (prefix !== void 0 && typeof attributes[prefix] !== "undefined" && attributes[prefix] !== null) {
+    return attributes[prefix];
+  }
+  return attributes;
 }
-__name(calculateISO8601DurationOpenAIVariantResetAt, "calculateISO8601DurationOpenAIVariantResetAt");
-
-// src/v3/utils/retries.ts
-var defaultRetryOptions = {
-  maxAttempts: 3,
-  factor: 2,
-  minTimeoutInMs: 1e3,
-  maxTimeoutInMs: 6e4,
-  randomize: true
-};
-var defaultFetchRetryOptions = {
-  byStatus: {
-    "429,408,409,5xx": {
-      strategy: "backoff",
-      ...defaultRetryOptions
-    }
-  },
-  connectionError: defaultRetryOptions,
-  timeout: defaultRetryOptions
-};
-function calculateNextRetryDelay(options, attempt) {
-  const opts = {
-    ...defaultRetryOptions,
-    ...options
-  };
-  if (attempt >= opts.maxAttempts) {
-    return;
+__name(primitiveValueOrflattenedAttributes, "primitiveValueOrflattenedAttributes");
+function rehydrateNull(value) {
+  if (value === NULL_SENTINEL) {
+    return null;
   }
-  const { factor, minTimeoutInMs, maxTimeoutInMs, randomize } = opts;
-  const random = randomize ? Math.random() + 1 : 1;
-  const timeout = Math.min(maxTimeoutInMs, random * minTimeoutInMs * Math.pow(factor, attempt - 1));
-  return Math.round(timeout);
+  return value;
 }
-__name(calculateNextRetryDelay, "calculateNextRetryDelay");
-function calculateResetAt2(resets, format, now = Date.now()) {
-  const resetAt = calculateResetAt(resets, format, new Date(now));
-  return resetAt?.getTime();
+__name(rehydrateNull, "rehydrateNull");
+
+// src/v3/utils/styleAttributes.ts
+function accessoryAttributes(accessory) {
+  return flattenAttributes(accessory, SemanticInternalAttributes.STYLE_ACCESSORY);
 }
-__name(calculateResetAt2, "calculateResetAt");
+__name(accessoryAttributes, "accessoryAttributes");
 
 // src/v3/apiClient/pagination.ts
 var _CursorPage = class _CursorPage {
@@ -2595,6 +2770,12 @@ var defaultRetryOptions2 = {
   maxTimeoutInMs: 6e4,
   randomize: false
 };
+var requestOptionsKeys = {
+  retry: true
+};
+var isRequestOptions = /* @__PURE__ */ __name((obj) => {
+  return typeof obj === "object" && obj !== null && !isEmptyObj(obj) && Object.keys(obj).every((k) => hasOwn(requestOptionsKeys, k));
+}, "isRequestOptions");
 function zodfetch(schema, url, requestInit, options) {
   return new ApiPromise(_doZodFetch(schema, url, requestInit, options));
 }
@@ -2645,16 +2826,47 @@ function zodfetchOffsetLimitPage(schema, url, params, requestInit, options) {
   return new OffsetLimitPagePromise(fetchResult, schema, url, params, requestInit, options);
 }
 __name(zodfetchOffsetLimitPage, "zodfetchOffsetLimitPage");
-async function _doZodFetch(schema, url, requestInit, options, attempt = 1) {
+async function traceZodFetch(params, callback) {
+  if (!params.options?.tracer) {
+    return callback();
+  }
+  const url = new URL(params.url);
+  const method = params.requestInit?.method ?? "GET";
+  const name = params.options.name ?? `${method} ${url.pathname}`;
+  return await params.options.tracer.startActiveSpan(name, async (span) => {
+    return await callback(span);
+  }, {
+    attributes: {
+      [SemanticInternalAttributes.STYLE_ICON]: params.options?.icon ?? "api",
+      ...params.options.attributes
+    }
+  });
+}
+__name(traceZodFetch, "traceZodFetch");
+async function _doZodFetch(schema, url, requestInit, options) {
+  const $requestInit = await requestInit;
+  return traceZodFetch({
+    url,
+    requestInit: $requestInit,
+    options
+  }, async (span) => {
+    const result = await _doZodFetchWithRetries(schema, url, $requestInit, options);
+    if (options?.onResponseBody && span) {
+      options.onResponseBody(result.data, span);
+    }
+    return result;
+  });
+}
+__name(_doZodFetch, "_doZodFetch");
+async function _doZodFetchWithRetries(schema, url, requestInit, options, attempt = 1) {
   try {
-    const $requestInit = await requestInit;
-    const response = await fetch(url, requestInitWithCache($requestInit));
+    const response = await fetch(url, requestInitWithCache(requestInit));
     const responseHeaders = createResponseHeaders(response.headers);
     if (!response.ok) {
       const retryResult = shouldRetry(response, attempt, options?.retry);
       if (retryResult.retry) {
-        await new Promise((resolve) => setTimeout(resolve, retryResult.delay));
-        return await _doZodFetch(schema, url, requestInit, options, attempt + 1);
+        await waitForRetry(url, attempt + 1, retryResult.delay, options, requestInit, response);
+        return await _doZodFetchWithRetries(schema, url, requestInit, options, attempt + 1);
       } else {
         const errText = await response.text().catch((e) => castToError2(e).message);
         const errJSON = safeJsonParse(errText);
@@ -2682,8 +2894,8 @@ async function _doZodFetch(schema, url, requestInit, options, attempt = 1) {
       };
       const delay = calculateNextRetryDelay(retry, attempt);
       if (delay) {
-        await new Promise((resolve) => setTimeout(resolve, delay));
-        return await _doZodFetch(schema, url, requestInit, options, attempt + 1);
+        await waitForRetry(url, attempt + 1, delay, options, requestInit);
+        return await _doZodFetchWithRetries(schema, url, requestInit, options, attempt + 1);
       }
     }
     throw new ApiConnectionError({
@@ -2691,7 +2903,7 @@ async function _doZodFetch(schema, url, requestInit, options, attempt = 1) {
     });
   }
 }
-__name(_doZodFetch, "_doZodFetch");
+__name(_doZodFetchWithRetries, "_doZodFetchWithRetries");
 function castToError2(err) {
   if (err instanceof Error)
     return err;
@@ -2728,8 +2940,25 @@ function shouldRetry(response, attempt, retryOptions) {
     return shouldRetryForOptions();
   if (response.status === 409)
     return shouldRetryForOptions();
-  if (response.status === 429)
+  if (response.status === 429) {
+    if (attempt >= (typeof retryOptions?.maxAttempts === "number" ? retryOptions?.maxAttempts : 3)) {
+      return {
+        retry: false
+      };
+    }
+    const resetAtUnixEpochMs = response.headers.get("x-ratelimit-reset");
+    if (resetAtUnixEpochMs) {
+      const resetAtUnixEpoch = parseInt(resetAtUnixEpochMs, 10);
+      const delay = resetAtUnixEpoch - Date.now() + Math.floor(Math.random() * 1e3);
+      if (delay > 0) {
+        return {
+          retry: true,
+          delay
+        };
+      }
+    }
     return shouldRetryForOptions();
+  }
   if (response.status >= 500)
     return shouldRetryForOptions();
   return {
@@ -2892,9 +3121,44 @@ fetchPage_fn2 = /* @__PURE__ */ __name(function(params1) {
 }, "#fetchPage");
 __name(_OffsetLimitPagePromise, "OffsetLimitPagePromise");
 var OffsetLimitPagePromise = _OffsetLimitPagePromise;
+async function waitForRetry(url, attempt, delay, options, requestInit, response) {
+  if (options?.tracer) {
+    const method = requestInit?.method ?? "GET";
+    return options.tracer.startActiveSpan(response ? `wait after ${response.status}` : `wait after error`, async (span) => {
+      await new Promise((resolve) => setTimeout(resolve, delay));
+    }, {
+      attributes: {
+        [SemanticInternalAttributes.STYLE_ICON]: "wait",
+        ...accessoryAttributes({
+          items: [
+            {
+              text: `retrying ${options?.name ?? method.toUpperCase()} in ${delay}ms`,
+              variant: "normal"
+            }
+          ],
+          style: "codepath"
+        })
+      }
+    });
+  }
+  await new Promise((resolve) => setTimeout(resolve, delay));
+}
+__name(waitForRetry, "waitForRetry");
+function isEmptyObj(obj) {
+  if (!obj)
+    return true;
+  for (const _k in obj)
+    return false;
+  return true;
+}
+__name(isEmptyObj, "isEmptyObj");
+function hasOwn(obj, key) {
+  return Object.prototype.hasOwnProperty.call(obj, key);
+}
+__name(hasOwn, "hasOwn");
 
 // src/v3/apiClient/index.ts
-var zodFetchOptions = {
+var DEFAULT_ZOD_FETCH_OPTIONS = {
   retry: {
     maxAttempts: 3,
     minTimeoutInMs: 1e3,
@@ -2905,17 +3169,18 @@ var zodFetchOptions = {
 };
 var _getHeaders, getHeaders_fn;
 var _ApiClient = class _ApiClient {
-  constructor(baseUrl, accessToken) {
+  constructor(baseUrl, accessToken, requestOptions = {}) {
     __privateAdd(this, _getHeaders);
     this.accessToken = accessToken;
     this.baseUrl = baseUrl.replace(/\/$/, "");
+    this.defaultRequestOptions = mergeRequestOptions(DEFAULT_ZOD_FETCH_OPTIONS, requestOptions);
   }
-  async getRunResult(runId) {
+  async getRunResult(runId, requestOptions) {
     try {
       return await zodfetch(TaskRunExecutionResult, `${this.baseUrl}/api/v1/runs/${runId}/result`, {
         method: "GET",
         headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
-      }, zodFetchOptions);
+      }, mergeRequestOptions(this.defaultRequestOptions, requestOptions));
     } catch (error) {
       if (error instanceof ApiError) {
         if (error.status === 404) {
@@ -2925,47 +3190,47 @@ var _ApiClient = class _ApiClient {
       throw error;
     }
   }
-  async getBatchResults(batchId) {
+  async getBatchResults(batchId, requestOptions) {
     return await zodfetch(BatchTaskRunExecutionResult, `${this.baseUrl}/api/v1/batches/${batchId}/results`, {
       method: "GET",
       headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
-    }, zodFetchOptions);
+    }, mergeRequestOptions(this.defaultRequestOptions, requestOptions));
   }
-  triggerTask(taskId, body, options) {
+  triggerTask(taskId, body, options, requestOptions) {
     const encodedTaskId = encodeURIComponent(taskId);
     return zodfetch(TriggerTaskResponse, `${this.baseUrl}/api/v1/tasks/${encodedTaskId}/trigger`, {
       method: "POST",
       headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, options?.spanParentAsLink ?? false),
       body: JSON.stringify(body)
-    }, zodFetchOptions);
+    }, mergeRequestOptions(this.defaultRequestOptions, requestOptions));
   }
-  batchTriggerTask(taskId, body, options) {
+  batchTriggerTask(taskId, body, options, requestOptions) {
     const encodedTaskId = encodeURIComponent(taskId);
     return zodfetch(BatchTriggerTaskResponse, `${this.baseUrl}/api/v1/tasks/${encodedTaskId}/batch`, {
       method: "POST",
       headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, options?.spanParentAsLink ?? false),
       body: JSON.stringify(body)
-    }, zodFetchOptions);
+    }, mergeRequestOptions(this.defaultRequestOptions, requestOptions));
   }
-  createUploadPayloadUrl(filename) {
+  createUploadPayloadUrl(filename, requestOptions) {
     return zodfetch(CreateUploadPayloadUrlResponseBody, `${this.baseUrl}/api/v1/packets/${filename}`, {
       method: "PUT",
       headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
-    }, zodFetchOptions);
+    }, mergeRequestOptions(this.defaultRequestOptions, requestOptions));
   }
-  getPayloadUrl(filename) {
+  getPayloadUrl(filename, requestOptions) {
     return zodfetch(CreateUploadPayloadUrlResponseBody, `${this.baseUrl}/api/v1/packets/${filename}`, {
       method: "GET",
       headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
-    }, zodFetchOptions);
+    }, mergeRequestOptions(this.defaultRequestOptions, requestOptions));
   }
-  retrieveRun(runId) {
+  retrieveRun(runId, requestOptions) {
     return zodfetch(RetrieveRunResponse, `${this.baseUrl}/api/v3/runs/${runId}`, {
       method: "GET",
       headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
-    }, zodFetchOptions);
+    }, mergeRequestOptions(this.defaultRequestOptions, requestOptions));
   }
-  listRuns(query) {
+  listRuns(query, requestOptions) {
     const searchParams = createSearchQueryForListRuns(query);
     return zodfetchCursorPage(ListRunResponseItem, `${this.baseUrl}/api/v1/runs`, {
       query: searchParams,
@@ -2975,9 +3240,9 @@ var _ApiClient = class _ApiClient {
     }, {
       method: "GET",
       headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
-    }, zodFetchOptions);
+    }, mergeRequestOptions(this.defaultRequestOptions, requestOptions));
   }
-  listProjectRuns(projectRef, query) {
+  listProjectRuns(projectRef, query, requestOptions) {
     const searchParams = createSearchQueryForListRuns(query);
     if (query?.env) {
       searchParams.append("filter[env]", Array.isArray(query.env) ? query.env.join(",") : query.env);
@@ -2990,35 +3255,35 @@ var _ApiClient = class _ApiClient {
     }, {
       method: "GET",
       headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
-    }, zodFetchOptions);
+    }, mergeRequestOptions(this.defaultRequestOptions, requestOptions));
   }
-  replayRun(runId) {
+  replayRun(runId, requestOptions) {
     return zodfetch(ReplayRunResponse, `${this.baseUrl}/api/v1/runs/${runId}/replay`, {
       method: "POST",
       headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
-    }, zodFetchOptions);
+    }, mergeRequestOptions(this.defaultRequestOptions, requestOptions));
   }
-  cancelRun(runId) {
+  cancelRun(runId, requestOptions) {
     return zodfetch(CanceledRunResponse, `${this.baseUrl}/api/v2/runs/${runId}/cancel`, {
       method: "POST",
       headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
-    }, zodFetchOptions);
+    }, mergeRequestOptions(this.defaultRequestOptions, requestOptions));
   }
-  rescheduleRun(runId, body) {
+  rescheduleRun(runId, body, requestOptions) {
     return zodfetch(RetrieveRunResponse, `${this.baseUrl}/api/v1/runs/${runId}/reschedule`, {
       method: "POST",
       headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false),
       body: JSON.stringify(body)
-    }, zodFetchOptions);
+    }, mergeRequestOptions(this.defaultRequestOptions, requestOptions));
   }
-  createSchedule(options) {
+  createSchedule(options, requestOptions) {
     return zodfetch(ScheduleObject, `${this.baseUrl}/api/v1/schedules`, {
       method: "POST",
       headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false),
       body: JSON.stringify(options)
-    });
+    }, mergeRequestOptions(this.defaultRequestOptions, requestOptions));
   }
-  listSchedules(options) {
+  listSchedules(options, requestOptions) {
     const searchParams = new URLSearchParams();
     if (options?.page) {
       searchParams.append("page", options.page.toString());
@@ -3032,77 +3297,77 @@ var _ApiClient = class _ApiClient {
     }, {
       method: "GET",
       headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
-    });
+    }, mergeRequestOptions(this.defaultRequestOptions, requestOptions));
   }
-  retrieveSchedule(scheduleId) {
+  retrieveSchedule(scheduleId, requestOptions) {
     return zodfetch(ScheduleObject, `${this.baseUrl}/api/v1/schedules/${scheduleId}`, {
       method: "GET",
       headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
-    });
+    }, mergeRequestOptions(this.defaultRequestOptions, requestOptions));
   }
-  updateSchedule(scheduleId, options) {
+  updateSchedule(scheduleId, options, requestOptions) {
     return zodfetch(ScheduleObject, `${this.baseUrl}/api/v1/schedules/${scheduleId}`, {
       method: "PUT",
       headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false),
       body: JSON.stringify(options)
-    });
+    }, mergeRequestOptions(this.defaultRequestOptions, requestOptions));
   }
-  deactivateSchedule(scheduleId) {
+  deactivateSchedule(scheduleId, requestOptions) {
     return zodfetch(ScheduleObject, `${this.baseUrl}/api/v1/schedules/${scheduleId}/deactivate`, {
       method: "POST",
       headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
-    });
+    }, mergeRequestOptions(this.defaultRequestOptions, requestOptions));
   }
-  activateSchedule(scheduleId) {
+  activateSchedule(scheduleId, requestOptions) {
     return zodfetch(ScheduleObject, `${this.baseUrl}/api/v1/schedules/${scheduleId}/activate`, {
       method: "POST",
       headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
-    });
+    }, mergeRequestOptions(this.defaultRequestOptions, requestOptions));
   }
-  deleteSchedule(scheduleId) {
+  deleteSchedule(scheduleId, requestOptions) {
     return zodfetch(DeletedScheduleObject, `${this.baseUrl}/api/v1/schedules/${scheduleId}`, {
       method: "DELETE",
       headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
-    });
+    }, mergeRequestOptions(this.defaultRequestOptions, requestOptions));
   }
-  listEnvVars(projectRef, slug) {
+  listEnvVars(projectRef, slug, requestOptions) {
     return zodfetch(EnvironmentVariables, `${this.baseUrl}/api/v1/projects/${projectRef}/envvars/${slug}`, {
       method: "GET",
       headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
-    });
+    }, mergeRequestOptions(this.defaultRequestOptions, requestOptions));
   }
-  importEnvVars(projectRef, slug, body) {
+  importEnvVars(projectRef, slug, body, requestOptions) {
     return zodfetch(EnvironmentVariableResponseBody, `${this.baseUrl}/api/v1/projects/${projectRef}/envvars/${slug}/import`, {
       method: "POST",
       headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false),
       body: JSON.stringify(body)
-    });
+    }, mergeRequestOptions(this.defaultRequestOptions, requestOptions));
   }
-  retrieveEnvVar(projectRef, slug, key) {
+  retrieveEnvVar(projectRef, slug, key, requestOptions) {
     return zodfetch(EnvironmentVariableValue, `${this.baseUrl}/api/v1/projects/${projectRef}/envvars/${slug}/${key}`, {
       method: "GET",
       headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
-    });
+    }, mergeRequestOptions(this.defaultRequestOptions, requestOptions));
   }
-  createEnvVar(projectRef, slug, body) {
+  createEnvVar(projectRef, slug, body, requestOptions) {
     return zodfetch(EnvironmentVariableResponseBody, `${this.baseUrl}/api/v1/projects/${projectRef}/envvars/${slug}`, {
       method: "POST",
       headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false),
       body: JSON.stringify(body)
-    });
+    }, mergeRequestOptions(this.defaultRequestOptions, requestOptions));
   }
-  updateEnvVar(projectRef, slug, key, body) {
+  updateEnvVar(projectRef, slug, key, body, requestOptions) {
     return zodfetch(EnvironmentVariableResponseBody, `${this.baseUrl}/api/v1/projects/${projectRef}/envvars/${slug}/${key}`, {
       method: "PUT",
       headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false),
       body: JSON.stringify(body)
-    });
+    }, mergeRequestOptions(this.defaultRequestOptions, requestOptions));
   }
-  deleteEnvVar(projectRef, slug, key) {
+  deleteEnvVar(projectRef, slug, key, requestOptions) {
     return zodfetch(EnvironmentVariableResponseBody, `${this.baseUrl}/api/v1/projects/${projectRef}/envvars/${slug}/${key}`, {
       method: "DELETE",
       headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
-    });
+    }, mergeRequestOptions(this.defaultRequestOptions, requestOptions));
   }
 };
 _getHeaders = new WeakSet();
@@ -3157,6 +3422,20 @@ function createSearchQueryForListRuns(query) {
   return searchParams;
 }
 __name(createSearchQueryForListRuns, "createSearchQueryForListRuns");
+function mergeRequestOptions(defaultOptions, options) {
+  if (!options) {
+    return defaultOptions;
+  }
+  return {
+    ...defaultOptions,
+    ...options,
+    retry: {
+      ...defaultOptions.retry,
+      ...options.retry
+    }
+  };
+}
+__name(mergeRequestOptions, "mergeRequestOptions");
 var _SimpleClock = class _SimpleClock {
   preciseNow() {
     const now = new preciseDate.PreciseDate();
@@ -3249,128 +3528,6 @@ function calculateAttributeValueLength(value) {
   return 0;
 }
 __name(calculateAttributeValueLength, "calculateAttributeValueLength");
-
-// src/v3/utils/flattenAttributes.ts
-var NULL_SENTINEL = "$@null((";
-function flattenAttributes(obj, prefix) {
-  const result = {};
-  if (obj === void 0) {
-    return result;
-  }
-  if (obj === null) {
-    result[prefix || ""] = NULL_SENTINEL;
-    return result;
-  }
-  if (typeof obj === "string") {
-    result[prefix || ""] = obj;
-    return result;
-  }
-  if (typeof obj === "number") {
-    result[prefix || ""] = obj;
-    return result;
-  }
-  if (typeof obj === "boolean") {
-    result[prefix || ""] = obj;
-    return result;
-  }
-  for (const [key, value] of Object.entries(obj)) {
-    const newPrefix = `${prefix ? `${prefix}.` : ""}${Array.isArray(obj) ? `[${key}]` : key}`;
-    if (Array.isArray(value)) {
-      for (let i = 0; i < value.length; i++) {
-        if (typeof value[i] === "object" && value[i] !== null) {
-          Object.assign(result, flattenAttributes(value[i], `${newPrefix}.[${i}]`));
-        } else {
-          if (value[i] === null) {
-            result[`${newPrefix}.[${i}]`] = NULL_SENTINEL;
-          } else {
-            result[`${newPrefix}.[${i}]`] = value[i];
-          }
-        }
-      }
-    } else if (isRecord(value)) {
-      Object.assign(result, flattenAttributes(value, newPrefix));
-    } else {
-      if (typeof value === "number" || typeof value === "string" || typeof value === "boolean") {
-        result[newPrefix] = value;
-      } else if (value === null) {
-        result[newPrefix] = NULL_SENTINEL;
-      }
-    }
-  }
-  return result;
-}
-__name(flattenAttributes, "flattenAttributes");
-function isRecord(value) {
-  return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-__name(isRecord, "isRecord");
-function unflattenAttributes(obj) {
-  if (typeof obj !== "object" || obj === null || Array.isArray(obj)) {
-    return obj;
-  }
-  if (typeof obj === "object" && obj !== null && Object.keys(obj).length === 1 && Object.keys(obj)[0] === "") {
-    return rehydrateNull(obj[""]);
-  }
-  if (Object.keys(obj).length === 0) {
-    return;
-  }
-  const result = {};
-  for (const [key, value] of Object.entries(obj)) {
-    const parts = key.split(".").reduce((acc, part) => {
-      if (part.includes("[")) {
-        const subparts = part.split(/\[|\]/).filter((p) => p !== "");
-        acc.push(...subparts);
-      } else {
-        acc.push(part);
-      }
-      return acc;
-    }, []);
-    let current = result;
-    for (let i = 0; i < parts.length - 1; i++) {
-      const part = parts[i];
-      const nextPart = parts[i + 1];
-      const isArray = /^\d+$/.test(nextPart);
-      if (isArray && !Array.isArray(current[part])) {
-        current[part] = [];
-      } else if (!isArray && current[part] === void 0) {
-        current[part] = {};
-      }
-      current = current[part];
-    }
-    const lastPart = parts[parts.length - 1];
-    current[lastPart] = rehydrateNull(value);
-  }
-  if (Object.keys(result).every((k) => /^\d+$/.test(k))) {
-    const maxIndex = Math.max(...Object.keys(result).map((k) => parseInt(k)));
-    const arrayResult = Array(maxIndex + 1);
-    for (const key in result) {
-      arrayResult[parseInt(key)] = result[key];
-    }
-    return arrayResult;
-  }
-  return result;
-}
-__name(unflattenAttributes, "unflattenAttributes");
-function primitiveValueOrflattenedAttributes(obj, prefix) {
-  if (typeof obj === "string" || typeof obj === "number" || typeof obj === "boolean" || obj === null || obj === void 0) {
-    return obj;
-  }
-  const attributes = flattenAttributes(obj, prefix);
-  if (prefix !== void 0 && typeof attributes[prefix] !== "undefined" && attributes[prefix] !== null) {
-    return attributes[prefix];
-  }
-  return attributes;
-}
-__name(primitiveValueOrflattenedAttributes, "primitiveValueOrflattenedAttributes");
-function rehydrateNull(value) {
-  if (value === NULL_SENTINEL) {
-    return null;
-  }
-  return value;
-}
-__name(rehydrateNull, "rehydrateNull");
-
-// src/v3/logger/taskLogger.ts
 var _NoopTaskLogger = class _NoopTaskLogger {
   debug() {
   }
@@ -3815,14 +3972,16 @@ var _TriggerTracer = class _TriggerTracer {
       attributes,
       startTime: clock.preciseNow()
     }, parentContext, async (span) => {
-      this.tracer.startSpan(name, {
-        ...options,
-        attributes: {
-          ...attributes,
-          [SemanticInternalAttributes.SPAN_PARTIAL]: true,
-          [SemanticInternalAttributes.SPAN_ID]: span.spanContext().spanId
-        }
-      }, parentContext).end();
+      if (taskContext.ctx) {
+        this.tracer.startSpan(name, {
+          ...options,
+          attributes: {
+            ...attributes,
+            [SemanticInternalAttributes.SPAN_PARTIAL]: true,
+            [SemanticInternalAttributes.SPAN_ID]: span.spanContext().spanId
+          }
+        }, parentContext).end();
+      }
       const usageMeasurement = usage.start();
       try {
         return await fn(span);
@@ -3835,12 +3994,14 @@ var _TriggerTracer = class _TriggerTracer {
         });
         throw e;
       } finally {
-        const usageSample = usage.stop(usageMeasurement);
-        const machine = taskContext.ctx?.machine;
-        span.setAttributes({
-          [SemanticInternalAttributes.USAGE_DURATION_MS]: usageSample.cpuTime,
-          [SemanticInternalAttributes.USAGE_COST_IN_CENTS]: machine?.centsPerMs ? usageSample.cpuTime * machine.centsPerMs : 0
-        });
+        if (taskContext.ctx) {
+          const usageSample = usage.stop(usageMeasurement);
+          const machine = taskContext.ctx.machine;
+          span.setAttributes({
+            [SemanticInternalAttributes.USAGE_DURATION_MS]: usageSample.cpuTime,
+            [SemanticInternalAttributes.USAGE_COST_IN_CENTS]: machine?.centsPerMs ? usageSample.cpuTime * machine.centsPerMs : 0
+          });
+        }
         span.end(clock.preciseNow());
       }
     });
@@ -4032,12 +4193,6 @@ function omit(obj, ...keys) {
 }
 __name(omit, "omit");
 
-// src/v3/utils/styleAttributes.ts
-function accessoryAttributes(accessory) {
-  return flattenAttributes(accessory, SemanticInternalAttributes.STYLE_ACCESSORY);
-}
-__name(accessoryAttributes, "accessoryAttributes");
-
 // src/v3/utils/detectDependencyVersion.ts
 function detectDependencyVersion(dependency) {
   return dependencies[dependency];
@@ -4313,6 +4468,7 @@ function safeJsonParse2(value) {
 }
 __name(safeJsonParse2, "safeJsonParse");
 
+exports.AbortTaskRunError = AbortTaskRunError;
 exports.ApiClient = ApiClient;
 exports.ApiConnectionError = ApiConnectionError;
 exports.ApiError = ApiError;
@@ -4331,6 +4487,7 @@ exports.CancellationSpanEvent = CancellationSpanEvent;
 exports.ClientToSharedQueueMessages = ClientToSharedQueueMessages;
 exports.Config = Config;
 exports.ConflictError = ConflictError;
+exports.CoordinatorSocketData = CoordinatorSocketData;
 exports.CoordinatorToPlatformMessages = CoordinatorToPlatformMessages;
 exports.CoordinatorToProdWorkerMessages = CoordinatorToProdWorkerMessages;
 exports.CreateAuthorizationCodeResponseSchema = CreateAuthorizationCodeResponseSchema;
@@ -4494,7 +4651,9 @@ exports.groupTaskMetadataIssuesByTask = groupTaskMetadataIssuesByTask;
 exports.imposeAttributeLimits = imposeAttributeLimits;
 exports.isCancellationSpanEvent = isCancellationSpanEvent;
 exports.isExceptionSpanEvent = isExceptionSpanEvent;
+exports.isRequestOptions = isRequestOptions;
 exports.logger = logger;
+exports.mergeRequestOptions = mergeRequestOptions;
 exports.millisecondsToNanoseconds = millisecondsToNanoseconds;
 exports.nanosecondsToMilliseconds = nanosecondsToMilliseconds;
 exports.omit = omit;
@@ -4504,6 +4663,7 @@ exports.parsePacket = parsePacket;
 exports.prettyPrintPacket = prettyPrintPacket;
 exports.primitiveValueOrflattenedAttributes = primitiveValueOrflattenedAttributes;
 exports.runtime = runtime;
+exports.sanitizeError = sanitizeError;
 exports.serverWebsocketMessages = serverWebsocketMessages;
 exports.stringPatternMatchers = stringPatternMatchers;
 exports.stringifyIO = stringifyIO;