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

package/dist/commonjs/v3/shared.js

@@ -21,40 +21,28 @@ Object.defineProperty(exports, "TaskRunPromise", { enumerable: true, get: functi
 const runs_js_1 = require("./runs.js");
 const tracer_js_1 = require("./tracer.js");
 function queue(options) {
+    v3_1.resourceCatalog.registerQueueMetadata(options);
+    // @ts-expect-error
+    options[Symbol.for("trigger.dev/queue")] = true;
     return options;
 }
 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 = v3_1.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 = v3_1.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 = v3_1.taskCatalog.getTaskManifest(params.id);
             return new v3_1.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) => {
@@ -66,13 +54,11 @@ function createTask(params) {
             }, params.id);
         },
         batchTriggerAndWait: async (items, options) => {
-            const taskMetadata = v3_1.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);
         },
     };
-    v3_1.taskCatalog.registerTaskMetadata({
+    registerTaskLifecycleHooks(params.id, params);
+    v3_1.resourceCatalog.registerTaskMetadata({
         id: params.id,
         description: params.description,
         queue: params.queue,
@@ -81,19 +67,23 @@ 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") {
+        v3_1.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
+ */
 function createToolTask(params) {
     const task = createSchemaTask({
         ...params,
@@ -111,12 +101,6 @@ function createToolTask(params) {
     };
 }
 function createSchemaTask(params) {
-    const customQueue = params.queue
-        ? queue({
-            name: params.queue?.name ?? `task/${params.id}`,
-            ...params.queue,
-        })
-        : undefined;
     const parsePayload = params.schema
         ? (0, v3_1.getSchemaParseFn)(params.schema)
         : undefined;
@@ -125,27 +109,18 @@ function createSchemaTask(params) {
         description: params.description,
         schema: params.schema,
         trigger: async (payload, options, requestOptions) => {
-            const taskMetadata = v3_1.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 = v3_1.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 = v3_1.taskCatalog.getTaskManifest(params.id);
             return new v3_1.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) => {
@@ -157,13 +132,11 @@ function createSchemaTask(params) {
             }, params.id);
         },
         batchTriggerAndWait: async (items, options) => {
-            const taskMetadata = v3_1.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);
         },
     };
-    v3_1.taskCatalog.registerTaskMetadata({
+    registerTaskLifecycleHooks(params.id, params);
+    v3_1.resourceCatalog.registerTaskMetadata({
         id: params.id,
         description: params.description,
         queue: params.queue,
@@ -172,16 +145,17 @@ 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") {
+        v3_1.resourceCatalog.registerQueueMetadata({
+            name: queue.name,
+            concurrencyLimit: queue.concurrencyLimit,
+            releaseConcurrencyOnWaitpoint: queue.releaseConcurrencyOnWaitpoint,
+        });
+    }
     // @ts-expect-error
     task[Symbol.for("trigger.dev/task")] = true;
     return task;
@@ -338,38 +312,39 @@ async function batchTrigger(id, items, options, requestOptions) {
  */
 async function batchTriggerById(items, options, requestOptions) {
     const apiClient = v3_1.apiClientManager.clientOrThrow();
-    const response = await apiClient.batchTriggerV2({
-        items: await Promise.all(items.map(async (item) => {
-            const taskMetadata = v3_1.taskCatalog.getTask(item.id);
+    const response = await apiClient.batchTriggerV3({
+        items: await Promise.all(items.map(async (item, index) => {
+            const taskMetadata = v3_1.resourceCatalog.getTask(item.id);
             const parsedPayload = taskMetadata?.fns.parsePayload
                 ? await taskMetadata?.fns.parsePayload(item.payload)
                 : item.payload;
             const payloadPacket = await (0, v3_1.stringifyIO)(parsedPayload);
+            const batchItemIdempotencyKey = await (0, v3_1.makeIdempotencyKey)((0, v3_1.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: v3_1.taskContext.ctx?.run.isTest,
                     payloadType: payloadPacket.dataType,
-                    idempotencyKey: await (0, v3_1.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: v3_1.taskContext.ctx?.attempt.id,
                     metadata: item.options?.metadata,
                     maxDuration: item.options?.maxDuration,
+                    idempotencyKey: (await (0, v3_1.makeIdempotencyKey)(item.options?.idempotencyKey)) ?? batchItemIdempotencyKey,
+                    idempotencyKeyTTL: item.options?.idempotencyKeyTTL ?? options?.idempotencyKeyTTL,
                     machine: item.options?.machine,
+                    priority: item.options?.priority,
+                    lockToVersion: item.options?.version ?? (0, v3_1.getEnvVar)("TRIGGER_VERSION"),
                 },
             };
         })),
+        parentRunId: v3_1.taskContext.ctx?.run.id,
     }, {
         spanParentAsLink: true,
-        idempotencyKey: await (0, v3_1.makeIdempotencyKey)(options?.idempotencyKey),
-        idempotencyKeyTTL: options?.idempotencyKeyTTL,
         processingStrategy: options?.triggerSequentially ? "sequential" : undefined,
     }, {
         name: "batch.trigger()",
@@ -380,17 +355,8 @@ 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);
                 }
             }
         },
@@ -398,9 +364,7 @@ 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;
@@ -489,19 +453,20 @@ async function batchTriggerByIdAndWait(items, options, requestOptions) {
     }
     const apiClient = v3_1.apiClientManager.clientOrThrow();
     return await tracer_js_1.tracer.startActiveSpan("batch.triggerAndWait()", async (span) => {
-        const response = await apiClient.batchTriggerV2({
-            items: await Promise.all(items.map(async (item) => {
-                const taskMetadata = v3_1.taskCatalog.getTask(item.id);
+        const response = await apiClient.batchTriggerV3({
+            items: await Promise.all(items.map(async (item, index) => {
+                const taskMetadata = v3_1.resourceCatalog.getTask(item.id);
                 const parsedPayload = taskMetadata?.fns.parsePayload
                     ? await taskMetadata?.fns.parsePayload(item.payload)
                     : item.payload;
                 const payloadPacket = await (0, v3_1.stringifyIO)(parsedPayload);
+                const batchItemIdempotencyKey = await (0, v3_1.makeIdempotencyKey)((0, v3_1.flattenIdempotencyKey)([options?.idempotencyKey, `${index}`]));
                 return {
                     task: item.id,
                     payload: payloadPacket.data,
                     options: {
                         lockToVersion: v3_1.taskContext.worker?.version,
-                        queue: item.options?.queue,
+                        queue: item.options?.queue ? { name: item.options.queue } : undefined,
                         concurrencyKey: item.options?.concurrencyKey,
                         test: v3_1.taskContext.ctx?.run.isTest,
                         payloadType: payloadPacket.dataType,
@@ -511,26 +476,24 @@ async function batchTriggerByIdAndWait(items, options, requestOptions) {
                         maxAttempts: item.options?.maxAttempts,
                         metadata: item.options?.metadata,
                         maxDuration: item.options?.maxDuration,
+                        idempotencyKey: (await (0, v3_1.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 v3_1.runtime.waitForBatch({
             id: response.id,
-            runs: response.runs.map((run) => run.id),
+            runCount: response.runCount,
             ctx,
         });
         const runs = await handleBatchTaskRunExecutionResultV2(result.items);
@@ -624,38 +587,39 @@ async function batchTriggerByIdAndWait(items, options, requestOptions) {
  */
 async function batchTriggerTasks(items, options, requestOptions) {
     const apiClient = v3_1.apiClientManager.clientOrThrow();
-    const response = await apiClient.batchTriggerV2({
-        items: await Promise.all(items.map(async (item) => {
-            const taskMetadata = v3_1.taskCatalog.getTask(item.task.id);
+    const response = await apiClient.batchTriggerV3({
+        items: await Promise.all(items.map(async (item, index) => {
+            const taskMetadata = v3_1.resourceCatalog.getTask(item.task.id);
             const parsedPayload = taskMetadata?.fns.parsePayload
                 ? await taskMetadata?.fns.parsePayload(item.payload)
                 : item.payload;
             const payloadPacket = await (0, v3_1.stringifyIO)(parsedPayload);
+            const batchItemIdempotencyKey = await (0, v3_1.makeIdempotencyKey)((0, v3_1.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: v3_1.taskContext.ctx?.run.isTest,
                     payloadType: payloadPacket.dataType,
-                    idempotencyKey: await (0, v3_1.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: v3_1.taskContext.ctx?.attempt.id,
                     metadata: item.options?.metadata,
                     maxDuration: item.options?.maxDuration,
+                    idempotencyKey: (await (0, v3_1.makeIdempotencyKey)(item.options?.idempotencyKey)) ?? batchItemIdempotencyKey,
+                    idempotencyKeyTTL: item.options?.idempotencyKeyTTL ?? options?.idempotencyKeyTTL,
                     machine: item.options?.machine,
+                    priority: item.options?.priority,
+                    lockToVersion: item.options?.version ?? (0, v3_1.getEnvVar)("TRIGGER_VERSION"),
                 },
             };
         })),
+        parentRunId: v3_1.taskContext.ctx?.run.id,
     }, {
         spanParentAsLink: true,
-        idempotencyKey: await (0, v3_1.makeIdempotencyKey)(options?.idempotencyKey),
-        idempotencyKeyTTL: options?.idempotencyKeyTTL,
         processingStrategy: options?.triggerSequentially ? "sequential" : undefined,
     }, {
         name: "batch.triggerByTask()",
@@ -666,17 +630,8 @@ 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);
                 }
             }
         },
@@ -684,9 +639,7 @@ 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;
@@ -775,19 +728,20 @@ async function batchTriggerAndWaitTasks(items, options, requestOptions) {
     }
     const apiClient = v3_1.apiClientManager.clientOrThrow();
     return await tracer_js_1.tracer.startActiveSpan("batch.triggerByTaskAndWait()", async (span) => {
-        const response = await apiClient.batchTriggerV2({
-            items: await Promise.all(items.map(async (item) => {
-                const taskMetadata = v3_1.taskCatalog.getTask(item.task.id);
+        const response = await apiClient.batchTriggerV3({
+            items: await Promise.all(items.map(async (item, index) => {
+                const taskMetadata = v3_1.resourceCatalog.getTask(item.task.id);
                 const parsedPayload = taskMetadata?.fns.parsePayload
                     ? await taskMetadata?.fns.parsePayload(item.payload)
                     : item.payload;
                 const payloadPacket = await (0, v3_1.stringifyIO)(parsedPayload);
+                const batchItemIdempotencyKey = await (0, v3_1.makeIdempotencyKey)((0, v3_1.flattenIdempotencyKey)([options?.idempotencyKey, `${index}`]));
                 return {
                     task: item.task.id,
                     payload: payloadPacket.data,
                     options: {
                         lockToVersion: v3_1.taskContext.worker?.version,
-                        queue: item.options?.queue,
+                        queue: item.options?.queue ? { name: item.options.queue } : undefined,
                         concurrencyKey: item.options?.concurrencyKey,
                         test: v3_1.taskContext.ctx?.run.isTest,
                         payloadType: payloadPacket.dataType,
@@ -797,26 +751,24 @@ async function batchTriggerAndWaitTasks(items, options, requestOptions) {
                         maxAttempts: item.options?.maxAttempts,
                         metadata: item.options?.metadata,
                         maxDuration: item.options?.maxDuration,
+                        idempotencyKey: (await (0, v3_1.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 v3_1.runtime.waitForBatch({
             id: response.id,
-            runs: response.runs.map((run) => run.id),
+            runCount: response.runCount,
             ctx,
         });
         const runs = await handleBatchTaskRunExecutionResultV2(result.items);
@@ -838,7 +790,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: v3_1.taskContext.ctx?.run.isTest,
             payloadType: payloadPacket.dataType,
@@ -848,10 +800,12 @@ async function trigger_internal(name, id, payload, parsePayload, options, reques
             ttl: options?.ttl,
             tags: options?.tags,
             maxAttempts: options?.maxAttempts,
-            parentAttempt: v3_1.taskContext.ctx?.attempt.id,
             metadata: options?.metadata,
             maxDuration: options?.maxDuration,
+            parentRunId: v3_1.taskContext.ctx?.run.id,
             machine: options?.machine,
+            priority: options?.priority,
+            lockToVersion: options?.version ?? (0, v3_1.getEnvVar)("TRIGGER_VERSION"),
         },
     }, {
         spanParentAsLink: true,
@@ -872,35 +826,41 @@ async function trigger_internal(name, id, payload, parsePayload, options, reques
 }
 async function batchTrigger_internal(name, taskIdentifier, items, options, parsePayload, requestOptions, queue) {
     const apiClient = v3_1.apiClientManager.clientOrThrow();
-    const response = await apiClient.batchTriggerV2({
-        items: await Promise.all(items.map(async (item) => {
+    const ctx = v3_1.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 (0, v3_1.stringifyIO)(parsedPayload);
+            const batchItemIdempotencyKey = await (0, v3_1.makeIdempotencyKey)((0, v3_1.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: v3_1.taskContext.ctx?.run.isTest,
                     payloadType: payloadPacket.dataType,
-                    idempotencyKey: await (0, v3_1.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: v3_1.taskContext.ctx?.attempt.id,
                     metadata: item.options?.metadata,
                     maxDuration: item.options?.maxDuration,
+                    idempotencyKey: (await (0, v3_1.makeIdempotencyKey)(item.options?.idempotencyKey)) ?? batchItemIdempotencyKey,
+                    idempotencyKeyTTL: item.options?.idempotencyKeyTTL ?? options?.idempotencyKeyTTL,
                     machine: item.options?.machine,
+                    priority: item.options?.priority,
+                    lockToVersion: item.options?.version ?? (0, v3_1.getEnvVar)("TRIGGER_VERSION"),
                 },
             };
         })),
+        parentRunId: ctx?.run.id,
     }, {
         spanParentAsLink: true,
-        idempotencyKey: await (0, v3_1.makeIdempotencyKey)(options?.idempotencyKey),
-        idempotencyKeyTTL: options?.idempotencyKeyTTL,
         processingStrategy: options?.triggerSequentially ? "sequential" : undefined,
     }, {
         name,
@@ -911,17 +871,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);
                 }
             }
         },
@@ -929,9 +880,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;
@@ -950,7 +899,7 @@ async function triggerAndWait_internal(name, id, payload, parsePayload, options,
             options: {
                 dependentAttempt: ctx.attempt.id,
                 lockToVersion: v3_1.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: v3_1.taskContext.ctx?.run.isTest,
                 payloadType: payloadPacket.dataType,
@@ -960,7 +909,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 (0, v3_1.makeIdempotencyKey)(options?.idempotencyKey),
+                idempotencyKeyTTL: options?.idempotencyKeyTTL,
                 machine: options?.machine,
+                priority: options?.priority,
+                releaseConcurrency: options?.releaseConcurrency,
             },
         }, {}, requestOptions);
         span.setAttribute("runId", response.id);
@@ -992,16 +947,21 @@ async function batchTriggerAndWait_internal(name, id, items, parsePayload, optio
     }
     const apiClient = v3_1.apiClientManager.clientOrThrow();
     return await tracer_js_1.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 (0, v3_1.stringifyIO)(parsedPayload);
+                const batchItemIdempotencyKey = await (0, v3_1.makeIdempotencyKey)((0, v3_1.flattenIdempotencyKey)([options?.idempotencyKey, `${index}`]));
                 return {
                     task: id,
                     payload: payloadPacket.data,
                     options: {
                         lockToVersion: v3_1.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: v3_1.taskContext.ctx?.run.isTest,
                         payloadType: payloadPacket.dataType,
@@ -1011,26 +971,24 @@ async function batchTriggerAndWait_internal(name, id, items, parsePayload, optio
                         maxAttempts: item.options?.maxAttempts,
                         metadata: item.options?.metadata,
                         maxDuration: item.options?.maxDuration,
+                        idempotencyKey: (await (0, v3_1.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 v3_1.runtime.waitForBatch({
             id: response.id,
-            runs: response.runs.map((run) => run.id),
+            runCount: response.runCount,
             ctx,
         });
         const runs = await handleBatchTaskRunExecutionResult(result.items, id);
@@ -1110,4 +1068,62 @@ async function handleTaskRunExecutionResult(execution, taskIdentifier) {
         };
     }
 }
+function registerTaskLifecycleHooks(taskId, params) {
+    if (params.init) {
+        v3_1.lifecycleHooks.registerTaskInitHook(taskId, {
+            fn: params.init,
+        });
+    }
+    if (params.onStart) {
+        v3_1.lifecycleHooks.registerTaskStartHook(taskId, {
+            fn: params.onStart,
+        });
+    }
+    if (params.onFailure) {
+        v3_1.lifecycleHooks.registerTaskFailureHook(taskId, {
+            fn: params.onFailure,
+        });
+    }
+    if (params.onSuccess) {
+        v3_1.lifecycleHooks.registerTaskSuccessHook(taskId, {
+            fn: params.onSuccess,
+        });
+    }
+    if (params.onComplete) {
+        v3_1.lifecycleHooks.registerTaskCompleteHook(taskId, {
+            fn: params.onComplete,
+        });
+    }
+    if (params.onWait) {
+        v3_1.lifecycleHooks.registerTaskWaitHook(taskId, {
+            fn: params.onWait,
+        });
+    }
+    if (params.onResume) {
+        v3_1.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
+        v3_1.lifecycleHooks.registerTaskCatchErrorHook(taskId, {
+            fn: params.catchError,
+        });
+    }
+    if (params.handleError) {
+        v3_1.lifecycleHooks.registerTaskCatchErrorHook(taskId, {
+            fn: params.handleError,
+        });
+    }
+    if (params.middleware) {
+        v3_1.lifecycleHooks.registerTaskMiddlewareHook(taskId, {
+            fn: params.middleware,
+        });
+    }
+    if (params.cleanup) {
+        v3_1.lifecycleHooks.registerTaskCleanupHook(taskId, {
+            fn: params.cleanup,
+        });
+    }
+}
 //# sourceMappingURL=shared.js.map