@trigger.dev/core 0.0.0-python-preview-20250226140121 → 0.0.0-rc-4-8-0-20261021151928

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

@@ -1,3 +1,17 @@
+export function isSchemaZodEsque(schema) {
+    return (typeof schema === "object" &&
+        schema !== null &&
+        ("_zod" in schema || "_def" in schema) &&
+        "parse" in schema &&
+        "parseAsync" in schema &&
+        "safeParse" in schema);
+}
+export function isSchemaValibotEsque(schema) {
+    return typeof schema === "object" && "_types" in schema;
+}
+export function isSchemaArkTypeEsque(schema) {
+    return typeof schema === "object" && "_inferIn" in schema && "_infer" in schema;
+}
 export function getSchemaParseFn(procedureParser) {
     const parser = procedureParser;
     if (typeof parser === "function" && typeof parser.assert === "function") {

package/dist/esm/v3/types/schemas.js.map

@@ -1 +1 @@
-{"version":3,"file":"schemas.js","sourceRoot":"","sources":["../../../../src/v3/types/schemas.ts"],"names":[],"mappings":"AA+EA,MAAM,UAAU,gBAAgB,CAAQ,eAAuB;IAC7D,MAAM,MAAM,GAAG,eAAsB,CAAC;IAEtC,IAAI,OAAO,MAAM,KAAK,UAAU,IAAI,OAAO,MAAM,CAAC,MAAM,KAAK,UAAU,EAAE,CAAC;QACxE,8HAA8H;QAC9H,OAAO,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IACpC,CAAC;IAED,IAAI,OAAO,MAAM,KAAK,UAAU,EAAE,CAAC;QACjC,kCAAkC;QAClC,6BAA6B;QAC7B,OAAO,MAAM,CAAC;IAChB,CAAC;IAED,IAAI,OAAO,MAAM,CAAC,UAAU,KAAK,UAAU,EAAE,CAAC;QAC5C,iBAAiB;QACjB,OAAO,MAAM,CAAC,UAAU,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IACxC,CAAC;IAED,IAAI,OAAO,MAAM,CAAC,KAAK,KAAK,UAAU,EAAE,CAAC;QACvC,iBAAiB;QACjB,iCAAiC;QACjC,OAAO,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IACnC,CAAC;IAED,IAAI,OAAO,MAAM,CAAC,YAAY,KAAK,UAAU,EAAE,CAAC;QAC9C,iBAAiB;QACjB,OAAO,MAAM,CAAC,YAAY,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IAC1C,CAAC;IAED,IAAI,OAAO,MAAM,CAAC,MAAM,KAAK,UAAU,EAAE,CAAC;QACxC,yBAAyB;QACzB,OAAO,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IACpC,CAAC;IAED,IAAI,OAAO,MAAM,CAAC,MAAM,KAAK,UAAU,EAAE,CAAC;QACxC,mBAAmB;QACnB,OAAO,CAAC,KAAK,EAAE,EAAE;YACf,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;YACrB,OAAO,KAAc,CAAC;QACxB,CAAC,CAAC;IACJ,CAAC;IAED,MAAM,IAAI,KAAK,CAAC,+BAA+B,CAAC,CAAC;AACnD,CAAC"}
+{"version":3,"file":"schemas.js","sourceRoot":"","sources":["../../../../src/v3/types/schemas.ts"],"names":[],"mappings":"AAwBA,MAAM,UAAU,gBAAgB,CAC9B,MAAe;IAEf,OAAO,CACL,OAAO,MAAM,KAAK,QAAQ;QAC1B,MAAM,KAAK,IAAI;QACf,CAAC,MAAM,IAAI,MAAM,IAAI,MAAM,IAAI,MAAM,CAAC;QACtC,OAAO,IAAI,MAAM;QACjB,YAAY,IAAI,MAAM;QACtB,WAAW,IAAI,MAAM,CACtB,CAAC;AACJ,CAAC;AAWD,MAAM,UAAU,oBAAoB,CAClC,MAAc;IAEd,OAAO,OAAO,MAAM,KAAK,QAAQ,IAAI,QAAQ,IAAI,MAAM,CAAC;AAC1D,CAAC;AAOD,MAAM,UAAU,oBAAoB,CAClC,MAAc;IAEd,OAAO,OAAO,MAAM,KAAK,QAAQ,IAAI,UAAU,IAAI,MAAM,IAAI,QAAQ,IAAI,MAAM,CAAC;AAClF,CAAC;AA4DD,MAAM,UAAU,gBAAgB,CAAQ,eAAuB;IAC7D,MAAM,MAAM,GAAG,eAAsB,CAAC;IAEtC,IAAI,OAAO,MAAM,KAAK,UAAU,IAAI,OAAO,MAAM,CAAC,MAAM,KAAK,UAAU,EAAE,CAAC;QACxE,8HAA8H;QAC9H,OAAO,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IACpC,CAAC;IAED,IAAI,OAAO,MAAM,KAAK,UAAU,EAAE,CAAC;QACjC,kCAAkC;QAClC,6BAA6B;QAC7B,OAAO,MAAM,CAAC;IAChB,CAAC;IAED,IAAI,OAAO,MAAM,CAAC,UAAU,KAAK,UAAU,EAAE,CAAC;QAC5C,iBAAiB;QACjB,OAAO,MAAM,CAAC,UAAU,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IACxC,CAAC;IAED,IAAI,OAAO,MAAM,CAAC,KAAK,KAAK,UAAU,EAAE,CAAC;QACvC,iBAAiB;QACjB,iCAAiC;QACjC,OAAO,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IACnC,CAAC;IAED,IAAI,OAAO,MAAM,CAAC,YAAY,KAAK,UAAU,EAAE,CAAC;QAC9C,iBAAiB;QACjB,OAAO,MAAM,CAAC,YAAY,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IAC1C,CAAC;IAED,IAAI,OAAO,MAAM,CAAC,MAAM,KAAK,UAAU,EAAE,CAAC;QACxC,yBAAyB;QACzB,OAAO,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IACpC,CAAC;IAED,IAAI,OAAO,MAAM,CAAC,MAAM,KAAK,UAAU,EAAE,CAAC;QACxC,mBAAmB;QACnB,OAAO,CAAC,KAAK,EAAE,EAAE;YACf,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;YACrB,OAAO,KAAc,CAAC;QACxB,CAAC,CAAC;IACJ,CAAC;IAED,MAAM,IAAI,KAAK,CAAC,+BAA+B,CAAC,CAAC;AACnD,CAAC"}

package/dist/esm/v3/types/tasks.d.ts

@@ -1,21 +1,17 @@
-import { SerializableJson } from "../../schemas/json.js";
-import { TriggerApiRequestOptions } from "../apiClient/index.js";
-import { RunTags } from "../schemas/api.js";
-import { MachineCpu, MachineMemory, MachinePresetName, RetryOptions, TaskMetadata, TaskRunContext } from "../schemas/index.js";
-import { QueueOptions } from "../schemas/schemas.js";
-import { IdempotencyKey } from "./idempotencyKeys.js";
-import { AnySchemaParseFn, inferSchemaIn, inferSchemaOut, Schema } from "./schemas.js";
-import { Prettify } from "./utils.js";
-import { inferToolParameters, ToolTaskParameters } from "./tools.js";
-type RequireOne<T, K extends keyof T> = {
-    [X in Exclude<keyof T, K>]?: T[X];
-} & {
-    [P in K]-?: T[P];
-};
-export type Queue = RequireOne<QueueOptions, "name">;
+import type { SerializableJson } from "../../schemas/json.js";
+import type { TriggerApiRequestOptions } from "../apiClient/index.js";
+import type { AnyOnCatchErrorHookFunction, OnCatchErrorHookFunction, OnCleanupHookFunction, OnCompleteHookFunction, OnFailureHookFunction, OnInitHookFunction, OnMiddlewareHookFunction, OnResumeHookFunction, OnStartHookFunction, OnSuccessHookFunction, OnWaitHookFunction, OnCancelHookFunction, OnStartAttemptHookFunction } from "../lifecycleHooks/types.js";
+import type { RunTags } from "../schemas/api.js";
+import type { MachineCpu, MachineMemory, MachinePresetName, RetryOptions, PromptMetadata, TaskMetadata, TaskRunContext } from "../schemas/index.js";
+import type { IdempotencyKey } from "./idempotencyKeys.js";
+import type { QueueOptions, TaskConcurrency } from "./queues.js";
+import type { AnySchemaParseFn, inferSchemaIn, inferSchemaOut, Schema } from "./schemas.js";
+import type { inferToolParameters, ToolTaskParameters } from "./tools.js";
+import type { Prettify } from "./utils.js";
+import type { JSONSchema } from "./jsonSchema.js";
+export type Queue = QueueOptions;
 export type TaskSchema = Schema;
 export type { inferSchemaIn } from "./schemas.js";
-type TaskRunConcurrencyOptions = Queue;
 export declare class SubtaskUnwrapError extends Error {
     readonly taskId: string;
     readonly runId: string;
@@ -33,24 +29,38 @@ export type RunFnParams<TInitOutput extends InitOutput> = Prettify<{
     ctx: Context;
     /** If you use the `init` function, this will be whatever you returned. */
     init?: TInitOutput;
-    /** Abort signal that is aborted when a task run exceeds it's maxDuration. Can be used to automatically cancel downstream requests */
-    signal?: AbortSignal;
+    /** Abort signal that is aborted when a task run exceeds it's maxDuration or if the task run is cancelled. Can be used to automatically cancel downstream requests */
+    signal: AbortSignal;
 }>;
 export type MiddlewareFnParams = Prettify<{
     ctx: Context;
     next: () => Promise<void>;
-    /** Abort signal that is aborted when a task run exceeds it's maxDuration. Can be used to automatically cancel downstream requests */
-    signal?: AbortSignal;
+    /** Abort signal that is aborted when a task run exceeds it's maxDuration or if the task run is cancelled. Can be used to automatically cancel downstream requests */
+    signal: AbortSignal;
 }>;
 export type InitFnParams = Prettify<{
     ctx: Context;
-    /** Abort signal that is aborted when a task run exceeds it's maxDuration. Can be used to automatically cancel downstream requests */
-    signal?: AbortSignal;
+    /** Abort signal that is aborted when a task run exceeds it's maxDuration or if the task run is cancelled. Can be used to automatically cancel downstream requests */
+    signal: AbortSignal;
 }>;
 export type StartFnParams = Prettify<{
     ctx: Context;
-    /** Abort signal that is aborted when a task run exceeds it's maxDuration. Can be used to automatically cancel downstream requests */
-    signal?: AbortSignal;
+    init?: InitOutput;
+    /** Abort signal that is aborted when a task run exceeds it's maxDuration or if the task run is cancelled. Can be used to automatically cancel downstream requests */
+    signal: AbortSignal;
+}>;
+export type StartAttemptFnParams = Prettify<{
+    ctx: Context;
+    init?: InitOutput;
+    /** Abort signal that is aborted when a task run exceeds it's maxDuration or if the task run is cancelled. Can be used to automatically cancel downstream requests */
+    signal: AbortSignal;
+}>;
+export type CancelFnParams = Prettify<{
+    ctx: Context;
+    /** Abort signal that is aborted when a task run exceeds it's maxDuration or if the task run is cancelled. Can be used to automatically cancel downstream requests */
+    signal: AbortSignal;
+    runPromise: Promise<unknown>;
+    init?: InitOutput;
 }>;
 export type Context = TaskRunContext;
 export type SuccessFnParams<TInitOutput extends InitOutput> = RunFnParams<TInitOutput>;
@@ -70,14 +80,14 @@ export type HandleErrorModificationOptions = {
 export type HandleErrorResult = undefined | void | HandleErrorModificationOptions | Promise<undefined | void | HandleErrorModificationOptions>;
 export type HandleErrorArgs = {
     ctx: Context;
-    init: unknown;
+    init?: Record<string, unknown>;
     retry?: RetryOptions;
     retryAt?: Date;
     retryDelayInMs?: number;
     /** Abort signal that is aborted when a task run exceeds it's maxDuration. Can be used to automatically cancel downstream requests */
     signal?: AbortSignal;
 };
-export type HandleErrorFunction = (payload: any, error: unknown, params: HandleErrorArgs) => HandleErrorResult;
+export type HandleErrorFunction = AnyOnCatchErrorHookFunction;
 type CommonTaskOptions<TIdentifier extends string, TPayload = void, TOutput = unknown, TInitOutput extends InitOutput = any> = {
     /** An id for your task. This must be unique inside your project and not change between versions.  */
     id: TIdentifier;
@@ -122,7 +132,24 @@ type CommonTaskOptions<TIdentifier extends string, TPayload = void, TOutput = un
       });
      * ```
      */
-    queue?: QueueOptions;
+    queue?: string | TaskQueueIn;
+    /**
+     * Limit how many of this task's runs execute at once, or hold shared named limits.
+     * Takes one limit or an array: an inline `{ perKey?, total? }` shape caps this task;
+     * a `concurrencyLimit()` instance (or its name) is shared across every task holding it.
+     * At most one inline limit plus up to two named limits.
+     *
+     * @example
+     *
+     * ```ts
+     * export const sendEmail = task({
+     *   id: "send-email",
+     *   concurrency: { total: 10 },
+     *   run: async (payload) => {},
+     * });
+     * ```
+     */
+    concurrency?: TaskConcurrency;
     /** Configure the spec of the [machine](https://trigger.dev/docs/machines) you want your task to run on.
      *
      * @example
@@ -170,6 +197,28 @@ type CommonTaskOptions<TIdentifier extends string, TPayload = void, TOutput = un
      * Minimum value is 5 seconds
      */
     maxDuration?: number;
+    /**
+     * Set a default time-to-live for runs of this task. If the run is not executed within this time, it will be removed from the queue and never execute.
+     *
+     * This can be a string like "1h" (1 hour), "30m" (30 minutes), "1d" (1 day), or a number of seconds.
+     *
+     * If omitted it will use the value in your `trigger.config.ts` file, if set.
+     *
+     * You can override this on a per-trigger basis by setting the `ttl` option when triggering the task.
+     *
+     * @example
+     *
+     * ```ts
+     * export const myTask = task({
+     *   id: "my-task",
+     *   ttl: "10m",
+     *   run: async (payload) => {
+     *     //...
+     *   },
+     * });
+     * ```
+     */
+    ttl?: string | number;
     /** This gets called when a task is triggered. It's where you put the code you want to execute.
      *
      * @param payload - The payload that is passed to your task when it's triggered. This must be JSON serializable.
@@ -178,16 +227,30 @@ type CommonTaskOptions<TIdentifier extends string, TPayload = void, TOutput = un
     run: (payload: TPayload, params: RunFnParams<TInitOutput>) => Promise<TOutput>;
     /**
      * init is called before the run function is called. It's useful for setting up any global state.
+     *
+     * @deprecated Use locals and middleware instead
      */
-    init?: (payload: TPayload, params: InitFnParams) => Promise<TInitOutput>;
+    init?: OnInitHookFunction<TPayload, TInitOutput>;
     /**
      * cleanup is called after the run function has completed.
+     *
+     * @deprecated Use middleware instead
      */
-    cleanup?: (payload: TPayload, params: RunFnParams<TInitOutput>) => Promise<void>;
+    cleanup?: OnCleanupHookFunction<TPayload, TInitOutput>;
     /**
      * handleError is called when the run function throws an error. It can be used to modify the error or return new retry options.
+     *
+     * @deprecated Use catchError instead
      */
-    handleError?: (payload: TPayload, error: unknown, params: HandleErrorFnParams<TInitOutput>) => HandleErrorResult;
+    handleError?: OnCatchErrorHookFunction<TPayload>;
+    /**
+     * catchError is called when the run function throws an error. It can be used to modify the error or return new retry options.
+     */
+    catchError?: OnCatchErrorHookFunction<TPayload>;
+    onResume?: OnResumeHookFunction<TPayload>;
+    onWait?: OnWaitHookFunction<TPayload>;
+    onComplete?: OnCompleteHookFunction<TPayload, TOutput>;
+    onCancel?: OnCancelHookFunction<TPayload, TOutput, TInitOutput>;
     /**
      * middleware allows you to run code "around" the run function. This can be useful for logging, metrics, or other cross-cutting concerns.
      *
@@ -205,21 +268,57 @@ type CommonTaskOptions<TIdentifier extends string, TPayload = void, TOutput = un
      * });
      * ```
      */
-    middleware?: (payload: TPayload, params: MiddlewareFnParams) => Promise<void>;
+    middleware?: OnMiddlewareHookFunction<TPayload>;
     /**
      * onStart is called the first time a task is executed in a run (not before every retry)
+     *
+     * @deprecated Use onStartAttempt instead
+     */
+    onStart?: OnStartHookFunction<TPayload, TInitOutput>;
+    /**
+     * onStartAttempt is called before each attempt of a task is executed.
+     *
+     * You can detect the first attempt by checking `ctx.attempt.number === 1`.
      */
-    onStart?: (payload: TPayload, params: StartFnParams) => Promise<void>;
+    onStartAttempt?: OnStartAttemptHookFunction<TPayload>;
     /**
      * onSuccess is called after the run function has successfully completed.
      */
-    onSuccess?: (payload: TPayload, output: TOutput, params: SuccessFnParams<TInitOutput>) => Promise<void>;
+    onSuccess?: OnSuccessHookFunction<TPayload, TOutput, TInitOutput>;
     /**
      * onFailure is called after a task run has failed (meaning the run function threw an error and won't be retried anymore)
      */
-    onFailure?: (payload: TPayload, error: unknown, params: FailureFnParams<TInitOutput>) => Promise<void>;
+    onFailure?: OnFailureHookFunction<TPayload, TInitOutput>;
+    /**
+     * JSON Schema for the task payload. This will be synced to the server during indexing.
+     * Should be a valid JSON Schema Draft 7 object.
+     */
+    jsonSchema?: JSONSchema;
+    /** @internal Set by SDK internals (e.g. `chat.agent()`, `schedules.task()`). */
+    triggerSource?: string;
+    /** @internal Agent configuration, only set when `triggerSource` is `"agent"`. */
+    agentConfig?: {
+        type: string;
+    };
+};
+/**
+ * A reference to a gate: another queue a run must also hold a concurrency slot in while
+ * it executes. A plain string names the gate queue; the object form pins the gate to a
+ * literal `concurrencyKey` instead of inheriting the run's own key.
+ */
+type TaskQueueIn = {
+    name?: string;
+    /**
+     * @deprecated Use `concurrency` on the task instead. `concurrencyLimit: 10` applies per
+     * `concurrencyKey` when runs pass one, and to the whole queue when they don't; the task's
+     * `concurrency` option says which you mean. Existing queues keep working unchanged.
+     */
+    concurrencyLimit?: number;
 };
 export type TaskOptions<TIdentifier extends string, TPayload = void, TOutput = unknown, TInitOutput extends InitOutput = any> = CommonTaskOptions<TIdentifier, TPayload, TOutput, TInitOutput>;
+export type TaskOptionsWithSchema<TIdentifier extends string, TOutput = unknown, TInitOutput extends InitOutput = any> = CommonTaskOptions<TIdentifier, any, TOutput, TInitOutput> & {
+    jsonSchema: JSONSchema;
+};
 export type TaskWithSchemaOptions<TIdentifier extends string, TSchema extends TaskSchema | undefined = undefined, TOutput = unknown, TInitOutput extends InitOutput = any> = CommonTaskOptions<TIdentifier, inferSchemaOut<TSchema>, TOutput, TInitOutput> & {
     schema?: TSchema;
 };
@@ -252,11 +351,9 @@ export type AnyBatchedRunHandle = BatchedRunHandle<string, any, any>;
 /**
  * A BatchRunHandle can be used to retrieve the runs of a batch trigger in a typesafe manner.
  */
-export type BatchRunHandle<TTaskIdentifier extends string, TPayload, TOutput> = BrandedRun<{
+export type BatchRunHandle<_TTaskIdentifier extends string, TPayload, TOutput> = BrandedRun<{
     batchId: string;
-    isCached: boolean;
-    idempotencyKey?: string;
-    runs: Array<BatchedRunHandle<TTaskIdentifier, TPayload, TOutput>>;
+    runCount: number;
     publicAccessToken: string;
 }, TOutput, TPayload>;
 export type RunHandleOutput<TRunHandle> = TRunHandle extends RunHandle<string, any, infer TOutput> ? TOutput : never;
@@ -327,6 +424,7 @@ export interface Task<TIdentifier extends string, TInput = void, TOutput = any>
      */
     id: TIdentifier;
     description?: string;
+    jsonSchema?: JSONSchema;
     /**
      * Trigger a task with the given payload, and continue without waiting for the result. If you want to wait for the result, use `triggerAndWait`. Returns the id of the triggered task run.
      * @param payload
@@ -337,12 +435,12 @@ export interface Task<TIdentifier extends string, TInput = void, TOutput = any>
     trigger: (payload: TInput, options?: TriggerOptions, requestOptions?: TriggerApiRequestOptions) => Promise<RunHandle<TIdentifier, TInput, TOutput>>;
     /**
      * Batch trigger multiple task runs with the given payloads, and continue without waiting for the results. If you want to wait for the results, use `batchTriggerAndWait`. Returns the id of the triggered batch.
-     * @param items
+     * @param items - Array, AsyncIterable, or ReadableStream of batch items
      * @returns InvokeBatchHandle
      * - `batchId` - The id of the triggered batch.
      * - `runs` - The ids of the triggered task runs.
      */
-    batchTrigger: (items: Array<BatchItem<TInput>>, options?: BatchTriggerOptions, requestOptions?: TriggerApiRequestOptions) => Promise<BatchRunHandle<TIdentifier, TInput, TOutput>>;
+    batchTrigger: (items: Array<BatchItem<TInput>> | AsyncIterable<BatchItem<TInput>> | ReadableStream<BatchItem<TInput>>, options?: BatchTriggerOptions, requestOptions?: TriggerApiRequestOptions) => Promise<BatchRunHandle<TIdentifier, TInput, TOutput>>;
     /**
      * Trigger a task with the given payload, and wait for the result. Returns the result of the task run
      * @param payload
@@ -359,10 +457,30 @@ export interface Task<TIdentifier extends string, TInput = void, TOutput = any>
      * }
      * ```
      */
-    triggerAndWait: (payload: TInput, options?: TriggerAndWaitOptions) => TaskRunPromise<TIdentifier, TOutput>;
+    triggerAndWait: (payload: TInput, options?: TriggerAndWaitOptions, requestOptions?: TriggerApiRequestOptions) => TaskRunPromise<TIdentifier, TOutput>;
+    /**
+     * Trigger a task and subscribe to its updates via realtime. Unlike `triggerAndWait`,
+     * this does NOT suspend the parent run — the parent stays alive and polls for updates.
+     * This enables parallel tool calls and proper abort signal handling.
+     *
+     * @param payload
+     * @param options - Options for the task run, including an optional `signal` to cancel the subscription and child run
+     * @returns TaskRunPromise
+     * @example
+     * ```
+     * const result = await task.triggerAndSubscribe({ foo: "bar" }, { signal: abortSignal });
+     *
+     * if (result.ok) {
+     *   console.log(result.output);
+     * } else {
+     *   console.error(result.error);
+     * }
+     * ```
+     */
+    triggerAndSubscribe: (payload: TInput, options?: TriggerAndSubscribeOptions) => TaskRunPromise<TIdentifier, TOutput>;
     /**
      * Batch trigger multiple task runs with the given payloads, and wait for the results. Returns the results of the task runs.
-     * @param items
+     * @param items - Array, AsyncIterable, or ReadableStream of batch items
      * @returns BatchResult
      * @example
      * ```
@@ -380,7 +498,7 @@ export interface Task<TIdentifier extends string, TInput = void, TOutput = any>
      * }
      * ```
      */
-    batchTriggerAndWait: (items: Array<BatchTriggerAndWaitItem<TInput>>, options?: BatchTriggerAndWaitOptions) => Promise<BatchResult<TIdentifier, TOutput>>;
+    batchTriggerAndWait: (items: Array<BatchTriggerAndWaitItem<TInput>> | AsyncIterable<BatchTriggerAndWaitItem<TInput>> | ReadableStream<BatchTriggerAndWaitItem<TInput>>, options?: BatchTriggerAndWaitOptions) => Promise<BatchResult<TIdentifier, TOutput>>;
 }
 export interface TaskWithSchema<TIdentifier extends string, TSchema extends TaskSchema | undefined = undefined, TOutput = any> extends Task<TIdentifier, inferSchemaIn<TSchema>, TOutput> {
     schema?: TSchema;
@@ -462,8 +580,26 @@ export type TriggerOptions = {
      * Specify a duration string like "1h", "10s", "30m", etc.
      */
     idempotencyKeyTTL?: string;
+    /**
+     * The maximum number of retry attempts for the task if it fails.
+     * If not specified, it will use the task or the default retry policy from your trigger.config file.
+     */
     maxAttempts?: number;
-    queue?: TaskRunConcurrencyOptions;
+    /**
+     * You can override the queue for the task. If a queue doesn't exist for the given name, the run will be in the PENDING_VERSION state until the queue is created..
+     */
+    queue?: string;
+    /**
+     * Override the task's named concurrency limits for this run. Strings only, like `queue`:
+     * pass a limit's name (e.g. `paidTier.name`). Replaces the task's declared named limits;
+     * the task's inline limit always applies.
+     */
+    concurrency?: string | string[];
+    /**
+     * The `concurrencyKey` creates a copy of the queue for every unique value of the key.
+     * For example, if the queue (set when triggering or on the task) has a concurrency limit of 10,
+     * and you set the concurrency key to `userId`, then each user will have their own queue with a concurrency limit of 10.
+     */
     concurrencyKey?: string;
     /**
      * The delay before the task is executed. This can be a string like "1h" or a Date object.
@@ -492,6 +628,25 @@ export type TriggerOptions = {
      * **Note:** Runs in development have a default `ttl` of 10 minutes. You can override this by setting the `ttl` option.
      */
     ttl?: string | number;
+    /**
+     * If triggered at the same time, a higher priority run will be executed first.
+     *
+     The value is a time offset in seconds that determines the order of dequeuing.
+     * If you trigger two runs 9 seconds apart but the second one has `priority: 10`, it will be executed before the first one.
+     *
+     * @example
+     * ```ts
+     // no priority = 0
+     await myTask.trigger({ foo: "bar" });
+  
+     //... imagine 9s pass by
+  
+     // this run will start before the run above that was triggered 9s ago (with no priority)
+     await myTask.trigger({ foo: "bar" }, { priority: 10 });
+     ```
+     *
+     */
+    priority?: number;
     /**
      * Tags to attach to the run. Tags can be used to filter runs in the dashboard and using the SDK.
      *
@@ -522,24 +677,153 @@ export type TriggerOptions = {
      * The machine preset to use for this run. This will override the task's machine preset and any defaults.
      */
     machine?: MachinePresetName;
-};
-export type TriggerAndWaitOptions = Omit<TriggerOptions, "idempotencyKey" | "idempotencyKeyTTL">;
-export type BatchTriggerOptions = {
-    idempotencyKey?: IdempotencyKey | string | string[];
-    idempotencyKeyTTL?: string;
     /**
-     * When true, triggers tasks sequentially in batch order. This ensures ordering but may be slower,
-     * especially for large batches.
+     * Specify the version of the deployed task to run. By default the "current" version is used at the time of execution,
+     * but you can specify a specific version to run here. You can also set the TRIGGER_VERSION environment
+     * variables to run a specific version for all tasks.
      *
-     * When false (default), triggers tasks in parallel for better performance, but order is not guaranteed.
+     * @example
      *
-     * Note: This only affects the order of run creation, not the actual task execution.
+     * ```ts
+     * await myTask.trigger({ foo: "bar" }, { version: "20250208.1" });
+     * ```
      *
-     * @default false
+     * Note that this option is only available for `trigger` and NOT `triggerAndWait` (and their batch counterparts). The "wait" versions will always be locked
+     * to the same version as the parent task that is triggering the child tasks.
      */
-    triggerSequentially?: boolean;
+    version?: string;
+    /**
+     * Pin this run to the deployment that was deployed under this external id — a commit SHA,
+     * a CI run id, a release tag — matching `trigger.dev deploy --external-id`.
+     *
+     * Use this when the code making the call and the tasks it triggers must be the same
+     * release. If nothing has been deployed under the id yet the run waits for it rather than
+     * running on the wrong version, and gives up after an hour if it never arrives.
+     *
+     * Usually you don't set this by hand: the SDK reads `TRIGGER_EXTERNAL_DEPLOYMENT_ID`, and
+     * with `TRIGGER_AUTOMATIC_SKEW_VERSION_PROTECTION=1` it discovers your hosting platform's
+     * commit variable automatically. Setting it here always wins over both.
+     *
+     * `version` (and the `TRIGGER_VERSION` environment variable) take precedence over this.
+     *
+     * @example
+     *
+     * ```ts
+     * await myTask.trigger({ foo: "bar" }, { externalDeploymentId: process.env.VERCEL_GIT_COMMIT_SHA });
+     * ```
+     */
+    externalDeploymentId?: string;
+    /**
+     * Specify the region to run the task in. This overrides the default region set for your project in the dashboard.
+     *
+     * Check the Regions page in the dashboard for regions that are available to you.
+     *
+     * In DEV this won't do anything, so it's fine to set it in your code.
+     *
+     * @example
+     *
+     * ```ts
+     * await myTask.trigger({ foo: "bar" }, { region: "us-east-1" });
+     * ```
+     */
+    region?: string;
+    /**
+     * Debounce settings for consolidating multiple trigger calls into a single delayed run.
+     *
+     * When a run with the same debounce key already exists in the delayed state, subsequent triggers
+     * "push" the existing run's execution time later rather than creating new runs.
+     *
+     * The debounce key is scoped to the task identifier, so different tasks can use the same key without conflicts.
+     *
+     * There is no time limit by default: while triggers keep arriving on the same key, the run
+     * keeps being pushed back and never executes. Set `maxDelay` to bound that.
+     *
+     * @example
+     *
+     * ```ts
+     * // Leading mode (default): executes with the FIRST payload
+     * await myTask.trigger({ some: "data1" }, { debounce: { key: "user-123", delay: "5s" } });
+     * await myTask.trigger({ some: "data2" }, { debounce: { key: "user-123", delay: "5s" } });
+     * // After 5 seconds, runs with { some: "data1" }
+     *
+     * // Trailing mode: executes with the LAST payload
+     * await myTask.trigger({ some: "data1" }, { debounce: { key: "user-123", delay: "5s", mode: "trailing" } });
+     * await myTask.trigger({ some: "data2" }, { debounce: { key: "user-123", delay: "5s", mode: "trailing" } });
+     * // After 5 seconds, runs with { some: "data2" }
+     * ```
+     */
+    debounce?: {
+        /**
+         * Unique key scoped to the task identifier. Runs with the same key will be debounced together.
+         * Maximum length is 512 characters.
+         */
+        key: string;
+        /**
+         * Duration string specifying how long to delay the run. If another trigger with the same key
+         * occurs within this duration, the delay is extended.
+         *
+         * When you also set `maxDelay`, keep `delay` well below it. A run is only pushed back while
+         * the new execution time stays inside `maxDelay`, so a `delay` at or above `maxDelay` leaves
+         * no room to push and every trigger creates its own run.
+         *
+         * Must be a duration, not a date: the value is re-applied every time the run is pushed
+         * back, so an absolute date cannot work and debouncing silently stops collapsing.
+         *
+         * Supported formats: `{number}s` (seconds), `{number}m` (minutes), `{number}h` or
+         * `{number}hr` (hours), `{number}d` (days), `{number}w` (weeks), optionally combined.
+         * Minimum delay is 1 second.
+         *
+         * @example "1s", "5s", "1m", "30m", "1h", "2h30m"
+         */
+        delay: string;
+        /**
+         * Controls which trigger's data is used when the debounced run finally executes.
+         *
+         * - `"leading"` (default): Use data from the first trigger (payload, metadata, tags, etc.)
+         * - `"trailing"`: Use data from the last trigger. Each subsequent trigger updates the run's
+         *   payload, metadata, tags, maxAttempts, maxDuration, and machine preset.
+         *
+         * @default "leading"
+         */
+        mode?: "leading" | "trailing";
+        /**
+         * Maximum total delay before the run must execute, regardless of subsequent triggers.
+         * This prevents indefinite delays when continuous triggers keep pushing the execution time.
+         *
+         * When specified, if a new trigger would push the execution time beyond this limit
+         * (measured from the first trigger), the current debounced run will be allowed to execute
+         * and a new run will be created for subsequent triggers.
+         *
+         * Without it a continuously triggered key is pushed back indefinitely and never runs. The
+         * gap between the two values is the room you have to push: a `delay` of `"10s"` with a
+         * `maxDelay` of `"5m"` keeps extending for just under 5 minutes from the first trigger,
+         * then runs.
+         *
+         * Supported formats: `{number}s` (seconds), `{number}m` (minutes), `{number}h` or
+         * `{number}hr` (hours), `{number}d` (days), `{number}w` (weeks), optionally combined.
+         *
+         * @example "30m", "2h", "1d", "2h30m"
+         */
+        maxDelay?: string;
+    };
+};
+export type TriggerAndWaitOptions = Omit<TriggerOptions, "version">;
+export type TriggerAndSubscribeOptions = Omit<TriggerOptions, "version"> & {
+    /** An AbortSignal to cancel the subscription. When fired, the subscription closes and the promise rejects. */
+    signal?: AbortSignal;
+    /**
+     * Whether to cancel the child run when the abort signal fires.
+     * @default true
+     */
+    cancelOnAbort?: boolean;
 };
-export type BatchTriggerAndWaitOptions = {
+export type BatchTriggerOptions = {
+    /**
+     * If no idempotencyKey is set on an individual item in the batch, it will use this key on each item + the array index.
+     * This is useful to prevent work being done again if the task has to retry.
+     */
+    idempotencyKey?: IdempotencyKey | string | string[];
+    idempotencyKeyTTL?: string;
     /**
      * When true, triggers tasks sequentially in batch order. This ensures ordering but may be slower,
      * especially for large batches.
@@ -552,6 +836,7 @@ export type BatchTriggerAndWaitOptions = {
      */
     triggerSequentially?: boolean;
 };
+export type BatchTriggerAndWaitOptions = BatchTriggerOptions;
 export type TaskMetadataWithFunctions = TaskMetadata & {
     fns: {
         run: (payload: any, params: RunFnParams<any>) => Promise<any>;
@@ -562,8 +847,16 @@ export type TaskMetadataWithFunctions = TaskMetadata & {
         onSuccess?: (payload: any, output: any, params: SuccessFnParams<any>) => Promise<void>;
         onFailure?: (payload: any, error: unknown, params: FailureFnParams<any>) => Promise<void>;
         onStart?: (payload: any, params: StartFnParams) => Promise<void>;
+        onStartAttempt?: (payload: any, params: StartAttemptFnParams) => Promise<void>;
         parsePayload?: AnySchemaParseFn;
     };
+    schema?: TaskSchema;
+};
+export type PromptMetadataWithFunctions = PromptMetadata & {
+    fns: {
+        resolve: (variables: Record<string, unknown>) => Promise<unknown>;
+    };
+    schema?: TaskSchema;
 };
 export type RunTypes<TTaskIdentifier extends string, TPayload, TOutput> = {
     output: TOutput;

package/dist/esm/v3/types/tasks.js.map

@@ -1 +1 @@
-{"version":3,"file":"tasks.js","sourceRoot":"","sources":["../../../../src/v3/types/tasks.ts"],"names":[],"mappings":"AA6BA,MAAM,OAAO,kBAAmB,SAAQ,KAAK;IAC3B,MAAM,CAAS;IACf,KAAK,CAAS;IACd,KAAK,CAAW;IAEhC,YAAY,MAAc,EAAE,KAAa,EAAE,YAAqB;QAC9D,IAAI,YAAY,YAAY,KAAK,EAAE,CAAC;YAClC,KAAK,CAAC,YAAY,MAAM,KAAK,YAAY,CAAC,OAAO,EAAE,CAAC,CAAC;YACrD,IAAI,CAAC,KAAK,GAAG,YAAY,CAAC;YAC1B,IAAI,CAAC,IAAI,GAAG,oBAAoB,CAAC;QACnC,CAAC;aAAM,CAAC;YACN,KAAK,CAAC,YAAY,MAAM,EAAE,CAAC,CAAC;YAC5B,IAAI,CAAC,IAAI,GAAG,oBAAoB,CAAC;YACjC,IAAI,CAAC,KAAK,GAAG,YAAY,CAAC;QAC5B,CAAC;QAED,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;QACrB,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;IACrB,CAAC;CACF;AAED,MAAM,OAAO,cAAoD,SAAQ,OAExE;IAUoB;IATnB,YACE,QAOS,EACQ,MAAmB;QAEpC,KAAK,CAAC,QAAQ,CAAC,CAAC;QAFC,WAAM,GAAN,MAAM,CAAa;IAGtC,CAAC;IAED,MAAM;QACJ,OAAO,IAAI,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,EAAE;YAC1B,IAAI,MAAM,CAAC,EAAE,EAAE,CAAC;gBACd,OAAO,MAAM,CAAC,MAAM,CAAC;YACvB,CAAC;iBAAM,CAAC;gBACN,MAAM,IAAI,kBAAkB,CAAC,IAAI,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC;YACrE,CAAC;QACH,CAAC,CAAC,CAAC;IACL,CAAC;CACF"}
+{"version":3,"file":"tasks.js","sourceRoot":"","sources":["../../../../src/v3/types/tasks.ts"],"names":[],"mappings":"AAsCA,MAAM,OAAO,kBAAmB,SAAQ,KAAK;IAC3B,MAAM,CAAS;IACf,KAAK,CAAS;IACd,KAAK,CAAW;IAEhC,YAAY,MAAc,EAAE,KAAa,EAAE,YAAqB;QAC9D,IAAI,YAAY,YAAY,KAAK,EAAE,CAAC;YAClC,KAAK,CAAC,YAAY,MAAM,KAAK,YAAY,CAAC,OAAO,EAAE,CAAC,CAAC;YACrD,IAAI,CAAC,KAAK,GAAG,YAAY,CAAC;YAC1B,IAAI,CAAC,IAAI,GAAG,oBAAoB,CAAC;QACnC,CAAC;aAAM,CAAC;YACN,KAAK,CAAC,YAAY,MAAM,EAAE,CAAC,CAAC;YAC5B,IAAI,CAAC,IAAI,GAAG,oBAAoB,CAAC;YACjC,IAAI,CAAC,KAAK,GAAG,YAAY,CAAC;QAC5B,CAAC;QAED,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;QACrB,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;IACrB,CAAC;CACF;AAED,MAAM,OAAO,cAAoD,SAAQ,OAExE;IAUoB,MAAM;IATzB,YACE,QAOS,EACQ,MAAmB;QAEpC,KAAK,CAAC,QAAQ,CAAC,CAAC;sBAFC,MAAM;IAGzB,CAAC;IAED,MAAM;QACJ,OAAO,IAAI,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,EAAE;YAC1B,IAAI,MAAM,CAAC,EAAE,EAAE,CAAC;gBACd,OAAO,MAAM,CAAC,MAAM,CAAC;YACvB,CAAC;iBAAM,CAAC;gBACN,MAAM,IAAI,kBAAkB,CAAC,IAAI,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC;YACrE,CAAC;QACH,CAAC,CAAC,CAAC;IACL,CAAC;CACF"}

package/dist/esm/v3/types/tools.d.ts

@@ -1,6 +1,17 @@
-import { z } from "zod";
-import type { Schema as AISchema } from "ai";
-import { Schema } from "./schemas.js";
-export type ToolTaskParameters = z.ZodTypeAny | AISchema<any>;
-export type inferToolParameters<PARAMETERS extends ToolTaskParameters> = PARAMETERS extends AISchema<any> ? PARAMETERS["_type"] : PARAMETERS extends z.ZodTypeAny ? z.infer<PARAMETERS> : never;
+import { type AnyZodSchema, type inferZodSchemaOutput, type Schema } from "./schemas.js";
+type ValidationResult<T> = {
+    success: true;
+    value: T;
+} | {
+    success: false;
+    error: Error;
+};
+type AISchema<T> = {
+    _type: T;
+    readonly jsonSchema: unknown;
+    readonly validate?: (value: unknown) => ValidationResult<T> | PromiseLike<ValidationResult<T>>;
+};
+export type ToolTaskParameters = AnyZodSchema | AISchema<any>;
+export type inferToolParameters<PARAMETERS extends ToolTaskParameters> = PARAMETERS extends AnyZodSchema ? inferZodSchemaOutput<PARAMETERS> : PARAMETERS extends AISchema<any> ? PARAMETERS["_type"] : never;
 export declare function convertToolParametersToSchema<TToolParameters extends ToolTaskParameters>(toolParameters: TToolParameters): Schema;
+export {};

package/dist/esm/v3/types/tools.js

@@ -1,12 +1,12 @@
-import { z } from "zod";
+import { isSchemaZodEsque, } from "./schemas.js";
 export function convertToolParametersToSchema(toolParameters) {
-    return toolParameters instanceof z.ZodSchema
+    return isSchemaZodEsque(toolParameters)
         ? toolParameters
         : convertAISchemaToTaskSchema(toolParameters);
 }
 function convertAISchemaToTaskSchema(schema) {
-    return (payload) => {
-        const result = schema.validate?.(payload);
+    return async (payload) => {
+        const result = await schema.validate?.(payload);
         if (!result) {
             throw new Error("Invalid payload");
         }

package/dist/esm/v3/types/tools.js.map

@@ -1 +1 @@
-{"version":3,"file":"tools.js","sourceRoot":"","sources":["../../../../src/v3/types/tools.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAaxB,MAAM,UAAU,6BAA6B,CAC3C,cAA+B;IAE/B,OAAO,cAAc,YAAY,CAAC,CAAC,SAAS;QAC1C,CAAC,CAAC,cAAc;QAChB,CAAC,CAAC,2BAA2B,CAAC,cAAc,CAAC,CAAC;AAClD,CAAC;AAED,SAAS,2BAA2B,CAAC,MAAqB;IACxD,OAAO,CAAC,OAAgB,EAAE,EAAE;QAC1B,MAAM,MAAM,GAAG,MAAM,CAAC,QAAQ,EAAE,CAAC,OAAO,CAAC,CAAC;QAE1C,IAAI,CAAC,MAAM,EAAE,CAAC;YACZ,MAAM,IAAI,KAAK,CAAC,iBAAiB,CAAC,CAAC;QACrC,CAAC;QAED,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC;YACpB,MAAM,MAAM,CAAC,KAAK,CAAC;QACrB,CAAC;QAED,OAAO,MAAM,CAAC,KAAK,CAAC;IACtB,CAAC,CAAC;AACJ,CAAC"}
+{"version":3,"file":"tools.js","sourceRoot":"","sources":["../../../../src/v3/types/tools.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,gBAAgB,GAIjB,MAAM,cAAc,CAAC;AAoBtB,MAAM,UAAU,6BAA6B,CAC3C,cAA+B;IAE/B,OAAO,gBAAgB,CAAC,cAAc,CAAC;QACrC,CAAC,CAAC,cAAc;QAChB,CAAC,CAAC,2BAA2B,CAAC,cAA+B,CAAC,CAAC;AACnE,CAAC;AAED,SAAS,2BAA2B,CAAC,MAAqB;IACxD,OAAO,KAAK,EAAE,OAAgB,EAAE,EAAE;QAChC,MAAM,MAAM,GAAG,MAAM,MAAM,CAAC,QAAQ,EAAE,CAAC,OAAO,CAAC,CAAC;QAEhD,IAAI,CAAC,MAAM,EAAE,CAAC;YACZ,MAAM,IAAI,KAAK,CAAC,iBAAiB,CAAC,CAAC;QACrC,CAAC;QAED,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC;YACpB,MAAM,MAAM,CAAC,KAAK,CAAC;QACrB,CAAC;QAED,OAAO,MAAM,CAAC,KAAK,CAAC;IACtB,CAAC,CAAC;AACJ,CAAC"}