@trigger.dev/sdk 3.2.2 → 3.3.0

package/dist/esm/v3/shared.js

@@ -1,6 +1,5 @@
 import { SpanKind } from "@opentelemetry/api";
-import { SEMATTRS_MESSAGING_DESTINATION, SEMATTRS_MESSAGING_OPERATION, SEMATTRS_MESSAGING_SYSTEM, } from "@opentelemetry/semantic-conventions";
-import { accessoryAttributes, apiClientManager, conditionallyImportPacket, convertToolParametersToSchema, createErrorTaskError, defaultRetryOptions, getSchemaParseFn, logger, makeIdempotencyKey, parsePacket, runtime, SemanticInternalAttributes, stringifyIO, SubtaskUnwrapError, taskCatalog, taskContext, TaskRunPromise, } from "@trigger.dev/core/v3";
+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 { tracer } from "./tracer.js";
 export { SubtaskUnwrapError, TaskRunPromise };
@@ -26,11 +25,11 @@ export function createTask(params) {
                 ...options,
             });
         },
-        batchTrigger: async (items) => {
+        batchTrigger: async (items, options) => {
             const taskMetadata = taskCatalog.getTaskManifest(params.id);
             return await batchTrigger_internal(taskMetadata && taskMetadata.exportName
                 ? `${taskMetadata.exportName}.batchTrigger()`
-                : `batchTrigger()`, params.id, items, undefined, undefined, customQueue);
+                : `batchTrigger()`, params.id, items, options, undefined, undefined, customQueue);
         },
         triggerAndWait: (payload, options) => {
             const taskMetadata = taskCatalog.getTaskManifest(params.id);
@@ -117,11 +116,11 @@ export function createSchemaTask(params) {
                 ...options,
             }, requestOptions);
         },
-        batchTrigger: async (items, 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, parsePayload, requestOptions, customQueue);
+                : `batchTrigger()`, params.id, items, options, parsePayload, requestOptions, customQueue);
         },
         triggerAndWait: (payload, options) => {
             const taskMetadata = taskCatalog.getTaskManifest(params.id);
@@ -264,8 +263,540 @@ 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, requestOptions) {
-    return await batchTrigger_internal("tasks.batchTrigger()", id, items, undefined, 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);
+            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: {
+                    queue: item.options?.queue,
+                    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,
+                },
+            };
+        })),
+    }, {
+        spanParentAsLink: true,
+        idempotencyKey: await makeIdempotencyKey(options?.idempotencyKey),
+        idempotencyKeyTTL: options?.idempotencyKeyTTL,
+    }, {
+        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;
+}
+/**
+ * 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, requestOptions) {
+    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,
+                    },
+                };
+            })),
+            dependentAttempt: ctx.attempt.id,
+        }, {}, 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,
+        });
+        const runs = await handleBatchTaskRunExecutionResultV2(result.items);
+        return {
+            id: result.id,
+            runs,
+        };
+    }, {
+        kind: SpanKind.PRODUCER,
+    });
+}
+/**
+ * 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);
+            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: {
+                    queue: item.options?.queue,
+                    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,
+                },
+            };
+        })),
+    }, {
+        spanParentAsLink: true,
+        idempotencyKey: await makeIdempotencyKey(options?.idempotencyKey),
+        idempotencyKeyTTL: options?.idempotencyKeyTTL,
+    }, {
+        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;
+}
+/**
+ * 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 batchTriggerAndWaitTasks(items, requestOptions) {
+    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.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,
+                    },
+                };
+            })),
+            dependentAttempt: ctx.attempt.id,
+        }, {}, 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,
+        });
+        const runs = await handleBatchTaskRunExecutionResultV2(result.items);
+        return {
+            id: result.id,
+            runs,
+        };
+    }, {
+        kind: SpanKind.PRODUCER,
+    });
 }
 async function trigger_internal(name, id, payload, parsePayload, options, requestOptions) {
     const apiClient = apiClientManager.clientOrThrow();
@@ -279,6 +810,7 @@ async function trigger_internal(name, id, payload, parsePayload, options, reques
             test: taskContext.ctx?.run.isTest,
             payloadType: payloadPacket.dataType,
             idempotencyKey: await makeIdempotencyKey(options?.idempotencyKey),
+            idempotencyKeyTTL: options?.idempotencyKeyTTL,
             delay: options?.delay,
             ttl: options?.ttl,
             tags: options?.tags,
@@ -293,30 +825,25 @@ async function trigger_internal(name, id, payload, parsePayload, options, reques
         name,
         tracer,
         icon: "trigger",
-        attributes: {
-            [SEMATTRS_MESSAGING_OPERATION]: "publish",
-            ["messaging.client_id"]: taskContext.worker?.id,
-            [SEMATTRS_MESSAGING_SYSTEM]: "trigger.dev",
-        },
         onResponseBody: (body, span) => {
-            body &&
-                typeof body === "object" &&
-                !Array.isArray(body) &&
-                "id" in body &&
-                typeof body.id === "string" &&
-                span.setAttribute("messaging.message.id", body.id);
+            if (body && typeof body === "object" && !Array.isArray(body)) {
+                if ("id" in body && typeof body.id === "string") {
+                    span.setAttribute("runId", body.id);
+                }
+            }
         },
         ...requestOptions,
     });
     return handle;
 }
-async function batchTrigger_internal(name, id, items, parsePayload, requestOptions, queue) {
+async function batchTrigger_internal(name, taskIdentifier, items, options, parsePayload, requestOptions, queue) {
     const apiClient = apiClientManager.clientOrThrow();
-    const response = await apiClient.batchTriggerTask(id, {
+    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: taskIdentifier,
                 payload: payloadPacket.data,
                 options: {
                     queue: item.options?.queue ?? queue,
@@ -324,6 +851,7 @@ async function batchTrigger_internal(name, id, items, parsePayload, requestOptio
                     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,
@@ -334,20 +862,40 @@ async function batchTrigger_internal(name, id, items, parsePayload, requestOptio
                 },
             };
         })),
-    }, { spanParentAsLink: true }, {
+    }, {
+        spanParentAsLink: true,
+        idempotencyKey: await makeIdempotencyKey(options?.idempotencyKey),
+        idempotencyKeyTTL: options?.idempotencyKeyTTL,
+    }, {
         name,
         tracer,
         icon: "trigger",
-        attributes: {
-            [SEMATTRS_MESSAGING_OPERATION]: "publish",
-            ["messaging.client_id"]: taskContext.worker?.id,
-            [SEMATTRS_MESSAGING_SYSTEM]: "trigger.dev",
+        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.batchId,
-        runs: response.runs.map((id) => ({ id })),
+        batchId: response.id,
+        isCached: response.isCached,
+        idempotencyKey: response.idempotencyKey,
+        runs: response.runs,
         publicAccessToken: response.publicAccessToken,
     };
     return handle;
@@ -370,7 +918,6 @@ async function triggerAndWait_internal(name, id, payload, parsePayload, options,
                 concurrencyKey: options?.concurrencyKey,
                 test: taskContext.ctx?.run.isTest,
                 payloadType: payloadPacket.dataType,
-                idempotencyKey: await makeIdempotencyKey(options?.idempotencyKey),
                 delay: options?.delay,
                 ttl: options?.ttl,
                 tags: options?.tags,
@@ -379,31 +926,15 @@ async function triggerAndWait_internal(name, id, payload, parsePayload, options,
                 maxDuration: options?.maxDuration,
             },
         }, {}, requestOptions);
-        span.setAttribute("messaging.message.id", response.id);
-        if (options?.idempotencyKey) {
-            // If an idempotency key is provided, we can check if the result is already available
-            const result = await apiClient.getRunResult(response.id);
-            if (result) {
-                logger.log(`Result reused from previous task run with idempotency key '${options.idempotencyKey}'.`, {
-                    runId: response.id,
-                    idempotencyKey: options.idempotencyKey,
-                });
-                return await handleTaskRunExecutionResult(result);
-            }
-        }
+        span.setAttribute("runId", response.id);
         const result = await runtime.waitForTask({
             id: response.id,
             ctx,
         });
-        return await handleTaskRunExecutionResult(result);
+        return await handleTaskRunExecutionResult(result, id);
     }, {
         kind: SpanKind.PRODUCER,
         attributes: {
-            [SemanticInternalAttributes.STYLE_ICON]: "trigger",
-            [SEMATTRS_MESSAGING_OPERATION]: "publish",
-            ["messaging.client_id"]: taskContext.worker?.id,
-            [SEMATTRS_MESSAGING_DESTINATION]: id,
-            [SEMATTRS_MESSAGING_SYSTEM]: "trigger.dev",
             ...accessoryAttributes({
                 items: [
                     {
@@ -423,11 +954,12 @@ async function batchTriggerAndWait_internal(name, id, items, parsePayload, reque
     }
     const apiClient = apiClientManager.clientOrThrow();
     return await tracer.startActiveSpan(name, async (span) => {
-        const response = await apiClient.batchTriggerTask(id, {
+        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,
@@ -435,7 +967,6 @@ async function batchTriggerAndWait_internal(name, id, items, parsePayload, reque
                         concurrencyKey: item.options?.concurrencyKey,
                         test: taskContext.ctx?.run.isTest,
                         payloadType: payloadPacket.dataType,
-                        idempotencyKey: await makeIdempotencyKey(item.options?.idempotencyKey),
                         delay: item.options?.delay,
                         ttl: item.options?.ttl,
                         tags: item.options?.tags,
@@ -447,52 +978,21 @@ async function batchTriggerAndWait_internal(name, id, items, parsePayload, reque
             })),
             dependentAttempt: ctx.attempt.id,
         }, {}, requestOptions);
-        span.setAttribute("messaging.message.id", response.batchId);
-        const getBatchResults = async () => {
-            // We need to check if the results are already available, but only if any of the items options has an idempotency key
-            const hasIdempotencyKey = items.some((item) => item.options?.idempotencyKey);
-            if (hasIdempotencyKey) {
-                const results = await apiClient.getBatchResults(response.batchId);
-                if (results) {
-                    return results;
-                }
-            }
-            return {
-                id: response.batchId,
-                items: [],
-            };
-        };
-        const existingResults = await getBatchResults();
-        const incompleteRuns = response.runs.filter((runId) => !existingResults.items.some((item) => item.id === runId));
-        if (incompleteRuns.length === 0) {
-            logger.log(`Results reused from previous task runs because of the provided idempotency keys.`);
-            // All runs are already completed
-            const runs = await handleBatchTaskRunExecutionResult(existingResults.items);
-            return {
-                id: existingResults.id,
-                runs,
-            };
+        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.batchId,
-            runs: incompleteRuns,
+            id: response.id,
+            runs: response.runs.map((run) => run.id),
             ctx,
         });
-        // Combine the already completed runs with the newly completed runs, ordered by the original order
-        const combinedItems = [];
-        for (const runId of response.runs) {
-            const existingItem = existingResults.items.find((item) => item.id === runId);
-            if (existingItem) {
-                combinedItems.push(existingItem);
-            }
-            else {
-                const newItem = result.items.find((item) => item.id === runId);
-                if (newItem) {
-                    combinedItems.push(newItem);
-                }
-            }
-        }
-        const runs = await handleBatchTaskRunExecutionResult(combinedItems);
+        const runs = await handleBatchTaskRunExecutionResult(result.items, id);
         return {
             id: result.id,
             runs,
@@ -500,12 +1000,6 @@ async function batchTriggerAndWait_internal(name, id, items, parsePayload, reque
     }, {
         kind: SpanKind.PRODUCER,
         attributes: {
-            [SemanticInternalAttributes.STYLE_ICON]: "trigger",
-            ["messaging.batch.message_count"]: items.length,
-            [SEMATTRS_MESSAGING_OPERATION]: "publish",
-            ["messaging.client_id"]: taskContext.worker?.id,
-            [SEMATTRS_MESSAGING_DESTINATION]: id,
-            [SEMATTRS_MESSAGING_SYSTEM]: "trigger.dev",
             ...accessoryAttributes({
                 items: [
                     {
@@ -518,17 +1012,35 @@ async function batchTriggerAndWait_internal(name, id, items, parsePayload, reque
         },
     });
 }
-async function handleBatchTaskRunExecutionResult(items) {
+async function handleBatchTaskRunExecutionResult(items, taskIdentifier) {
+    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, taskIdentifier);
+        }));
+        return results;
+    }
+    return await tracer.startActiveSpan("store.downloadPayloads", async (span) => {
+        const results = await Promise.all(items.map(async (item) => {
+            return await handleTaskRunExecutionResult(item, taskIdentifier);
+        }));
+        return results;
+    }, {
+        kind: SpanKind.INTERNAL,
+        [SemanticInternalAttributes.STYLE_ICON]: "cloud-download",
+    });
+}
+async function handleBatchTaskRunExecutionResultV2(items) {
     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);
+            return await handleTaskRunExecutionResult(item, item.taskIdentifier ?? "unknown");
         }));
         return results;
     }
     return await tracer.startActiveSpan("store.downloadPayloads", async (span) => {
         const results = await Promise.all(items.map(async (item) => {
-            return await handleTaskRunExecutionResult(item);
+            return await handleTaskRunExecutionResult(item, item.taskIdentifier ?? "unknown");
         }));
         return results;
     }, {
@@ -536,13 +1048,14 @@ async function handleBatchTaskRunExecutionResult(items) {
         [SemanticInternalAttributes.STYLE_ICON]: "cloud-download",
     });
 }
-async function handleTaskRunExecutionResult(execution) {
+async function handleTaskRunExecutionResult(execution, taskIdentifier) {
     if (execution.ok) {
         const outputPacket = { data: execution.output, dataType: execution.outputType };
         const importedPacket = await conditionallyImportPacket(outputPacket, tracer);
         return {
             ok: true,
             id: execution.id,
+            taskIdentifier: (execution.taskIdentifier ?? taskIdentifier),
             output: await parsePacket(importedPacket),
         };
     }
@@ -550,6 +1063,7 @@ async function handleTaskRunExecutionResult(execution) {
         return {
             ok: false,
             id: execution.id,
+            taskIdentifier: (execution.taskIdentifier ?? taskIdentifier),
             error: createErrorTaskError(execution.error),
         };
     }