@trigger.dev/sdk 4.3.0 → 4.3.2

package/dist/esm/v3/shared.js

@@ -1,5 +1,5 @@
 import { SpanKind } from "@opentelemetry/api";
-import { accessoryAttributes, apiClientManager, conditionallyImportPacket, convertToolParametersToSchema, createErrorTaskError, defaultRetryOptions, flattenIdempotencyKey, getEnvVar, getSchemaParseFn, lifecycleHooks, makeIdempotencyKey, parsePacket, resourceCatalog, runtime, SemanticInternalAttributes, stringifyIO, SubtaskUnwrapError, taskContext, TaskRunPromise, } from "@trigger.dev/core/v3";
+import { accessoryAttributes, ApiError, apiClientManager, conditionallyImportPacket, convertToolParametersToSchema, createErrorTaskError, defaultRetryOptions, flattenIdempotencyKey, getEnvVar, getSchemaParseFn, lifecycleHooks, makeIdempotencyKey, parsePacket, RateLimitError, resourceCatalog, runtime, SemanticInternalAttributes, stringifyIO, SubtaskUnwrapError, taskContext, TaskRunPromise, } from "@trigger.dev/core/v3";
 import { tracer } from "./tracer.js";
 export { SubtaskUnwrapError, TaskRunPromise };
 export function queue(options) {
@@ -221,63 +221,14 @@ export async function batchTriggerAndWait(id, items, 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) {
+// Implementation
+export async function batchTriggerById(...args) {
+    const [items, options, requestOptions] = args;
     const apiClient = apiClientManager.clientOrThrow(requestOptions?.clientConfig);
-    const response = await apiClient.batchTriggerV3({
-        items: await Promise.all(items.map(async (item, index) => {
+    // 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)
@@ -285,6 +236,7 @@ export async function batchTriggerById(items, options, requestOptions) {
             const payloadPacket = await stringifyIO(parsedPayload);
             const batchItemIdempotencyKey = await makeIdempotencyKey(flattenIdempotencyKey([options?.idempotencyKey, `${index}`]));
             return {
+                index,
                 task: item.id,
                 payload: payloadPacket.data,
                 options: {
@@ -304,257 +256,266 @@ export async function batchTriggerById(items, options, requestOptions) {
                     priority: item.options?.priority,
                     region: item.options?.region,
                     lockToVersion: item.options?.version ?? getEnvVar("TRIGGER_VERSION"),
+                    debounce: item.options?.debounce,
                 },
             };
-        })),
-        parentRunId: taskContext.ctx?.run.id,
-    }, {
-        spanParentAsLink: true,
-        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 ("runCount" in body && typeof body.runCount === "number") {
-                    span.setAttribute("runCount", body.runCount);
-                }
-            }
-        },
-        ...requestOptions,
-    });
-    const handle = {
-        batchId: response.id,
-        runCount: response.runCount,
-        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(requestOptions?.clientConfig);
-    return await tracer.startActiveSpan("batch.triggerAndWait()", async (span) => {
-        const response = await apiClient.batchTriggerV3({
-            items: 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 {
-                    task: item.id,
-                    payload: payloadPacket.data,
-                    options: {
-                        lockToVersion: taskContext.worker?.version,
-                        queue: item.options?.queue ? { name: item.options.queue } : undefined,
-                        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,
-                    },
-                };
-            })),
-            parentRunId: ctx.run.id,
-            resumeParentOnCompletion: true,
+    // 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,
+                    queue: item.options?.queue ? { name: item.options.queue } : undefined,
+                    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);
+            return {
+                id: result.id,
+                runs,
+            };
         }, {
-            processingStrategy: options?.triggerSequentially ? "sequential" : undefined,
-        }, requestOptions);
-        span.setAttribute("batchId", response.id);
-        span.setAttribute("runCount", response.runCount);
-        const result = await runtime.waitForBatch({
-            id: response.id,
+            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);
+            return {
+                id: result.id,
+                runs,
+            };
+        }, {
+            kind: SpanKind.PRODUCER,
+            attributes: {
+                [SemanticInternalAttributes.STYLE_ICON]: "trigger",
+            },
+        });
+    }
+}
+// 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 ? { name: item.options.queue } : undefined,
+                    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 ?? getEnvVar("TRIGGER_VERSION"),
+                    debounce: item.options?.debounce,
+                },
+            };
+        }));
+        // 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,
-            ctx,
+            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 runs = await handleBatchTaskRunExecutionResultV2(result.items);
-        return {
-            id: result.id,
-            runs,
+        const handle = {
+            batchId: response.id,
+            runCount: response.runCount,
+            publicAccessToken: response.publicAccessToken,
         };
-    }, {
-        kind: SpanKind.PRODUCER,
-        attributes: {
-            [SemanticInternalAttributes.STYLE_ICON]: "trigger",
-        },
-    });
+        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 batchTriggerTasks(items, options, requestOptions) {
+// 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);
-    const response = await apiClient.batchTriggerV3({
-        items: await Promise.all(items.map(async (item, index) => {
+    // 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)
@@ -562,9 +523,11 @@ export async function batchTriggerTasks(items, options, requestOptions) {
             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,
                     queue: item.options?.queue ? { name: item.options.queue } : undefined,
                     concurrencyKey: item.options?.concurrencyKey,
                     test: taskContext.ctx?.run.isTest,
@@ -580,176 +543,511 @@ export async function batchTriggerTasks(items, options, requestOptions) {
                     machine: item.options?.machine,
                     priority: item.options?.priority,
                     region: item.options?.region,
-                    lockToVersion: item.options?.version ?? getEnvVar("TRIGGER_VERSION"),
+                    debounce: item.options?.debounce,
                 },
             };
-        })),
-        parentRunId: taskContext.ctx?.run.id,
-    }, {
-        spanParentAsLink: true,
-        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 ("runCount" in body && typeof body.runCount === "number") {
-                    span.setAttribute("runCount", body.runCount);
-                }
-            }
-        },
-        ...requestOptions,
-    });
-    const handle = {
-        batchId: response.id,
-        runCount: response.runCount,
-        publicAccessToken: response.publicAccessToken,
-    };
-    return handle;
+        }));
+        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);
+            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);
+            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.
+ * 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
  *
- * @template TTask - Union type of tasks to be triggered, extends AnyTask
+ * @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) {
+    let batch;
+    try {
+        // Phase 1: Create batch
+        batch = await apiClient.createBatch({
+            runCount: items.length,
+            parentRunId: options.parentRunId,
+            resumeParentOnCompletion: options.resumeParentOnCompletion,
+            idempotencyKey: options.idempotencyKey,
+        }, { 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,
+    };
+}
+/**
+ * Error thrown when batch trigger operations fail.
+ * Includes context about which phase failed and the batch details.
  *
- * @param {Array<BatchByIdAndWaitItem<InferRunTypes<TTask>>>} items - Array of task items to trigger
- * @param {TriggerApiRequestOptions} [requestOptions] - Optional API request configuration
+ * When the underlying error is a rate limit (429), additional properties are exposed:
+ * - `isRateLimited`: true
+ * - `retryAfterMs`: milliseconds until the rate limit resets
+ */
+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;
+        }
+    }
+}
+/**
+ * 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`;
+        }
+        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.
  *
- * @returns {Promise<BatchByIdResult<TTask>>} A promise that resolves with the batch results, including
- * success/failure status and strongly-typed outputs for each task
+ * @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);
+}
+// ============================================================================
+// Streaming Helpers
+// ============================================================================
+/**
+ * Type guard to check if a value is an AsyncIterable
+ */
+function isAsyncIterable(value) {
+    return (value != null &&
+        typeof value === "object" &&
+        Symbol.asyncIterator in value &&
+        typeof value[Symbol.asyncIterator] === "function");
+}
+/**
+ * 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.
  *
- * @throws {Error} If called outside of a task.run() context
- * @throws {Error} If no API client is configured
+ * @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;
+        }
+    }
+    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.
  *
- * @example
- * ```ts
- * import { batch, task } from "@trigger.dev/sdk/v3";
+ * @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: {
+                queue: item.options?.queue ? { name: item.options.queue } : undefined,
+                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 ?? getEnvVar("TRIGGER_VERSION"),
+                debounce: item.options?.debounce,
+            },
+        };
+    }
+}
+/**
+ * Transform a stream of BatchByIdAndWaitItem to BatchItemNDJSON format for triggerAndWait.
+ * Uses the current worker version for lockToVersion.
  *
- * 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 }
- *       }
- *     ]);
+ * @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,
+                queue: item.options?.queue ? { name: item.options.queue } : undefined,
+                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.
  *
- *     // 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);
- *       }
- *     }
- *   }
- * });
- * ```
+ * @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: {
+                queue: item.options?.queue ? { name: item.options.queue } : undefined,
+                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 ?? getEnvVar("TRIGGER_VERSION"),
+                debounce: item.options?.debounce,
+            },
+        };
+    }
+}
+/**
+ * Transform a stream of BatchByTaskAndWaitItem to BatchItemNDJSON format for triggerAndWait.
  *
- * @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
+ */
+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,
+                queue: item.options?.queue ? { name: item.options.queue } : undefined,
+                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.
  *
- * The function provides full type safety for:
- * - Task IDs
- * - Payload types
- * - Return value types
- * - Error handling
+ * @internal
  */
-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()");
+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: {
+                queue: item.options?.queue
+                    ? { name: item.options.queue }
+                    : queue
+                        ? { name: queue }
+                        : undefined,
+                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 ?? getEnvVar("TRIGGER_VERSION"),
+                debounce: item.options?.debounce,
+            },
+        };
     }
-    const apiClient = apiClientManager.clientOrThrow(requestOptions?.clientConfig);
-    return await tracer.startActiveSpan("batch.triggerByTaskAndWait()", async (span) => {
-        const response = await apiClient.batchTriggerV3({
-            items: 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 {
-                    task: item.task.id,
-                    payload: payloadPacket.data,
-                    options: {
-                        lockToVersion: taskContext.worker?.version,
-                        queue: item.options?.queue ? { name: item.options.queue } : undefined,
-                        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,
-                    },
-                };
-            })),
-            parentRunId: ctx.run.id,
-            resumeParentOnCompletion: true,
-        }, {
-            processingStrategy: options?.triggerSequentially ? "sequential" : undefined,
-        }, 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);
-        return {
-            id: result.id,
-            runs,
+}
+/**
+ * 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}`]));
+        yield {
+            index: index++,
+            task: taskIdentifier,
+            payload: payloadPacket.data,
+            options: {
+                lockToVersion: taskContext.worker?.version,
+                queue: item.options?.queue
+                    ? { name: item.options.queue }
+                    : queue
+                        ? { name: queue }
+                        : undefined,
+                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,
+            },
         };
-    }, {
-        kind: SpanKind.PRODUCER,
-        attributes: {
-            [SemanticInternalAttributes.STYLE_ICON]: "trigger",
-        },
-    });
+    }
 }
 async function trigger_internal(name, id, payload, parsePayload, options, requestOptions) {
     const apiClient = apiClientManager.clientOrThrow(requestOptions?.clientConfig);
@@ -775,6 +1073,7 @@ async function trigger_internal(name, id, payload, parsePayload, options, reques
             priority: options?.priority,
             region: options?.region,
             lockToVersion: options?.version ?? getEnvVar("TRIGGER_VERSION"),
+            debounce: options?.debounce,
         },
     }, {
         spanParentAsLink: true,
@@ -796,12 +1095,15 @@ async function trigger_internal(name, id, payload, parsePayload, options, reques
 async function batchTrigger_internal(name, taskIdentifier, items, options, parsePayload, requestOptions, queue) {
     const apiClient = apiClientManager.clientOrThrow(requestOptions?.clientConfig);
     const ctx = taskContext.ctx;
-    const response = await apiClient.batchTriggerV3({
-        items: await Promise.all(items.map(async (item, index) => {
+    // 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}`]));
             return {
+                index,
                 task: taskIdentifier,
                 payload: payloadPacket.data,
                 options: {
@@ -827,33 +1129,75 @@ async function batchTrigger_internal(name, taskIdentifier, items, options, parse
                     lockToVersion: item.options?.version ?? getEnvVar("TRIGGER_VERSION"),
                 },
             };
-        })),
-        parentRunId: ctx?.run.id,
-    }, {
-        spanParentAsLink: true,
-        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 ("runCount" in body && Array.isArray(body.runCount)) {
-                    span.setAttribute("runCount", body.runCount);
-                }
-            }
-        },
-        ...requestOptions,
-    });
-    const handle = {
-        batchId: response.id,
-        runCount: response.runCount,
-        publicAccessToken: response.publicAccessToken,
-    };
-    return handle;
+        }));
+        // Execute 2-phase batch
+        const response = await tracer.startActiveSpan(name, async (span) => {
+            const result = await executeBatchTwoPhase(apiClient, ndJsonItems, {
+                parentRunId: 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",
+                ...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
+        const response = await tracer.startActiveSpan(name, async (span) => {
+            const result = await executeBatchTwoPhaseStreaming(apiClient, transformedItems, {
+                parentRunId: 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",
+                ...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;
@@ -885,6 +1229,7 @@ async function triggerAndWait_internal(name, id, payload, parsePayload, options,
                 machine: options?.machine,
                 priority: options?.priority,
                 region: options?.region,
+                debounce: options?.debounce,
             },
         }, {}, requestOptions);
         span.setAttribute("runId", response.id);
@@ -915,72 +1260,117 @@ async function batchTriggerAndWait_internal(name, id, items, parsePayload, optio
         throw new Error("batchTriggerAndWait can only be used from inside a task.run()");
     }
     const apiClient = apiClientManager.clientOrThrow(requestOptions?.clientConfig);
-    return await tracer.startActiveSpan(name, async (span) => {
-        const response = await apiClient.batchTriggerV3({
-            items: 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}`]));
-                return {
-                    task: id,
-                    payload: payloadPacket.data,
-                    options: {
-                        lockToVersion: taskContext.worker?.version,
-                        queue: item.options?.queue
-                            ? { name: item.options.queue }
-                            : queue
-                                ? { name: queue }
-                                : undefined,
-                        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,
-                    },
-                };
-            })),
-            resumeParentOnCompletion: true,
-            parentRunId: ctx.run.id,
+    // 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}`]));
+            return {
+                index,
+                task: id,
+                payload: payloadPacket.data,
+                options: {
+                    lockToVersion: taskContext.worker?.version,
+                    queue: item.options?.queue
+                        ? { name: item.options.queue }
+                        : queue
+                            ? { name: queue }
+                            : undefined,
+                    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,
+                },
+            };
+        }));
+        return await tracer.startActiveSpan(name, 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 handleBatchTaskRunExecutionResult(result.items, id);
+            return {
+                id: result.id,
+                runs,
+            };
         }, {
-            processingStrategy: options?.triggerSequentially ? "sequential" : undefined,
-        }, requestOptions);
-        span.setAttribute("batchId", response.id);
-        span.setAttribute("runCount", response.runCount);
-        const result = await runtime.waitForBatch({
-            id: response.id,
-            runCount: response.runCount,
-            ctx,
+            kind: SpanKind.PRODUCER,
+            attributes: {
+                [SemanticInternalAttributes.STYLE_ICON]: "trigger",
+                ...accessoryAttributes({
+                    items: [
+                        {
+                            text: id,
+                            variant: "normal",
+                        },
+                    ],
+                    style: "codepath",
+                }),
+            },
         });
-        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);
+        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: 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 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");