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

package/dist/esm/v3/shared.js

@@ -1,43 +1,121 @@
 import { SpanKind } from "@opentelemetry/api";
-import { accessoryAttributes, apiClientManager, conditionallyImportPacket, convertToolParametersToSchema, createErrorTaskError, defaultRetryOptions, getSchemaParseFn, makeIdempotencyKey, parsePacket, runtime, SemanticInternalAttributes, stringifyIO, SubtaskUnwrapError, taskCatalog, taskContext, TaskRunPromise, } from "@trigger.dev/core/v3";
-import { runs } from "./runs.js";
+import { accessoryAttributes, apiClientManager, ApiError, conditionallyExportPacket, conditionallyImportPacket, convertToolParametersToSchema, createErrorFromCauses, createErrorTaskError, defaultRetryOptions, flattenIdempotencyKey, generateFriendlyId, getIdempotencyKeyOptions, getSchemaParseFn, lifecycleHooks, makeIdempotencyKey, packetRequiresOffloading, parsePacket, RateLimitError, resourceCatalog, runtime, SemanticInternalAttributes, stringifyIO, SubtaskUnwrapError, taskContext, TaskRunPromise, } from "@trigger.dev/core/v3";
+import { resolveTriggerExternalDeploymentId, scopedEnvVar } from "./externalDeploymentId.js";
 import { tracer } from "./tracer.js";
+import { triggerConcurrencyBody, validateConcurrencyLimitName } from "./concurrency-shared.js";
 export { SubtaskUnwrapError, TaskRunPromise };
+/** A task's `queue` is a queue object or a string reference to a queue defined elsewhere. */
+function normalizeTaskQueue(queue) {
+    if (!queue) {
+        return {};
+    }
+    return { queue: typeof queue === "string" ? { name: queue } : queue };
+}
+/**
+ * Validates and normalizes the task `concurrency` option into its manifest shape:
+ * at most one inline limit (caps this task) plus up to two named limits (shared).
+ */
+function normalizeTaskConcurrency(taskId, concurrency) {
+    if (!concurrency) {
+        return undefined;
+    }
+    const items = Array.isArray(concurrency) ? concurrency : [concurrency];
+    const inline = [];
+    const limits = [];
+    for (const item of items) {
+        if (typeof item === "string") {
+            limits.push(item);
+        }
+        else if (item &&
+            typeof item === "object" &&
+            "name" in item &&
+            typeof item.name === "string") {
+            validateConcurrencyLimitName(item.name);
+            resourceCatalog.registerConcurrencyLimitMetadata(item);
+            limits.push(item.name);
+        }
+        else if (item && typeof item === "object") {
+            inline.push({ perKey: item.perKey, total: item.total });
+        }
+    }
+    if (inline.length > 1) {
+        throw new Error(`Task "${taskId}": concurrency accepts at most one inline limit. Give shared limits a name with concurrencyLimit().`);
+    }
+    if (limits.length > 2) {
+        throw new Error(`Task "${taskId}": concurrency accepts at most two named limits.`);
+    }
+    return {
+        inline: inline[0],
+        limits: limits.length > 0 ? limits : undefined,
+    };
+}
+/** Builds the queue field of a trigger request body. */
+function triggerQueueBody(queue, fallbackQueueName) {
+    const name = queue ?? fallbackQueueName;
+    return { queue: name ? { name } : undefined };
+}
 export function queue(options) {
+    resourceCatalog.registerQueueMetadata(options);
+    // @ts-expect-error
+    options[Symbol.for("trigger.dev/queue")] = true;
+    return options;
+}
+/**
+ * Declares a named, shareable concurrency limit. Tasks hold it via their `concurrency`
+ * option; every task holding the same limit draws from the same pools.
+ *
+ * @example
+ *
+ * ```ts
+ * export const openaiLimit = concurrencyLimit({ name: "openai", total: 25 });
+ *
+ * export const generateSummary = task({
+ *   id: "generate-summary",
+ *   concurrency: [{ total: 5 }, openaiLimit],
+ *   run: async (payload) => {},
+ * });
+ * ```
+ */
+export function concurrencyLimit(options) {
+    validateConcurrencyLimitName(options.name);
+    resourceCatalog.registerConcurrencyLimitMetadata(options);
+    // @ts-expect-error
+    options[Symbol.for("trigger.dev/concurrencyLimit")] = true;
     return options;
 }
 export function createTask(params) {
-    const customQueue = params.queue
-        ? queue({
-            name: params.queue?.name ?? `task/${params.id}`,
-            ...params.queue,
-        })
-        : undefined;
+    const normalizedQueue = normalizeTaskQueue(params.queue);
     const task = {
         id: params.id,
         description: params.description,
+        jsonSchema: params.jsonSchema,
         trigger: async (payload, options) => {
-            const taskMetadata = taskCatalog.getTaskManifest(params.id);
-            return await trigger_internal(taskMetadata && taskMetadata.exportName
-                ? `${taskMetadata.exportName}.trigger()`
-                : `trigger()`, params.id, payload, undefined, {
-                queue: customQueue,
+            return await trigger_internal("trigger()", params.id, payload, undefined, {
+                queue: normalizedQueue.queue?.name,
                 ...options,
             });
         },
         batchTrigger: async (items, options) => {
-            const taskMetadata = taskCatalog.getTaskManifest(params.id);
-            return await batchTrigger_internal(taskMetadata && taskMetadata.exportName
-                ? `${taskMetadata.exportName}.batchTrigger()`
-                : `batchTrigger()`, params.id, items, options, undefined, undefined, customQueue);
+            return await batchTrigger_internal("batchTrigger()", params.id, items, options, undefined, undefined, normalizedQueue.queue?.name);
         },
-        triggerAndWait: (payload, options) => {
-            const taskMetadata = taskCatalog.getTaskManifest(params.id);
+        triggerAndWait: (payload, options, requestOptions) => {
+            return new TaskRunPromise((resolve, reject) => {
+                triggerAndWait_internal("triggerAndWait()", params.id, payload, undefined, {
+                    queue: normalizedQueue.queue?.name,
+                    ...options,
+                }, requestOptions)
+                    .then((result) => {
+                    resolve(result);
+                })
+                    .catch((error) => {
+                    reject(error);
+                });
+            }, params.id);
+        },
+        triggerAndSubscribe: (payload, options) => {
             return new TaskRunPromise((resolve, reject) => {
-                triggerAndWait_internal(taskMetadata && taskMetadata.exportName
-                    ? `${taskMetadata.exportName}.triggerAndWait()`
-                    : `triggerAndWait()`, params.id, payload, undefined, {
-                    queue: customQueue,
+                triggerAndSubscribe_internal("triggerAndSubscribe()", params.id, payload, undefined, {
+                    queue: normalizedQueue.queue?.name,
                     ...options,
                 })
                     .then((result) => {
@@ -49,34 +127,46 @@ export function createTask(params) {
             }, params.id);
         },
         batchTriggerAndWait: async (items, options) => {
-            const taskMetadata = taskCatalog.getTaskManifest(params.id);
-            return await batchTriggerAndWait_internal(taskMetadata && taskMetadata.exportName
-                ? `${taskMetadata.exportName}.batchTriggerAndWait()`
-                : `batchTriggerAndWait()`, params.id, items, undefined, options, undefined, customQueue);
+            return await batchTriggerAndWait_internal("batchTriggerAndWait()", params.id, items, undefined, options, undefined, normalizedQueue.queue?.name);
         },
     };
-    taskCatalog.registerTaskMetadata({
+    registerTaskLifecycleHooks(params.id, params);
+    resourceCatalog.registerTaskMetadata({
         id: params.id,
         description: params.description,
-        queue: params.queue,
+        queue: normalizedQueue.queue,
+        concurrency: normalizeTaskConcurrency(params.id, params.concurrency),
         retry: params.retry ? { ...defaultRetryOptions, ...params.retry } : undefined,
         machine: typeof params.machine === "string" ? { preset: params.machine } : params.machine,
+        triggerSource: params.triggerSource,
+        agentConfig: params.agentConfig,
         maxDuration: params.maxDuration,
+        ttl: params.ttl,
+        payloadSchema: params.jsonSchema,
         fns: {
             run: params.run,
-            init: params.init,
-            cleanup: params.cleanup,
-            middleware: params.middleware,
-            handleError: params.handleError,
-            onSuccess: params.onSuccess,
-            onFailure: params.onFailure,
-            onStart: params.onStart,
         },
     });
+    const queue = normalizedQueue.queue;
+    /**
+     * A string queue name (bare or as a tuple's first element) is a REFERENCE to a
+     * queue defined elsewhere; registering it would create an empty definition that
+     * can shadow the real one depending on module evaluation order.
+     */
+    const homeIsReference = typeof params.queue === "string";
+    if (queue && typeof queue.name === "string" && !homeIsReference) {
+        resourceCatalog.registerQueueMetadata({
+            name: queue.name,
+            concurrencyLimit: queue.concurrencyLimit,
+        });
+    }
     // @ts-expect-error
     task[Symbol.for("trigger.dev/task")] = true;
     return task;
 }
+/**
+ * @deprecated Use `schemaTask` plus AI SDK `tool()` with `execute: ai.toolExecute(task)` instead.
+ */
 export function createToolTask(params) {
     const task = createSchemaTask({
         ...params,
@@ -94,41 +184,41 @@ export function createToolTask(params) {
     };
 }
 export function createSchemaTask(params) {
-    const customQueue = params.queue
-        ? queue({
-            name: params.queue?.name ?? `task/${params.id}`,
-            ...params.queue,
-        })
-        : undefined;
     const parsePayload = params.schema
         ? getSchemaParseFn(params.schema)
         : undefined;
+    const normalizedQueue = normalizeTaskQueue(params.queue);
     const task = {
         id: params.id,
         description: params.description,
         schema: params.schema,
         trigger: async (payload, options, requestOptions) => {
-            const taskMetadata = taskCatalog.getTaskManifest(params.id);
-            return await trigger_internal(taskMetadata && taskMetadata.exportName
-                ? `${taskMetadata.exportName}.trigger()`
-                : `trigger()`, params.id, payload, parsePayload, {
-                queue: customQueue,
+            return await trigger_internal("trigger()", params.id, payload, parsePayload, {
+                queue: normalizedQueue.queue?.name,
                 ...options,
             }, requestOptions);
         },
         batchTrigger: async (items, options, requestOptions) => {
-            const taskMetadata = taskCatalog.getTaskManifest(params.id);
-            return await batchTrigger_internal(taskMetadata && taskMetadata.exportName
-                ? `${taskMetadata.exportName}.batchTrigger()`
-                : `batchTrigger()`, params.id, items, options, parsePayload, requestOptions, customQueue);
+            return await batchTrigger_internal("batchTrigger()", params.id, items, options, parsePayload, requestOptions, normalizedQueue.queue?.name);
         },
         triggerAndWait: (payload, options) => {
-            const taskMetadata = taskCatalog.getTaskManifest(params.id);
             return new TaskRunPromise((resolve, reject) => {
-                triggerAndWait_internal(taskMetadata && taskMetadata.exportName
-                    ? `${taskMetadata.exportName}.triggerAndWait()`
-                    : `triggerAndWait()`, params.id, payload, parsePayload, {
-                    queue: customQueue,
+                triggerAndWait_internal("triggerAndWait()", params.id, payload, parsePayload, {
+                    queue: normalizedQueue.queue?.name,
+                    ...options,
+                })
+                    .then((result) => {
+                    resolve(result);
+                })
+                    .catch((error) => {
+                    reject(error);
+                });
+            }, params.id);
+        },
+        triggerAndSubscribe: (payload, options) => {
+            return new TaskRunPromise((resolve, reject) => {
+                triggerAndSubscribe_internal("triggerAndSubscribe()", params.id, payload, parsePayload, {
+                    queue: normalizedQueue.queue?.name,
                     ...options,
                 })
                     .then((result) => {
@@ -140,31 +230,40 @@ export function createSchemaTask(params) {
             }, params.id);
         },
         batchTriggerAndWait: async (items, options) => {
-            const taskMetadata = taskCatalog.getTaskManifest(params.id);
-            return await batchTriggerAndWait_internal(taskMetadata && taskMetadata.exportName
-                ? `${taskMetadata.exportName}.batchTriggerAndWait()`
-                : `batchTriggerAndWait()`, params.id, items, parsePayload, options, undefined, customQueue);
+            return await batchTriggerAndWait_internal("batchTriggerAndWait()", params.id, items, parsePayload, options, undefined, normalizedQueue.queue?.name);
         },
     };
-    taskCatalog.registerTaskMetadata({
+    registerTaskLifecycleHooks(params.id, params);
+    resourceCatalog.registerTaskMetadata({
         id: params.id,
         description: params.description,
-        queue: params.queue,
+        queue: normalizedQueue.queue,
+        concurrency: normalizeTaskConcurrency(params.id, params.concurrency),
         retry: params.retry ? { ...defaultRetryOptions, ...params.retry } : undefined,
         machine: typeof params.machine === "string" ? { preset: params.machine } : params.machine,
+        triggerSource: params.triggerSource,
+        agentConfig: params.agentConfig,
         maxDuration: params.maxDuration,
+        ttl: params.ttl,
         fns: {
             run: params.run,
-            init: params.init,
-            cleanup: params.cleanup,
-            middleware: params.middleware,
-            handleError: params.handleError,
-            onSuccess: params.onSuccess,
-            onFailure: params.onFailure,
-            onStart: params.onStart,
             parsePayload,
         },
+        schema: params.schema,
     });
+    const queue = normalizedQueue.queue;
+    /**
+     * A string queue name (bare or as a tuple's first element) is a REFERENCE to a
+     * queue defined elsewhere; registering it would create an empty definition that
+     * can shadow the real one depending on module evaluation order.
+     */
+    const homeIsReference = typeof params.queue === "string";
+    if (queue && typeof queue.name === "string" && !homeIsReference) {
+        resourceCatalog.registerQueueMetadata({
+            name: queue.name,
+            concurrencyLimit: queue.concurrencyLimit,
+        });
+    }
     // @ts-expect-error
     task[Symbol.for("trigger.dev/task")] = true;
     return task;
@@ -217,6 +316,38 @@ export function triggerAndWait(id, payload, options, requestOptions) {
         });
     }, id);
 }
+/**
+ * Trigger a task and subscribe to its updates via realtime. Unlike `triggerAndWait`,
+ * this does NOT suspend the parent run — the parent stays alive and subscribes to updates.
+ * This enables parallel execution and proper abort signal handling.
+ *
+ * @param id - The id of the task to trigger
+ * @param payload
+ * @param options - Options for the task run, including an optional `signal` to cancel the subscription and child run
+ * @returns TaskRunPromise
+ * @example
+ * ```ts
+ * import { tasks } from "@trigger.dev/sdk/v3";
+ * const result = await tasks.triggerAndSubscribe("my-task", { foo: "bar" });
+ *
+ * if (result.ok) {
+ *   console.log(result.output);
+ * } else {
+ *   console.error(result.error);
+ * }
+ * ```
+ */
+export function triggerAndSubscribe(id, payload, options, requestOptions) {
+    return new TaskRunPromise((resolve, reject) => {
+        triggerAndSubscribe_internal("tasks.triggerAndSubscribe()", id, payload, undefined, options, requestOptions)
+            .then((result) => {
+            resolve(result);
+        })
+            .catch((error) => {
+            reject(error);
+        });
+    }, id);
+}
 /**
  * Batch trigger multiple task runs with the given payloads, and wait for the results. Returns the results of the task runs.
  * @param id - The id of the task to trigger
@@ -244,597 +375,946 @@ export function triggerAndWait(id, payload, options, requestOptions) {
 export async function batchTriggerAndWait(id, items, options, requestOptions) {
     return await batchTriggerAndWait_internal("tasks.batchTriggerAndWait()", id, items, undefined, options, requestOptions);
 }
-/**
- * Trigger a task by its identifier with the given payload and poll until the run is completed.
- *
- * @example
- *
- * ```ts
- * import { tasks, runs } from "@trigger.dev/sdk/v3";
- * import type { myTask } from "./myTasks"; // Import just the type of the task
- *
- * const run = await tasks.triggerAndPoll<typeof myTask>("my-task", { foo: "bar" }); // The id and payload are fully typesafe
- * console.log(run.output) // The output is also fully typed
- * ```
- *
- * @returns {Run} The completed run, either successful or failed.
- */
-export async function triggerAndPoll(id, payload, options, requestOptions) {
-    const handle = await trigger(id, payload, options, requestOptions);
-    return runs.poll(handle, options, requestOptions);
-}
 export async function batchTrigger(id, items, options, requestOptions) {
     return await batchTrigger_internal("tasks.batchTrigger()", id, items, options, undefined, requestOptions);
 }
-/**
- * Triggers multiple runs of different tasks with specified payloads and options.
- *
- * @template TTask - The type of task(s) to be triggered, extends AnyTask
- *
- * @param {Array<BatchByIdItem<InferRunTypes<TTask>>>} items - Array of task items to trigger
- * @param {BatchTriggerOptions} [options] - Optional batch-level trigger options
- * @param {TriggerApiRequestOptions} [requestOptions] - Optional API request configuration
- *
- * @returns {Promise<BatchRunHandleFromTypes<InferRunTypes<TTask>>>} A promise that resolves with the batch run handle
- * containing batch ID, cached status, idempotency info, runs, and public access token
- *
- * @example
- * ```ts
- * import { batch } from "@trigger.dev/sdk/v3";
- * import type { myTask1, myTask2 } from "~/trigger/myTasks";
- *
- * // Trigger multiple tasks with different payloads
- * const result = await batch.trigger<typeof myTask1 | typeof myTask2>([
- *   {
- *     id: "my-task-1",
- *     payload: { some: "data" },
- *     options: {
- *       queue: "default",
- *       concurrencyKey: "key",
- *       idempotencyKey: "unique-key",
- *       delay: "5m",
- *       tags: ["tag1", "tag2"]
- *     }
- *   },
- *   {
- *     id: "my-task-2",
- *     payload: { other: "data" }
- *   }
- * ]);
- * ```
- *
- * @description
- * Each task item in the array can include:
- * - `id`: The unique identifier of the task
- * - `payload`: The data to pass to the task
- * - `options`: Optional task-specific settings including:
- *   - `queue`: Specify a queue for the task
- *   - `concurrencyKey`: Control concurrent execution
- *   - `idempotencyKey`: Prevent duplicate runs
- *   - `idempotencyKeyTTL`: Time-to-live for idempotency key
- *   - `delay`: Delay before task execution
- *   - `ttl`: Time-to-live for the task
- *   - `tags`: Array of tags for the task
- *   - `maxAttempts`: Maximum retry attempts
- *   - `metadata`: Additional metadata
- *   - `maxDuration`: Maximum execution duration
- */
-export async function batchTriggerById(items, options, requestOptions) {
-    const apiClient = apiClientManager.clientOrThrow();
-    const response = await apiClient.batchTriggerV2({
-        items: await Promise.all(items.map(async (item) => {
-            const taskMetadata = taskCatalog.getTask(item.id);
+// Implementation
+export async function batchTriggerById(...args) {
+    const [items, options, requestOptions] = args;
+    const apiClient = apiClientManager.clientOrThrow(requestOptions?.clientConfig);
+    // Check if items is an array or a stream
+    if (Array.isArray(items)) {
+        // Array path: existing logic
+        const ndJsonItems = await Promise.all(items.map(async (item, index) => {
+            const taskMetadata = resourceCatalog.getTask(item.id);
             const parsedPayload = taskMetadata?.fns.parsePayload
                 ? await taskMetadata?.fns.parsePayload(item.payload)
                 : item.payload;
             const payloadPacket = await stringifyIO(parsedPayload);
+            const batchItemIdempotencyKey = await makeIdempotencyKey(flattenIdempotencyKey([options?.idempotencyKey, `${index}`]));
             return {
+                index,
                 task: item.id,
                 payload: payloadPacket.data,
                 options: {
-                    queue: item.options?.queue,
+                    ...triggerQueueBody(item.options?.queue),
+                    ...triggerConcurrencyBody(item.options?.concurrency),
                     concurrencyKey: item.options?.concurrencyKey,
                     test: taskContext.ctx?.run.isTest,
                     payloadType: payloadPacket.dataType,
-                    idempotencyKey: await makeIdempotencyKey(item.options?.idempotencyKey),
-                    idempotencyKeyTTL: item.options?.idempotencyKeyTTL,
                     delay: item.options?.delay,
                     ttl: item.options?.ttl,
                     tags: item.options?.tags,
                     maxAttempts: item.options?.maxAttempts,
-                    parentAttempt: taskContext.ctx?.attempt.id,
                     metadata: item.options?.metadata,
                     maxDuration: item.options?.maxDuration,
+                    idempotencyKey: (await makeIdempotencyKey(item.options?.idempotencyKey)) ?? batchItemIdempotencyKey,
+                    idempotencyKeyTTL: item.options?.idempotencyKeyTTL ?? options?.idempotencyKeyTTL,
                     machine: item.options?.machine,
+                    priority: item.options?.priority,
+                    region: item.options?.region,
+                    lockToVersion: item.options?.version ?? scopedEnvVar("TRIGGER_VERSION"),
+                    externalDeploymentId: resolveTriggerExternalDeploymentId(item.options?.externalDeploymentId),
+                    debounce: item.options?.debounce,
                 },
             };
-        })),
-    }, {
-        spanParentAsLink: true,
-        idempotencyKey: await makeIdempotencyKey(options?.idempotencyKey),
-        idempotencyKeyTTL: options?.idempotencyKeyTTL,
-        processingStrategy: options?.triggerSequentially ? "sequential" : undefined,
-    }, {
-        name: "batch.trigger()",
-        tracer,
-        icon: "trigger",
-        onResponseBody(body, span) {
-            if (body && typeof body === "object" && !Array.isArray(body)) {
-                if ("id" in body && typeof body.id === "string") {
-                    span.setAttribute("batchId", body.id);
-                }
-                if ("runs" in body && Array.isArray(body.runs)) {
-                    span.setAttribute("runCount", body.runs.length);
-                }
-                if ("isCached" in body && typeof body.isCached === "boolean") {
-                    if (body.isCached) {
-                        console.warn(`Result is a cached response because the request was idempotent.`);
-                    }
-                    span.setAttribute("isCached", body.isCached);
-                }
-                if ("idempotencyKey" in body && typeof body.idempotencyKey === "string") {
-                    span.setAttribute("idempotencyKey", body.idempotencyKey);
-                }
-            }
-        },
-        ...requestOptions,
-    });
-    const handle = {
-        batchId: response.id,
-        isCached: response.isCached,
-        idempotencyKey: response.idempotencyKey,
-        runs: response.runs,
-        publicAccessToken: response.publicAccessToken,
-    };
-    return handle;
+        }));
+        // Execute 2-phase batch
+        const response = await tracer.startActiveSpan("batch.trigger()", async (span) => {
+            const result = await executeBatchTwoPhase(apiClient, ndJsonItems, {
+                parentRunId: taskContext.ctx?.run.id,
+                idempotencyKey: await makeIdempotencyKey(options?.idempotencyKey),
+                spanParentAsLink: true, // Fire-and-forget: child runs get separate trace IDs
+            }, requestOptions);
+            span.setAttribute("batchId", result.id);
+            span.setAttribute("runCount", result.runCount);
+            return result;
+        }, {
+            kind: SpanKind.PRODUCER,
+            attributes: {
+                [SemanticInternalAttributes.STYLE_ICON]: "trigger",
+            },
+        });
+        const handle = {
+            batchId: response.id,
+            runCount: response.runCount,
+            publicAccessToken: response.publicAccessToken,
+        };
+        return handle;
+    }
+    else {
+        // Stream path: convert to AsyncIterable and transform
+        const asyncItems = normalizeToAsyncIterable(items);
+        const transformedItems = transformBatchItemsStream(asyncItems, options);
+        // Execute streaming 2-phase batch
+        const response = await tracer.startActiveSpan("batch.trigger()", async (span) => {
+            const result = await executeBatchTwoPhaseStreaming(apiClient, transformedItems, {
+                parentRunId: taskContext.ctx?.run.id,
+                idempotencyKey: await makeIdempotencyKey(options?.idempotencyKey),
+                spanParentAsLink: true, // Fire-and-forget: child runs get separate trace IDs
+            }, requestOptions);
+            span.setAttribute("batchId", result.id);
+            span.setAttribute("runCount", result.runCount);
+            return result;
+        }, {
+            kind: SpanKind.PRODUCER,
+            attributes: {
+                [SemanticInternalAttributes.STYLE_ICON]: "trigger",
+            },
+        });
+        const handle = {
+            batchId: response.id,
+            runCount: response.runCount,
+            publicAccessToken: response.publicAccessToken,
+        };
+        return handle;
+    }
 }
-/**
- * Triggers multiple tasks and waits for all of them to complete before returning their results.
- * This function must be called from within a task.run() context.
- *
- * @template TTask - Union type of tasks to be triggered, extends AnyTask
- *
- * @param {Array<BatchByIdAndWaitItem<InferRunTypes<TTask>>>} items - Array of task items to trigger
- * @param {TriggerApiRequestOptions} [requestOptions] - Optional API request configuration
- *
- * @returns {Promise<BatchByIdResult<TTask>>} A promise that resolves with the batch results, including
- * success/failure status and strongly-typed outputs for each task
- *
- * @throws {Error} If called outside of a task.run() context
- * @throws {Error} If no API client is configured
- *
- * @example
- * ```ts
- * import { batch, task } from "@trigger.dev/sdk/v3";
- *
- * export const parentTask = task({
- *   id: "parent-task",
- *   run: async (payload: string) => {
- *     const results = await batch.triggerAndWait<typeof childTask1 | typeof childTask2>([
- *       {
- *         id: "child-task-1",
- *         payload: { foo: "World" },
- *         options: {
- *           queue: "default",
- *           delay: "5m",
- *           tags: ["batch", "child1"]
- *         }
- *       },
- *       {
- *         id: "child-task-2",
- *         payload: { bar: 42 }
- *       }
- *     ]);
- *
- *     // Type-safe result handling
- *     for (const result of results) {
- *       if (result.ok) {
- *         switch (result.taskIdentifier) {
- *           case "child-task-1":
- *             console.log("Child task 1 output:", result.output); // string type
- *             break;
- *           case "child-task-2":
- *             console.log("Child task 2 output:", result.output); // number type
- *             break;
- *         }
- *       } else {
- *         console.error("Task failed:", result.error);
- *       }
- *     }
- *   }
- * });
- * ```
- *
- * @description
- * Each task item in the array can include:
- * - `id`: The task identifier (must match one of the tasks in the union type)
- * - `payload`: Strongly-typed payload matching the task's input type
- * - `options`: Optional task-specific settings including:
- *   - `queue`: Specify a queue for the task
- *   - `concurrencyKey`: Control concurrent execution
- *   - `delay`: Delay before task execution
- *   - `ttl`: Time-to-live for the task
- *   - `tags`: Array of tags for the task
- *   - `maxAttempts`: Maximum retry attempts
- *   - `metadata`: Additional metadata
- *   - `maxDuration`: Maximum execution duration
- *
- * The function provides full type safety for:
- * - Task IDs
- * - Payload types
- * - Return value types
- * - Error handling
- */
-export async function batchTriggerByIdAndWait(items, options, requestOptions) {
+// Implementation
+export async function batchTriggerByIdAndWait(...args) {
+    const [items, options, requestOptions] = args;
     const ctx = taskContext.ctx;
     if (!ctx) {
         throw new Error("batchTriggerAndWait can only be used from inside a task.run()");
     }
-    const apiClient = apiClientManager.clientOrThrow();
-    return await tracer.startActiveSpan("batch.triggerAndWait()", async (span) => {
-        const response = await apiClient.batchTriggerV2({
-            items: await Promise.all(items.map(async (item) => {
-                const taskMetadata = taskCatalog.getTask(item.id);
-                const parsedPayload = taskMetadata?.fns.parsePayload
-                    ? await taskMetadata?.fns.parsePayload(item.payload)
-                    : item.payload;
-                const payloadPacket = await stringifyIO(parsedPayload);
-                return {
-                    task: item.id,
-                    payload: payloadPacket.data,
-                    options: {
-                        lockToVersion: taskContext.worker?.version,
-                        queue: item.options?.queue,
-                        concurrencyKey: item.options?.concurrencyKey,
-                        test: taskContext.ctx?.run.isTest,
-                        payloadType: payloadPacket.dataType,
-                        delay: item.options?.delay,
-                        ttl: item.options?.ttl,
-                        tags: item.options?.tags,
-                        maxAttempts: item.options?.maxAttempts,
-                        metadata: item.options?.metadata,
-                        maxDuration: item.options?.maxDuration,
-                        machine: item.options?.machine,
-                    },
-                };
-            })),
-            dependentAttempt: ctx.attempt.id,
+    const apiClient = apiClientManager.clientOrThrow(requestOptions?.clientConfig);
+    // Check if items is an array or a stream
+    if (Array.isArray(items)) {
+        // Array path: existing logic
+        const ndJsonItems = await Promise.all(items.map(async (item, index) => {
+            const taskMetadata = resourceCatalog.getTask(item.id);
+            const parsedPayload = taskMetadata?.fns.parsePayload
+                ? await taskMetadata?.fns.parsePayload(item.payload)
+                : item.payload;
+            const payloadPacket = await stringifyIO(parsedPayload);
+            const batchItemIdempotencyKey = await makeIdempotencyKey(flattenIdempotencyKey([options?.idempotencyKey, `${index}`]));
+            return {
+                index,
+                task: item.id,
+                payload: payloadPacket.data,
+                options: {
+                    lockToVersion: taskContext.worker?.version,
+                    ...triggerQueueBody(item.options?.queue),
+                    ...triggerConcurrencyBody(item.options?.concurrency),
+                    concurrencyKey: item.options?.concurrencyKey,
+                    test: taskContext.ctx?.run.isTest,
+                    payloadType: payloadPacket.dataType,
+                    delay: item.options?.delay,
+                    ttl: item.options?.ttl,
+                    tags: item.options?.tags,
+                    maxAttempts: item.options?.maxAttempts,
+                    metadata: item.options?.metadata,
+                    maxDuration: item.options?.maxDuration,
+                    idempotencyKey: (await makeIdempotencyKey(item.options?.idempotencyKey)) ?? batchItemIdempotencyKey,
+                    idempotencyKeyTTL: item.options?.idempotencyKeyTTL ?? options?.idempotencyKeyTTL,
+                    machine: item.options?.machine,
+                    priority: item.options?.priority,
+                    region: item.options?.region,
+                    debounce: item.options?.debounce,
+                },
+            };
+        }));
+        return await tracer.startActiveSpan("batch.triggerAndWait()", async (span) => {
+            // Execute 2-phase batch
+            const response = await executeBatchTwoPhase(apiClient, ndJsonItems, {
+                parentRunId: ctx.run.id,
+                resumeParentOnCompletion: true,
+                idempotencyKey: await makeIdempotencyKey(options?.idempotencyKey),
+                spanParentAsLink: false, // Waiting: child runs share parent's trace ID
+            }, requestOptions);
+            span.setAttribute("batchId", response.id);
+            span.setAttribute("runCount", response.runCount);
+            const result = await runtime.waitForBatch({
+                id: response.id,
+                runCount: response.runCount,
+                ctx,
+            });
+            const runs = await handleBatchTaskRunExecutionResultV2(result.items, response.taskIdentifiers);
+            return {
+                id: result.id,
+                runs,
+            };
         }, {
-            processingStrategy: options?.triggerSequentially ? "sequential" : undefined,
-        }, requestOptions);
-        span.setAttribute("batchId", response.id);
-        span.setAttribute("runCount", response.runs.length);
-        span.setAttribute("isCached", response.isCached);
-        if (response.isCached) {
-            console.warn(`Result is a cached response because the request was idempotent.`);
-        }
-        if (response.idempotencyKey) {
-            span.setAttribute("idempotencyKey", response.idempotencyKey);
-        }
-        const result = await runtime.waitForBatch({
-            id: response.id,
-            runs: response.runs.map((run) => run.id),
-            ctx,
+            kind: SpanKind.PRODUCER,
+            attributes: {
+                [SemanticInternalAttributes.STYLE_ICON]: "trigger",
+            },
         });
-        const runs = await handleBatchTaskRunExecutionResultV2(result.items);
-        return {
-            id: result.id,
-            runs,
-        };
-    }, {
-        kind: SpanKind.PRODUCER,
-        attributes: {
-            [SemanticInternalAttributes.STYLE_ICON]: "trigger",
-        },
-    });
+    }
+    else {
+        // Stream path: convert to AsyncIterable and transform
+        const asyncItems = normalizeToAsyncIterable(items);
+        const transformedItems = transformBatchItemsStreamForWait(asyncItems, options);
+        return await tracer.startActiveSpan("batch.triggerAndWait()", async (span) => {
+            // Execute streaming 2-phase batch
+            const response = await executeBatchTwoPhaseStreaming(apiClient, transformedItems, {
+                parentRunId: ctx.run.id,
+                resumeParentOnCompletion: true,
+                idempotencyKey: await makeIdempotencyKey(options?.idempotencyKey),
+                spanParentAsLink: false, // Waiting: child runs share parent's trace ID
+            }, requestOptions);
+            span.setAttribute("batchId", response.id);
+            span.setAttribute("runCount", response.runCount);
+            const result = await runtime.waitForBatch({
+                id: response.id,
+                runCount: response.runCount,
+                ctx,
+            });
+            const runs = await handleBatchTaskRunExecutionResultV2(result.items, response.taskIdentifiers);
+            return {
+                id: result.id,
+                runs,
+            };
+        }, {
+            kind: SpanKind.PRODUCER,
+            attributes: {
+                [SemanticInternalAttributes.STYLE_ICON]: "trigger",
+            },
+        });
+    }
 }
-/**
- * Triggers multiple tasks and waits for all of them to complete before returning their results.
- * This function must be called from within a task.run() context.
- *
- * @template TTask - Union type of tasks to be triggered, extends AnyTask
- *
- * @param {Array<BatchByIdAndWaitItem<InferRunTypes<TTask>>>} items - Array of task items to trigger
- * @param {TriggerApiRequestOptions} [requestOptions] - Optional API request configuration
- *
- * @returns {Promise<BatchByIdResult<TTask>>} A promise that resolves with the batch results, including
- * success/failure status and strongly-typed outputs for each task
- *
- * @throws {Error} If called outside of a task.run() context
- * @throws {Error} If no API client is configured
- *
- * @example
- * ```ts
- * import { batch, task } from "@trigger.dev/sdk/v3";
- *
- * export const parentTask = task({
- *   id: "parent-task",
- *   run: async (payload: string) => {
- *     const results = await batch.triggerAndWait<typeof childTask1 | typeof childTask2>([
- *       {
- *         id: "child-task-1",
- *         payload: { foo: "World" },
- *         options: {
- *           queue: "default",
- *           delay: "5m",
- *           tags: ["batch", "child1"]
- *         }
- *       },
- *       {
- *         id: "child-task-2",
- *         payload: { bar: 42 }
- *       }
- *     ]);
- *
- *     // Type-safe result handling
- *     for (const result of results) {
- *       if (result.ok) {
- *         switch (result.taskIdentifier) {
- *           case "child-task-1":
- *             console.log("Child task 1 output:", result.output); // string type
- *             break;
- *           case "child-task-2":
- *             console.log("Child task 2 output:", result.output); // number type
- *             break;
- *         }
- *       } else {
- *         console.error("Task failed:", result.error);
- *       }
- *     }
- *   }
- * });
- * ```
- *
- * @description
- * Each task item in the array can include:
- * - `id`: The task identifier (must match one of the tasks in the union type)
- * - `payload`: Strongly-typed payload matching the task's input type
- * - `options`: Optional task-specific settings including:
- *   - `queue`: Specify a queue for the task
- *   - `concurrencyKey`: Control concurrent execution
- *   - `delay`: Delay before task execution
- *   - `ttl`: Time-to-live for the task
- *   - `tags`: Array of tags for the task
- *   - `maxAttempts`: Maximum retry attempts
- *   - `metadata`: Additional metadata
- *   - `maxDuration`: Maximum execution duration
- *
- * The function provides full type safety for:
- * - Task IDs
- * - Payload types
- * - Return value types
- * - Error handling
- */
-export async function batchTriggerTasks(items, options, requestOptions) {
-    const apiClient = apiClientManager.clientOrThrow();
-    const response = await apiClient.batchTriggerV2({
-        items: await Promise.all(items.map(async (item) => {
-            const taskMetadata = taskCatalog.getTask(item.task.id);
+// Implementation
+export async function batchTriggerTasks(...args) {
+    const [items, options, requestOptions] = args;
+    const apiClient = apiClientManager.clientOrThrow(requestOptions?.clientConfig);
+    // Check if items is an array or a stream
+    if (Array.isArray(items)) {
+        // Array path: existing logic
+        const ndJsonItems = await Promise.all(items.map(async (item, index) => {
+            const taskMetadata = resourceCatalog.getTask(item.task.id);
             const parsedPayload = taskMetadata?.fns.parsePayload
                 ? await taskMetadata?.fns.parsePayload(item.payload)
                 : item.payload;
             const payloadPacket = await stringifyIO(parsedPayload);
+            const batchItemIdempotencyKey = await makeIdempotencyKey(flattenIdempotencyKey([options?.idempotencyKey, `${index}`]));
             return {
+                index,
                 task: item.task.id,
                 payload: payloadPacket.data,
                 options: {
-                    queue: item.options?.queue,
+                    ...triggerQueueBody(item.options?.queue),
+                    ...triggerConcurrencyBody(item.options?.concurrency),
                     concurrencyKey: item.options?.concurrencyKey,
                     test: taskContext.ctx?.run.isTest,
                     payloadType: payloadPacket.dataType,
-                    idempotencyKey: await makeIdempotencyKey(item.options?.idempotencyKey),
-                    idempotencyKeyTTL: item.options?.idempotencyKeyTTL,
                     delay: item.options?.delay,
                     ttl: item.options?.ttl,
                     tags: item.options?.tags,
                     maxAttempts: item.options?.maxAttempts,
-                    parentAttempt: taskContext.ctx?.attempt.id,
                     metadata: item.options?.metadata,
                     maxDuration: item.options?.maxDuration,
+                    idempotencyKey: (await makeIdempotencyKey(item.options?.idempotencyKey)) ?? batchItemIdempotencyKey,
+                    idempotencyKeyTTL: item.options?.idempotencyKeyTTL ?? options?.idempotencyKeyTTL,
                     machine: item.options?.machine,
+                    priority: item.options?.priority,
+                    region: item.options?.region,
+                    lockToVersion: item.options?.version ?? scopedEnvVar("TRIGGER_VERSION"),
+                    externalDeploymentId: resolveTriggerExternalDeploymentId(item.options?.externalDeploymentId),
+                    debounce: item.options?.debounce,
                 },
             };
-        })),
-    }, {
-        spanParentAsLink: true,
-        idempotencyKey: await makeIdempotencyKey(options?.idempotencyKey),
-        idempotencyKeyTTL: options?.idempotencyKeyTTL,
-        processingStrategy: options?.triggerSequentially ? "sequential" : undefined,
-    }, {
-        name: "batch.triggerByTask()",
-        tracer,
-        icon: "trigger",
-        onResponseBody(body, span) {
-            if (body && typeof body === "object" && !Array.isArray(body)) {
-                if ("id" in body && typeof body.id === "string") {
-                    span.setAttribute("batchId", body.id);
-                }
-                if ("runs" in body && Array.isArray(body.runs)) {
-                    span.setAttribute("runCount", body.runs.length);
-                }
-                if ("isCached" in body && typeof body.isCached === "boolean") {
-                    if (body.isCached) {
-                        console.warn(`Result is a cached response because the request was idempotent.`);
-                    }
-                    span.setAttribute("isCached", body.isCached);
-                }
-                if ("idempotencyKey" in body && typeof body.idempotencyKey === "string") {
-                    span.setAttribute("idempotencyKey", body.idempotencyKey);
-                }
-            }
-        },
-        ...requestOptions,
-    });
-    const handle = {
-        batchId: response.id,
-        isCached: response.isCached,
-        idempotencyKey: response.idempotencyKey,
-        runs: response.runs,
-        publicAccessToken: response.publicAccessToken,
-    };
-    return handle;
+        }));
+        // Execute 2-phase batch
+        const response = await tracer.startActiveSpan("batch.triggerByTask()", async (span) => {
+            const result = await executeBatchTwoPhase(apiClient, ndJsonItems, {
+                parentRunId: taskContext.ctx?.run.id,
+                idempotencyKey: await makeIdempotencyKey(options?.idempotencyKey),
+                spanParentAsLink: true, // Fire-and-forget: child runs get separate trace IDs
+            }, requestOptions);
+            span.setAttribute("batchId", result.id);
+            span.setAttribute("runCount", result.runCount);
+            return result;
+        }, {
+            kind: SpanKind.PRODUCER,
+            attributes: {
+                [SemanticInternalAttributes.STYLE_ICON]: "trigger",
+            },
+        });
+        const handle = {
+            batchId: response.id,
+            runCount: response.runCount,
+            publicAccessToken: response.publicAccessToken,
+        };
+        return handle;
+    }
+    else {
+        // Stream path: convert to AsyncIterable and transform
+        const streamItems = items;
+        const asyncItems = normalizeToAsyncIterable(streamItems);
+        const transformedItems = transformBatchByTaskItemsStream(asyncItems, options);
+        // Execute streaming 2-phase batch
+        const response = await tracer.startActiveSpan("batch.triggerByTask()", async (span) => {
+            const result = await executeBatchTwoPhaseStreaming(apiClient, transformedItems, {
+                parentRunId: taskContext.ctx?.run.id,
+                idempotencyKey: await makeIdempotencyKey(options?.idempotencyKey),
+                spanParentAsLink: true, // Fire-and-forget: child runs get separate trace IDs
+            }, requestOptions);
+            span.setAttribute("batchId", result.id);
+            span.setAttribute("runCount", result.runCount);
+            return result;
+        }, {
+            kind: SpanKind.PRODUCER,
+            attributes: {
+                [SemanticInternalAttributes.STYLE_ICON]: "trigger",
+            },
+        });
+        const handle = {
+            batchId: response.id,
+            runCount: response.runCount,
+            publicAccessToken: response.publicAccessToken,
+        };
+        return handle;
+    }
 }
-/**
- * Triggers multiple tasks and waits for all of them to complete before returning their results.
- * This function must be called from within a task.run() context.
- *
- * @template TTask - Union type of tasks to be triggered, extends AnyTask
- *
- * @param {Array<BatchByIdAndWaitItem<InferRunTypes<TTask>>>} items - Array of task items to trigger
- * @param {TriggerApiRequestOptions} [requestOptions] - Optional API request configuration
- *
- * @returns {Promise<BatchByIdResult<TTask>>} A promise that resolves with the batch results, including
- * success/failure status and strongly-typed outputs for each task
- *
- * @throws {Error} If called outside of a task.run() context
- * @throws {Error} If no API client is configured
- *
- * @example
- * ```ts
- * import { batch, task } from "@trigger.dev/sdk/v3";
+// Implementation
+export async function batchTriggerAndWaitTasks(...args) {
+    const [items, options, requestOptions] = args;
+    const ctx = taskContext.ctx;
+    if (!ctx) {
+        throw new Error("batchTriggerAndWait can only be used from inside a task.run()");
+    }
+    const apiClient = apiClientManager.clientOrThrow(requestOptions?.clientConfig);
+    // Check if items is an array or a stream
+    if (Array.isArray(items)) {
+        // Array path: existing logic
+        const ndJsonItems = await Promise.all(items.map(async (item, index) => {
+            const taskMetadata = resourceCatalog.getTask(item.task.id);
+            const parsedPayload = taskMetadata?.fns.parsePayload
+                ? await taskMetadata?.fns.parsePayload(item.payload)
+                : item.payload;
+            const payloadPacket = await stringifyIO(parsedPayload);
+            const batchItemIdempotencyKey = await makeIdempotencyKey(flattenIdempotencyKey([options?.idempotencyKey, `${index}`]));
+            return {
+                index,
+                task: item.task.id,
+                payload: payloadPacket.data,
+                options: {
+                    lockToVersion: taskContext.worker?.version,
+                    ...triggerQueueBody(item.options?.queue),
+                    ...triggerConcurrencyBody(item.options?.concurrency),
+                    concurrencyKey: item.options?.concurrencyKey,
+                    test: taskContext.ctx?.run.isTest,
+                    payloadType: payloadPacket.dataType,
+                    delay: item.options?.delay,
+                    ttl: item.options?.ttl,
+                    tags: item.options?.tags,
+                    maxAttempts: item.options?.maxAttempts,
+                    metadata: item.options?.metadata,
+                    maxDuration: item.options?.maxDuration,
+                    idempotencyKey: (await makeIdempotencyKey(item.options?.idempotencyKey)) ?? batchItemIdempotencyKey,
+                    idempotencyKeyTTL: item.options?.idempotencyKeyTTL ?? options?.idempotencyKeyTTL,
+                    machine: item.options?.machine,
+                    priority: item.options?.priority,
+                    region: item.options?.region,
+                    debounce: item.options?.debounce,
+                },
+            };
+        }));
+        return await tracer.startActiveSpan("batch.triggerByTaskAndWait()", async (span) => {
+            // Execute 2-phase batch
+            const response = await executeBatchTwoPhase(apiClient, ndJsonItems, {
+                parentRunId: ctx.run.id,
+                resumeParentOnCompletion: true,
+                idempotencyKey: await makeIdempotencyKey(options?.idempotencyKey),
+                spanParentAsLink: false, // Waiting: child runs share parent's trace ID
+            }, requestOptions);
+            span.setAttribute("batchId", response.id);
+            span.setAttribute("runCount", response.runCount);
+            const result = await runtime.waitForBatch({
+                id: response.id,
+                runCount: response.runCount,
+                ctx,
+            });
+            const runs = await handleBatchTaskRunExecutionResultV2(result.items, response.taskIdentifiers);
+            return {
+                id: result.id,
+                runs,
+            };
+        }, {
+            kind: SpanKind.PRODUCER,
+            attributes: {
+                [SemanticInternalAttributes.STYLE_ICON]: "trigger",
+            },
+        });
+    }
+    else {
+        // Stream path: convert to AsyncIterable and transform
+        const streamItems = items;
+        const asyncItems = normalizeToAsyncIterable(streamItems);
+        const transformedItems = transformBatchByTaskItemsStreamForWait(asyncItems, options);
+        return await tracer.startActiveSpan("batch.triggerByTaskAndWait()", async (span) => {
+            // Execute streaming 2-phase batch
+            const response = await executeBatchTwoPhaseStreaming(apiClient, transformedItems, {
+                parentRunId: ctx.run.id,
+                resumeParentOnCompletion: true,
+                idempotencyKey: await makeIdempotencyKey(options?.idempotencyKey),
+                spanParentAsLink: false, // Waiting: child runs share parent's trace ID
+            }, requestOptions);
+            span.setAttribute("batchId", response.id);
+            span.setAttribute("runCount", response.runCount);
+            const result = await runtime.waitForBatch({
+                id: response.id,
+                runCount: response.runCount,
+                ctx,
+            });
+            const runs = await handleBatchTaskRunExecutionResultV2(result.items, response.taskIdentifiers);
+            return {
+                id: result.id,
+                runs,
+            };
+        }, {
+            kind: SpanKind.PRODUCER,
+            attributes: {
+                [SemanticInternalAttributes.STYLE_ICON]: "trigger",
+            },
+        });
+    }
+}
+export function uniqueBatchTaskIdentifiers(items) {
+    return Array.from(new Set(items.map((item) => item.task))).sort();
+}
+/**
+ * Helper function that executes a 2-phase batch trigger:
+ * 1. Creates the batch record with expected run count
+ * 2. Streams items as NDJSON to the server
  *
- * export const parentTask = task({
- *   id: "parent-task",
- *   run: async (payload: string) => {
- *     const results = await batch.triggerAndWait<typeof childTask1 | typeof childTask2>([
- *       {
- *         id: "child-task-1",
- *         payload: { foo: "World" },
- *         options: {
- *           queue: "default",
- *           delay: "5m",
- *           tags: ["batch", "child1"]
- *         }
- *       },
- *       {
- *         id: "child-task-2",
- *         payload: { bar: 42 }
- *       }
- *     ]);
+ * @param apiClient - The API client instance
+ * @param items - Array of batch items
+ * @param options - Batch options including trace context settings
+ * @param options.spanParentAsLink - If true, child runs will have separate trace IDs with a link to parent.
+ *                                   Use true for batchTrigger (fire-and-forget), false for batchTriggerAndWait.
+ * @param requestOptions - Optional request options
+ * @internal
+ */
+async function executeBatchTwoPhase(apiClient, items, options, requestOptions) {
+    // Offload any oversized per-item payloads to object storage before streaming, so a batch
+    // of large items keeps the request body small — the same treatment single triggers get.
+    // Both the array and streaming batch paths funnel through here, so this is the one place
+    // batch offloading needs to happen. Wrap failures so a presign/upload error carries the
+    // same batch context (phase, itemCount, rate-limit info) as the create/stream phases.
+    try {
+        items = await offloadBatchItemPayloads(items, apiClient);
+    }
+    catch (error) {
+        throw new BatchTriggerError(`Failed to offload payloads for batch with ${items.length} items`, {
+            cause: error,
+            phase: "offload",
+            itemCount: items.length,
+        });
+    }
+    let batch;
+    try {
+        // Phase 1: Create batch
+        batch = await apiClient.createBatch({
+            runCount: items.length,
+            taskIdentifiers: uniqueBatchTaskIdentifiers(items),
+            parentRunId: options.parentRunId,
+            resumeParentOnCompletion: options.resumeParentOnCompletion,
+            idempotencyKey: options.idempotencyKey,
+            idempotencyKeyOptions: options.idempotencyKeyOptions,
+        }, { spanParentAsLink: options.spanParentAsLink }, requestOptions);
+    }
+    catch (error) {
+        // Wrap with context about which phase failed
+        throw new BatchTriggerError(`Failed to create batch with ${items.length} items`, {
+            cause: error,
+            phase: "create",
+            itemCount: items.length,
+        });
+    }
+    // If the batch was cached (idempotent replay), skip streaming items
+    if (!batch.isCached) {
+        try {
+            // Phase 2: Stream items
+            await apiClient.streamBatchItems(batch.id, items, requestOptions);
+        }
+        catch (error) {
+            // Wrap with context about which phase failed and include batch ID
+            throw new BatchTriggerError(`Failed to stream items for batch ${batch.id} (${items.length} items)`, { cause: error, phase: "stream", batchId: batch.id, itemCount: items.length });
+        }
+    }
+    return {
+        id: batch.id,
+        runCount: batch.runCount,
+        publicAccessToken: batch.publicAccessToken,
+        taskIdentifiers: items.map((item) => item.task),
+    };
+}
+/**
+ * Offload any oversized per-item payloads in a batch to object storage, mirroring the
+ * single-trigger offload path. Small payloads pass through untouched. Every returned item
+ * carries `options.payloadSize` (the pre-offload serialized byte size) so the pipeline can
+ * reason about payload size without downloading an "application/store" reference.
  *
- *     // Type-safe result handling
- *     for (const result of results) {
- *       if (result.ok) {
- *         switch (result.taskIdentifier) {
- *           case "child-task-1":
- *             console.log("Child task 1 output:", result.output); // string type
- *             break;
- *           case "child-task-2":
- *             console.log("Child task 2 output:", result.output); // number type
- *             break;
- *         }
- *       } else {
- *         console.error("Task failed:", result.error);
- *       }
- *     }
- *   }
- * });
- * ```
+ * Uploads run with bounded concurrency so a batch of large items doesn't fire an unbounded
+ * number of simultaneous presigned PUTs.
  *
- * @description
- * Each task item in the array can include:
- * - `id`: The task identifier (must match one of the tasks in the union type)
- * - `payload`: Strongly-typed payload matching the task's input type
- * - `options`: Optional task-specific settings including:
- *   - `queue`: Specify a queue for the task
- *   - `concurrencyKey`: Control concurrent execution
- *   - `delay`: Delay before task execution
- *   - `ttl`: Time-to-live for the task
- *   - `tags`: Array of tags for the task
- *   - `maxAttempts`: Maximum retry attempts
- *   - `metadata`: Additional metadata
- *   - `maxDuration`: Maximum execution duration
+ * @internal Exported for testing.
+ */
+export async function offloadBatchItemPayloads(items, apiClient, concurrency = 10) {
+    if (items.length === 0) {
+        return items;
+    }
+    const results = new Array(items.length);
+    let cursor = 0;
+    async function worker() {
+        while (cursor < items.length) {
+            const index = cursor++;
+            results[index] = await offloadBatchItemPayload(items[index], apiClient);
+        }
+    }
+    await Promise.all(Array.from({ length: Math.min(concurrency, items.length) }, () => worker()));
+    return results;
+}
+async function offloadBatchItemPayload(item, apiClient) {
+    // The batch builders serialize each payload to a string via stringifyIO before we get
+    // here; anything else has no inline body to offload or measure.
+    if (typeof item.payload !== "string" || item.payload.length === 0) {
+        return item;
+    }
+    const dataType = item.options?.payloadType ?? "application/json";
+    // Already an object-store reference — the caller pre-offloaded it, nothing to do.
+    if (dataType === "application/store") {
+        return item;
+    }
+    const packet = { data: item.payload, dataType };
+    // Measure before offload so the size reflects the real payload, not the small reference
+    // we may replace it with.
+    const { size: payloadSize } = packetRequiresOffloading(packet);
+    const exported = await conditionallyExportPacket(packet, createTriggerPayloadPathPrefix(), undefined, apiClient);
+    return {
+        ...item,
+        payload: exported.data,
+        options: {
+            ...item.options,
+            payloadType: exported.dataType,
+            payloadSize,
+        },
+    };
+}
+/**
+ * Error thrown when batch trigger operations fail.
+ * Includes context about which phase failed and the batch details.
  *
- * The function provides full type safety for:
- * - Task IDs
- * - Payload types
- * - Return value types
- * - Error handling
+ * When the underlying error is a rate limit (429), additional properties are exposed:
+ * - `isRateLimited`: true
+ * - `retryAfterMs`: milliseconds until the rate limit resets
  */
-export async function batchTriggerAndWaitTasks(items, options, requestOptions) {
-    const ctx = taskContext.ctx;
-    if (!ctx) {
-        throw new Error("batchTriggerAndWait can only be used from inside a task.run()");
+export class BatchTriggerError extends Error {
+    phase;
+    batchId;
+    itemCount;
+    /** True if the error was caused by rate limiting (HTTP 429) */
+    isRateLimited;
+    /** Milliseconds until the rate limit resets. Only set when `isRateLimited` is true. */
+    retryAfterMs;
+    /** The underlying API error, if the cause was an ApiError */
+    apiError;
+    /** The underlying cause of the error */
+    cause;
+    constructor(message, options) {
+        // Build enhanced message that includes the cause's message
+        const fullMessage = buildBatchErrorMessage(message, options.cause);
+        super(fullMessage, { cause: options.cause });
+        this.name = "BatchTriggerError";
+        this.cause = options.cause;
+        this.phase = options.phase;
+        this.batchId = options.batchId;
+        this.itemCount = options.itemCount;
+        // Extract rate limit info from cause
+        if (options.cause instanceof RateLimitError) {
+            this.isRateLimited = true;
+            this.retryAfterMs = options.cause.millisecondsUntilReset;
+            this.apiError = options.cause;
+        }
+        else if (options.cause instanceof ApiError) {
+            this.isRateLimited = options.cause.status === 429;
+            this.apiError = options.cause;
+        }
+        else {
+            this.isRateLimited = false;
+        }
     }
-    const apiClient = apiClientManager.clientOrThrow();
-    return await tracer.startActiveSpan("batch.triggerByTaskAndWait()", async (span) => {
-        const response = await apiClient.batchTriggerV2({
-            items: await Promise.all(items.map(async (item) => {
-                const taskMetadata = taskCatalog.getTask(item.task.id);
-                const parsedPayload = taskMetadata?.fns.parsePayload
-                    ? await taskMetadata?.fns.parsePayload(item.payload)
-                    : item.payload;
-                const payloadPacket = await stringifyIO(parsedPayload);
-                return {
-                    task: item.task.id,
-                    payload: payloadPacket.data,
-                    options: {
-                        lockToVersion: taskContext.worker?.version,
-                        queue: item.options?.queue,
-                        concurrencyKey: item.options?.concurrencyKey,
-                        test: taskContext.ctx?.run.isTest,
-                        payloadType: payloadPacket.dataType,
-                        delay: item.options?.delay,
-                        ttl: item.options?.ttl,
-                        tags: item.options?.tags,
-                        maxAttempts: item.options?.maxAttempts,
-                        metadata: item.options?.metadata,
-                        maxDuration: item.options?.maxDuration,
-                        machine: item.options?.machine,
-                    },
-                };
-            })),
-            dependentAttempt: ctx.attempt.id,
-        }, {
-            processingStrategy: options?.triggerSequentially ? "sequential" : undefined,
-        }, requestOptions);
-        span.setAttribute("batchId", response.id);
-        span.setAttribute("runCount", response.runs.length);
-        span.setAttribute("isCached", response.isCached);
-        if (response.isCached) {
-            console.warn(`Result is a cached response because the request was idempotent.`);
+}
+/**
+ * Build an enhanced error message that includes context from the cause.
+ */
+function buildBatchErrorMessage(baseMessage, cause) {
+    if (!cause) {
+        return baseMessage;
+    }
+    // Handle RateLimitError specifically for better messaging
+    if (cause instanceof RateLimitError) {
+        const retryMs = cause.millisecondsUntilReset;
+        if (retryMs !== undefined) {
+            const retrySeconds = Math.ceil(retryMs / 1000);
+            return `${baseMessage}: Rate limit exceeded - retry after ${retrySeconds}s`;
         }
-        if (response.idempotencyKey) {
-            span.setAttribute("idempotencyKey", response.idempotencyKey);
+        return `${baseMessage}: Rate limit exceeded`;
+    }
+    // Handle other ApiErrors
+    if (cause instanceof ApiError) {
+        return `${baseMessage}: ${cause.message}`;
+    }
+    // Handle generic errors
+    if (cause instanceof Error) {
+        return `${baseMessage}: ${cause.message}`;
+    }
+    return baseMessage;
+}
+/**
+ * Execute a streaming 2-phase batch trigger where items are streamed from an AsyncIterable.
+ * Unlike executeBatchTwoPhase, this doesn't know the count upfront.
+ *
+ * @param apiClient - The API client instance
+ * @param items - AsyncIterable of batch items
+ * @param options - Batch options including trace context settings
+ * @param options.spanParentAsLink - If true, child runs will have separate trace IDs with a link to parent.
+ *                                   Use true for batchTrigger (fire-and-forget), false for batchTriggerAndWait.
+ * @param requestOptions - Optional request options
+ * @internal
+ */
+async function executeBatchTwoPhaseStreaming(apiClient, items, options, requestOptions) {
+    // For streaming, we need to buffer items to get the count first
+    // This is because createBatch requires runCount upfront
+    // In the future, we could add a streaming-first endpoint that doesn't require this
+    const itemsArray = [];
+    for await (const item of items) {
+        itemsArray.push(item);
+    }
+    // Now we can use the regular 2-phase approach
+    return executeBatchTwoPhase(apiClient, itemsArray, options, requestOptions);
+}
+/**
+ * Type guard to check if a value is a ReadableStream
+ */
+function isReadableStream(value) {
+    return (value != null &&
+        typeof value === "object" &&
+        "getReader" in value &&
+        typeof value.getReader === "function");
+}
+/**
+ * Convert a ReadableStream to an AsyncIterable.
+ * Properly cancels the stream when the consumer terminates early.
+ *
+ * @internal Exported for testing purposes
+ */
+export async function* readableStreamToAsyncIterable(stream) {
+    const reader = stream.getReader();
+    try {
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            yield value;
         }
-        const result = await runtime.waitForBatch({
-            id: response.id,
-            runs: response.runs.map((run) => run.id),
-            ctx,
-        });
-        const runs = await handleBatchTaskRunExecutionResultV2(result.items);
-        return {
-            id: result.id,
-            runs,
+    }
+    finally {
+        try {
+            await reader.cancel();
+        }
+        catch {
+            // Ignore errors - stream might already be errored or closed
+        }
+        reader.releaseLock();
+    }
+}
+/**
+ * Normalize stream input to AsyncIterable
+ */
+function normalizeToAsyncIterable(input) {
+    if (isReadableStream(input)) {
+        return readableStreamToAsyncIterable(input);
+    }
+    return input;
+}
+/**
+ * Transform a stream of BatchByIdItem to BatchItemNDJSON format.
+ * Handles payload serialization and idempotency key generation.
+ *
+ * @internal
+ */
+async function* transformBatchItemsStream(items, options) {
+    let index = 0;
+    for await (const item of items) {
+        const taskMetadata = resourceCatalog.getTask(item.id);
+        const parsedPayload = taskMetadata?.fns.parsePayload
+            ? await taskMetadata?.fns.parsePayload(item.payload)
+            : item.payload;
+        const payloadPacket = await stringifyIO(parsedPayload);
+        const batchItemIdempotencyKey = await makeIdempotencyKey(flattenIdempotencyKey([options?.idempotencyKey, `${index}`]));
+        yield {
+            index: index++,
+            task: item.id,
+            payload: payloadPacket.data,
+            options: {
+                ...triggerQueueBody(item.options?.queue),
+                ...triggerConcurrencyBody(item.options?.concurrency),
+                concurrencyKey: item.options?.concurrencyKey,
+                test: taskContext.ctx?.run.isTest,
+                payloadType: payloadPacket.dataType,
+                delay: item.options?.delay,
+                ttl: item.options?.ttl,
+                tags: item.options?.tags,
+                maxAttempts: item.options?.maxAttempts,
+                metadata: item.options?.metadata,
+                maxDuration: item.options?.maxDuration,
+                idempotencyKey: (await makeIdempotencyKey(item.options?.idempotencyKey)) ?? batchItemIdempotencyKey,
+                idempotencyKeyTTL: item.options?.idempotencyKeyTTL ?? options?.idempotencyKeyTTL,
+                machine: item.options?.machine,
+                priority: item.options?.priority,
+                region: item.options?.region,
+                lockToVersion: item.options?.version ?? scopedEnvVar("TRIGGER_VERSION"),
+                externalDeploymentId: resolveTriggerExternalDeploymentId(item.options?.externalDeploymentId),
+                debounce: item.options?.debounce,
+            },
         };
-    }, {
-        kind: SpanKind.PRODUCER,
-        attributes: {
-            [SemanticInternalAttributes.STYLE_ICON]: "trigger",
-        },
-    });
+    }
+}
+/**
+ * Transform a stream of BatchByIdAndWaitItem to BatchItemNDJSON format for triggerAndWait.
+ * Uses the current worker version for lockToVersion.
+ *
+ * @internal
+ */
+async function* transformBatchItemsStreamForWait(items, options) {
+    let index = 0;
+    for await (const item of items) {
+        const taskMetadata = resourceCatalog.getTask(item.id);
+        const parsedPayload = taskMetadata?.fns.parsePayload
+            ? await taskMetadata?.fns.parsePayload(item.payload)
+            : item.payload;
+        const payloadPacket = await stringifyIO(parsedPayload);
+        const batchItemIdempotencyKey = await makeIdempotencyKey(flattenIdempotencyKey([options?.idempotencyKey, `${index}`]));
+        yield {
+            index: index++,
+            task: item.id,
+            payload: payloadPacket.data,
+            options: {
+                lockToVersion: taskContext.worker?.version,
+                ...triggerQueueBody(item.options?.queue),
+                ...triggerConcurrencyBody(item.options?.concurrency),
+                concurrencyKey: item.options?.concurrencyKey,
+                test: taskContext.ctx?.run.isTest,
+                payloadType: payloadPacket.dataType,
+                delay: item.options?.delay,
+                ttl: item.options?.ttl,
+                tags: item.options?.tags,
+                maxAttempts: item.options?.maxAttempts,
+                metadata: item.options?.metadata,
+                maxDuration: item.options?.maxDuration,
+                idempotencyKey: (await makeIdempotencyKey(item.options?.idempotencyKey)) ?? batchItemIdempotencyKey,
+                idempotencyKeyTTL: item.options?.idempotencyKeyTTL ?? options?.idempotencyKeyTTL,
+                machine: item.options?.machine,
+                priority: item.options?.priority,
+                region: item.options?.region,
+                debounce: item.options?.debounce,
+            },
+        };
+    }
+}
+/**
+ * Transform a stream of BatchByTaskItem to BatchItemNDJSON format.
+ *
+ * @internal
+ */
+async function* transformBatchByTaskItemsStream(items, options) {
+    let index = 0;
+    for await (const item of items) {
+        const taskMetadata = resourceCatalog.getTask(item.task.id);
+        const parsedPayload = taskMetadata?.fns.parsePayload
+            ? await taskMetadata?.fns.parsePayload(item.payload)
+            : item.payload;
+        const payloadPacket = await stringifyIO(parsedPayload);
+        const batchItemIdempotencyKey = await makeIdempotencyKey(flattenIdempotencyKey([options?.idempotencyKey, `${index}`]));
+        yield {
+            index: index++,
+            task: item.task.id,
+            payload: payloadPacket.data,
+            options: {
+                ...triggerQueueBody(item.options?.queue),
+                ...triggerConcurrencyBody(item.options?.concurrency),
+                concurrencyKey: item.options?.concurrencyKey,
+                test: taskContext.ctx?.run.isTest,
+                payloadType: payloadPacket.dataType,
+                delay: item.options?.delay,
+                ttl: item.options?.ttl,
+                tags: item.options?.tags,
+                maxAttempts: item.options?.maxAttempts,
+                metadata: item.options?.metadata,
+                maxDuration: item.options?.maxDuration,
+                idempotencyKey: (await makeIdempotencyKey(item.options?.idempotencyKey)) ?? batchItemIdempotencyKey,
+                idempotencyKeyTTL: item.options?.idempotencyKeyTTL ?? options?.idempotencyKeyTTL,
+                machine: item.options?.machine,
+                priority: item.options?.priority,
+                region: item.options?.region,
+                lockToVersion: item.options?.version ?? scopedEnvVar("TRIGGER_VERSION"),
+                externalDeploymentId: resolveTriggerExternalDeploymentId(item.options?.externalDeploymentId),
+                debounce: item.options?.debounce,
+            },
+        };
+    }
+}
+/**
+ * Transform a stream of BatchByTaskAndWaitItem to BatchItemNDJSON format for triggerAndWait.
+ *
+ * @internal
+ */
+async function* transformBatchByTaskItemsStreamForWait(items, options) {
+    let index = 0;
+    for await (const item of items) {
+        const taskMetadata = resourceCatalog.getTask(item.task.id);
+        const parsedPayload = taskMetadata?.fns.parsePayload
+            ? await taskMetadata?.fns.parsePayload(item.payload)
+            : item.payload;
+        const payloadPacket = await stringifyIO(parsedPayload);
+        const batchItemIdempotencyKey = await makeIdempotencyKey(flattenIdempotencyKey([options?.idempotencyKey, `${index}`]));
+        yield {
+            index: index++,
+            task: item.task.id,
+            payload: payloadPacket.data,
+            options: {
+                lockToVersion: taskContext.worker?.version,
+                ...triggerQueueBody(item.options?.queue),
+                ...triggerConcurrencyBody(item.options?.concurrency),
+                concurrencyKey: item.options?.concurrencyKey,
+                test: taskContext.ctx?.run.isTest,
+                payloadType: payloadPacket.dataType,
+                delay: item.options?.delay,
+                ttl: item.options?.ttl,
+                tags: item.options?.tags,
+                maxAttempts: item.options?.maxAttempts,
+                metadata: item.options?.metadata,
+                maxDuration: item.options?.maxDuration,
+                idempotencyKey: (await makeIdempotencyKey(item.options?.idempotencyKey)) ?? batchItemIdempotencyKey,
+                idempotencyKeyTTL: item.options?.idempotencyKeyTTL ?? options?.idempotencyKeyTTL,
+                machine: item.options?.machine,
+                priority: item.options?.priority,
+                region: item.options?.region,
+                debounce: item.options?.debounce,
+            },
+        };
+    }
+}
+/**
+ * Transform a stream of BatchItem (single task type) to BatchItemNDJSON format.
+ *
+ * @internal
+ */
+async function* transformSingleTaskBatchItemsStream(taskIdentifier, items, parsePayload, options, queue) {
+    let index = 0;
+    for await (const item of items) {
+        const parsedPayload = parsePayload ? await parsePayload(item.payload) : item.payload;
+        const payloadPacket = await stringifyIO(parsedPayload);
+        const batchItemIdempotencyKey = await makeIdempotencyKey(flattenIdempotencyKey([options?.idempotencyKey, `${index}`]));
+        yield {
+            index: index++,
+            task: taskIdentifier,
+            payload: payloadPacket.data,
+            options: {
+                ...triggerQueueBody(item.options?.queue, queue),
+                ...triggerConcurrencyBody(item.options?.concurrency),
+                concurrencyKey: item.options?.concurrencyKey,
+                test: taskContext.ctx?.run.isTest,
+                payloadType: payloadPacket.dataType,
+                delay: item.options?.delay,
+                ttl: item.options?.ttl,
+                tags: item.options?.tags,
+                maxAttempts: item.options?.maxAttempts,
+                metadata: item.options?.metadata,
+                maxDuration: item.options?.maxDuration,
+                idempotencyKey: (await makeIdempotencyKey(item.options?.idempotencyKey)) ?? batchItemIdempotencyKey,
+                idempotencyKeyTTL: item.options?.idempotencyKeyTTL ?? options?.idempotencyKeyTTL,
+                machine: item.options?.machine,
+                priority: item.options?.priority,
+                region: item.options?.region,
+                lockToVersion: item.options?.version ?? scopedEnvVar("TRIGGER_VERSION"),
+                externalDeploymentId: resolveTriggerExternalDeploymentId(item.options?.externalDeploymentId),
+                debounce: item.options?.debounce,
+            },
+        };
+    }
+}
+/**
+ * Transform a stream of BatchTriggerAndWaitItem (single task type) to BatchItemNDJSON format.
+ *
+ * @internal
+ */
+async function* transformSingleTaskBatchItemsStreamForWait(taskIdentifier, items, parsePayload, options, queue) {
+    let index = 0;
+    for await (const item of items) {
+        const parsedPayload = parsePayload ? await parsePayload(item.payload) : item.payload;
+        const payloadPacket = await stringifyIO(parsedPayload);
+        const batchItemIdempotencyKey = await makeIdempotencyKey(flattenIdempotencyKey([options?.idempotencyKey, `${index}`]));
+        // Process item-specific idempotency key and extract options
+        const itemIdempotencyKey = await makeIdempotencyKey(item.options?.idempotencyKey);
+        const finalIdempotencyKey = itemIdempotencyKey ?? batchItemIdempotencyKey;
+        const idempotencyKeyOptions = itemIdempotencyKey
+            ? getIdempotencyKeyOptions(itemIdempotencyKey)
+            : undefined;
+        yield {
+            index: index++,
+            task: taskIdentifier,
+            payload: payloadPacket.data,
+            options: {
+                lockToVersion: taskContext.worker?.version,
+                ...triggerQueueBody(item.options?.queue, queue),
+                ...triggerConcurrencyBody(item.options?.concurrency),
+                concurrencyKey: item.options?.concurrencyKey,
+                test: taskContext.ctx?.run.isTest,
+                payloadType: payloadPacket.dataType,
+                delay: item.options?.delay,
+                ttl: item.options?.ttl,
+                tags: item.options?.tags,
+                maxAttempts: item.options?.maxAttempts,
+                metadata: item.options?.metadata,
+                maxDuration: item.options?.maxDuration,
+                idempotencyKey: finalIdempotencyKey?.toString(),
+                idempotencyKeyTTL: item.options?.idempotencyKeyTTL ?? options?.idempotencyKeyTTL,
+                idempotencyKeyOptions,
+                machine: item.options?.machine,
+                priority: item.options?.priority,
+                region: item.options?.region,
+                debounce: item.options?.debounce,
+            },
+        };
+    }
 }
 async function trigger_internal(name, id, payload, parsePayload, options, requestOptions) {
-    const apiClient = apiClientManager.clientOrThrow();
+    const apiClient = apiClientManager.clientOrThrow(requestOptions?.clientConfig);
     const parsedPayload = parsePayload ? await parsePayload(payload) : payload;
-    const payloadPacket = await stringifyIO(parsedPayload);
+    const { packet: triggerPayloadPacket, payloadSize } = await prepareTriggerPayload(parsedPayload, apiClient);
+    // Process idempotency key and extract options for storage
+    const processedIdempotencyKey = await makeIdempotencyKey(options?.idempotencyKey);
+    const idempotencyKeyOptions = processedIdempotencyKey
+        ? getIdempotencyKeyOptions(processedIdempotencyKey)
+        : undefined;
     const handle = await apiClient.triggerTask(id, {
-        payload: payloadPacket.data,
+        payload: triggerPayloadPacket.data,
         options: {
-            queue: options?.queue,
+            ...triggerQueueBody(options?.queue),
+            ...triggerConcurrencyBody(options?.concurrency),
             concurrencyKey: options?.concurrencyKey,
             test: taskContext.ctx?.run.isTest,
-            payloadType: payloadPacket.dataType,
-            idempotencyKey: await makeIdempotencyKey(options?.idempotencyKey),
+            payloadType: triggerPayloadPacket.dataType,
+            payloadSize,
+            idempotencyKey: processedIdempotencyKey?.toString(),
             idempotencyKeyTTL: options?.idempotencyKeyTTL,
+            idempotencyKeyOptions,
             delay: options?.delay,
             ttl: options?.ttl,
             tags: options?.tags,
             maxAttempts: options?.maxAttempts,
-            parentAttempt: taskContext.ctx?.attempt.id,
             metadata: options?.metadata,
             maxDuration: options?.maxDuration,
+            parentRunId: taskContext.ctx?.run.id,
             machine: options?.machine,
+            priority: options?.priority,
+            region: options?.region,
+            lockToVersion: options?.version ?? scopedEnvVar("TRIGGER_VERSION"),
+            externalDeploymentId: resolveTriggerExternalDeploymentId(options?.externalDeploymentId),
+            debounce: options?.debounce,
         },
     }, {
         spanParentAsLink: true,
@@ -854,96 +1334,169 @@ async function trigger_internal(name, id, payload, parsePayload, options, reques
     return handle;
 }
 async function batchTrigger_internal(name, taskIdentifier, items, options, parsePayload, requestOptions, queue) {
-    const apiClient = apiClientManager.clientOrThrow();
-    const response = await apiClient.batchTriggerV2({
-        items: await Promise.all(items.map(async (item) => {
+    const apiClient = apiClientManager.clientOrThrow(requestOptions?.clientConfig);
+    const ctx = taskContext.ctx;
+    // Check if items is an array or a stream
+    if (Array.isArray(items)) {
+        // Prepare items as BatchItemNDJSON
+        const ndJsonItems = await Promise.all(items.map(async (item, index) => {
             const parsedPayload = parsePayload ? await parsePayload(item.payload) : item.payload;
             const payloadPacket = await stringifyIO(parsedPayload);
+            const batchItemIdempotencyKey = await makeIdempotencyKey(flattenIdempotencyKey([options?.idempotencyKey, `${index}`]));
+            // Process item-specific idempotency key and extract options
+            const itemIdempotencyKey = await makeIdempotencyKey(item.options?.idempotencyKey);
+            const finalIdempotencyKey = itemIdempotencyKey ?? batchItemIdempotencyKey;
+            const idempotencyKeyOptions = itemIdempotencyKey
+                ? getIdempotencyKeyOptions(itemIdempotencyKey)
+                : undefined;
             return {
+                index,
                 task: taskIdentifier,
                 payload: payloadPacket.data,
                 options: {
-                    queue: item.options?.queue ?? queue,
+                    ...triggerQueueBody(item.options?.queue, queue),
+                    ...triggerConcurrencyBody(item.options?.concurrency),
                     concurrencyKey: item.options?.concurrencyKey,
                     test: taskContext.ctx?.run.isTest,
                     payloadType: payloadPacket.dataType,
-                    idempotencyKey: await makeIdempotencyKey(item.options?.idempotencyKey),
-                    idempotencyKeyTTL: item.options?.idempotencyKeyTTL,
                     delay: item.options?.delay,
                     ttl: item.options?.ttl,
                     tags: item.options?.tags,
                     maxAttempts: item.options?.maxAttempts,
-                    parentAttempt: taskContext.ctx?.attempt.id,
                     metadata: item.options?.metadata,
                     maxDuration: item.options?.maxDuration,
+                    idempotencyKey: finalIdempotencyKey?.toString(),
+                    idempotencyKeyTTL: item.options?.idempotencyKeyTTL ?? options?.idempotencyKeyTTL,
+                    idempotencyKeyOptions,
                     machine: item.options?.machine,
+                    priority: item.options?.priority,
+                    region: item.options?.region,
+                    lockToVersion: item.options?.version ?? scopedEnvVar("TRIGGER_VERSION"),
+                    externalDeploymentId: resolveTriggerExternalDeploymentId(item.options?.externalDeploymentId),
+                    debounce: item.options?.debounce,
                 },
             };
-        })),
-    }, {
-        spanParentAsLink: true,
-        idempotencyKey: await makeIdempotencyKey(options?.idempotencyKey),
-        idempotencyKeyTTL: options?.idempotencyKeyTTL,
-        processingStrategy: options?.triggerSequentially ? "sequential" : undefined,
-    }, {
-        name,
-        tracer,
-        icon: "trigger",
-        onResponseBody(body, span) {
-            if (body && typeof body === "object" && !Array.isArray(body)) {
-                if ("id" in body && typeof body.id === "string") {
-                    span.setAttribute("batchId", body.id);
-                }
-                if ("runs" in body && Array.isArray(body.runs)) {
-                    span.setAttribute("runCount", body.runs.length);
-                }
-                if ("isCached" in body && typeof body.isCached === "boolean") {
-                    if (body.isCached) {
-                        console.warn(`Result is a cached response because the request was idempotent.`);
-                    }
-                    span.setAttribute("isCached", body.isCached);
-                }
-                if ("idempotencyKey" in body && typeof body.idempotencyKey === "string") {
-                    span.setAttribute("idempotencyKey", body.idempotencyKey);
-                }
-            }
-        },
-        ...requestOptions,
-    });
-    const handle = {
-        batchId: response.id,
-        isCached: response.isCached,
-        idempotencyKey: response.idempotencyKey,
-        runs: response.runs,
-        publicAccessToken: response.publicAccessToken,
-    };
-    return handle;
+        }));
+        // Execute 2-phase batch
+        // Process batch-level idempotency key
+        const batchIdempotencyKey = await makeIdempotencyKey(options?.idempotencyKey);
+        const batchIdempotencyKeyOptions = batchIdempotencyKey
+            ? getIdempotencyKeyOptions(batchIdempotencyKey)
+            : undefined;
+        const response = await tracer.startActiveSpan(name, async (span) => {
+            const result = await executeBatchTwoPhase(apiClient, ndJsonItems, {
+                parentRunId: ctx?.run.id,
+                idempotencyKey: batchIdempotencyKey?.toString(),
+                idempotencyKeyOptions: batchIdempotencyKeyOptions,
+                spanParentAsLink: true, // Fire-and-forget: child runs get separate trace IDs
+            }, requestOptions);
+            span.setAttribute("batchId", result.id);
+            span.setAttribute("runCount", result.runCount);
+            return result;
+        }, {
+            kind: SpanKind.PRODUCER,
+            attributes: {
+                [SemanticInternalAttributes.STYLE_ICON]: "trigger",
+                ...accessoryAttributes({
+                    items: [
+                        {
+                            text: taskIdentifier,
+                            variant: "normal",
+                        },
+                    ],
+                    style: "codepath",
+                }),
+            },
+        });
+        const handle = {
+            batchId: response.id,
+            runCount: response.runCount,
+            publicAccessToken: response.publicAccessToken,
+        };
+        return handle;
+    }
+    else {
+        // Stream path: convert to AsyncIterable and transform
+        const asyncItems = normalizeToAsyncIterable(items);
+        const transformedItems = transformSingleTaskBatchItemsStream(taskIdentifier, asyncItems, parsePayload, options, queue);
+        // Execute streaming 2-phase batch
+        // Process batch-level idempotency key
+        const streamBatchIdempotencyKey = await makeIdempotencyKey(options?.idempotencyKey);
+        const streamBatchIdempotencyKeyOptions = streamBatchIdempotencyKey
+            ? getIdempotencyKeyOptions(streamBatchIdempotencyKey)
+            : undefined;
+        const response = await tracer.startActiveSpan(name, async (span) => {
+            const result = await executeBatchTwoPhaseStreaming(apiClient, transformedItems, {
+                parentRunId: ctx?.run.id,
+                idempotencyKey: streamBatchIdempotencyKey?.toString(),
+                idempotencyKeyOptions: streamBatchIdempotencyKeyOptions,
+                spanParentAsLink: true, // Fire-and-forget: child runs get separate trace IDs
+            }, requestOptions);
+            span.setAttribute("batchId", result.id);
+            span.setAttribute("runCount", result.runCount);
+            return result;
+        }, {
+            kind: SpanKind.PRODUCER,
+            attributes: {
+                [SemanticInternalAttributes.STYLE_ICON]: "trigger",
+                ...accessoryAttributes({
+                    items: [
+                        {
+                            text: taskIdentifier,
+                            variant: "normal",
+                        },
+                    ],
+                    style: "codepath",
+                }),
+            },
+        });
+        const handle = {
+            batchId: response.id,
+            runCount: response.runCount,
+            publicAccessToken: response.publicAccessToken,
+        };
+        return handle;
+    }
 }
 async function triggerAndWait_internal(name, id, payload, parsePayload, options, requestOptions) {
     const ctx = taskContext.ctx;
     if (!ctx) {
         throw new Error("triggerAndWait can only be used from inside a task.run()");
     }
-    const apiClient = apiClientManager.clientOrThrow();
+    const apiClient = apiClientManager.clientOrThrow(requestOptions?.clientConfig);
     const parsedPayload = parsePayload ? await parsePayload(payload) : payload;
-    const payloadPacket = await stringifyIO(parsedPayload);
+    const { packet: triggerPayloadPacket, payloadSize } = await prepareTriggerPayload(parsedPayload, apiClient);
+    // Process idempotency key and extract options for storage
+    const processedIdempotencyKey = await makeIdempotencyKey(options?.idempotencyKey);
+    const idempotencyKeyOptions = processedIdempotencyKey
+        ? getIdempotencyKeyOptions(processedIdempotencyKey)
+        : undefined;
     return await tracer.startActiveSpan(name, async (span) => {
         const response = await apiClient.triggerTask(id, {
-            payload: payloadPacket.data,
+            payload: triggerPayloadPacket.data,
             options: {
-                dependentAttempt: ctx.attempt.id,
                 lockToVersion: taskContext.worker?.version, // Lock to current version because we're waiting for it to finish
-                queue: options?.queue,
+                ...triggerQueueBody(options?.queue),
+                ...triggerConcurrencyBody(options?.concurrency),
                 concurrencyKey: options?.concurrencyKey,
                 test: taskContext.ctx?.run.isTest,
-                payloadType: payloadPacket.dataType,
+                payloadType: triggerPayloadPacket.dataType,
+                payloadSize,
                 delay: options?.delay,
                 ttl: options?.ttl,
                 tags: options?.tags,
                 maxAttempts: options?.maxAttempts,
                 metadata: options?.metadata,
                 maxDuration: options?.maxDuration,
+                resumeParentOnCompletion: true,
+                parentRunId: ctx.run.id,
+                idempotencyKey: processedIdempotencyKey?.toString(),
+                idempotencyKeyTTL: options?.idempotencyKeyTTL,
+                idempotencyKeyOptions,
                 machine: options?.machine,
+                priority: options?.priority,
+                region: options?.region,
+                debounce: options?.debounce,
             },
         }, {}, requestOptions);
         span.setAttribute("runId", response.id);
@@ -968,59 +1521,118 @@ async function triggerAndWait_internal(name, id, payload, parsePayload, options,
         },
     });
 }
-async function batchTriggerAndWait_internal(name, id, items, parsePayload, options, requestOptions, queue) {
+async function triggerAndSubscribe_internal(name, id, payload, parsePayload, options, requestOptions) {
     const ctx = taskContext.ctx;
     if (!ctx) {
-        throw new Error("batchTriggerAndWait can only be used from inside a task.run()");
+        throw new Error("triggerAndSubscribe can only be used from inside a task.run()");
     }
-    const apiClient = apiClientManager.clientOrThrow();
+    const apiClient = apiClientManager.clientOrThrow(requestOptions?.clientConfig);
+    const parsedPayload = parsePayload ? await parsePayload(payload) : payload;
+    const { packet: triggerPayloadPacket, payloadSize } = await prepareTriggerPayload(parsedPayload, apiClient);
+    const processedIdempotencyKey = await makeIdempotencyKey(options?.idempotencyKey);
+    const idempotencyKeyOptions = processedIdempotencyKey
+        ? getIdempotencyKeyOptions(processedIdempotencyKey)
+        : undefined;
     return await tracer.startActiveSpan(name, async (span) => {
-        const response = await apiClient.batchTriggerV2({
-            items: await Promise.all(items.map(async (item) => {
-                const parsedPayload = parsePayload ? await parsePayload(item.payload) : item.payload;
-                const payloadPacket = await stringifyIO(parsedPayload);
-                return {
-                    task: id,
-                    payload: payloadPacket.data,
-                    options: {
-                        lockToVersion: taskContext.worker?.version,
-                        queue: item.options?.queue ?? queue,
-                        concurrencyKey: item.options?.concurrencyKey,
-                        test: taskContext.ctx?.run.isTest,
-                        payloadType: payloadPacket.dataType,
-                        delay: item.options?.delay,
-                        ttl: item.options?.ttl,
-                        tags: item.options?.tags,
-                        maxAttempts: item.options?.maxAttempts,
-                        metadata: item.options?.metadata,
-                        maxDuration: item.options?.maxDuration,
-                        machine: item.options?.machine,
-                    },
-                };
-            })),
-            dependentAttempt: ctx.attempt.id,
-        }, {
-            processingStrategy: options?.triggerSequentially ? "sequential" : undefined,
-        }, requestOptions);
-        span.setAttribute("batchId", response.id);
-        span.setAttribute("runCount", response.runs.length);
-        span.setAttribute("isCached", response.isCached);
-        if (response.isCached) {
-            console.warn(`Result is a cached response because the request was idempotent.`);
+        const response = await apiClient.triggerTask(id, {
+            payload: triggerPayloadPacket.data,
+            options: {
+                lockToVersion: taskContext.worker?.version,
+                ...triggerQueueBody(options?.queue),
+                ...triggerConcurrencyBody(options?.concurrency),
+                concurrencyKey: options?.concurrencyKey,
+                test: taskContext.ctx?.run.isTest,
+                payloadType: triggerPayloadPacket.dataType,
+                payloadSize,
+                delay: options?.delay,
+                ttl: options?.ttl,
+                tags: options?.tags,
+                maxAttempts: options?.maxAttempts,
+                metadata: options?.metadata,
+                maxDuration: options?.maxDuration,
+                parentRunId: ctx.run.id,
+                // NOTE: no resumeParentOnCompletion — parent stays alive and subscribes
+                idempotencyKey: processedIdempotencyKey?.toString(),
+                idempotencyKeyTTL: options?.idempotencyKeyTTL,
+                idempotencyKeyOptions,
+                machine: options?.machine,
+                priority: options?.priority,
+                region: options?.region,
+                debounce: options?.debounce,
+            },
+        }, {}, requestOptions);
+        // Set attributes after trigger so the dashboard can link to the child run
+        span.setAttribute("messaging.message.id", response.id);
+        span.setAttribute("runId", response.id);
+        span.setAttribute(SemanticInternalAttributes.ENTITY_TYPE, "run");
+        span.setAttribute(SemanticInternalAttributes.ENTITY_ID, response.id);
+        // Optionally cancel the child run when the abort signal fires (default: true)
+        const cancelOnAbort = options?.cancelOnAbort !== false;
+        let onAbort;
+        if (options?.signal && cancelOnAbort) {
+            if (options.signal.aborted) {
+                await apiClient.cancelRun(response.id).catch(() => { });
+                throw new DOMException("Aborted", "AbortError");
+            }
+            onAbort = () => {
+                apiClient.cancelRun(response.id).catch(() => { });
+            };
+            // `{ once: true }` auto-removes the listener on abort, but if the
+            // run completes normally the listener stays attached and pins
+            // `apiClient` + `response.id` until the signal is GC'd. Long-lived
+            // signals shared across many calls accumulate dead listeners; the
+            // `finally` below removes the listener on every exit path.
+            options.signal.addEventListener("abort", onAbort, { once: true });
+        }
+        try {
+            for await (const run of apiClient.subscribeToRun(response.id, {
+                closeOnComplete: true,
+                signal: options?.signal,
+                skipColumns: ["payload"],
+            })) {
+                if (run.isSuccess) {
+                    // run.output from subscribeToRun is already deserialized
+                    return {
+                        ok: true,
+                        id: response.id,
+                        taskIdentifier: id,
+                        output: run.output,
+                    };
+                }
+                if (run.isFailed || run.isCancelled) {
+                    // Note: this intentionally diverges from `triggerAndWait`'s
+                    // error shape. `triggerAndWait` receives a full `TaskRunError`
+                    // (with `type` discriminator: BUILT_IN_ERROR, CUSTOM_ERROR,
+                    // INTERNAL_ERROR, STRING_ERROR) via the completion message and
+                    // passes it through `createErrorTaskError` to preserve the
+                    // discriminator. `subscribeToRun` only surfaces a
+                    // `SerializedError` (`{ name, message, stackTrace, causes }`)
+                    // because `createJsonErrorObject` strips the discriminator before
+                    // the record hits the realtime stream. We can't reconstruct the
+                    // discriminator here without lossy guessing — callers that
+                    // need exact error-type matching should use `triggerAndWait`
+                    // instead; subscribers get message, name and the cause chain.
+                    const cause = run.error?.causes?.length
+                        ? createErrorFromCauses(run.error.causes)
+                        : undefined;
+                    const error = new Error(run.error?.message ?? `Task ${id} failed (${run.status})`, cause ? { cause } : undefined);
+                    if (run.error?.name)
+                        error.name = run.error.name;
+                    return {
+                        ok: false,
+                        id: response.id,
+                        taskIdentifier: id,
+                        error,
+                    };
+                }
+            }
+            throw new Error(`Task ${id}: subscription ended without completion`);
         }
-        if (response.idempotencyKey) {
-            span.setAttribute("idempotencyKey", response.idempotencyKey);
+        finally {
+            if (onAbort && options?.signal) {
+                options.signal.removeEventListener("abort", onAbort);
+            }
         }
-        const result = await runtime.waitForBatch({
-            id: response.id,
-            runs: response.runs.map((run) => run.id),
-            ctx,
-        });
-        const runs = await handleBatchTaskRunExecutionResult(result.items, id);
-        return {
-            id: result.id,
-            runs,
-        };
     }, {
         kind: SpanKind.PRODUCER,
         attributes: {
@@ -1037,6 +1649,141 @@ async function batchTriggerAndWait_internal(name, id, items, parsePayload, optio
         },
     });
 }
+async function batchTriggerAndWait_internal(name, id, items, parsePayload, options, requestOptions, queue) {
+    const ctx = taskContext.ctx;
+    if (!ctx) {
+        throw new Error("batchTriggerAndWait can only be used from inside a task.run()");
+    }
+    const apiClient = apiClientManager.clientOrThrow(requestOptions?.clientConfig);
+    // Check if items is an array or a stream
+    if (Array.isArray(items)) {
+        // Prepare items as BatchItemNDJSON
+        const ndJsonItems = await Promise.all(items.map(async (item, index) => {
+            const parsedPayload = parsePayload ? await parsePayload(item.payload) : item.payload;
+            const payloadPacket = await stringifyIO(parsedPayload);
+            const batchItemIdempotencyKey = await makeIdempotencyKey(flattenIdempotencyKey([options?.idempotencyKey, `${index}`]));
+            // Process item-specific idempotency key and extract options
+            const itemIdempotencyKey = await makeIdempotencyKey(item.options?.idempotencyKey);
+            const finalIdempotencyKey = itemIdempotencyKey ?? batchItemIdempotencyKey;
+            const idempotencyKeyOptions = itemIdempotencyKey
+                ? getIdempotencyKeyOptions(itemIdempotencyKey)
+                : undefined;
+            return {
+                index,
+                task: id,
+                payload: payloadPacket.data,
+                options: {
+                    lockToVersion: taskContext.worker?.version,
+                    ...triggerQueueBody(item.options?.queue, queue),
+                    ...triggerConcurrencyBody(item.options?.concurrency),
+                    concurrencyKey: item.options?.concurrencyKey,
+                    test: taskContext.ctx?.run.isTest,
+                    payloadType: payloadPacket.dataType,
+                    delay: item.options?.delay,
+                    ttl: item.options?.ttl,
+                    tags: item.options?.tags,
+                    maxAttempts: item.options?.maxAttempts,
+                    metadata: item.options?.metadata,
+                    maxDuration: item.options?.maxDuration,
+                    idempotencyKey: finalIdempotencyKey?.toString(),
+                    idempotencyKeyTTL: item.options?.idempotencyKeyTTL ?? options?.idempotencyKeyTTL,
+                    idempotencyKeyOptions,
+                    machine: item.options?.machine,
+                    priority: item.options?.priority,
+                    region: item.options?.region,
+                    debounce: item.options?.debounce,
+                },
+            };
+        }));
+        // Process batch-level idempotency key
+        const batchIdempotencyKey = await makeIdempotencyKey(options?.idempotencyKey);
+        const batchIdempotencyKeyOptions = batchIdempotencyKey
+            ? getIdempotencyKeyOptions(batchIdempotencyKey)
+            : undefined;
+        return await tracer.startActiveSpan(name, async (span) => {
+            // Execute 2-phase batch
+            const response = await executeBatchTwoPhase(apiClient, ndJsonItems, {
+                parentRunId: ctx.run.id,
+                resumeParentOnCompletion: true,
+                idempotencyKey: batchIdempotencyKey?.toString(),
+                idempotencyKeyOptions: batchIdempotencyKeyOptions,
+                spanParentAsLink: false, // Waiting: child runs share parent's trace ID
+            }, requestOptions);
+            span.setAttribute("batchId", response.id);
+            span.setAttribute("runCount", response.runCount);
+            const result = await runtime.waitForBatch({
+                id: response.id,
+                runCount: response.runCount,
+                ctx,
+            });
+            const runs = await handleBatchTaskRunExecutionResult(result.items, id);
+            return {
+                id: result.id,
+                runs,
+            };
+        }, {
+            kind: SpanKind.PRODUCER,
+            attributes: {
+                [SemanticInternalAttributes.STYLE_ICON]: "trigger",
+                ...accessoryAttributes({
+                    items: [
+                        {
+                            text: id,
+                            variant: "normal",
+                        },
+                    ],
+                    style: "codepath",
+                }),
+            },
+        });
+    }
+    else {
+        // Stream path: convert to AsyncIterable and transform
+        const asyncItems = normalizeToAsyncIterable(items);
+        const transformedItems = transformSingleTaskBatchItemsStreamForWait(id, asyncItems, parsePayload, options, queue);
+        // Process batch-level idempotency key for streaming path
+        const streamBatchIdempotencyKey = await makeIdempotencyKey(options?.idempotencyKey);
+        const streamBatchIdempotencyKeyOptions = streamBatchIdempotencyKey
+            ? getIdempotencyKeyOptions(streamBatchIdempotencyKey)
+            : undefined;
+        return await tracer.startActiveSpan(name, async (span) => {
+            // Execute streaming 2-phase batch
+            const response = await executeBatchTwoPhaseStreaming(apiClient, transformedItems, {
+                parentRunId: ctx.run.id,
+                resumeParentOnCompletion: true,
+                idempotencyKey: streamBatchIdempotencyKey?.toString(),
+                idempotencyKeyOptions: streamBatchIdempotencyKeyOptions,
+                spanParentAsLink: false, // Waiting: child runs share parent's trace ID
+            }, requestOptions);
+            span.setAttribute("batchId", response.id);
+            span.setAttribute("runCount", response.runCount);
+            const result = await runtime.waitForBatch({
+                id: response.id,
+                runCount: response.runCount,
+                ctx,
+            });
+            const runs = await handleBatchTaskRunExecutionResult(result.items, id);
+            return {
+                id: result.id,
+                runs,
+            };
+        }, {
+            kind: SpanKind.PRODUCER,
+            attributes: {
+                [SemanticInternalAttributes.STYLE_ICON]: "trigger",
+                ...accessoryAttributes({
+                    items: [
+                        {
+                            text: id,
+                            variant: "normal",
+                        },
+                    ],
+                    style: "codepath",
+                }),
+            },
+        });
+    }
+}
 async function handleBatchTaskRunExecutionResult(items, taskIdentifier) {
     const someObjectStoreOutputs = items.some((item) => item.ok && item.outputType === "application/store");
     if (!someObjectStoreOutputs) {
@@ -1055,17 +1802,17 @@ async function handleBatchTaskRunExecutionResult(items, taskIdentifier) {
         [SemanticInternalAttributes.STYLE_ICON]: "cloud-download",
     });
 }
-async function handleBatchTaskRunExecutionResultV2(items) {
+async function handleBatchTaskRunExecutionResultV2(items, taskIdentifiers) {
     const someObjectStoreOutputs = items.some((item) => item.ok && item.outputType === "application/store");
     if (!someObjectStoreOutputs) {
-        const results = await Promise.all(items.map(async (item) => {
-            return await handleTaskRunExecutionResult(item, item.taskIdentifier ?? "unknown");
+        const results = await Promise.all(items.map(async (item, index) => {
+            return await handleTaskRunExecutionResult(item, item.taskIdentifier ?? taskIdentifiers?.[index] ?? "unknown");
         }));
         return results;
     }
     return await tracer.startActiveSpan("store.downloadPayloads", async (span) => {
-        const results = await Promise.all(items.map(async (item) => {
-            return await handleTaskRunExecutionResult(item, item.taskIdentifier ?? "unknown");
+        const results = await Promise.all(items.map(async (item, index) => {
+            return await handleTaskRunExecutionResult(item, item.taskIdentifier ?? taskIdentifiers?.[index] ?? "unknown");
         }));
         return results;
     }, {
@@ -1093,4 +1840,90 @@ async function handleTaskRunExecutionResult(execution, taskIdentifier) {
         };
     }
 }
+function registerTaskLifecycleHooks(taskId, params) {
+    if (params.init) {
+        lifecycleHooks.registerTaskInitHook(taskId, {
+            fn: params.init,
+        });
+    }
+    if (params.onStart) {
+        lifecycleHooks.registerTaskStartHook(taskId, {
+            fn: params.onStart,
+        });
+    }
+    if (params.onStartAttempt) {
+        lifecycleHooks.registerTaskStartAttemptHook(taskId, {
+            fn: params.onStartAttempt,
+        });
+    }
+    if (params.onFailure) {
+        lifecycleHooks.registerTaskFailureHook(taskId, {
+            fn: params.onFailure,
+        });
+    }
+    if (params.onSuccess) {
+        lifecycleHooks.registerTaskSuccessHook(taskId, {
+            fn: params.onSuccess,
+        });
+    }
+    if (params.onComplete) {
+        lifecycleHooks.registerTaskCompleteHook(taskId, {
+            fn: params.onComplete,
+        });
+    }
+    if (params.onWait) {
+        lifecycleHooks.registerTaskWaitHook(taskId, {
+            fn: params.onWait,
+        });
+    }
+    if (params.onResume) {
+        lifecycleHooks.registerTaskResumeHook(taskId, {
+            fn: params.onResume,
+        });
+    }
+    if (params.catchError) {
+        // We don't need to use an adapter here because catchError is the new version of handleError
+        lifecycleHooks.registerTaskCatchErrorHook(taskId, {
+            fn: params.catchError,
+        });
+    }
+    if (params.handleError) {
+        lifecycleHooks.registerTaskCatchErrorHook(taskId, {
+            fn: params.handleError,
+        });
+    }
+    if (params.middleware) {
+        lifecycleHooks.registerTaskMiddlewareHook(taskId, {
+            fn: params.middleware,
+        });
+    }
+    if (params.cleanup) {
+        lifecycleHooks.registerTaskCleanupHook(taskId, {
+            fn: params.cleanup,
+        });
+    }
+    if (params.onCancel) {
+        lifecycleHooks.registerTaskCancelHook(taskId, {
+            fn: params.onCancel,
+        });
+    }
+}
+async function prepareTriggerPayload(payload, apiClient) {
+    const payloadPacket = await stringifyIO(payload);
+    // Measure the serialized size before any offload, so it reflects the real payload
+    // size rather than the small "application/store" reference we may send instead.
+    const { size: payloadSize } = packetRequiresOffloading(payloadPacket);
+    const packet = await conditionallyExportPacket(payloadPacket, createTriggerPayloadPathPrefix(), undefined, apiClient);
+    return { packet, payloadSize };
+}
+/**
+ * Build the object-storage path prefix for an offloaded trigger payload.
+ *
+ * Every segment is generated here, so nothing caller-controlled reaches the key.
+ * The id's alphabet is lowercase alphanumeric, which no layer between here and the
+ * object store rewrites, so the path the SDK asks for is the path that gets stored.
+ */
+function createTriggerPayloadPathPrefix() {
+    return `trigger/${generateFriendlyId("packet")}/payload`;
+}
 //# sourceMappingURL=shared.js.map