@trigger.dev/core 0.0.0-v3-prerelease-20240517090458 → 0.0.0-v3-prerelease-20240606120239

package/dist/v3/index.js

@@ -1,8 +1,10 @@
 'use strict';
 
 var api = require('@opentelemetry/api');
-var zodValidationError = require('zod-validation-error');
 var zod = require('zod');
+var zodValidationError = require('zod-validation-error');
+var formDataEncoder = require('form-data-encoder');
+var stream = require('stream');
 var preciseDate = require('@google-cloud/precise-date');
 var apiLogs = require('@opentelemetry/api-logs');
 var humanizeDuration = require('humanize-duration');
@@ -32,423 +34,70 @@ var __privateMethod = (obj, member, method) => {
   return method;
 };
 
-// src/v3/apiErrors.ts
-var _APIError = class _APIError extends Error {
-  constructor(status, error, message, headers) {
-    super(`${_APIError.makeMessage(status, error, message)}`);
-    this.status = status;
-    this.headers = headers;
-    const data = error;
-    this.error = data;
-    this.code = data?.["code"];
-    this.param = data?.["param"];
-    this.type = data?.["type"];
-  }
-  static makeMessage(status, error, message) {
-    const msg = error?.message ? typeof error.message === "string" ? error.message : JSON.stringify(error.message) : error ? JSON.stringify(error) : message;
-    if (status && msg) {
-      return `${status} ${msg}`;
-    }
-    if (status) {
-      return `${status} status code (no body)`;
-    }
-    if (msg) {
-      return msg;
-    }
-    return "(no status code or body)";
-  }
-  static generate(status, errorResponse, message, headers) {
-    if (!status) {
-      return new APIConnectionError({
-        cause: castToError(errorResponse)
-      });
-    }
-    const error = errorResponse?.["error"];
-    if (status === 400) {
-      return new BadRequestError(status, error, message, headers);
-    }
-    if (status === 401) {
-      return new AuthenticationError(status, error, message, headers);
-    }
-    if (status === 403) {
-      return new PermissionDeniedError(status, error, message, headers);
-    }
-    if (status === 404) {
-      return new NotFoundError(status, error, message, headers);
-    }
-    if (status === 409) {
-      return new ConflictError(status, error, message, headers);
-    }
-    if (status === 422) {
-      return new UnprocessableEntityError(status, error, message, headers);
-    }
-    if (status === 429) {
-      return new RateLimitError(status, error, message, headers);
-    }
-    if (status >= 500) {
-      return new InternalServerError(status, error, message, headers);
-    }
-    return new _APIError(status, error, message, headers);
-  }
-};
-__name(_APIError, "APIError");
-var APIError = _APIError;
-var _APIConnectionError = class _APIConnectionError extends APIError {
-  constructor({ message, cause }) {
-    super(void 0, void 0, message || "Connection error.", void 0);
-    __publicField(this, "status");
-    if (cause)
-      this.cause = cause;
-  }
-};
-__name(_APIConnectionError, "APIConnectionError");
-var APIConnectionError = _APIConnectionError;
-var _BadRequestError = class _BadRequestError extends APIError {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "status", 400);
-  }
-};
-__name(_BadRequestError, "BadRequestError");
-var BadRequestError = _BadRequestError;
-var _AuthenticationError = class _AuthenticationError extends APIError {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "status", 401);
-  }
-};
-__name(_AuthenticationError, "AuthenticationError");
-var AuthenticationError = _AuthenticationError;
-var _PermissionDeniedError = class _PermissionDeniedError extends APIError {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "status", 403);
-  }
-};
-__name(_PermissionDeniedError, "PermissionDeniedError");
-var PermissionDeniedError = _PermissionDeniedError;
-var _NotFoundError = class _NotFoundError extends APIError {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "status", 404);
-  }
-};
-__name(_NotFoundError, "NotFoundError");
-var NotFoundError = _NotFoundError;
-var _ConflictError = class _ConflictError extends APIError {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "status", 409);
-  }
-};
-__name(_ConflictError, "ConflictError");
-var ConflictError = _ConflictError;
-var _UnprocessableEntityError = class _UnprocessableEntityError extends APIError {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "status", 422);
-  }
-};
-__name(_UnprocessableEntityError, "UnprocessableEntityError");
-var UnprocessableEntityError = _UnprocessableEntityError;
-var _RateLimitError = class _RateLimitError extends APIError {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "status", 429);
-  }
-};
-__name(_RateLimitError, "RateLimitError");
-var RateLimitError = _RateLimitError;
-var _InternalServerError = class _InternalServerError extends APIError {
+// package.json
+var version = "0.0.0-v3-prerelease-20240606120239";
+var dependencies = {
+  "@google-cloud/precise-date": "^4.0.0",
+  "@opentelemetry/api": "^1.8.0",
+  "@opentelemetry/api-logs": "^0.48.0",
+  "@opentelemetry/exporter-logs-otlp-http": "^0.49.1",
+  "@opentelemetry/exporter-trace-otlp-http": "^0.49.1",
+  "@opentelemetry/instrumentation": "^0.49.1",
+  "@opentelemetry/resources": "^1.22.0",
+  "@opentelemetry/sdk-logs": "^0.49.1",
+  "@opentelemetry/sdk-node": "^0.49.1",
+  "@opentelemetry/sdk-trace-base": "^1.22.0",
+  "@opentelemetry/sdk-trace-node": "^1.22.0",
+  "@opentelemetry/semantic-conventions": "^1.22.0",
+  "form-data-encoder": "^4.0.2",
+  "humanize-duration": "^3.27.3",
+  "socket.io-client": "4.7.4",
+  superjson: "^2.2.1",
+  ulidx: "^2.2.1",
+  zod: "3.22.3",
+  "zod-error": "1.5.0",
+  "zod-validation-error": "^1.5.0"
 };
-__name(_InternalServerError, "InternalServerError");
-var InternalServerError = _InternalServerError;
-function castToError(err) {
-  if (err instanceof Error)
-    return err;
-  return new Error(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);
-    }
-  }
-}
-__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/zodfetch.ts
-var defaultRetryOptions2 = {
-  maxAttempts: 3,
-  factor: 2,
-  minTimeoutInMs: 1e3,
-  maxTimeoutInMs: 6e4,
-  randomize: false
-};
-async function zodfetch(schema, url, requestInit, options) {
-  return await _doZodFetch(schema, url, requestInit, options);
-}
-__name(zodfetch, "zodfetch");
-async function _doZodFetch(schema, url, requestInit, options, attempt = 1) {
-  try {
-    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);
-      } else {
-        const errText = await response.text().catch((e) => castToError2(e).message);
-        const errJSON = safeJsonParse(errText);
-        const errMessage = errJSON ? void 0 : errText;
-        throw APIError.generate(response.status, errJSON, errMessage, responseHeaders);
-      }
-    }
-    const jsonBody = await response.json();
-    const parsedResult = schema.safeParse(jsonBody);
-    if (parsedResult.success) {
-      return parsedResult.data;
-    }
-    throw zodValidationError.fromZodError(parsedResult.error);
-  } catch (error) {
-    if (error instanceof APIError) {
-      throw error;
-    }
-    if (options?.retry) {
-      const retry = {
-        ...defaultRetryOptions2,
-        ...options.retry
-      };
-      const delay = calculateNextRetryDelay(retry, attempt);
-      if (delay) {
-        await new Promise((resolve) => setTimeout(resolve, delay));
-        return await _doZodFetch(schema, url, requestInit, options, attempt + 1);
-      }
-    }
-    throw new APIConnectionError({
-      cause: castToError2(error)
-    });
-  }
-}
-__name(_doZodFetch, "_doZodFetch");
-function castToError2(err) {
-  if (err instanceof Error)
-    return err;
-  return new Error(err);
-}
-__name(castToError2, "castToError");
-function shouldRetry(response, attempt, retryOptions) {
-  function shouldRetryForOptions() {
-    const retry = {
-      ...defaultRetryOptions2,
-      ...retryOptions
-    };
-    const delay = calculateNextRetryDelay(retry, attempt);
-    if (delay) {
-      return {
-        retry: true,
-        delay
-      };
-    } else {
-      return {
-        retry: false
-      };
-    }
-  }
-  __name(shouldRetryForOptions, "shouldRetryForOptions");
-  const shouldRetryHeader = response.headers.get("x-should-retry");
-  if (shouldRetryHeader === "true")
-    return shouldRetryForOptions();
-  if (shouldRetryHeader === "false")
-    return {
-      retry: false
-    };
-  if (response.status === 408)
-    return shouldRetryForOptions();
-  if (response.status === 409)
-    return shouldRetryForOptions();
-  if (response.status === 429)
-    return shouldRetryForOptions();
-  if (response.status >= 500)
-    return shouldRetryForOptions();
-  return {
-    retry: false
-  };
-}
-__name(shouldRetry, "shouldRetry");
-function safeJsonParse(text) {
-  try {
-    return JSON.parse(text);
-  } catch (e) {
-    return void 0;
-  }
-}
-__name(safeJsonParse, "safeJsonParse");
-function createResponseHeaders(headers) {
-  return new Proxy(Object.fromEntries(
-    // @ts-ignore
-    headers.entries()
-  ), {
-    get(target, name) {
-      const key = name.toString();
-      return target[key.toLowerCase()] || target[key];
-    }
-  });
-}
-__name(createResponseHeaders, "createResponseHeaders");
-function requestInitWithCache(requestInit) {
-  try {
-    const withCache = {
-      ...requestInit,
-      cache: "no-cache"
-    };
-    const _ = new Request("http://localhost", withCache);
-    return withCache;
-  } catch (error) {
-    return requestInit ?? {};
-  }
-}
-__name(requestInitWithCache, "requestInitWithCache");
-var CreateAuthorizationCodeResponseSchema = zod.z.object({
-  url: zod.z.string().url(),
-  authorizationCode: zod.z.string()
-});
-var GetPersonalAccessTokenRequestSchema = zod.z.object({
-  authorizationCode: zod.z.string()
-});
-var GetPersonalAccessTokenResponseSchema = zod.z.object({
-  token: zod.z.object({
-    token: zod.z.string(),
-    obfuscatedToken: zod.z.string()
-  }).nullable()
-});
-var TaskRunBuiltInError = zod.z.object({
-  type: zod.z.literal("BUILT_IN_ERROR"),
-  name: zod.z.string(),
-  message: zod.z.string(),
-  stackTrace: zod.z.string()
-});
-var TaskRunCustomErrorObject = zod.z.object({
-  type: zod.z.literal("CUSTOM_ERROR"),
-  raw: zod.z.string()
-});
-var TaskRunStringError = zod.z.object({
-  type: zod.z.literal("STRING_ERROR"),
-  raw: zod.z.string()
-});
-var TaskRunErrorCodes = {
-  COULD_NOT_FIND_EXECUTOR: "COULD_NOT_FIND_EXECUTOR",
-  COULD_NOT_FIND_TASK: "COULD_NOT_FIND_TASK",
-  CONFIGURED_INCORRECTLY: "CONFIGURED_INCORRECTLY",
-  TASK_ALREADY_RUNNING: "TASK_ALREADY_RUNNING",
-  TASK_EXECUTION_FAILED: "TASK_EXECUTION_FAILED",
-  TASK_EXECUTION_ABORTED: "TASK_EXECUTION_ABORTED",
-  TASK_PROCESS_EXITED_WITH_NON_ZERO_CODE: "TASK_PROCESS_EXITED_WITH_NON_ZERO_CODE",
-  TASK_RUN_CANCELLED: "TASK_RUN_CANCELLED",
-  TASK_OUTPUT_ERROR: "TASK_OUTPUT_ERROR",
-  HANDLE_ERROR_ERROR: "HANDLE_ERROR_ERROR",
-  GRACEFUL_EXIT_TIMEOUT: "GRACEFUL_EXIT_TIMEOUT"
+var CreateAuthorizationCodeResponseSchema = zod.z.object({
+  url: zod.z.string().url(),
+  authorizationCode: zod.z.string()
+});
+var GetPersonalAccessTokenRequestSchema = zod.z.object({
+  authorizationCode: zod.z.string()
+});
+var GetPersonalAccessTokenResponseSchema = zod.z.object({
+  token: zod.z.object({
+    token: zod.z.string(),
+    obfuscatedToken: zod.z.string()
+  }).nullable()
+});
+var TaskRunBuiltInError = zod.z.object({
+  type: zod.z.literal("BUILT_IN_ERROR"),
+  name: zod.z.string(),
+  message: zod.z.string(),
+  stackTrace: zod.z.string()
+});
+var TaskRunCustomErrorObject = zod.z.object({
+  type: zod.z.literal("CUSTOM_ERROR"),
+  raw: zod.z.string()
+});
+var TaskRunStringError = zod.z.object({
+  type: zod.z.literal("STRING_ERROR"),
+  raw: zod.z.string()
+});
+var TaskRunErrorCodes = {
+  COULD_NOT_FIND_EXECUTOR: "COULD_NOT_FIND_EXECUTOR",
+  COULD_NOT_FIND_TASK: "COULD_NOT_FIND_TASK",
+  CONFIGURED_INCORRECTLY: "CONFIGURED_INCORRECTLY",
+  TASK_ALREADY_RUNNING: "TASK_ALREADY_RUNNING",
+  TASK_EXECUTION_FAILED: "TASK_EXECUTION_FAILED",
+  TASK_EXECUTION_ABORTED: "TASK_EXECUTION_ABORTED",
+  TASK_PROCESS_EXITED_WITH_NON_ZERO_CODE: "TASK_PROCESS_EXITED_WITH_NON_ZERO_CODE",
+  TASK_PROCESS_SIGKILL_TIMEOUT: "TASK_PROCESS_SIGKILL_TIMEOUT",
+  TASK_RUN_CANCELLED: "TASK_RUN_CANCELLED",
+  TASK_OUTPUT_ERROR: "TASK_OUTPUT_ERROR",
+  HANDLE_ERROR_ERROR: "HANDLE_ERROR_ERROR",
+  GRACEFUL_EXIT_TIMEOUT: "GRACEFUL_EXIT_TIMEOUT"
 };
 var TaskRunInternalError = zod.z.object({
   type: zod.z.literal("INTERNAL_ERROR"),
@@ -460,10 +109,12 @@ var TaskRunInternalError = zod.z.object({
     "TASK_EXECUTION_FAILED",
     "TASK_EXECUTION_ABORTED",
     "TASK_PROCESS_EXITED_WITH_NON_ZERO_CODE",
+    "TASK_PROCESS_SIGKILL_TIMEOUT",
     "TASK_RUN_CANCELLED",
     "TASK_OUTPUT_ERROR",
     "HANDLE_ERROR_ERROR",
-    "GRACEFUL_EXIT_TIMEOUT"
+    "GRACEFUL_EXIT_TIMEOUT",
+    "TASK_RUN_HEARTBEAT_TIMEOUT"
   ]),
   message: zod.z.string().optional()
 });
@@ -725,7 +376,16 @@ var TaskFileMetadata = zod.z.object({
   filePath: zod.z.string(),
   exportName: zod.z.string()
 });
-var TaskMetadataWithFilePath = TaskMetadata.merge(TaskFileMetadata);
+var TaskMetadataWithFilePath = zod.z.object({
+  id: zod.z.string(),
+  packageVersion: zod.z.string(),
+  queue: QueueOptions.optional(),
+  retry: RetryOptions.optional(),
+  machine: Machine.partial().optional(),
+  triggerSource: zod.z.string().optional(),
+  filePath: zod.z.string(),
+  exportName: zod.z.string()
+});
 var PostStartCauses = zod.z.enum([
   "index",
   "create",
@@ -766,6 +426,13 @@ var WaitReason = zod.z.enum([
   "WAIT_FOR_TASK",
   "WAIT_FOR_BATCH"
 ]);
+var TaskRunExecutionLazyAttemptPayload = zod.z.object({
+  runId: zod.z.string(),
+  messageId: zod.z.string(),
+  isTest: zod.z.boolean(),
+  traceContext: zod.z.record(zod.z.unknown()),
+  environment: zod.z.record(zod.z.string()).optional()
+});
 
 // src/v3/schemas/resources.ts
 var TaskResource = zod.z.object({
@@ -787,57 +454,204 @@ var ImageDetailsMetadata = zod.z.object({
   contentHash: zod.z.string(),
   imageTag: zod.z.string()
 });
-
-// src/v3/schemas/api.ts
-var WhoAmIResponseSchema = zod.z.object({
-  userId: zod.z.string(),
-  email: zod.z.string().email(),
-  dashboardUrl: zod.z.string()
-});
-var GetProjectResponseBody = zod.z.object({
-  id: zod.z.string(),
-  externalRef: zod.z.string(),
-  name: zod.z.string(),
-  slug: zod.z.string(),
-  createdAt: zod.z.coerce.date(),
-  organization: zod.z.object({
-    id: zod.z.string(),
-    title: zod.z.string(),
-    slug: zod.z.string(),
-    createdAt: zod.z.coerce.date()
-  })
-});
-var GetProjectsResponseBody = zod.z.array(GetProjectResponseBody);
-var GetProjectEnvResponse = zod.z.object({
-  apiKey: zod.z.string(),
-  name: zod.z.string(),
-  apiUrl: zod.z.string()
-});
-var CreateBackgroundWorkerRequestBody = zod.z.object({
-  localOnly: zod.z.boolean(),
-  metadata: BackgroundWorkerMetadata
-});
-var CreateBackgroundWorkerResponse = zod.z.object({
-  id: zod.z.string(),
-  version: zod.z.string(),
-  contentHash: zod.z.string()
-});
-var TriggerTaskRequestBody = zod.z.object({
-  payload: zod.z.any(),
-  context: zod.z.any(),
-  options: zod.z.object({
-    dependentAttempt: zod.z.string().optional(),
-    dependentBatch: zod.z.string().optional(),
-    lockToVersion: zod.z.string().optional(),
-    queue: QueueOptions.optional(),
-    concurrencyKey: zod.z.string().optional(),
-    idempotencyKey: zod.z.string().optional(),
-    test: zod.z.boolean().optional(),
-    payloadType: zod.z.string().optional()
-  }).optional()
-});
-var TriggerTaskResponse = zod.z.object({
-  id: zod.z.string()
+function parseError(error) {
+  if (error instanceof Error) {
+    return {
+      type: "BUILT_IN_ERROR",
+      name: error.name,
+      message: error.message,
+      stackTrace: error.stack ?? ""
+    };
+  }
+  if (typeof error === "string") {
+    return {
+      type: "STRING_ERROR",
+      raw: error
+    };
+  }
+  try {
+    return {
+      type: "CUSTOM_ERROR",
+      raw: JSON.stringify(error)
+    };
+  } catch (e) {
+    return {
+      type: "CUSTOM_ERROR",
+      raw: String(error)
+    };
+  }
+}
+__name(parseError, "parseError");
+function createErrorTaskError(error) {
+  switch (error.type) {
+    case "BUILT_IN_ERROR": {
+      const e = new Error(error.message);
+      e.name = error.name;
+      e.stack = error.stackTrace;
+      return e;
+    }
+    case "STRING_ERROR": {
+      return error.raw;
+    }
+    case "CUSTOM_ERROR": {
+      return JSON.parse(error.raw);
+    }
+    case "INTERNAL_ERROR": {
+      return new Error(`trigger.dev internal error (${error.code})`);
+    }
+  }
+}
+__name(createErrorTaskError, "createErrorTaskError");
+var SerializedError = zod.z.object({
+  message: zod.z.string(),
+  name: zod.z.string().optional(),
+  stackTrace: zod.z.string().optional()
+});
+function createJsonErrorObject(error) {
+  switch (error.type) {
+    case "BUILT_IN_ERROR": {
+      return {
+        name: error.name,
+        message: error.message,
+        stackTrace: error.stackTrace
+      };
+    }
+    case "STRING_ERROR": {
+      return {
+        message: error.raw
+      };
+    }
+    case "CUSTOM_ERROR": {
+      return {
+        message: error.raw
+      };
+    }
+    case "INTERNAL_ERROR": {
+      return {
+        message: `trigger.dev internal error (${error.code})`
+      };
+    }
+  }
+}
+__name(createJsonErrorObject, "createJsonErrorObject");
+function correctErrorStackTrace(stackTrace, projectDir, options) {
+  const [errorLine, ...traceLines] = stackTrace.split("\n");
+  return [
+    options?.removeFirstLine ? void 0 : errorLine,
+    ...traceLines.map((line) => correctStackTraceLine(line, projectDir, options?.isDev))
+  ].filter(Boolean).join("\n");
+}
+__name(correctErrorStackTrace, "correctErrorStackTrace");
+var LINES_TO_IGNORE = [
+  /ConsoleInterceptor/,
+  /TriggerTracer/,
+  /TaskExecutor/,
+  /EXECUTE_TASK_RUN/,
+  /@trigger.dev\/core/,
+  /packages\/core\/src\/v3/,
+  /safeJsonProcess/,
+  /__entryPoint.ts/,
+  /ZodIpc/,
+  /startActiveSpan/,
+  /processTicksAndRejections/
+];
+function correctStackTraceLine(line, projectDir, isDev) {
+  if (LINES_TO_IGNORE.some((regex) => regex.test(line))) {
+    return;
+  }
+  if (isDev && projectDir && !line.includes(projectDir)) {
+    return;
+  }
+  return line.trim();
+}
+__name(correctStackTraceLine, "correctStackTraceLine");
+function groupTaskMetadataIssuesByTask(tasks, issues) {
+  return issues.reduce((acc, issue) => {
+    if (issue.path.length === 0) {
+      return acc;
+    }
+    const taskIndex = issue.path[1];
+    if (typeof taskIndex !== "number") {
+      return acc;
+    }
+    const task = tasks[taskIndex];
+    if (!task) {
+      return acc;
+    }
+    const restOfPath = issue.path.slice(2);
+    const taskId = task.id;
+    const taskName = task.exportName;
+    const filePath = task.filePath;
+    const key = taskIndex;
+    const existing = acc[key] ?? {
+      id: taskId,
+      exportName: taskName,
+      filePath,
+      issues: []
+    };
+    existing.issues.push({
+      message: issue.message,
+      path: restOfPath.length === 0 ? void 0 : restOfPath.join(".")
+    });
+    return {
+      ...acc,
+      [key]: existing
+    };
+  }, {});
+}
+__name(groupTaskMetadataIssuesByTask, "groupTaskMetadataIssuesByTask");
+
+// src/v3/schemas/api.ts
+var WhoAmIResponseSchema = zod.z.object({
+  userId: zod.z.string(),
+  email: zod.z.string().email(),
+  dashboardUrl: zod.z.string()
+});
+var GetProjectResponseBody = zod.z.object({
+  id: zod.z.string(),
+  externalRef: zod.z.string(),
+  name: zod.z.string(),
+  slug: zod.z.string(),
+  createdAt: zod.z.coerce.date(),
+  organization: zod.z.object({
+    id: zod.z.string(),
+    title: zod.z.string(),
+    slug: zod.z.string(),
+    createdAt: zod.z.coerce.date()
+  })
+});
+var GetProjectsResponseBody = zod.z.array(GetProjectResponseBody);
+var GetProjectEnvResponse = zod.z.object({
+  apiKey: zod.z.string(),
+  name: zod.z.string(),
+  apiUrl: zod.z.string()
+});
+var CreateBackgroundWorkerRequestBody = zod.z.object({
+  localOnly: zod.z.boolean(),
+  metadata: BackgroundWorkerMetadata,
+  supportsLazyAttempts: zod.z.boolean().optional()
+});
+var CreateBackgroundWorkerResponse = zod.z.object({
+  id: zod.z.string(),
+  version: zod.z.string(),
+  contentHash: zod.z.string()
+});
+var TriggerTaskRequestBody = zod.z.object({
+  payload: zod.z.any(),
+  context: zod.z.any(),
+  options: zod.z.object({
+    dependentAttempt: zod.z.string().optional(),
+    dependentBatch: zod.z.string().optional(),
+    lockToVersion: zod.z.string().optional(),
+    queue: QueueOptions.optional(),
+    concurrencyKey: zod.z.string().optional(),
+    idempotencyKey: zod.z.string().optional(),
+    test: zod.z.boolean().optional(),
+    payloadType: zod.z.string().optional()
+  }).optional()
+});
+var TriggerTaskResponse = zod.z.object({
+  id: zod.z.string()
 });
 var BatchTriggerTaskRequestBody = zod.z.object({
   items: TriggerTaskRequestBody.array(),
@@ -928,7 +742,7 @@ var ReplayRunResponse = zod.z.object({
   id: zod.z.string()
 });
 var CanceledRunResponse = zod.z.object({
-  message: zod.z.string()
+  id: zod.z.string()
 });
 var ScheduledTaskPayload = zod.z.object({
   /** The schedule id associated with this run (you can have many schedules for the same task).
@@ -978,17 +792,18 @@ var CreateScheduleOptions = zod.z.object({
   externalId: zod.z.string().optional()
 });
 var UpdateScheduleOptions = CreateScheduleOptions;
+var ScheduleGenerator = zod.z.object({
+  type: zod.z.literal("CRON"),
+  expression: zod.z.string(),
+  description: zod.z.string()
+});
 var ScheduleObject = zod.z.object({
   id: zod.z.string(),
   task: zod.z.string(),
   active: zod.z.boolean(),
   deduplicationKey: zod.z.string().nullish(),
   externalId: zod.z.string().nullish(),
-  generator: zod.z.object({
-    type: zod.z.literal("CRON"),
-    expression: zod.z.string(),
-    description: zod.z.string()
-  }),
+  generator: ScheduleGenerator,
   nextRun: zod.z.coerce.date().nullish(),
   environments: zod.z.array(zod.z.object({
     id: zod.z.string(),
@@ -1012,12 +827,28 @@ var ListScheduleOptions = zod.z.object({
   perPage: zod.z.number().optional()
 });
 var RunStatus = zod.z.enum([
-  "PENDING",
+  /// Task hasn't been deployed yet but is waiting to be executed
+  "WAITING_FOR_DEPLOY",
+  /// Task is waiting to be executed by a worker
+  "QUEUED",
+  /// Task is currently being executed by a worker
   "EXECUTING",
-  "PAUSED",
+  /// Task has failed and is waiting to be retried
+  "REATTEMPTING",
+  /// Task has been paused by the system, and will be resumed by the system
+  "FROZEN",
+  /// Task has been completed successfully
   "COMPLETED",
+  /// Task has been canceled by the user
+  "CANCELED",
+  /// Task has been completed with errors
   "FAILED",
-  "CANCELED"
+  /// Task has crashed and won't be retried, most likely the worker ran out of resources, e.g. memory or storage
+  "CRASHED",
+  /// Task was interrupted during execution, mostly this happens in development environments
+  "INTERRUPTED",
+  /// Task has failed to complete, due to an error in the system
+  "SYSTEM_FAILURE"
 ]);
 var AttemptStatus = zod.z.enum([
   "PENDING",
@@ -1027,23 +858,83 @@ var AttemptStatus = zod.z.enum([
   "FAILED",
   "CANCELED"
 ]);
-var RetrieveRunResponse = zod.z.object({
+var RunEnvironmentDetails = zod.z.object({
+  id: zod.z.string(),
+  name: zod.z.string(),
+  user: zod.z.string().optional()
+});
+var RunScheduleDetails = zod.z.object({
+  id: zod.z.string(),
+  externalId: zod.z.string().optional(),
+  deduplicationKey: zod.z.string().optional(),
+  generator: ScheduleGenerator
+});
+var CommonRunFields = {
   id: zod.z.string(),
   status: RunStatus,
   taskIdentifier: zod.z.string(),
   idempotencyKey: zod.z.string().optional(),
   version: zod.z.string().optional(),
+  isQueued: zod.z.boolean(),
+  isExecuting: zod.z.boolean(),
+  isCompleted: zod.z.boolean(),
+  isSuccess: zod.z.boolean(),
+  isFailed: zod.z.boolean(),
+  isCancelled: zod.z.boolean(),
+  isTest: zod.z.boolean(),
   createdAt: zod.z.coerce.date(),
   updatedAt: zod.z.coerce.date(),
+  startedAt: zod.z.coerce.date().optional(),
+  finishedAt: zod.z.coerce.date().optional()
+};
+var RetrieveRunResponse = zod.z.object({
+  ...CommonRunFields,
+  payload: zod.z.any().optional(),
+  output: zod.z.any().optional(),
+  schedule: RunScheduleDetails.optional(),
   attempts: zod.z.array(zod.z.object({
     id: zod.z.string(),
     status: AttemptStatus,
     createdAt: zod.z.coerce.date(),
     updatedAt: zod.z.coerce.date(),
     startedAt: zod.z.coerce.date().optional(),
-    completedAt: zod.z.coerce.date().optional()
+    completedAt: zod.z.coerce.date().optional(),
+    error: SerializedError.optional()
   }).optional())
 });
+var ListRunResponseItem = zod.z.object({
+  ...CommonRunFields,
+  env: RunEnvironmentDetails
+});
+var ListRunResponse = zod.z.object({
+  data: zod.z.array(ListRunResponseItem),
+  pagination: zod.z.object({
+    next: zod.z.string().optional(),
+    previous: zod.z.string().optional()
+  })
+});
+var CreateEnvironmentVariableRequestBody = zod.z.object({
+  name: zod.z.string(),
+  value: zod.z.string()
+});
+var UpdateEnvironmentVariableRequestBody = zod.z.object({
+  value: zod.z.string()
+});
+var ImportEnvironmentVariablesRequestBody = zod.z.object({
+  variables: zod.z.record(zod.z.string()),
+  override: zod.z.boolean().optional()
+});
+var EnvironmentVariableResponseBody = zod.z.object({
+  success: zod.z.boolean()
+});
+var EnvironmentVariableValue = zod.z.object({
+  value: zod.z.string()
+});
+var EnvironmentVariable = zod.z.object({
+  name: zod.z.string(),
+  value: zod.z.string()
+});
+var EnvironmentVariables = zod.z.array(EnvironmentVariable);
 var BackgroundWorkerServerMessages = zod.z.discriminatedUnion("type", [
   zod.z.object({
     type: zod.z.literal("EXECUTE_RUNS"),
@@ -1060,12 +951,16 @@ var BackgroundWorkerServerMessages = zod.z.discriminatedUnion("type", [
     version: zod.z.string(),
     machine: Machine,
     // identifiers
-    id: zod.z.string(),
+    id: zod.z.string().optional(),
     envId: zod.z.string(),
     envType: EnvironmentType,
     orgId: zod.z.string(),
     projectId: zod.z.string(),
     runId: zod.z.string()
+  }),
+  zod.z.object({
+    type: zod.z.literal("EXECUTE_RUN_LAZY_ATTEMPT"),
+    payload: TaskRunExecutionLazyAttemptPayload
   })
 ]);
 var serverWebsocketMessages = {
@@ -1086,10 +981,20 @@ var BackgroundWorkerClientMessages = zod.z.discriminatedUnion("type", [
     completion: TaskRunExecutionResult,
     execution: TaskRunExecution
   }),
+  zod.z.object({
+    version: zod.z.literal("v1").default("v1"),
+    type: zod.z.literal("TASK_RUN_FAILED_TO_RUN"),
+    completion: TaskRunFailedExecutionResult
+  }),
   zod.z.object({
     version: zod.z.literal("v1").default("v1"),
     type: zod.z.literal("TASK_HEARTBEAT"),
     id: zod.z.string()
+  }),
+  zod.z.object({
+    version: zod.z.literal("v1").default("v1"),
+    type: zod.z.literal("TASK_RUN_HEARTBEAT"),
+    id: zod.z.string()
   })
 ]);
 var BackgroundWorkerProperties = zod.z.object({
@@ -1100,7 +1005,8 @@ var BackgroundWorkerProperties = zod.z.object({
 var clientWebsocketMessages = {
   READY_FOR_TASKS: zod.z.object({
     version: zod.z.literal("v1").default("v1"),
-    backgroundWorkerId: zod.z.string()
+    backgroundWorkerId: zod.z.string(),
+    inProgressRuns: zod.z.string().array().optional()
   }),
   BACKGROUND_WORKER_DEPRECATED: zod.z.object({
     version: zod.z.literal("v1").default("v1"),
@@ -1119,11 +1025,17 @@ var workerToChildMessages = {
     traceContext: zod.z.record(zod.z.unknown()),
     metadata: BackgroundWorkerProperties
   }),
-  TASK_RUN_COMPLETED_NOTIFICATION: zod.z.object({
-    version: zod.z.literal("v1").default("v1"),
-    completion: TaskRunExecutionResult,
-    execution: TaskRunExecution
-  }),
+  TASK_RUN_COMPLETED_NOTIFICATION: zod.z.discriminatedUnion("version", [
+    zod.z.object({
+      version: zod.z.literal("v1"),
+      completion: TaskRunExecutionResult,
+      execution: TaskRunExecution
+    }),
+    zod.z.object({
+      version: zod.z.literal("v2"),
+      completion: TaskRunExecutionResult
+    })
+  ]),
   CLEANUP: zod.z.object({
     version: zod.z.literal("v1").default("v1"),
     flush: zod.z.boolean().default(false),
@@ -1164,6 +1076,10 @@ var childToWorkerMessages = {
     version: zod.z.literal("v1").default("v1"),
     id: zod.z.string()
   }),
+  TASK_RUN_HEARTBEAT: zod.z.object({
+    version: zod.z.literal("v1").default("v1"),
+    id: zod.z.string()
+  }),
   READY_TO_DISPOSE: zod.z.undefined(),
   WAIT_FOR_DURATION: zod.z.object({
     version: zod.z.literal("v1").default("v1"),
@@ -1203,6 +1119,12 @@ 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()
   },
@@ -1267,13 +1189,19 @@ var ProdWorkerToChildMessages = {
     })
   },
   TASK_RUN_COMPLETED_NOTIFICATION: {
-    message: zod.z.object({
-      version: zod.z.literal("v1").default("v1"),
-      completion: TaskRunExecutionResult,
-      execution: TaskRunExecution
-    })
-  },
-  CLEANUP: {
+    message: zod.z.discriminatedUnion("version", [
+      zod.z.object({
+        version: zod.z.literal("v1"),
+        completion: TaskRunExecutionResult,
+        execution: TaskRunExecution
+      }),
+      zod.z.object({
+        version: zod.z.literal("v2"),
+        completion: TaskRunExecutionResult
+      })
+    ])
+  },
+  CLEANUP: {
     message: zod.z.object({
       version: zod.z.literal("v1").default("v1"),
       flush: zod.z.boolean().default(false),
@@ -1399,6 +1327,17 @@ var PlatformToProviderMessages = {
     })
   }
 };
+var CreateWorkerMessage = zod.z.object({
+  projectRef: zod.z.string(),
+  envId: zod.z.string(),
+  deploymentId: zod.z.string(),
+  metadata: zod.z.object({
+    cliPackageVersion: zod.z.string().optional(),
+    contentHash: zod.z.string(),
+    packageVersion: zod.z.string(),
+    tasks: TaskResource.array()
+  })
+});
 var CoordinatorToPlatformMessages = {
   LOG: {
     message: zod.z.object({
@@ -1408,18 +1347,15 @@ var CoordinatorToPlatformMessages = {
     })
   },
   CREATE_WORKER: {
-    message: zod.z.object({
-      version: zod.z.literal("v1").default("v1"),
-      projectRef: zod.z.string(),
-      envId: zod.z.string(),
-      deploymentId: zod.z.string(),
-      metadata: zod.z.object({
-        cliPackageVersion: zod.z.string().optional(),
-        contentHash: zod.z.string(),
-        packageVersion: zod.z.string(),
-        tasks: TaskResource.array()
+    message: zod.z.discriminatedUnion("version", [
+      CreateWorkerMessage.extend({
+        version: zod.z.literal("v1")
+      }),
+      CreateWorkerMessage.extend({
+        version: zod.z.literal("v2"),
+        supportsLazyAttempts: zod.z.boolean()
       })
-    }),
+    ]),
     callback: zod.z.discriminatedUnion("success", [
       zod.z.object({
         success: zod.z.literal(false)
@@ -1429,6 +1365,23 @@ var CoordinatorToPlatformMessages = {
       })
     ])
   },
+  CREATE_TASK_RUN_ATTEMPT: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      runId: zod.z.string(),
+      envId: zod.z.string()
+    }),
+    callback: zod.z.discriminatedUnion("success", [
+      zod.z.object({
+        success: zod.z.literal(false),
+        reason: zod.z.string().optional()
+      }),
+      zod.z.object({
+        success: zod.z.literal(true),
+        executionPayload: ProdTaskRunExecutionPayload
+      })
+    ])
+  },
   READY_FOR_EXECUTION: {
     message: zod.z.object({
       version: zod.z.literal("v1").default("v1"),
@@ -1445,6 +1398,24 @@ var CoordinatorToPlatformMessages = {
       })
     ])
   },
+  READY_FOR_LAZY_ATTEMPT: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      runId: zod.z.string(),
+      envId: zod.z.string(),
+      totalCompletions: zod.z.number()
+    }),
+    callback: zod.z.discriminatedUnion("success", [
+      zod.z.object({
+        success: zod.z.literal(false),
+        reason: zod.z.string().optional()
+      }),
+      zod.z.object({
+        success: zod.z.literal(true),
+        lazyPayload: TaskRunExecutionLazyAttemptPayload
+      })
+    ])
+  },
   READY_FOR_RESUME: {
     message: zod.z.object({
       version: zod.z.literal("v1").default("v1"),
@@ -1463,12 +1434,24 @@ var CoordinatorToPlatformMessages = {
       }).optional()
     })
   },
+  TASK_RUN_FAILED_TO_RUN: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      completion: TaskRunFailedExecutionResult
+    })
+  },
   TASK_HEARTBEAT: {
     message: zod.z.object({
       version: zod.z.literal("v1").default("v1"),
       attemptFriendlyId: zod.z.string()
     })
   },
+  TASK_RUN_HEARTBEAT: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      runId: zod.z.string()
+    })
+  },
   CHECKPOINT_CREATED: {
     message: zod.z.object({
       version: zod.z.literal("v1").default("v1"),
@@ -1507,6 +1490,17 @@ var CoordinatorToPlatformMessages = {
         stack: zod.z.string().optional()
       })
     })
+  },
+  RUN_CRASHED: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      runId: zod.z.string(),
+      error: zod.z.object({
+        name: zod.z.string(),
+        message: zod.z.string(),
+        stack: zod.z.string().optional()
+      })
+    })
   }
 };
 var PlatformToCoordinatorMessages = {
@@ -1534,6 +1528,13 @@ var PlatformToCoordinatorMessages = {
       attemptFriendlyId: zod.z.string()
     })
   },
+  REQUEST_RUN_CANCELLATION: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      runId: zod.z.string(),
+      delayInMs: zod.z.number().optional()
+    })
+  },
   READY_FOR_RETRY: {
     message: zod.z.object({
       version: zod.z.literal("v1").default("v1"),
@@ -1577,6 +1578,12 @@ var SharedQueueToClientMessages = {
     })
   }
 };
+var IndexTasksMessage = zod.z.object({
+  version: zod.z.literal("v1"),
+  deploymentId: zod.z.string(),
+  tasks: TaskResource.array(),
+  packageVersion: zod.z.string()
+});
 var ProdWorkerToCoordinatorMessages = {
   LOG: {
     message: zod.z.object({
@@ -1586,12 +1593,15 @@ var ProdWorkerToCoordinatorMessages = {
     callback: zod.z.void()
   },
   INDEX_TASKS: {
-    message: zod.z.object({
-      version: zod.z.literal("v1").default("v1"),
-      deploymentId: zod.z.string(),
-      tasks: TaskResource.array(),
-      packageVersion: zod.z.string()
-    }),
+    message: zod.z.discriminatedUnion("version", [
+      IndexTasksMessage.extend({
+        version: zod.z.literal("v1")
+      }),
+      IndexTasksMessage.extend({
+        version: zod.z.literal("v2"),
+        supportsLazyAttempts: zod.z.boolean()
+      })
+    ]),
     callback: zod.z.discriminatedUnion("success", [
       zod.z.object({
         success: zod.z.literal(false)
@@ -1608,6 +1618,13 @@ var ProdWorkerToCoordinatorMessages = {
       totalCompletions: zod.z.number()
     })
   },
+  READY_FOR_LAZY_ATTEMPT: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      runId: zod.z.string(),
+      totalCompletions: zod.z.number()
+    })
+  },
   READY_FOR_RESUME: {
     message: zod.z.object({
       version: zod.z.literal("v1").default("v1"),
@@ -1644,6 +1661,12 @@ var ProdWorkerToCoordinatorMessages = {
       attemptFriendlyId: zod.z.string()
     })
   },
+  TASK_RUN_HEARTBEAT: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      runId: zod.z.string()
+    })
+  },
   TASK_RUN_COMPLETED: {
     message: zod.z.object({
       version: zod.z.literal("v1").default("v1"),
@@ -1655,6 +1678,12 @@ var ProdWorkerToCoordinatorMessages = {
       shouldExit: zod.z.boolean()
     })
   },
+  TASK_RUN_FAILED_TO_RUN: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      completion: TaskRunFailedExecutionResult
+    })
+  },
   WAIT_FOR_DURATION: {
     message: zod.z.object({
       version: zod.z.literal("v1").default("v1"),
@@ -1699,6 +1728,32 @@ var ProdWorkerToCoordinatorMessages = {
         stack: zod.z.string().optional()
       })
     })
+  },
+  CREATE_TASK_RUN_ATTEMPT: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      runId: zod.z.string()
+    }),
+    callback: zod.z.discriminatedUnion("success", [
+      zod.z.object({
+        success: zod.z.literal(false),
+        reason: zod.z.string().optional()
+      }),
+      zod.z.object({
+        success: zod.z.literal(true),
+        executionPayload: ProdTaskRunExecutionPayload
+      })
+    ])
+  },
+  UNRECOVERABLE_ERROR: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      error: zod.z.object({
+        name: zod.z.string(),
+        message: zod.z.string(),
+        stack: zod.z.string().optional()
+      })
+    })
   }
 };
 var CoordinatorToProdWorkerMessages = {
@@ -1722,6 +1777,12 @@ var CoordinatorToProdWorkerMessages = {
       executionPayload: ProdTaskRunExecutionPayload
     })
   },
+  EXECUTE_TASK_RUN_LAZY_ATTEMPT: {
+    message: zod.z.object({
+      version: zod.z.literal("v1").default("v1"),
+      lazyPayload: TaskRunExecutionLazyAttemptPayload
+    })
+  },
   REQUEST_ATTEMPT_CANCELLATION: {
     message: zod.z.object({
       version: zod.z.literal("v1").default("v1"),
@@ -1729,9 +1790,15 @@ var CoordinatorToProdWorkerMessages = {
     })
   },
   REQUEST_EXIT: {
-    message: zod.z.object({
-      version: zod.z.literal("v1").default("v1")
-    })
+    message: zod.z.discriminatedUnion("version", [
+      zod.z.object({
+        version: zod.z.literal("v1")
+      }),
+      zod.z.object({
+        version: zod.z.literal("v2"),
+        delayInMs: zod.z.number().optional()
+      })
+    ])
   },
   READY_FOR_RETRY: {
     message: zod.z.object({
@@ -2087,48 +2154,795 @@ var _TaskContextAPI = class _TaskContextAPI {
         [SemanticInternalAttributes.IDEMPOTENCY_KEY]: this.ctx.run.idempotencyKey
       };
     }
-    return {};
+    return {};
+  }
+  disable() {
+    unregisterGlobal(API_NAME);
+  }
+  setGlobalTaskContext(taskContext2) {
+    return registerGlobal(API_NAME, taskContext2);
+  }
+};
+_getTaskContext = new WeakSet();
+getTaskContext_fn = /* @__PURE__ */ __name(function() {
+  return getGlobal(API_NAME);
+}, "#getTaskContext");
+__name(_TaskContextAPI, "TaskContextAPI");
+var TaskContextAPI = _TaskContextAPI;
+
+// src/v3/task-context-api.ts
+var taskContext = TaskContextAPI.getInstance();
+
+// src/v3/apiClient/errors.ts
+var _ApiError = class _ApiError extends Error {
+  constructor(status, error, message, headers) {
+    super(`${_ApiError.makeMessage(status, error, message)}`);
+    this.status = status;
+    this.headers = headers;
+    const data = error;
+    this.error = data;
+    this.code = data?.["code"];
+    this.param = data?.["param"];
+    this.type = data?.["type"];
+  }
+  static makeMessage(status, error, message) {
+    const msg = error?.message ? typeof error.message === "string" ? error.message : JSON.stringify(error.message) : error ? JSON.stringify(error) : message;
+    if (status && msg) {
+      return `${status} ${msg}`;
+    }
+    if (status) {
+      return `${status} status code (no body)`;
+    }
+    if (msg) {
+      return msg;
+    }
+    return "(no status code or body)";
+  }
+  static generate(status, errorResponse, message, headers) {
+    if (!status) {
+      return new ApiConnectionError({
+        cause: castToError(errorResponse)
+      });
+    }
+    const error = errorResponse?.["error"];
+    if (status === 400) {
+      return new BadRequestError(status, error, message, headers);
+    }
+    if (status === 401) {
+      return new AuthenticationError(status, error, message, headers);
+    }
+    if (status === 403) {
+      return new PermissionDeniedError(status, error, message, headers);
+    }
+    if (status === 404) {
+      return new NotFoundError(status, error, message, headers);
+    }
+    if (status === 409) {
+      return new ConflictError(status, error, message, headers);
+    }
+    if (status === 422) {
+      return new UnprocessableEntityError(status, error, message, headers);
+    }
+    if (status === 429) {
+      return new RateLimitError(status, error, message, headers);
+    }
+    if (status >= 500) {
+      return new InternalServerError(status, error, message, headers);
+    }
+    return new _ApiError(status, error, message, headers);
+  }
+};
+__name(_ApiError, "ApiError");
+var ApiError = _ApiError;
+var _ApiConnectionError = class _ApiConnectionError extends ApiError {
+  constructor({ message, cause }) {
+    super(void 0, void 0, message || "Connection error.", void 0);
+    __publicField(this, "status");
+    if (cause)
+      this.cause = cause;
+  }
+};
+__name(_ApiConnectionError, "ApiConnectionError");
+var ApiConnectionError = _ApiConnectionError;
+var _BadRequestError = class _BadRequestError extends ApiError {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "status", 400);
+  }
+};
+__name(_BadRequestError, "BadRequestError");
+var BadRequestError = _BadRequestError;
+var _AuthenticationError = class _AuthenticationError extends ApiError {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "status", 401);
+  }
+};
+__name(_AuthenticationError, "AuthenticationError");
+var AuthenticationError = _AuthenticationError;
+var _PermissionDeniedError = class _PermissionDeniedError extends ApiError {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "status", 403);
+  }
+};
+__name(_PermissionDeniedError, "PermissionDeniedError");
+var PermissionDeniedError = _PermissionDeniedError;
+var _NotFoundError = class _NotFoundError extends ApiError {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "status", 404);
+  }
+};
+__name(_NotFoundError, "NotFoundError");
+var NotFoundError = _NotFoundError;
+var _ConflictError = class _ConflictError extends ApiError {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "status", 409);
+  }
+};
+__name(_ConflictError, "ConflictError");
+var ConflictError = _ConflictError;
+var _UnprocessableEntityError = class _UnprocessableEntityError extends ApiError {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "status", 422);
+  }
+};
+__name(_UnprocessableEntityError, "UnprocessableEntityError");
+var UnprocessableEntityError = _UnprocessableEntityError;
+var _RateLimitError = class _RateLimitError extends ApiError {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "status", 429);
+  }
+};
+__name(_RateLimitError, "RateLimitError");
+var RateLimitError = _RateLimitError;
+var _InternalServerError = class _InternalServerError extends ApiError {
+};
+__name(_InternalServerError, "InternalServerError");
+var InternalServerError = _InternalServerError;
+function castToError(err) {
+  if (err instanceof Error)
+    return err;
+  return new Error(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);
+    }
+  }
+}
+__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/pagination.ts
+var _CursorPage = class _CursorPage {
+  constructor(data, pagination, pageFetcher) {
+    this.pageFetcher = pageFetcher;
+    this.data = data;
+    this.pagination = pagination;
+  }
+  getPaginatedItems() {
+    return this.data ?? [];
+  }
+  hasNextPage() {
+    return !!this.pagination.next;
+  }
+  hasPreviousPage() {
+    return !!this.pagination.previous;
+  }
+  getNextPage() {
+    if (!this.pagination.next) {
+      throw new Error("No next page available");
+    }
+    return this.pageFetcher({
+      after: this.pagination.next
+    });
+  }
+  getPreviousPage() {
+    if (!this.pagination.previous) {
+      throw new Error("No previous page available");
+    }
+    return this.pageFetcher({
+      before: this.pagination.previous
+    });
+  }
+  async *iterPages() {
+    let page = this;
+    yield page;
+    while (page.hasNextPage()) {
+      page = await page.getNextPage();
+      yield page;
+    }
+  }
+  async *[Symbol.asyncIterator]() {
+    for await (const page of this.iterPages()) {
+      for (const item of page.getPaginatedItems()) {
+        yield item;
+      }
+    }
+  }
+};
+__name(_CursorPage, "CursorPage");
+var CursorPage = _CursorPage;
+var _OffsetLimitPage = class _OffsetLimitPage {
+  constructor(data, pagination, pageFetcher) {
+    this.pageFetcher = pageFetcher;
+    this.data = data;
+    this.pagination = pagination;
+  }
+  getPaginatedItems() {
+    return this.data ?? [];
+  }
+  hasNextPage() {
+    return this.pagination.currentPage < this.pagination.totalPages;
+  }
+  hasPreviousPage() {
+    return this.pagination.currentPage > 1;
+  }
+  getNextPage() {
+    if (!this.hasNextPage()) {
+      throw new Error("No next page available");
+    }
+    return this.pageFetcher({
+      page: this.pagination.currentPage + 1
+    });
+  }
+  getPreviousPage() {
+    if (!this.hasPreviousPage()) {
+      throw new Error("No previous page available");
+    }
+    return this.pageFetcher({
+      page: this.pagination.currentPage - 1
+    });
+  }
+  async *iterPages() {
+    let page = this;
+    yield page;
+    while (page.hasNextPage()) {
+      page = await page.getNextPage();
+      yield page;
+    }
+  }
+  async *[Symbol.asyncIterator]() {
+    for await (const page of this.iterPages()) {
+      for (const item of page.getPaginatedItems()) {
+        yield item;
+      }
+    }
+  }
+};
+__name(_OffsetLimitPage, "OffsetLimitPage");
+var OffsetLimitPage = _OffsetLimitPage;
+
+// src/v3/apiClient/core.ts
+var defaultRetryOptions2 = {
+  maxAttempts: 3,
+  factor: 2,
+  minTimeoutInMs: 1e3,
+  maxTimeoutInMs: 6e4,
+  randomize: false
+};
+function zodfetch(schema, url, requestInit, options) {
+  return new ApiPromise(_doZodFetch(schema, url, requestInit, options));
+}
+__name(zodfetch, "zodfetch");
+function zodfetchCursorPage(schema, url, params, requestInit, options) {
+  const query = new URLSearchParams(params.query);
+  if (params.limit) {
+    query.set("page[size]", String(params.limit));
+  }
+  if (params.after) {
+    query.set("page[after]", params.after);
+  }
+  if (params.before) {
+    query.set("page[before]", params.before);
+  }
+  const cursorPageSchema = zod.z.object({
+    data: zod.z.array(schema),
+    pagination: zod.z.object({
+      next: zod.z.string().optional(),
+      previous: zod.z.string().optional()
+    })
+  });
+  const $url = new URL(url);
+  $url.search = query.toString();
+  const fetchResult = _doZodFetch(cursorPageSchema, $url.href, requestInit, options);
+  return new CursorPagePromise(fetchResult, schema, url, params, requestInit, options);
+}
+__name(zodfetchCursorPage, "zodfetchCursorPage");
+function zodfetchOffsetLimitPage(schema, url, params, requestInit, options) {
+  const query = new URLSearchParams(params.query);
+  if (params.limit) {
+    query.set("perPage", String(params.limit));
+  }
+  if (params.page) {
+    query.set("page", String(params.page));
+  }
+  const offsetLimitPageSchema = zod.z.object({
+    data: zod.z.array(schema),
+    pagination: zod.z.object({
+      currentPage: zod.z.coerce.number(),
+      totalPages: zod.z.coerce.number(),
+      count: zod.z.coerce.number()
+    })
+  });
+  const $url = new URL(url);
+  $url.search = query.toString();
+  const fetchResult = _doZodFetch(offsetLimitPageSchema, $url.href, requestInit, options);
+  return new OffsetLimitPagePromise(fetchResult, schema, url, params, requestInit, options);
+}
+__name(zodfetchOffsetLimitPage, "zodfetchOffsetLimitPage");
+function zodupload(schema, url, body, requestInit, options) {
+  const finalRequestInit = createMultipartFormRequestInit(body, requestInit);
+  return new ApiPromise(_doZodFetch(schema, url, finalRequestInit, options));
+}
+__name(zodupload, "zodupload");
+async function createMultipartFormRequestInit(body, requestInit) {
+  const form = await createForm(body);
+  const encoder = new formDataEncoder.FormDataEncoder(form);
+  const finalHeaders = {};
+  for (const [key, value] of Object.entries(requestInit?.headers || {})) {
+    finalHeaders[key] = value;
+  }
+  for (const [key, value] of Object.entries(encoder.headers)) {
+    finalHeaders[key] = value;
+  }
+  finalHeaders["Content-Length"] = String(encoder.contentLength);
+  const finalRequestInit = {
+    ...requestInit,
+    headers: finalHeaders,
+    body: stream.Readable.from(encoder),
+    // @ts-expect-error
+    duplex: "half"
+  };
+  return finalRequestInit;
+}
+__name(createMultipartFormRequestInit, "createMultipartFormRequestInit");
+var createForm = /* @__PURE__ */ __name(async (body) => {
+  const form = new FormData();
+  await Promise.all(Object.entries(body || {}).map(([key, value]) => addFormValue(form, key, value)));
+  return form;
+}, "createForm");
+async function _doZodFetch(schema, url, requestInit, options, attempt = 1) {
+  try {
+    const $requestInit = await 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);
+      } else {
+        const errText = await response.text().catch((e) => castToError2(e).message);
+        const errJSON = safeJsonParse(errText);
+        const errMessage = errJSON ? void 0 : errText;
+        throw ApiError.generate(response.status, errJSON, errMessage, responseHeaders);
+      }
+    }
+    const jsonBody = await response.json();
+    const parsedResult = schema.safeParse(jsonBody);
+    if (parsedResult.success) {
+      return {
+        data: parsedResult.data,
+        response
+      };
+    }
+    throw zodValidationError.fromZodError(parsedResult.error);
+  } catch (error) {
+    if (error instanceof ApiError) {
+      throw error;
+    }
+    if (options?.retry) {
+      const retry = {
+        ...defaultRetryOptions2,
+        ...options.retry
+      };
+      const delay = calculateNextRetryDelay(retry, attempt);
+      if (delay) {
+        await new Promise((resolve) => setTimeout(resolve, delay));
+        return await _doZodFetch(schema, url, requestInit, options, attempt + 1);
+      }
+    }
+    throw new ApiConnectionError({
+      cause: castToError2(error)
+    });
+  }
+}
+__name(_doZodFetch, "_doZodFetch");
+function castToError2(err) {
+  if (err instanceof Error)
+    return err;
+  return new Error(err);
+}
+__name(castToError2, "castToError");
+function shouldRetry(response, attempt, retryOptions) {
+  function shouldRetryForOptions() {
+    const retry = {
+      ...defaultRetryOptions2,
+      ...retryOptions
+    };
+    const delay = calculateNextRetryDelay(retry, attempt);
+    if (delay) {
+      return {
+        retry: true,
+        delay
+      };
+    } else {
+      return {
+        retry: false
+      };
+    }
+  }
+  __name(shouldRetryForOptions, "shouldRetryForOptions");
+  const shouldRetryHeader = response.headers.get("x-should-retry");
+  if (shouldRetryHeader === "true")
+    return shouldRetryForOptions();
+  if (shouldRetryHeader === "false")
+    return {
+      retry: false
+    };
+  if (response.status === 408)
+    return shouldRetryForOptions();
+  if (response.status === 409)
+    return shouldRetryForOptions();
+  if (response.status === 429)
+    return shouldRetryForOptions();
+  if (response.status >= 500)
+    return shouldRetryForOptions();
+  return {
+    retry: false
+  };
+}
+__name(shouldRetry, "shouldRetry");
+function safeJsonParse(text) {
+  try {
+    return JSON.parse(text);
+  } catch (e) {
+    return void 0;
+  }
+}
+__name(safeJsonParse, "safeJsonParse");
+function createResponseHeaders(headers) {
+  return new Proxy(Object.fromEntries(
+    // @ts-ignore
+    headers.entries()
+  ), {
+    get(target, name) {
+      const key = name.toString();
+      return target[key.toLowerCase()] || target[key];
+    }
+  });
+}
+__name(createResponseHeaders, "createResponseHeaders");
+function requestInitWithCache(requestInit) {
+  try {
+    const withCache = {
+      ...requestInit,
+      cache: "no-cache"
+    };
+    const _ = new Request("http://localhost", withCache);
+    return withCache;
+  } catch (error) {
+    return requestInit ?? {};
+  }
+}
+__name(requestInitWithCache, "requestInitWithCache");
+var addFormValue = /* @__PURE__ */ __name(async (form, key, value) => {
+  if (value === void 0)
+    return;
+  if (value == null) {
+    throw new TypeError(`Received null for "${key}"; to pass null in FormData, you must use the string 'null'`);
+  }
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    form.append(key, String(value));
+  } else if (isUploadable(value) || isBlobLike(value) || value instanceof Buffer || value instanceof ArrayBuffer) {
+    const file = await toFile(value);
+    form.append(key, file);
+  } else if (Array.isArray(value)) {
+    await Promise.all(value.map((entry) => addFormValue(form, key + "[]", entry)));
+  } else if (typeof value === "object") {
+    await Promise.all(Object.entries(value).map(([name, prop]) => addFormValue(form, `${key}[${name}]`, prop)));
+  } else {
+    throw new TypeError(`Invalid value given to form, expected a string, number, boolean, object, Array, File or Blob but got ${value} instead`);
+  }
+}, "addFormValue");
+async function toFile(value, name, options) {
+  value = await value;
+  options ??= isFileLike(value) ? {
+    lastModified: value.lastModified,
+    type: value.type
+  } : {};
+  if (isResponseLike(value)) {
+    const blob = await value.blob();
+    name ||= new URL(value.url).pathname.split(/[\\/]/).pop() ?? "unknown_file";
+    return new File([
+      blob
+    ], name, options);
+  }
+  const bits = await getBytes(value);
+  name ||= getName(value) ?? "unknown_file";
+  if (!options.type) {
+    const type = bits[0]?.type;
+    if (typeof type === "string") {
+      options = {
+        ...options,
+        type
+      };
+    }
   }
-  disable() {
-    unregisterGlobal(API_NAME);
+  return new File(bits, name, options);
+}
+__name(toFile, "toFile");
+function getName(value) {
+  return getStringFromMaybeBuffer(value.name) || getStringFromMaybeBuffer(value.filename) || // For fs.ReadStream
+  getStringFromMaybeBuffer(value.path)?.split(/[\\/]/).pop();
+}
+__name(getName, "getName");
+var getStringFromMaybeBuffer = /* @__PURE__ */ __name((x) => {
+  if (typeof x === "string")
+    return x;
+  if (typeof Buffer !== "undefined" && x instanceof Buffer)
+    return String(x);
+  return void 0;
+}, "getStringFromMaybeBuffer");
+async function getBytes(value) {
+  let parts = [];
+  if (typeof value === "string" || ArrayBuffer.isView(value) || // includes Uint8Array, Buffer, etc.
+  value instanceof ArrayBuffer) {
+    parts.push(value);
+  } else if (isBlobLike(value)) {
+    parts.push(await value.arrayBuffer());
+  } else if (isAsyncIterableIterator(value)) {
+    for await (const chunk of value) {
+      parts.push(chunk);
+    }
+  } else {
+    throw new Error(`Unexpected data type: ${typeof value}; constructor: ${value?.constructor?.name}; props: ${propsForError(value)}`);
   }
-  setGlobalTaskContext(taskContext2) {
-    return registerGlobal(API_NAME, taskContext2);
+  return parts;
+}
+__name(getBytes, "getBytes");
+function propsForError(value) {
+  const props = Object.getOwnPropertyNames(value);
+  return `[${props.map((p) => `"${p}"`).join(", ")}]`;
+}
+__name(propsForError, "propsForError");
+var isAsyncIterableIterator = /* @__PURE__ */ __name((value) => value != null && typeof value === "object" && typeof value[Symbol.asyncIterator] === "function", "isAsyncIterableIterator");
+var isResponseLike = /* @__PURE__ */ __name((value) => value != null && typeof value === "object" && typeof value.url === "string" && typeof value.blob === "function", "isResponseLike");
+var isFileLike = /* @__PURE__ */ __name((value) => value != null && typeof value === "object" && typeof value.name === "string" && typeof value.lastModified === "number" && isBlobLike(value), "isFileLike");
+var isBlobLike = /* @__PURE__ */ __name((value) => value != null && typeof value === "object" && typeof value.size === "number" && typeof value.type === "string" && typeof value.text === "function" && typeof value.slice === "function" && typeof value.arrayBuffer === "function", "isBlobLike");
+var isFsReadStream = /* @__PURE__ */ __name((value) => value instanceof stream.Readable, "isFsReadStream");
+var isUploadable = /* @__PURE__ */ __name((value) => {
+  return isFileLike(value) || isResponseLike(value) || isFsReadStream(value);
+}, "isUploadable");
+var isRecordLike = /* @__PURE__ */ __name((value) => value != null && typeof value === "object" && !Array.isArray(value) && Object.keys(value).length > 0 && Object.keys(value).every((key) => typeof key === "string" && typeof value[key] === "string"), "isRecordLike");
+var _ApiPromise = class _ApiPromise extends Promise {
+  constructor(responsePromise) {
+    super((resolve) => {
+      resolve(null);
+    });
+    this.responsePromise = responsePromise;
+  }
+  /**
+  * Gets the raw `Response` instance instead of parsing the response
+  * data.
+  *
+  * If you want to parse the response body but still get the `Response`
+  * instance, you can use {@link withResponse()}.
+  */
+  asResponse() {
+    return this.responsePromise.then((p) => p.response);
+  }
+  /**
+  * Gets the parsed response data and the raw `Response` instance.
+  *
+  * If you just want to get the raw `Response` instance without parsing it,
+  * you can use {@link asResponse()}.
+  */
+  async withResponse() {
+    const [data, response] = await Promise.all([
+      this.parse(),
+      this.asResponse()
+    ]);
+    return {
+      data,
+      response
+    };
+  }
+  parse() {
+    return this.responsePromise.then((result) => result.data);
+  }
+  then(onfulfilled, onrejected) {
+    return this.parse().then(onfulfilled, onrejected);
+  }
+  catch(onrejected) {
+    return this.parse().catch(onrejected);
+  }
+  finally(onfinally) {
+    return this.parse().finally(onfinally);
   }
 };
-_getTaskContext = new WeakSet();
-getTaskContext_fn = /* @__PURE__ */ __name(function() {
-  return getGlobal(API_NAME);
-}, "#getTaskContext");
-__name(_TaskContextAPI, "TaskContextAPI");
-var TaskContextAPI = _TaskContextAPI;
-
-// src/v3/task-context-api.ts
-var taskContext = TaskContextAPI.getInstance();
-
-// package.json
-var version = "0.0.0-v3-prerelease-20240517090458";
-var dependencies = {
-  "@google-cloud/precise-date": "^4.0.0",
-  "@opentelemetry/api": "^1.8.0",
-  "@opentelemetry/api-logs": "^0.48.0",
-  "@opentelemetry/exporter-logs-otlp-http": "^0.49.1",
-  "@opentelemetry/exporter-trace-otlp-http": "^0.49.1",
-  "@opentelemetry/instrumentation": "^0.49.1",
-  "@opentelemetry/resources": "^1.22.0",
-  "@opentelemetry/sdk-logs": "^0.49.1",
-  "@opentelemetry/sdk-node": "^0.49.1",
-  "@opentelemetry/sdk-trace-base": "^1.22.0",
-  "@opentelemetry/sdk-trace-node": "^1.22.0",
-  "@opentelemetry/semantic-conventions": "^1.22.0",
-  "humanize-duration": "^3.27.3",
-  superjson: "^2.2.1",
-  ulidx: "^2.2.1",
-  zod: "3.22.3",
-  "zod-error": "1.5.0",
-  "zod-validation-error": "^1.5.0",
-  "socket.io-client": "4.7.4"
+__name(_ApiPromise, "ApiPromise");
+var ApiPromise = _ApiPromise;
+var _fetchPage, fetchPage_fn;
+var _CursorPagePromise = class _CursorPagePromise extends ApiPromise {
+  constructor(result, schema, url, params, requestInit, options) {
+    super(result.then((result2) => ({
+      data: new CursorPage(result2.data.data, result2.data.pagination, __privateMethod(this, _fetchPage, fetchPage_fn).bind(this)),
+      response: result2.response
+    })));
+    __privateAdd(this, _fetchPage);
+    this.schema = schema;
+    this.url = url;
+    this.params = params;
+    this.requestInit = requestInit;
+    this.options = options;
+  }
+  /**
+  * Allow auto-paginating iteration on an unawaited list call, eg:
+  *
+  *    for await (const item of client.items.list()) {
+  *      console.log(item)
+  *    }
+  */
+  async *[Symbol.asyncIterator]() {
+    const page = await this;
+    for await (const item of page) {
+      yield item;
+    }
+  }
 };
+_fetchPage = new WeakSet();
+fetchPage_fn = /* @__PURE__ */ __name(function(params) {
+  return zodfetchCursorPage(this.schema, this.url, {
+    ...this.params,
+    ...params
+  }, this.requestInit, this.options);
+}, "#fetchPage");
+__name(_CursorPagePromise, "CursorPagePromise");
+var CursorPagePromise = _CursorPagePromise;
+var _fetchPage2, fetchPage_fn2;
+var _OffsetLimitPagePromise = class _OffsetLimitPagePromise extends ApiPromise {
+  constructor(result, schema, url, params, requestInit, options) {
+    super(result.then((result2) => ({
+      data: new OffsetLimitPage(result2.data.data, result2.data.pagination, __privateMethod(this, _fetchPage2, fetchPage_fn2).bind(this)),
+      response: result2.response
+    })));
+    __privateAdd(this, _fetchPage2);
+    this.schema = schema;
+    this.url = url;
+    this.params = params;
+    this.requestInit = requestInit;
+    this.options = options;
+  }
+  /**
+  * Allow auto-paginating iteration on an unawaited list call, eg:
+  *
+  *    for await (const item of client.items.list()) {
+  *      console.log(item)
+  *    }
+  */
+  async *[Symbol.asyncIterator]() {
+    const page = await this;
+    for await (const item of page) {
+      yield item;
+    }
+  }
+};
+_fetchPage2 = new WeakSet();
+fetchPage_fn2 = /* @__PURE__ */ __name(function(params1) {
+  return zodfetchOffsetLimitPage(this.schema, this.url, {
+    ...this.params,
+    ...params1
+  }, this.requestInit, this.options);
+}, "#fetchPage");
+__name(_OffsetLimitPagePromise, "OffsetLimitPagePromise");
+var OffsetLimitPagePromise = _OffsetLimitPagePromise;
 
 // src/v3/apiClient/index.ts
 var zodFetchOptions = {
@@ -2154,7 +2968,7 @@ var _ApiClient = class _ApiClient {
         headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
       }, zodFetchOptions);
     } catch (error) {
-      if (error instanceof APIError) {
+      if (error instanceof ApiError) {
         if (error.status === 404) {
           return void 0;
         }
@@ -2169,14 +2983,16 @@ var _ApiClient = class _ApiClient {
     }, zodFetchOptions);
   }
   triggerTask(taskId, body, options) {
-    return zodfetch(TriggerTaskResponse, `${this.baseUrl}/api/v1/tasks/${taskId}/trigger`, {
+    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);
   }
   batchTriggerTask(taskId, body, options) {
-    return zodfetch(BatchTriggerTaskResponse, `${this.baseUrl}/api/v1/tasks/${taskId}/batch`, {
+    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)
@@ -2200,6 +3016,33 @@ var _ApiClient = class _ApiClient {
       headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
     }, zodFetchOptions);
   }
+  listRuns(query) {
+    const searchParams = createSearchQueryForListRuns(query);
+    return zodfetchCursorPage(ListRunResponseItem, `${this.baseUrl}/api/v1/runs`, {
+      query: searchParams,
+      limit: query?.limit,
+      after: query?.after,
+      before: query?.before
+    }, {
+      method: "GET",
+      headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
+    }, zodFetchOptions);
+  }
+  listProjectRuns(projectRef, query) {
+    const searchParams = createSearchQueryForListRuns(query);
+    if (query?.env) {
+      searchParams.append("filter[env]", Array.isArray(query.env) ? query.env.join(",") : query.env);
+    }
+    return zodfetchCursorPage(ListRunResponseItem, `${this.baseUrl}/api/v1/projects/${projectRef}/runs`, {
+      query: searchParams,
+      limit: query?.limit,
+      after: query?.after,
+      before: query?.before
+    }, {
+      method: "GET",
+      headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
+    }, zodFetchOptions);
+  }
   replayRun(runId) {
     return zodfetch(ReplayRunResponse, `${this.baseUrl}/api/v1/runs/${runId}/replay`, {
       method: "POST",
@@ -2227,7 +3070,10 @@ var _ApiClient = class _ApiClient {
     if (options?.perPage) {
       searchParams.append("perPage", options.perPage.toString());
     }
-    return zodfetch(ListSchedulesResult, `${this.baseUrl}/api/v1/schedules${searchParams.size > 0 ? `?${searchParams}` : ""}`, {
+    return zodfetchOffsetLimitPage(ScheduleObject, `${this.baseUrl}/api/v1/schedules`, {
+      page: options?.page,
+      limit: options?.perPage
+    }, {
       method: "GET",
       headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
     });
@@ -2263,6 +3109,52 @@ var _ApiClient = class _ApiClient {
       headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
     });
   }
+  listEnvVars(projectRef, slug) {
+    return zodfetch(EnvironmentVariables, `${this.baseUrl}/api/v1/projects/${projectRef}/envvars/${slug}`, {
+      method: "GET",
+      headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
+    });
+  }
+  importEnvVars(projectRef, slug, body) {
+    if (isRecordLike(body.variables)) {
+      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)
+      });
+    } else {
+      return zodupload(EnvironmentVariableResponseBody, `${this.baseUrl}/api/v1/projects/${projectRef}/envvars/${slug}/import`, body, {
+        method: "POST",
+        headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
+      });
+    }
+  }
+  retrieveEnvVar(projectRef, slug, key) {
+    return zodfetch(EnvironmentVariableValue, `${this.baseUrl}/api/v1/projects/${projectRef}/envvars/${slug}/${key}`, {
+      method: "GET",
+      headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
+    });
+  }
+  createEnvVar(projectRef, slug, body) {
+    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)
+    });
+  }
+  updateEnvVar(projectRef, slug, key, body) {
+    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)
+    });
+  }
+  deleteEnvVar(projectRef, slug, key) {
+    return zodfetch(EnvironmentVariableResponseBody, `${this.baseUrl}/api/v1/projects/${projectRef}/envvars/${slug}/${key}`, {
+      method: "DELETE",
+      headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
+    });
+  }
 };
 _getHeaders = new WeakSet();
 getHeaders_fn = /* @__PURE__ */ __name(function(spanParentAsLink) {
@@ -2282,6 +3174,40 @@ getHeaders_fn = /* @__PURE__ */ __name(function(spanParentAsLink) {
 }, "#getHeaders");
 __name(_ApiClient, "ApiClient");
 var ApiClient = _ApiClient;
+function createSearchQueryForListRuns(query) {
+  const searchParams = new URLSearchParams();
+  if (query) {
+    if (query.status) {
+      searchParams.append("filter[status]", Array.isArray(query.status) ? query.status.join(",") : query.status);
+    }
+    if (query.taskIdentifier) {
+      searchParams.append("filter[taskIdentifier]", Array.isArray(query.taskIdentifier) ? query.taskIdentifier.join(",") : query.taskIdentifier);
+    }
+    if (query.version) {
+      searchParams.append("filter[version]", Array.isArray(query.version) ? query.version.join(",") : query.version);
+    }
+    if (query.bulkAction) {
+      searchParams.append("filter[bulkAction]", query.bulkAction);
+    }
+    if (query.schedule) {
+      searchParams.append("filter[schedule]", query.schedule);
+    }
+    if (typeof query.isTest === "boolean") {
+      searchParams.append("filter[isTest]", String(query.isTest));
+    }
+    if (query.from) {
+      searchParams.append("filter[createdAt][from]", query.from instanceof Date ? query.from.getTime().toString() : query.from.toString());
+    }
+    if (query.to) {
+      searchParams.append("filter[createdAt][to]", query.to instanceof Date ? query.to.getTime().toString() : query.to.toString());
+    }
+    if (query.period) {
+      searchParams.append("filter[createdAt][period]", query.period);
+    }
+  }
+  return searchParams;
+}
+__name(createSearchQueryForListRuns, "createSearchQueryForListRuns");
 var _SimpleClock = class _SimpleClock {
   preciseNow() {
     const now = new preciseDate.PreciseDate();
@@ -2331,145 +3257,6 @@ var ClockAPI = _ClockAPI;
 // src/v3/clock-api.ts
 var clock = ClockAPI.getInstance();
 
-// src/v3/errors.ts
-function parseError(error) {
-  if (error instanceof Error) {
-    return {
-      type: "BUILT_IN_ERROR",
-      name: error.name,
-      message: error.message,
-      stackTrace: error.stack ?? ""
-    };
-  }
-  if (typeof error === "string") {
-    return {
-      type: "STRING_ERROR",
-      raw: error
-    };
-  }
-  try {
-    return {
-      type: "CUSTOM_ERROR",
-      raw: JSON.stringify(error)
-    };
-  } catch (e) {
-    return {
-      type: "CUSTOM_ERROR",
-      raw: String(error)
-    };
-  }
-}
-__name(parseError, "parseError");
-function createErrorTaskError(error) {
-  switch (error.type) {
-    case "BUILT_IN_ERROR": {
-      const e = new Error(error.message);
-      e.name = error.name;
-      e.stack = error.stackTrace;
-      return e;
-    }
-    case "STRING_ERROR": {
-      return error.raw;
-    }
-    case "CUSTOM_ERROR": {
-      return JSON.parse(error.raw);
-    }
-    case "INTERNAL_ERROR": {
-      return new Error(`trigger.dev internal error (${error.code})`);
-    }
-  }
-}
-__name(createErrorTaskError, "createErrorTaskError");
-function createJsonErrorObject(error) {
-  switch (error.type) {
-    case "BUILT_IN_ERROR": {
-      return {
-        name: error.name,
-        message: error.message,
-        stackTrace: error.stackTrace
-      };
-    }
-    case "STRING_ERROR": {
-      return {
-        message: error.raw
-      };
-    }
-    case "CUSTOM_ERROR": {
-      return {
-        message: error.raw
-      };
-    }
-    case "INTERNAL_ERROR": {
-      return {
-        message: `trigger.dev internal error (${error.code})`
-      };
-    }
-  }
-}
-__name(createJsonErrorObject, "createJsonErrorObject");
-function correctErrorStackTrace(stackTrace, projectDir, options) {
-  const [errorLine, ...traceLines] = stackTrace.split("\n");
-  return [
-    options?.removeFirstLine ? void 0 : errorLine,
-    ...traceLines.map((line) => correctStackTraceLine(line, projectDir))
-  ].filter(Boolean).join("\n");
-}
-__name(correctErrorStackTrace, "correctErrorStackTrace");
-var LINES_TO_IGNORE = [
-  /ConsoleInterceptor/,
-  /TriggerTracer/,
-  /TaskExecutor/,
-  /EXECUTE_TASK_RUN/,
-  /@trigger.dev\/core/,
-  /safeJsonProcess/,
-  /__entryPoint.ts/
-];
-function correctStackTraceLine(line, projectDir) {
-  if (LINES_TO_IGNORE.some((regex) => regex.test(line))) {
-    return;
-  }
-  if (projectDir && !line.includes(projectDir)) {
-    return;
-  }
-  return line.trim();
-}
-__name(correctStackTraceLine, "correctStackTraceLine");
-function groupTaskMetadataIssuesByTask(tasks, issues) {
-  return issues.reduce((acc, issue) => {
-    if (issue.path.length === 0) {
-      return acc;
-    }
-    const taskIndex = issue.path[1];
-    if (typeof taskIndex !== "number") {
-      return acc;
-    }
-    const task = tasks[taskIndex];
-    if (!task) {
-      return acc;
-    }
-    const restOfPath = issue.path.slice(2);
-    const taskId = task.id;
-    const taskName = task.exportName;
-    const filePath = task.filePath;
-    const key = taskIndex;
-    const existing = acc[key] ?? {
-      id: taskId,
-      exportName: taskName,
-      filePath,
-      issues: []
-    };
-    existing.issues.push({
-      message: issue.message,
-      path: restOfPath.length === 0 ? void 0 : restOfPath.join(".")
-    });
-    return {
-      ...acc,
-      [key]: existing
-    };
-  }, {});
-}
-__name(groupTaskMetadataIssuesByTask, "groupTaskMetadataIssuesByTask");
-
 // src/v3/limits.ts
 var OTEL_SPAN_ATTRIBUTE_COUNT_LIMIT = 256;
 var OTEL_LOG_ATTRIBUTE_COUNT_LIMIT = 256;
@@ -2809,7 +3596,7 @@ var _APIClientManagerAPI = class _APIClientManagerAPI {
   }
   get accessToken() {
     const store = __privateMethod(this, _getConfig, getConfig_fn).call(this);
-    return store?.secretKey ?? getEnvVar("TRIGGER_SECRET_KEY");
+    return store?.secretKey ?? getEnvVar("TRIGGER_SECRET_KEY") ?? getEnvVar("TRIGGER_ACCESS_TOKEN");
   }
   get client() {
     if (!this.baseURL || !this.accessToken) {
@@ -3501,9 +4288,9 @@ function safeJsonParse2(value) {
 }
 __name(safeJsonParse2, "safeJsonParse");
 
-exports.APIConnectionError = APIConnectionError;
-exports.APIError = APIError;
 exports.ApiClient = ApiClient;
+exports.ApiConnectionError = ApiConnectionError;
+exports.ApiError = ApiError;
 exports.AttemptStatus = AttemptStatus;
 exports.AuthenticationError = AuthenticationError;
 exports.BackgroundWorkerClientMessages = BackgroundWorkerClientMessages;
@@ -3524,11 +4311,17 @@ exports.CoordinatorToProdWorkerMessages = CoordinatorToProdWorkerMessages;
 exports.CreateAuthorizationCodeResponseSchema = CreateAuthorizationCodeResponseSchema;
 exports.CreateBackgroundWorkerRequestBody = CreateBackgroundWorkerRequestBody;
 exports.CreateBackgroundWorkerResponse = CreateBackgroundWorkerResponse;
+exports.CreateEnvironmentVariableRequestBody = CreateEnvironmentVariableRequestBody;
 exports.CreateScheduleOptions = CreateScheduleOptions;
 exports.CreateUploadPayloadUrlResponseBody = CreateUploadPayloadUrlResponseBody;
+exports.CursorPage = CursorPage;
 exports.DeletedScheduleObject = DeletedScheduleObject;
 exports.DeploymentErrorData = DeploymentErrorData;
 exports.EnvironmentType = EnvironmentType;
+exports.EnvironmentVariable = EnvironmentVariable;
+exports.EnvironmentVariableResponseBody = EnvironmentVariableResponseBody;
+exports.EnvironmentVariableValue = EnvironmentVariableValue;
+exports.EnvironmentVariables = EnvironmentVariables;
 exports.EventFilter = EventFilter;
 exports.ExceptionEventProperties = ExceptionEventProperties;
 exports.ExceptionSpanEvent = ExceptionSpanEvent;
@@ -3549,9 +4342,12 @@ exports.GetProjectEnvResponse = GetProjectEnvResponse;
 exports.GetProjectResponseBody = GetProjectResponseBody;
 exports.GetProjectsResponseBody = GetProjectsResponseBody;
 exports.ImageDetailsMetadata = ImageDetailsMetadata;
+exports.ImportEnvironmentVariablesRequestBody = ImportEnvironmentVariablesRequestBody;
 exports.InitializeDeploymentRequestBody = InitializeDeploymentRequestBody;
 exports.InitializeDeploymentResponseBody = InitializeDeploymentResponseBody;
 exports.InternalServerError = InternalServerError;
+exports.ListRunResponse = ListRunResponse;
+exports.ListRunResponseItem = ListRunResponseItem;
 exports.ListScheduleOptions = ListScheduleOptions;
 exports.ListSchedulesResult = ListSchedulesResult;
 exports.Machine = Machine;
@@ -3568,6 +4364,7 @@ exports.OTEL_LOG_ATTRIBUTE_VALUE_LENGTH_LIMIT = OTEL_LOG_ATTRIBUTE_VALUE_LENGTH_
 exports.OTEL_SPAN_ATTRIBUTE_COUNT_LIMIT = OTEL_SPAN_ATTRIBUTE_COUNT_LIMIT;
 exports.OTEL_SPAN_ATTRIBUTE_VALUE_LENGTH_LIMIT = OTEL_SPAN_ATTRIBUTE_VALUE_LENGTH_LIMIT;
 exports.OTEL_SPAN_EVENT_COUNT_LIMIT = OTEL_SPAN_EVENT_COUNT_LIMIT;
+exports.OffsetLimitPage = OffsetLimitPage;
 exports.OtherSpanEvent = OtherSpanEvent;
 exports.PRIMARY_VARIANT = PRIMARY_VARIANT;
 exports.PermissionDeniedError = PermissionDeniedError;
@@ -3588,10 +4385,14 @@ exports.RateLimitOptions = RateLimitOptions;
 exports.ReplayRunResponse = ReplayRunResponse;
 exports.RetrieveRunResponse = RetrieveRunResponse;
 exports.RetryOptions = RetryOptions;
+exports.RunEnvironmentDetails = RunEnvironmentDetails;
+exports.RunScheduleDetails = RunScheduleDetails;
 exports.RunStatus = RunStatus;
+exports.ScheduleGenerator = ScheduleGenerator;
 exports.ScheduleObject = ScheduleObject;
 exports.ScheduledTaskPayload = ScheduledTaskPayload;
 exports.SemanticInternalAttributes = SemanticInternalAttributes;
+exports.SerializedError = SerializedError;
 exports.SharedQueueToClientMessages = SharedQueueToClientMessages;
 exports.SlidingWindowRateLimit = SlidingWindowRateLimit;
 exports.SpanEvent = SpanEvent;
@@ -3615,6 +4416,7 @@ exports.TaskRunExecution = TaskRunExecution;
 exports.TaskRunExecutionAttempt = TaskRunExecutionAttempt;
 exports.TaskRunExecutionBatch = TaskRunExecutionBatch;
 exports.TaskRunExecutionEnvironment = TaskRunExecutionEnvironment;
+exports.TaskRunExecutionLazyAttemptPayload = TaskRunExecutionLazyAttemptPayload;
 exports.TaskRunExecutionOrganization = TaskRunExecutionOrganization;
 exports.TaskRunExecutionPayload = TaskRunExecutionPayload;
 exports.TaskRunExecutionProject = TaskRunExecutionProject;
@@ -3631,6 +4433,7 @@ exports.TriggerTaskResponse = TriggerTaskResponse;
 exports.TriggerTracer = TriggerTracer;
 exports.UncaughtExceptionMessage = UncaughtExceptionMessage;
 exports.UnprocessableEntityError = UnprocessableEntityError;
+exports.UpdateEnvironmentVariableRequestBody = UpdateEnvironmentVariableRequestBody;
 exports.UpdateScheduleOptions = UpdateScheduleOptions;
 exports.WaitReason = WaitReason;
 exports.WhoAmIResponseSchema = WhoAmIResponseSchema;