@trigger.dev/core 0.0.0-prerelease-20260508094307 → 0.0.0-prerelease-deployment-base-image-20260814120901

package/dist/esm/v3/schemas/api.js

@@ -3,6 +3,8 @@ import { DeserializedJsonSchema } from "../../schemas/json.js";
 import { FlushedRunMetadata, GitMeta, MachinePresetName, SerializedError, TaskRunError, } from "./common.js";
 import { BackgroundWorkerMetadata } from "./resources.js";
 import { DequeuedMessage, MachineResources } from "./runEngine.js";
+import { QueueTypeName } from "./queues.js";
+import { ScheduleWindow } from "./schemas.js";
 export const RunEngineVersion = z.union([z.literal("V1"), z.literal("V2")]);
 export const WhoAmIResponseSchema = z.object({
     userId: z.string(),
@@ -24,6 +26,10 @@ export const GetProjectResponseBody = z.object({
     name: z.string(),
     slug: z.string(),
     createdAt: z.coerce.date(),
+    // Worker-group name of the project's default region, or null when unset
+    // (the project falls back to the global platform default). Optional so a
+    // newer client still parses responses from an older server that omits it.
+    defaultRegion: z.string().nullable().optional(),
     organization: z.object({
         id: z.string(),
         title: z.string(),
@@ -38,6 +44,17 @@ export const GetOrgsResponseBody = z.array(z.object({
     slug: z.string(),
     createdAt: z.coerce.date(),
 }));
+export const CreateOrgRequestBody = z.object({
+    title: z.string().trim().min(3).max(50),
+    companySize: z.string().optional(),
+    companyUrl: z.string().optional(),
+});
+export const CreateOrgResponseBody = z.object({
+    id: z.string(),
+    title: z.string(),
+    slug: z.string(),
+    createdAt: z.coerce.date(),
+});
 export const CreateProjectRequestBody = z.object({
     name: z
         .string()
@@ -51,6 +68,17 @@ export const GetProjectEnvResponse = z.object({
     apiUrl: z.string(),
     projectId: z.string(),
 });
+export const ProjectEnvironment = z.object({
+    id: z.string(),
+    /// The slug used as the environment identifier in env var endpoints (e.g. "dev", "stg", "prod", "preview")
+    slug: z.string(),
+    type: z.enum(["DEVELOPMENT", "STAGING", "PREVIEW", "PRODUCTION"]),
+    /// Whether this is the branchable parent (preview); individual branches are not returned
+    isBranchableEnvironment: z.boolean(),
+    branchName: z.string().nullable(),
+    paused: z.boolean(),
+});
+export const GetProjectEnvironmentsResponseBody = z.array(ProjectEnvironment);
 // Zod schema for the response body type
 export const GetWorkerTaskResponse = z.object({
     id: z.string(),
@@ -59,6 +87,7 @@ export const GetWorkerTaskResponse = z.object({
     triggerSource: z.string(),
     createdAt: z.coerce.date(),
     payloadSchema: z.any().nullish(),
+    queueConfig: z.any().nullish(),
 });
 export const GetWorkerByTagResponse = z.object({
     worker: z.object({
@@ -105,7 +134,13 @@ export const IdempotencyKeyOptionsSchema = z.object({
     key: z.string(),
     scope: z.enum(["run", "attempt", "global"]),
 });
-export const TriggerTaskRequestBody = z.object({
+// Coerces user-supplied concurrencyKey values to string. The downstream Prisma
+// column is String?, so passing a number (a common foot-gun when callers do
+// `concurrencyKey: payload.userId`) used to fail at `prisma.taskRun.create`
+// with PrismaClientValidationError. Accept the intent and stringify here.
+const ConcurrencyKeySchema = z.union([z.string(), z.number()]).transform((value) => String(value));
+export const TriggerTaskRequestBody = z
+    .object({
     payload: z.any(),
     context: z.any(),
     options: z
@@ -142,9 +177,15 @@ export const TriggerTaskRequestBody = z.object({
             concurrencyLimit: z.number().int().optional(),
         })
             .optional(),
-        concurrencyKey: z.string().optional(),
+        concurrencyKey: ConcurrencyKeySchema.optional(),
         delay: z.string().or(z.coerce.date()).optional(),
-        idempotencyKey: z.string().optional(),
+        idempotencyKey: z
+            .string()
+            // Caps user-supplied keys before they reach the unique idempotency index
+            // on the underlying table — values past this fail at the database layer
+            // rather than returning a clean 400.
+            .max(2048, "idempotencyKey must be 2048 characters or less")
+            .optional(),
         idempotencyKeyTTL: z.string().optional(),
         /** The original user-provided idempotency key and scope */
         idempotencyKeyOptions: IdempotencyKeyOptionsSchema.optional(),
@@ -154,6 +195,12 @@ export const TriggerTaskRequestBody = z.object({
         metadata: z.any(),
         metadataType: z.string().optional(),
         payloadType: z.string().optional(),
+        /**
+         * Byte size of the (pre-offload) serialized payload, measured by the caller
+         * before any object-store offload. Lets the pipeline know how large a payload
+         * is without downloading an "application/store" reference.
+         */
+        payloadSize: z.number().int().nonnegative().optional(),
         tags: RunTags.optional(),
         test: z.boolean().optional(),
         ttl: z.string().or(z.number().nonnegative().int()).optional(),
@@ -170,6 +217,18 @@ export const TriggerTaskRequestBody = z.object({
             .optional(),
     })
         .optional(),
+})
+    .superRefine((value, ctx) => {
+    if (value.options?.payloadType !== "application/store") {
+        return;
+    }
+    if (typeof value.payload !== "string" || value.payload.length === 0) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "payload must be a non-empty string when options.payloadType is application/store",
+            path: ["payload"],
+        });
+    }
 });
 export const TriggerTaskResponse = z.object({
     id: z.string(),
@@ -185,9 +244,15 @@ export const BatchTriggerTaskItem = z.object({
     context: z.any(),
     options: z
         .object({
-        concurrencyKey: z.string().optional(),
+        concurrencyKey: ConcurrencyKeySchema.optional(),
         delay: z.string().or(z.coerce.date()).optional(),
-        idempotencyKey: z.string().optional(),
+        idempotencyKey: z
+            .string()
+            // Caps user-supplied keys before they reach the unique idempotency index
+            // on the underlying table — values past this fail at the database layer
+            // rather than returning a clean 400.
+            .max(2048, "idempotencyKey must be 2048 characters or less")
+            .optional(),
         idempotencyKeyTTL: z.string().optional(),
         /** The original user-provided idempotency key and scope */
         idempotencyKeyOptions: IdempotencyKeyOptionsSchema.optional(),
@@ -199,6 +264,8 @@ export const BatchTriggerTaskItem = z.object({
         metadataType: z.string().optional(),
         parentAttempt: z.string().optional(),
         payloadType: z.string().optional(),
+        /** Byte size of the (pre-offload) serialized payload for this item. */
+        payloadSize: z.number().int().nonnegative().optional(),
         queue: z
             .object({
             name: z.string(),
@@ -273,12 +340,20 @@ export const BatchTriggerTaskV3Response = z.object({
 export const CreateBatchRequestBody = z.object({
     /** Expected number of items in the batch */
     runCount: z.number().int().positive(),
+    /** Distinct task identifiers expected in the item stream */
+    taskIdentifiers: z.array(z.string().min(1)).min(1).optional(),
     /** Parent run ID for batchTriggerAndWait (friendly ID) */
     parentRunId: z.string().optional(),
     /** Whether to resume parent on completion (true for batchTriggerAndWait) */
     resumeParentOnCompletion: z.boolean().optional(),
     /** Idempotency key for the batch */
-    idempotencyKey: z.string().optional(),
+    idempotencyKey: z
+        .string()
+        // Caps user-supplied keys before they reach the unique idempotency index
+        // on the underlying table — values past this fail at the database layer
+        // rather than returning a clean 400.
+        .max(2048, "idempotencyKey must be 2048 characters or less")
+        .optional(),
     /** The original user-provided idempotency key and scope */
     idempotencyKeyOptions: IdempotencyKeyOptionsSchema.optional(),
 });
@@ -297,7 +372,12 @@ export const CreateBatchResponse = z.object({
 });
 /**
  * Phase 2: Individual item in the NDJSON stream
- * Each line in the NDJSON body should match this schema
+ * Each line in the NDJSON body should match this schema.
+ *
+ * `options` reuses the strict shape from BatchTriggerTaskItem so that the
+ * Phase-2 streaming path validates option fields identically to the V2/V3
+ * batch trigger endpoints — historically this used z.record(z.unknown()) and
+ * let invalid values (e.g. numeric concurrencyKey) reach Prisma.
  */
 export const BatchItemNDJSON = z.object({
     /** Zero-based index of this item (used for idempotency and ordering) */
@@ -307,7 +387,7 @@ export const BatchItemNDJSON = z.object({
     /** The payload for this task run */
     payload: z.unknown().optional(),
     /** Options for this specific item */
-    options: z.record(z.unknown()).optional(),
+    options: BatchTriggerTaskItem.shape.options,
 });
 /**
  * Phase 2: Stream items response
@@ -406,7 +486,7 @@ export const DeploymentTriggeredVia = z
 // They are re-exported through the schemas barrel (index.ts)
 export const UpsertBranchRequestBody = z.object({
     git: GitMeta.optional(),
-    env: z.enum(["preview"]),
+    env: z.enum(["preview", "development"]),
     branch: z.string(),
 });
 export const UpsertBranchResponseBody = z.object({
@@ -706,6 +786,13 @@ export const CreateScheduleOptions = z.object({
      *
      */
     timezone: z.string().optional(),
+    /** Optionally delay each occurrence by a stable amount within this window.
+     * Absolute windows use whole minutes or hours up to 24 hours and are capped at the next
+     * nominal interval. Percentages are relative to each nominal interval.
+     *
+     * @example "30m", "2h", "24h", "30%", "100%"
+     */
+    window: ScheduleWindow.optional(),
 });
 export const UpdateScheduleOptions = CreateScheduleOptions.omit({ deduplicationKey: true });
 export const ScheduleGenerator = z.object({
@@ -722,7 +809,11 @@ export const ScheduleObject = z.object({
     externalId: z.string().nullish(),
     generator: ScheduleGenerator,
     timezone: z.string(),
+    window: ScheduleWindow.optional(),
+    /** The next nominal CRON time. */
     nextRun: z.coerce.date().nullish(),
+    /** The stable assigned time for the next nominal CRON time. */
+    nextRunEffectiveAt: z.coerce.date().nullish(),
     environments: z.array(z.object({
         id: z.string(),
         type: z.string(),
@@ -826,6 +917,8 @@ const CommonRunFields = {
     baseCostInCents: z.number(),
     durationMs: z.number(),
     metadata: z.record(z.any()).optional(),
+    taskKind: z.string().optional(),
+    region: z.string().optional(),
 };
 const RetrieveRunCommandFields = {
     ...CommonRunFields,
@@ -860,9 +953,97 @@ export const ListRunResponse = z.object({
         previous: z.string().optional(),
     }),
 });
+const StringOrStringArray = z.union([z.string(), z.array(z.string())]);
+const MachineOrMachineArray = z.union([MachinePresetName, z.array(MachinePresetName)]);
+const QueueOrQueueArray = z.union([QueueTypeName, z.array(QueueTypeName)]);
+const DateOrNumber = z.union([z.coerce.date(), z.number()]);
+const BulkActionFilterRequestBody = z
+    .object({
+    status: z.union([RunStatus, z.array(RunStatus)]).optional(),
+    taskIdentifier: StringOrStringArray.optional(),
+    version: StringOrStringArray.optional(),
+    from: DateOrNumber.optional(),
+    to: DateOrNumber.optional(),
+    period: z.string().optional(),
+    bulkAction: z.string().optional(),
+    tag: StringOrStringArray.optional(),
+    schedule: z.string().optional(),
+    isTest: z.boolean().optional(),
+    batch: z.string().optional(),
+    queue: QueueOrQueueArray.optional(),
+    machine: MachineOrMachineArray.optional(),
+    region: StringOrStringArray.optional(),
+})
+    .refine((filter) => Object.values(filter).some(isNonEmptyBulkActionFilterValue), {
+    message: "At least one filter must be provided",
+});
+/** Recursively checks for at least one non-undefined, non-empty value. */
+function isNonEmptyBulkActionFilterValue(value) {
+    if (value === undefined) {
+        return false;
+    }
+    if (Array.isArray(value)) {
+        return value.some(isNonEmptyBulkActionFilterValue);
+    }
+    if (typeof value === "string") {
+        return value.trim().length > 0;
+    }
+    return true;
+}
+const BulkActionSelectionRequestBody = {
+    filter: BulkActionFilterRequestBody.optional(),
+    runIds: z.array(z.string()).min(1).optional(),
+    name: z.string().max(255, "Name must be less than 255 characters").optional(),
+};
+export const CreateBulkActionRequestBody = z
+    .discriminatedUnion("action", [
+    z.object({
+        action: z.literal("cancel"),
+        targetRegion: z.never().optional(),
+        ...BulkActionSelectionRequestBody,
+    }),
+    z.object({
+        action: z.literal("replay"),
+        targetRegion: z.string().optional(),
+        ...BulkActionSelectionRequestBody,
+    }),
+])
+    .refine((body) => (body.filter ? 1 : 0) + (body.runIds ? 1 : 0) === 1, {
+    message: "Exactly one of filter or runIds must be provided",
+});
+export const BulkActionStatus = z.enum(["PENDING", "COMPLETED", "ABORTED"]);
+export const BulkActionType = z.enum(["CANCEL", "REPLAY"]);
+export const BulkActionObject = z.object({
+    id: z.string(),
+    name: z.string().optional(),
+    type: BulkActionType,
+    status: BulkActionStatus,
+    counts: z.object({
+        total: z.number(),
+        success: z.number(),
+        failure: z.number(),
+    }),
+    createdAt: z.coerce.date(),
+    completedAt: z.coerce.date().optional(),
+});
+export const CreateBulkActionResponseBody = z.object({
+    id: z.string(),
+});
+export const AbortBulkActionResponseBody = z.object({
+    id: z.string(),
+});
+export const ListBulkActionsResponseBody = z.object({
+    data: z.array(BulkActionObject),
+    pagination: z.object({
+        next: z.string().optional(),
+        previous: z.string().optional(),
+    }),
+});
 export const CreateEnvironmentVariableRequestBody = z.object({
     name: z.string(),
     value: z.string(),
+    // When omitted, the variable defaults to non-secret (the DB default is false).
+    isSecret: z.boolean().optional(),
 });
 export const UpdateEnvironmentVariableRequestBody = z.object({
     value: z.string(),
@@ -871,6 +1052,8 @@ export const ImportEnvironmentVariablesRequestBody = z.object({
     variables: z.record(z.string()),
     parentVariables: z.record(z.string()).optional(),
     override: z.boolean().optional(),
+    // When omitted, variables default to non-secret (the DB default is false).
+    isSecret: z.boolean().optional(),
     source: z
         .discriminatedUnion("type", [
         z.object({ type: z.literal("user"), userId: z.string() }),
@@ -994,7 +1177,13 @@ export const CreateWaitpointTokenRequestBody = z.object({
      *
      * Note: This waitpoint may already be complete, in which case when you wait for it, it will immediately continue.
      */
-    idempotencyKey: z.string().optional(),
+    idempotencyKey: z
+        .string()
+        // Caps user-supplied keys before they reach the unique idempotency index
+        // on the underlying table — values past this fail at the database layer
+        // rather than returning a clean 400.
+        .max(2048, "idempotencyKey must be 2048 characters or less")
+        .optional(),
     /**
      * When set, this means the passed in idempotency key will expire after this time.
      * This means after that time if you pass the same idempotency key again, you will get a new waitpoint.
@@ -1029,7 +1218,13 @@ export const CreateWaitpointTokenResponseBody = z.object({
 export const CreateInputStreamWaitpointRequestBody = z.object({
     streamId: z.string(),
     timeout: z.string().optional(),
-    idempotencyKey: z.string().optional(),
+    idempotencyKey: z
+        .string()
+        // Caps user-supplied keys before they reach the unique idempotency index
+        // on the underlying table — values past this fail at the database layer
+        // rather than returning a clean 400.
+        .max(2048, "idempotencyKey must be 2048 characters or less")
+        .optional(),
     idempotencyKeyTTL: z.string().optional(),
     tags: z.union([z.string(), z.array(z.string())]).optional(),
     /**
@@ -1054,7 +1249,13 @@ export const CreateSessionStreamWaitpointRequestBody = z.object({
     session: z.string(),
     io: z.enum(["out", "in"]),
     timeout: z.string().optional(),
-    idempotencyKey: z.string().optional(),
+    idempotencyKey: z
+        .string()
+        // Caps user-supplied keys before they reach the unique idempotency index
+        // on the underlying table — values past this fail at the database layer
+        // rather than returning a clean 400.
+        .max(2048, "idempotencyKey must be 2048 characters or less")
+        .optional(),
     idempotencyKeyTTL: z.string().optional(),
     tags: z.union([z.string(), z.array(z.string())]).optional(),
     /**
@@ -1106,6 +1307,12 @@ export const SessionTriggerConfig = z.object({
     queue: z.string().max(128).optional(),
     tags: z.array(z.string().max(128)).max(5).optional(),
     maxAttempts: z.number().int().positive().max(10).optional(),
+    /** Per-run wall-clock cap (seconds). Forwarded to `TaskRunOptions.maxDuration`. */
+    maxDuration: z.number().int().positive().optional(),
+    /** Pin every run to a specific worker version. Forwarded to `TaskRunOptions.lockToVersion`. */
+    lockToVersion: z.string().optional(),
+    /** Region to schedule runs in. Forwarded to `TaskRunOptions.region`. */
+    region: z.string().optional(),
     /** Convenience field surfaced to chat.agent via the wire payload. */
     idleTimeoutInSeconds: z.number().int().positive().max(3600).optional(),
 });
@@ -1285,7 +1492,13 @@ export const WaitForDurationRequestBody = z.object({
      *
      * Note: This waitpoint may already be complete, in which case when you wait for it, it will immediately continue.
      */
-    idempotencyKey: z.string().optional(),
+    idempotencyKey: z
+        .string()
+        // Caps user-supplied keys before they reach the unique idempotency index
+        // on the underlying table — values past this fail at the database layer
+        // rather than returning a clean 400.
+        .max(2048, "idempotencyKey must be 2048 characters or less")
+        .optional(),
     /**
      * When set, this means the passed in idempotency key will expire after this time.
      * This means after that time if you pass the same idempotency key again, you will get a new waitpoint.
@@ -1312,7 +1525,7 @@ export function isWaitpointOutputTimeout(output) {
         const json = JSON.parse(output);
         return json.code === WAITPOINT_TIMEOUT_ERROR_CODE;
     }
-    catch (e) {
+    catch (_e) {
         return false;
     }
 }
@@ -1372,6 +1585,7 @@ export const ApiDeploymentListResponseItem = z.object({
     git: z.record(z.any()).optional(),
     error: DeploymentErrorData.optional(),
 });
+export const RetrieveCurrentDeploymentResponseBody = ApiDeploymentListResponseItem;
 export const ApiBranchListResponseBody = z.object({
     branches: z.array(z.object({
         id: z.string(),
@@ -1440,6 +1654,8 @@ export const RetrieveSpanDetailResponseBody = z.object({
         inputCost: z.number().optional(),
         outputCost: z.number().optional(),
         totalCost: z.number().optional(),
+        cachedCost: z.number().optional(),
+        cacheCreationCost: z.number().optional(),
         tokensPerSecond: z.number().optional(),
         msToFirstChunk: z.number().optional(),
         durationMs: z.number(),
@@ -1466,6 +1682,33 @@ export const AppendToStreamResponseBody = z.object({
 export const SendInputStreamResponseBody = z.object({
     ok: z.boolean(),
 });
+/**
+ * Response body for `GET /realtime/v1/sessions/:id/:io/records`. A non-SSE,
+ * `wait=0` drain of a session channel — used at run boot for snapshot
+ * replay where the SSE long-poll tax (~1s on empty streams) was the
+ * dominant cost.
+ *
+ * `data` is the parsed chunk body (the SDK writer puts the chunk object
+ * directly into the S2 record envelope; the route unwraps the envelope
+ * and forwards the inner object as-is). Callers use it directly — no
+ * additional JSON.parse step. Schema is `z.unknown()` because chunk
+ * shape varies by `chunk.type` (the AI SDK's `UIMessageChunk`
+ * discriminated union plus Trigger control records); consumers
+ * already runtime-check on the discriminator and tolerate malformed
+ * records by skipping them.
+ */
+export const ReadSessionStreamRecordsResponseBody = z.object({
+    records: z.array(z.object({
+        data: z.unknown(),
+        id: z.string(),
+        seqNum: z.number(),
+        // S2 record headers — present on Trigger control records (e.g.
+        // `trigger-control: turn-complete` plus sibling headers). The
+        // server has always serialized them; older schemas stripped them
+        // client-side, so treat as optional.
+        headers: z.array(z.tuple([z.string(), z.string()])).optional(),
+    })),
+});
 export const ResolvePromptRequestBody = z.object({
     variables: z.record(z.unknown()).default({}),
     label: z.string().optional(),