@trigger.dev/sdk 3.3.16 → 4.0.0-v4-beta.0

package/dist/esm/v3/shared.js

@@ -1,43 +1,31 @@
 import { SpanKind } from "@opentelemetry/api";
-import { accessoryAttributes, apiClientManager, conditionallyImportPacket, convertToolParametersToSchema, createErrorTaskError, defaultRetryOptions, getSchemaParseFn, makeIdempotencyKey, parsePacket, runtime, SemanticInternalAttributes, stringifyIO, SubtaskUnwrapError, taskCatalog, taskContext, TaskRunPromise, } from "@trigger.dev/core/v3";
+import { 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 { runs } from "./runs.js";
 import { tracer } from "./tracer.js";
 export { SubtaskUnwrapError, TaskRunPromise };
 export function queue(options) {
+    resourceCatalog.registerQueueMetadata(options);
+    // @ts-expect-error
+    options[Symbol.for("trigger.dev/queue")] = true;
     return options;
 }
 export function createTask(params) {
-    const customQueue = params.queue
-        ? queue({
-            name: params.queue?.name ?? `task/${params.id}`,
-            ...params.queue,
-        })
-        : undefined;
     const task = {
         id: params.id,
         description: params.description,
         trigger: async (payload, options) => {
-            const taskMetadata = taskCatalog.getTaskManifest(params.id);
-            return await trigger_internal(taskMetadata && taskMetadata.exportName
-                ? `${taskMetadata.exportName}.trigger()`
-                : `trigger()`, params.id, payload, undefined, {
-                queue: customQueue,
+            return await trigger_internal("trigger()", params.id, payload, undefined, {
+                queue: params.queue?.name,
                 ...options,
             });
         },
         batchTrigger: async (items, options) => {
-            const taskMetadata = taskCatalog.getTaskManifest(params.id);
-            return await batchTrigger_internal(taskMetadata && taskMetadata.exportName
-                ? `${taskMetadata.exportName}.batchTrigger()`
-                : `batchTrigger()`, params.id, items, options, undefined, undefined, customQueue);
+            return await batchTrigger_internal("batchTrigger()", params.id, items, options, undefined, undefined, params.queue?.name);
         },
         triggerAndWait: (payload, options) => {
-            const taskMetadata = taskCatalog.getTaskManifest(params.id);
             return new TaskRunPromise((resolve, reject) => {
-                triggerAndWait_internal(taskMetadata && taskMetadata.exportName
-                    ? `${taskMetadata.exportName}.triggerAndWait()`
-                    : `triggerAndWait()`, params.id, payload, undefined, {
-                    queue: customQueue,
+                triggerAndWait_internal("triggerAndWait()", params.id, payload, undefined, {
+                    queue: params.queue?.name,
                     ...options,
                 })
                     .then((result) => {
@@ -49,13 +37,11 @@ export function createTask(params) {
             }, params.id);
         },
         batchTriggerAndWait: async (items, options) => {
-            const taskMetadata = taskCatalog.getTaskManifest(params.id);
-            return await batchTriggerAndWait_internal(taskMetadata && taskMetadata.exportName
-                ? `${taskMetadata.exportName}.batchTriggerAndWait()`
-                : `batchTriggerAndWait()`, params.id, items, undefined, options, undefined, customQueue);
+            return await batchTriggerAndWait_internal("batchTriggerAndWait()", params.id, items, undefined, options, undefined, params.queue?.name);
         },
     };
-    taskCatalog.registerTaskMetadata({
+    registerTaskLifecycleHooks(params.id, params);
+    resourceCatalog.registerTaskMetadata({
         id: params.id,
         description: params.description,
         queue: params.queue,
@@ -64,19 +50,23 @@ export function createTask(params) {
         maxDuration: params.maxDuration,
         fns: {
             run: params.run,
-            init: params.init,
-            cleanup: params.cleanup,
-            middleware: params.middleware,
-            handleError: params.handleError,
-            onSuccess: params.onSuccess,
-            onFailure: params.onFailure,
-            onStart: params.onStart,
         },
     });
+    const queue = params.queue;
+    if (queue && typeof queue.name === "string") {
+        resourceCatalog.registerQueueMetadata({
+            name: queue.name,
+            concurrencyLimit: queue.concurrencyLimit,
+            releaseConcurrencyOnWaitpoint: queue.releaseConcurrencyOnWaitpoint,
+        });
+    }
     // @ts-expect-error
     task[Symbol.for("trigger.dev/task")] = true;
     return task;
 }
+/**
+ * @deprecated use ai.tool() instead
+ */
 export function createToolTask(params) {
     const task = createSchemaTask({
         ...params,
@@ -94,12 +84,6 @@ export function createToolTask(params) {
     };
 }
 export function createSchemaTask(params) {
-    const customQueue = params.queue
-        ? queue({
-            name: params.queue?.name ?? `task/${params.id}`,
-            ...params.queue,
-        })
-        : undefined;
     const parsePayload = params.schema
         ? getSchemaParseFn(params.schema)
         : undefined;
@@ -108,27 +92,18 @@ export function createSchemaTask(params) {
         description: params.description,
         schema: params.schema,
         trigger: async (payload, options, requestOptions) => {
-            const taskMetadata = taskCatalog.getTaskManifest(params.id);
-            return await trigger_internal(taskMetadata && taskMetadata.exportName
-                ? `${taskMetadata.exportName}.trigger()`
-                : `trigger()`, params.id, payload, parsePayload, {
-                queue: customQueue,
+            return await trigger_internal("trigger()", params.id, payload, parsePayload, {
+                queue: params.queue?.name,
                 ...options,
             }, requestOptions);
         },
         batchTrigger: async (items, options, requestOptions) => {
-            const taskMetadata = taskCatalog.getTaskManifest(params.id);
-            return await batchTrigger_internal(taskMetadata && taskMetadata.exportName
-                ? `${taskMetadata.exportName}.batchTrigger()`
-                : `batchTrigger()`, params.id, items, options, parsePayload, requestOptions, customQueue);
+            return await batchTrigger_internal("batchTrigger()", params.id, items, options, parsePayload, requestOptions, params.queue?.name);
         },
         triggerAndWait: (payload, options) => {
-            const taskMetadata = taskCatalog.getTaskManifest(params.id);
             return new TaskRunPromise((resolve, reject) => {
-                triggerAndWait_internal(taskMetadata && taskMetadata.exportName
-                    ? `${taskMetadata.exportName}.triggerAndWait()`
-                    : `triggerAndWait()`, params.id, payload, parsePayload, {
-                    queue: customQueue,
+                triggerAndWait_internal("triggerAndWait()", params.id, payload, parsePayload, {
+                    queue: params.queue?.name,
                     ...options,
                 })
                     .then((result) => {
@@ -140,13 +115,11 @@ export function createSchemaTask(params) {
             }, params.id);
         },
         batchTriggerAndWait: async (items, options) => {
-            const taskMetadata = taskCatalog.getTaskManifest(params.id);
-            return await batchTriggerAndWait_internal(taskMetadata && taskMetadata.exportName
-                ? `${taskMetadata.exportName}.batchTriggerAndWait()`
-                : `batchTriggerAndWait()`, params.id, items, parsePayload, options, undefined, customQueue);
+            return await batchTriggerAndWait_internal("batchTriggerAndWait()", params.id, items, parsePayload, options, undefined, params.queue?.name);
         },
     };
-    taskCatalog.registerTaskMetadata({
+    registerTaskLifecycleHooks(params.id, params);
+    resourceCatalog.registerTaskMetadata({
         id: params.id,
         description: params.description,
         queue: params.queue,
@@ -155,16 +128,17 @@ export function createSchemaTask(params) {
         maxDuration: params.maxDuration,
         fns: {
             run: params.run,
-            init: params.init,
-            cleanup: params.cleanup,
-            middleware: params.middleware,
-            handleError: params.handleError,
-            onSuccess: params.onSuccess,
-            onFailure: params.onFailure,
-            onStart: params.onStart,
             parsePayload,
         },
     });
+    const queue = params.queue;
+    if (queue && typeof queue.name === "string") {
+        resourceCatalog.registerQueueMetadata({
+            name: queue.name,
+            concurrencyLimit: queue.concurrencyLimit,
+            releaseConcurrencyOnWaitpoint: queue.releaseConcurrencyOnWaitpoint,
+        });
+    }
     // @ts-expect-error
     task[Symbol.for("trigger.dev/task")] = true;
     return task;
@@ -321,38 +295,39 @@ export async function batchTrigger(id, items, options, requestOptions) {
  */
 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 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: {
-                    queue: item.options?.queue,
+                    queue: item.options?.queue ? { name: item.options.queue } : undefined,
                     concurrencyKey: item.options?.concurrencyKey,
                     test: taskContext.ctx?.run.isTest,
                     payloadType: payloadPacket.dataType,
-                    idempotencyKey: await makeIdempotencyKey(item.options?.idempotencyKey),
-                    idempotencyKeyTTL: item.options?.idempotencyKeyTTL,
                     delay: item.options?.delay,
                     ttl: item.options?.ttl,
                     tags: item.options?.tags,
                     maxAttempts: item.options?.maxAttempts,
-                    parentAttempt: taskContext.ctx?.attempt.id,
                     metadata: item.options?.metadata,
                     maxDuration: item.options?.maxDuration,
+                    idempotencyKey: (await makeIdempotencyKey(item.options?.idempotencyKey)) ?? batchItemIdempotencyKey,
+                    idempotencyKeyTTL: item.options?.idempotencyKeyTTL ?? options?.idempotencyKeyTTL,
                     machine: item.options?.machine,
+                    priority: item.options?.priority,
+                    lockToVersion: item.options?.version ?? getEnvVar("TRIGGER_VERSION"),
                 },
             };
         })),
+        parentRunId: taskContext.ctx?.run.id,
     }, {
         spanParentAsLink: true,
-        idempotencyKey: await makeIdempotencyKey(options?.idempotencyKey),
-        idempotencyKeyTTL: options?.idempotencyKeyTTL,
         processingStrategy: options?.triggerSequentially ? "sequential" : undefined,
     }, {
         name: "batch.trigger()",
@@ -363,17 +338,8 @@ export async function batchTriggerById(items, options, requestOptions) {
                 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);
+                if ("runCount" in body && typeof body.runCount === "number") {
+                    span.setAttribute("runCount", body.runCount);
                 }
             }
         },
@@ -381,9 +347,7 @@ export async function batchTriggerById(items, options, requestOptions) {
     });
     const handle = {
         batchId: response.id,
-        isCached: response.isCached,
-        idempotencyKey: response.idempotencyKey,
-        runs: response.runs,
+        runCount: response.runCount,
         publicAccessToken: response.publicAccessToken,
     };
     return handle;
@@ -472,19 +436,20 @@ export async function batchTriggerByIdAndWait(items, options, requestOptions) {
     }
     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 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,
+                        queue: item.options?.queue ? { name: item.options.queue } : undefined,
                         concurrencyKey: item.options?.concurrencyKey,
                         test: taskContext.ctx?.run.isTest,
                         payloadType: payloadPacket.dataType,
@@ -494,26 +459,24 @@ export async function batchTriggerByIdAndWait(items, options, requestOptions) {
                         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,
                     },
                 };
             })),
-            dependentAttempt: ctx.attempt.id,
+            parentRunId: ctx.run.id,
+            resumeParentOnCompletion: true,
         }, {
             processingStrategy: options?.triggerSequentially ? "sequential" : undefined,
         }, requestOptions);
         span.setAttribute("batchId", response.id);
-        span.setAttribute("runCount", response.runs.length);
-        span.setAttribute("isCached", response.isCached);
-        if (response.isCached) {
-            console.warn(`Result is a cached response because the request was idempotent.`);
-        }
-        if (response.idempotencyKey) {
-            span.setAttribute("idempotencyKey", response.idempotencyKey);
-        }
+        span.setAttribute("runCount", response.runCount);
         const result = await runtime.waitForBatch({
             id: response.id,
-            runs: response.runs.map((run) => run.id),
+            runCount: response.runCount,
             ctx,
         });
         const runs = await handleBatchTaskRunExecutionResultV2(result.items);
@@ -607,38 +570,39 @@ export async function batchTriggerByIdAndWait(items, options, requestOptions) {
  */
 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 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: {
-                    queue: item.options?.queue,
+                    queue: item.options?.queue ? { name: item.options.queue } : undefined,
                     concurrencyKey: item.options?.concurrencyKey,
                     test: taskContext.ctx?.run.isTest,
                     payloadType: payloadPacket.dataType,
-                    idempotencyKey: await makeIdempotencyKey(item.options?.idempotencyKey),
-                    idempotencyKeyTTL: item.options?.idempotencyKeyTTL,
                     delay: item.options?.delay,
                     ttl: item.options?.ttl,
                     tags: item.options?.tags,
                     maxAttempts: item.options?.maxAttempts,
-                    parentAttempt: taskContext.ctx?.attempt.id,
                     metadata: item.options?.metadata,
                     maxDuration: item.options?.maxDuration,
+                    idempotencyKey: (await makeIdempotencyKey(item.options?.idempotencyKey)) ?? batchItemIdempotencyKey,
+                    idempotencyKeyTTL: item.options?.idempotencyKeyTTL ?? options?.idempotencyKeyTTL,
                     machine: item.options?.machine,
+                    priority: item.options?.priority,
+                    lockToVersion: item.options?.version ?? getEnvVar("TRIGGER_VERSION"),
                 },
             };
         })),
+        parentRunId: taskContext.ctx?.run.id,
     }, {
         spanParentAsLink: true,
-        idempotencyKey: await makeIdempotencyKey(options?.idempotencyKey),
-        idempotencyKeyTTL: options?.idempotencyKeyTTL,
         processingStrategy: options?.triggerSequentially ? "sequential" : undefined,
     }, {
         name: "batch.triggerByTask()",
@@ -649,17 +613,8 @@ export async function batchTriggerTasks(items, options, requestOptions) {
                 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);
+                if ("runCount" in body && typeof body.runCount === "number") {
+                    span.setAttribute("runCount", body.runCount);
                 }
             }
         },
@@ -667,9 +622,7 @@ export async function batchTriggerTasks(items, options, requestOptions) {
     });
     const handle = {
         batchId: response.id,
-        isCached: response.isCached,
-        idempotencyKey: response.idempotencyKey,
-        runs: response.runs,
+        runCount: response.runCount,
         publicAccessToken: response.publicAccessToken,
     };
     return handle;
@@ -758,19 +711,20 @@ export async function batchTriggerAndWaitTasks(items, options, requestOptions) {
     }
     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 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,
+                        queue: item.options?.queue ? { name: item.options.queue } : undefined,
                         concurrencyKey: item.options?.concurrencyKey,
                         test: taskContext.ctx?.run.isTest,
                         payloadType: payloadPacket.dataType,
@@ -780,26 +734,24 @@ export async function batchTriggerAndWaitTasks(items, options, requestOptions) {
                         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,
                     },
                 };
             })),
-            dependentAttempt: ctx.attempt.id,
+            parentRunId: ctx.run.id,
+            resumeParentOnCompletion: true,
         }, {
             processingStrategy: options?.triggerSequentially ? "sequential" : undefined,
         }, requestOptions);
         span.setAttribute("batchId", response.id);
-        span.setAttribute("runCount", response.runs.length);
-        span.setAttribute("isCached", response.isCached);
-        if (response.isCached) {
-            console.warn(`Result is a cached response because the request was idempotent.`);
-        }
-        if (response.idempotencyKey) {
-            span.setAttribute("idempotencyKey", response.idempotencyKey);
-        }
+        span.setAttribute("runCount", response.runCount);
         const result = await runtime.waitForBatch({
             id: response.id,
-            runs: response.runs.map((run) => run.id),
+            runCount: response.runCount,
             ctx,
         });
         const runs = await handleBatchTaskRunExecutionResultV2(result.items);
@@ -821,7 +773,7 @@ async function trigger_internal(name, id, payload, parsePayload, options, reques
     const handle = await apiClient.triggerTask(id, {
         payload: payloadPacket.data,
         options: {
-            queue: options?.queue,
+            queue: options?.queue ? { name: options.queue } : undefined,
             concurrencyKey: options?.concurrencyKey,
             test: taskContext.ctx?.run.isTest,
             payloadType: payloadPacket.dataType,
@@ -831,10 +783,12 @@ async function trigger_internal(name, id, payload, parsePayload, options, reques
             ttl: options?.ttl,
             tags: options?.tags,
             maxAttempts: options?.maxAttempts,
-            parentAttempt: taskContext.ctx?.attempt.id,
             metadata: options?.metadata,
             maxDuration: options?.maxDuration,
+            parentRunId: taskContext.ctx?.run.id,
             machine: options?.machine,
+            priority: options?.priority,
+            lockToVersion: options?.version ?? getEnvVar("TRIGGER_VERSION"),
         },
     }, {
         spanParentAsLink: true,
@@ -855,35 +809,41 @@ 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();
-    const response = await apiClient.batchTriggerV2({
-        items: await Promise.all(items.map(async (item) => {
+    const ctx = taskContext.ctx;
+    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: taskIdentifier,
                 payload: payloadPacket.data,
                 options: {
-                    queue: item.options?.queue ?? queue,
+                    queue: item.options?.queue
+                        ? { name: item.options.queue }
+                        : queue
+                            ? { name: queue }
+                            : undefined,
                     concurrencyKey: item.options?.concurrencyKey,
                     test: taskContext.ctx?.run.isTest,
                     payloadType: payloadPacket.dataType,
-                    idempotencyKey: await makeIdempotencyKey(item.options?.idempotencyKey),
-                    idempotencyKeyTTL: item.options?.idempotencyKeyTTL,
                     delay: item.options?.delay,
                     ttl: item.options?.ttl,
                     tags: item.options?.tags,
                     maxAttempts: item.options?.maxAttempts,
-                    parentAttempt: taskContext.ctx?.attempt.id,
                     metadata: item.options?.metadata,
                     maxDuration: item.options?.maxDuration,
+                    idempotencyKey: (await makeIdempotencyKey(item.options?.idempotencyKey)) ?? batchItemIdempotencyKey,
+                    idempotencyKeyTTL: item.options?.idempotencyKeyTTL ?? options?.idempotencyKeyTTL,
                     machine: item.options?.machine,
+                    priority: item.options?.priority,
+                    lockToVersion: item.options?.version ?? getEnvVar("TRIGGER_VERSION"),
                 },
             };
         })),
+        parentRunId: ctx?.run.id,
     }, {
         spanParentAsLink: true,
-        idempotencyKey: await makeIdempotencyKey(options?.idempotencyKey),
-        idempotencyKeyTTL: options?.idempotencyKeyTTL,
         processingStrategy: options?.triggerSequentially ? "sequential" : undefined,
     }, {
         name,
@@ -894,17 +854,8 @@ async function batchTrigger_internal(name, taskIdentifier, items, options, parse
                 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);
+                if ("runCount" in body && Array.isArray(body.runCount)) {
+                    span.setAttribute("runCount", body.runCount);
                 }
             }
         },
@@ -912,9 +863,7 @@ async function batchTrigger_internal(name, taskIdentifier, items, options, parse
     });
     const handle = {
         batchId: response.id,
-        isCached: response.isCached,
-        idempotencyKey: response.idempotencyKey,
-        runs: response.runs,
+        runCount: response.runCount,
         publicAccessToken: response.publicAccessToken,
     };
     return handle;
@@ -933,7 +882,7 @@ async function triggerAndWait_internal(name, id, payload, parsePayload, options,
             options: {
                 dependentAttempt: ctx.attempt.id,
                 lockToVersion: taskContext.worker?.version, // Lock to current version because we're waiting for it to finish
-                queue: options?.queue,
+                queue: options?.queue ? { name: options.queue } : undefined,
                 concurrencyKey: options?.concurrencyKey,
                 test: taskContext.ctx?.run.isTest,
                 payloadType: payloadPacket.dataType,
@@ -943,7 +892,13 @@ async function triggerAndWait_internal(name, id, payload, parsePayload, options,
                 maxAttempts: options?.maxAttempts,
                 metadata: options?.metadata,
                 maxDuration: options?.maxDuration,
+                resumeParentOnCompletion: true,
+                parentRunId: ctx.run.id,
+                idempotencyKey: await makeIdempotencyKey(options?.idempotencyKey),
+                idempotencyKeyTTL: options?.idempotencyKeyTTL,
                 machine: options?.machine,
+                priority: options?.priority,
+                releaseConcurrency: options?.releaseConcurrency,
             },
         }, {}, requestOptions);
         span.setAttribute("runId", response.id);
@@ -975,16 +930,21 @@ async function batchTriggerAndWait_internal(name, id, items, parsePayload, optio
     }
     const apiClient = apiClientManager.clientOrThrow();
     return await tracer.startActiveSpan(name, async (span) => {
-        const response = await apiClient.batchTriggerV2({
-            items: await Promise.all(items.map(async (item) => {
+        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 ?? queue,
+                        queue: item.options?.queue
+                            ? { name: item.options.queue }
+                            : queue
+                                ? { name: queue }
+                                : undefined,
                         concurrencyKey: item.options?.concurrencyKey,
                         test: taskContext.ctx?.run.isTest,
                         payloadType: payloadPacket.dataType,
@@ -994,26 +954,24 @@ async function batchTriggerAndWait_internal(name, id, items, parsePayload, optio
                         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,
                     },
                 };
             })),
-            dependentAttempt: ctx.attempt.id,
+            resumeParentOnCompletion: true,
+            parentRunId: ctx.run.id,
         }, {
             processingStrategy: options?.triggerSequentially ? "sequential" : undefined,
         }, requestOptions);
         span.setAttribute("batchId", response.id);
-        span.setAttribute("runCount", response.runs.length);
-        span.setAttribute("isCached", response.isCached);
-        if (response.isCached) {
-            console.warn(`Result is a cached response because the request was idempotent.`);
-        }
-        if (response.idempotencyKey) {
-            span.setAttribute("idempotencyKey", response.idempotencyKey);
-        }
+        span.setAttribute("runCount", response.runCount);
         const result = await runtime.waitForBatch({
             id: response.id,
-            runs: response.runs.map((run) => run.id),
+            runCount: response.runCount,
             ctx,
         });
         const runs = await handleBatchTaskRunExecutionResult(result.items, id);
@@ -1093,4 +1051,62 @@ async function handleTaskRunExecutionResult(execution, taskIdentifier) {
         };
     }
 }
+function registerTaskLifecycleHooks(taskId, params) {
+    if (params.init) {
+        lifecycleHooks.registerTaskInitHook(taskId, {
+            fn: params.init,
+        });
+    }
+    if (params.onStart) {
+        lifecycleHooks.registerTaskStartHook(taskId, {
+            fn: params.onStart,
+        });
+    }
+    if (params.onFailure) {
+        lifecycleHooks.registerTaskFailureHook(taskId, {
+            fn: params.onFailure,
+        });
+    }
+    if (params.onSuccess) {
+        lifecycleHooks.registerTaskSuccessHook(taskId, {
+            fn: params.onSuccess,
+        });
+    }
+    if (params.onComplete) {
+        lifecycleHooks.registerTaskCompleteHook(taskId, {
+            fn: params.onComplete,
+        });
+    }
+    if (params.onWait) {
+        lifecycleHooks.registerTaskWaitHook(taskId, {
+            fn: params.onWait,
+        });
+    }
+    if (params.onResume) {
+        lifecycleHooks.registerTaskResumeHook(taskId, {
+            fn: params.onResume,
+        });
+    }
+    if (params.catchError) {
+        // We don't need to use an adapter here because catchError is the new version of handleError
+        lifecycleHooks.registerTaskCatchErrorHook(taskId, {
+            fn: params.catchError,
+        });
+    }
+    if (params.handleError) {
+        lifecycleHooks.registerTaskCatchErrorHook(taskId, {
+            fn: params.handleError,
+        });
+    }
+    if (params.middleware) {
+        lifecycleHooks.registerTaskMiddlewareHook(taskId, {
+            fn: params.middleware,
+        });
+    }
+    if (params.cleanup) {
+        lifecycleHooks.registerTaskCleanupHook(taskId, {
+            fn: params.cleanup,
+        });
+    }
+}
 //# sourceMappingURL=shared.js.map