@trigger.dev/core 0.0.0-v3-prerelease-20240523152756 → 0.0.0-v3-prerelease-20240612084127

package/dist/v3/workers/index.mjs

@@ -1,4 +1,5 @@
 import { SpanStatusCode, DiagLogLevel, diag, DiagConsoleLogger, propagation, context, SpanKind } from '@opentelemetry/api';
+import { z } from 'zod';
 import { logs, SeverityNumber } from '@opentelemetry/api-logs';
 import { OTLPLogExporter } from '@opentelemetry/exporter-logs-otlp-http';
 import { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-http';
@@ -7,10 +8,9 @@ import { Resource, detectResourcesSync, processDetectorSync } from '@opentelemet
 import { LoggerProvider, BatchLogRecordProcessor, SimpleLogRecordProcessor } from '@opentelemetry/sdk-logs';
 import { NodeTracerProvider, BatchSpanProcessor, SimpleSpanProcessor } from '@opentelemetry/sdk-trace-node';
 import { SemanticResourceAttributes } from '@opentelemetry/semantic-conventions';
-import { z } from 'zod';
 import { fromZodError } from 'zod-validation-error';
 import { FormDataEncoder } from 'form-data-encoder';
-import { Readable } from 'stream';
+import { Readable } from 'node:stream';
 import { PreciseDate } from '@google-cloud/precise-date';
 import util from 'node:util';
 
@@ -38,8 +38,6 @@ var __privateMethod = (obj, member, method) => {
   __accessCheck(obj, member, "access private method");
   return method;
 };
-
-// src/v3/errors.ts
 function parseError(error) {
   if (error instanceof Error) {
     return {
@@ -68,6 +66,11 @@ function parseError(error) {
   }
 }
 __name(parseError, "parseError");
+var SerializedError = z.object({
+  message: z.string(),
+  name: z.string().optional(),
+  stackTrace: z.string().optional()
+});
 
 // src/v3/limits.ts
 var OTEL_SPAN_ATTRIBUTE_COUNT_LIMIT = 256;
@@ -352,7 +355,7 @@ function getEnvVar(name) {
 __name(getEnvVar, "getEnvVar");
 
 // package.json
-var version = "0.0.0-v3-prerelease-20240523152756";
+var version = "0.0.0-v3-prerelease-20240612084127";
 
 // src/v3/otel/tracingSDK.ts
 var _a;
@@ -522,6 +525,7 @@ var TaskRunErrorCodes = {
   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",
@@ -537,10 +541,12 @@ var TaskRunInternalError = 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: z.string().optional()
 });
@@ -790,7 +796,7 @@ var QueueOptions = z.object({
   /** @deprecated This feature is coming soon */
   rateLimit: RateLimitOptions.optional()
 });
-var TaskMetadata = z.object({
+z.object({
   id: z.string(),
   packageVersion: z.string(),
   queue: QueueOptions.optional(),
@@ -798,11 +804,20 @@ var TaskMetadata = z.object({
   machine: Machine.partial().optional(),
   triggerSource: z.string().optional()
 });
-var TaskFileMetadata = z.object({
+z.object({
+  filePath: z.string(),
+  exportName: z.string()
+});
+z.object({
+  id: z.string(),
+  packageVersion: z.string(),
+  queue: QueueOptions.optional(),
+  retry: RetryOptions.optional(),
+  machine: Machine.partial().optional(),
+  triggerSource: z.string().optional(),
   filePath: z.string(),
   exportName: z.string()
 });
-TaskMetadata.merge(TaskFileMetadata);
 z.enum([
   "index",
   "create",
@@ -843,6 +858,13 @@ z.enum([
   "WAIT_FOR_TASK",
   "WAIT_FOR_BATCH"
 ]);
+z.object({
+  runId: z.string(),
+  messageId: z.string(),
+  isTest: z.boolean(),
+  traceContext: z.record(z.unknown()),
+  environment: z.record(z.string()).optional()
+});
 
 // src/v3/schemas/resources.ts
 var TaskResource = z.object({
@@ -892,7 +914,8 @@ z.object({
 });
 z.object({
   localOnly: z.boolean(),
-  metadata: BackgroundWorkerMetadata
+  metadata: BackgroundWorkerMetadata,
+  supportsLazyAttempts: z.boolean().optional()
 });
 z.object({
   id: z.string(),
@@ -969,7 +992,8 @@ z.object({
 var DeploymentErrorData = z.object({
   name: z.string(),
   message: z.string(),
-  stack: z.string().optional()
+  stack: z.string().optional(),
+  stderr: z.string().optional()
 });
 z.object({
   id: z.string(),
@@ -1005,7 +1029,7 @@ var ReplayRunResponse = z.object({
   id: z.string()
 });
 var CanceledRunResponse = z.object({
-  message: z.string()
+  id: z.string()
 });
 z.object({
   /** The schedule id associated with this run (you can have many schedules for the same task).
@@ -1054,17 +1078,18 @@ z.object({
   */
   externalId: z.string().optional()
 });
+var ScheduleGenerator = z.object({
+  type: z.literal("CRON"),
+  expression: z.string(),
+  description: z.string()
+});
 var ScheduleObject = z.object({
   id: z.string(),
   task: z.string(),
   active: z.boolean(),
   deduplicationKey: z.string().nullish(),
   externalId: z.string().nullish(),
-  generator: z.object({
-    type: z.literal("CRON"),
-    expression: z.string(),
-    description: z.string()
-  }),
+  generator: ScheduleGenerator,
   nextRun: z.coerce.date().nullish(),
   environments: z.array(z.object({
     id: z.string(),
@@ -1075,7 +1100,7 @@ var ScheduleObject = z.object({
 var DeletedScheduleObject = z.object({
   id: z.string()
 });
-var ListSchedulesResult = z.object({
+z.object({
   data: z.array(ScheduleObject),
   pagination: z.object({
     currentPage: z.number(),
@@ -1088,12 +1113,28 @@ z.object({
   perPage: z.number().optional()
 });
 var RunStatus = 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 = z.enum([
   "PENDING",
@@ -1103,23 +1144,61 @@ var AttemptStatus = z.enum([
   "FAILED",
   "CANCELED"
 ]);
-var RetrieveRunResponse = z.object({
+var RunEnvironmentDetails = z.object({
+  id: z.string(),
+  name: z.string(),
+  user: z.string().optional()
+});
+var RunScheduleDetails = z.object({
+  id: z.string(),
+  externalId: z.string().optional(),
+  deduplicationKey: z.string().optional(),
+  generator: ScheduleGenerator
+});
+var CommonRunFields = {
   id: z.string(),
   status: RunStatus,
   taskIdentifier: z.string(),
   idempotencyKey: z.string().optional(),
   version: z.string().optional(),
+  isQueued: z.boolean(),
+  isExecuting: z.boolean(),
+  isCompleted: z.boolean(),
+  isSuccess: z.boolean(),
+  isFailed: z.boolean(),
+  isCancelled: z.boolean(),
+  isTest: z.boolean(),
   createdAt: z.coerce.date(),
   updatedAt: z.coerce.date(),
+  startedAt: z.coerce.date().optional(),
+  finishedAt: z.coerce.date().optional()
+};
+var RetrieveRunResponse = z.object({
+  ...CommonRunFields,
+  payload: z.any().optional(),
+  output: z.any().optional(),
+  schedule: RunScheduleDetails.optional(),
   attempts: z.array(z.object({
     id: z.string(),
     status: AttemptStatus,
     createdAt: z.coerce.date(),
     updatedAt: z.coerce.date(),
     startedAt: z.coerce.date().optional(),
-    completedAt: z.coerce.date().optional()
+    completedAt: z.coerce.date().optional(),
+    error: SerializedError.optional()
   }).optional())
 });
+var ListRunResponseItem = z.object({
+  ...CommonRunFields,
+  env: RunEnvironmentDetails
+});
+z.object({
+  data: z.array(ListRunResponseItem),
+  pagination: z.object({
+    next: z.string().optional(),
+    previous: z.string().optional()
+  })
+});
 z.object({
   name: z.string(),
   value: z.string()
@@ -1143,10 +1222,10 @@ var EnvironmentVariable = z.object({
 });
 var EnvironmentVariables = z.array(EnvironmentVariable);
 
-// src/v3/apiErrors.ts
-var _APIError = class _APIError extends Error {
+// src/v3/apiClient/errors.ts
+var _ApiError = class _ApiError extends Error {
   constructor(status, error, message, headers) {
-    super(`${_APIError.makeMessage(status, error, message)}`);
+    super(`${_ApiError.makeMessage(status, error, message)}`);
     this.status = status;
     this.headers = headers;
     const data = error;
@@ -1170,7 +1249,7 @@ var _APIError = class _APIError extends Error {
   }
   static generate(status, errorResponse, message, headers) {
     if (!status) {
-      return new APIConnectionError({
+      return new ApiConnectionError({
         cause: castToError(errorResponse)
       });
     }
@@ -1199,12 +1278,12 @@ var _APIError = class _APIError extends Error {
     if (status >= 500) {
       return new InternalServerError(status, error, message, headers);
     }
-    return new _APIError(status, error, message, headers);
+    return new _ApiError(status, error, message, headers);
   }
 };
-__name(_APIError, "APIError");
-var APIError = _APIError;
-var _APIConnectionError = class _APIConnectionError extends APIError {
+__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");
@@ -1212,9 +1291,9 @@ var _APIConnectionError = class _APIConnectionError extends APIError {
       this.cause = cause;
   }
 };
-__name(_APIConnectionError, "APIConnectionError");
-var APIConnectionError = _APIConnectionError;
-var _BadRequestError = class _BadRequestError extends APIError {
+__name(_ApiConnectionError, "ApiConnectionError");
+var ApiConnectionError = _ApiConnectionError;
+var _BadRequestError = class _BadRequestError extends ApiError {
   constructor() {
     super(...arguments);
     __publicField(this, "status", 400);
@@ -1222,7 +1301,7 @@ var _BadRequestError = class _BadRequestError extends APIError {
 };
 __name(_BadRequestError, "BadRequestError");
 var BadRequestError = _BadRequestError;
-var _AuthenticationError = class _AuthenticationError extends APIError {
+var _AuthenticationError = class _AuthenticationError extends ApiError {
   constructor() {
     super(...arguments);
     __publicField(this, "status", 401);
@@ -1230,7 +1309,7 @@ var _AuthenticationError = class _AuthenticationError extends APIError {
 };
 __name(_AuthenticationError, "AuthenticationError");
 var AuthenticationError = _AuthenticationError;
-var _PermissionDeniedError = class _PermissionDeniedError extends APIError {
+var _PermissionDeniedError = class _PermissionDeniedError extends ApiError {
   constructor() {
     super(...arguments);
     __publicField(this, "status", 403);
@@ -1238,7 +1317,7 @@ var _PermissionDeniedError = class _PermissionDeniedError extends APIError {
 };
 __name(_PermissionDeniedError, "PermissionDeniedError");
 var PermissionDeniedError = _PermissionDeniedError;
-var _NotFoundError = class _NotFoundError extends APIError {
+var _NotFoundError = class _NotFoundError extends ApiError {
   constructor() {
     super(...arguments);
     __publicField(this, "status", 404);
@@ -1246,7 +1325,7 @@ var _NotFoundError = class _NotFoundError extends APIError {
 };
 __name(_NotFoundError, "NotFoundError");
 var NotFoundError = _NotFoundError;
-var _ConflictError = class _ConflictError extends APIError {
+var _ConflictError = class _ConflictError extends ApiError {
   constructor() {
     super(...arguments);
     __publicField(this, "status", 409);
@@ -1254,7 +1333,7 @@ var _ConflictError = class _ConflictError extends APIError {
 };
 __name(_ConflictError, "ConflictError");
 var ConflictError = _ConflictError;
-var _UnprocessableEntityError = class _UnprocessableEntityError extends APIError {
+var _UnprocessableEntityError = class _UnprocessableEntityError extends ApiError {
   constructor() {
     super(...arguments);
     __publicField(this, "status", 422);
@@ -1262,7 +1341,7 @@ var _UnprocessableEntityError = class _UnprocessableEntityError extends APIError
 };
 __name(_UnprocessableEntityError, "UnprocessableEntityError");
 var UnprocessableEntityError = _UnprocessableEntityError;
-var _RateLimitError = class _RateLimitError extends APIError {
+var _RateLimitError = class _RateLimitError extends ApiError {
   constructor() {
     super(...arguments);
     __publicField(this, "status", 429);
@@ -1270,7 +1349,7 @@ var _RateLimitError = class _RateLimitError extends APIError {
 };
 __name(_RateLimitError, "RateLimitError");
 var RateLimitError = _RateLimitError;
-var _InternalServerError = class _InternalServerError extends APIError {
+var _InternalServerError = class _InternalServerError extends ApiError {
 };
 __name(_InternalServerError, "InternalServerError");
 var InternalServerError = _InternalServerError;
@@ -1303,6 +1382,108 @@ function calculateNextRetryDelay(options, attempt) {
   return Math.round(timeout);
 }
 __name(calculateNextRetryDelay, "calculateNextRetryDelay");
+
+// 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,
@@ -1310,11 +1491,62 @@ var defaultRetryOptions2 = {
   maxTimeoutInMs: 6e4,
   randomize: false
 };
-async function zodfetch(schema, url, requestInit, options) {
-  return await _doZodFetch(schema, url, requestInit, options);
+function zodfetch(schema, url, requestInit, options) {
+  return new ApiPromise(_doZodFetch(schema, url, requestInit, options));
 }
 __name(zodfetch, "zodfetch");
-async function zodupload(schema, url, body, requestInit, options) {
+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 = z.object({
+    data: z.array(schema),
+    pagination: z.object({
+      next: z.string().optional(),
+      previous: 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 = z.object({
+    data: z.array(schema),
+    pagination: z.object({
+      currentPage: z.coerce.number(),
+      totalPages: z.coerce.number(),
+      count: 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(form);
   const finalHeaders = {};
@@ -1332,9 +1564,9 @@ async function zodupload(schema, url, body, requestInit, options) {
     // @ts-expect-error
     duplex: "half"
   };
-  return await _doZodFetch(schema, url, finalRequestInit, options);
+  return finalRequestInit;
 }
-__name(zodupload, "zodupload");
+__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)));
@@ -1342,7 +1574,8 @@ var createForm = /* @__PURE__ */ __name(async (body) => {
 }, "createForm");
 async function _doZodFetch(schema, url, requestInit, options, attempt = 1) {
   try {
-    const response = await fetch(url, requestInitWithCache(requestInit));
+    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);
@@ -1353,17 +1586,20 @@ async function _doZodFetch(schema, url, requestInit, options, attempt = 1) {
         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);
+        throw ApiError.generate(response.status, errJSON, errMessage, responseHeaders);
       }
     }
     const jsonBody = await response.json();
     const parsedResult = schema.safeParse(jsonBody);
     if (parsedResult.success) {
-      return parsedResult.data;
+      return {
+        data: parsedResult.data,
+        response
+      };
     }
     throw fromZodError(parsedResult.error);
   } catch (error) {
-    if (error instanceof APIError) {
+    if (error instanceof ApiError) {
       throw error;
     }
     if (options?.retry) {
@@ -1377,7 +1613,7 @@ async function _doZodFetch(schema, url, requestInit, options, attempt = 1) {
         return await _doZodFetch(schema, url, requestInit, options, attempt + 1);
       }
     }
-    throw new APIConnectionError({
+    throw new ApiConnectionError({
       cause: castToError2(error)
     });
   }
@@ -1550,6 +1786,128 @@ 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);
+  }
+};
+__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 = {
@@ -1575,7 +1933,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;
         }
@@ -1590,14 +1948,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)
@@ -1621,6 +1981,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",
@@ -1648,7 +2035,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)
     });
@@ -1749,6 +2139,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");
 
 // src/v3/apiClientManager/index.ts
 var API_NAME2 = "api-client";