@trigger.dev/sdk 0.0.0-prerelease-20260911153544 → 0.0.0-prerelease-windows-bundle-fix-20260928100448

package/dist/commonjs/v3/shared.d.ts

@@ -1,8 +1,25 @@
-import { type ApiRequestOptions, type InitOutput, type Queue, type QueueOptions, type TaskFromIdentifier, type TaskRunContext, ApiError, SubtaskUnwrapError, TaskRunPromise, type AnyRunHandle, type AnyTask, type BatchByIdAndWaitItem, type BatchByIdItem, type BatchByIdResult, type BatchByTaskAndWaitItem, type BatchByTaskItem, type BatchByTaskResult, type BatchItem, type BatchItemNDJSON, type BatchResult, type BatchRunHandle, type BatchRunHandleFromTypes, type BatchTasksRunHandleFromTypes, type BatchTriggerAndWaitOptions, type BatchTriggerOptions, type InferRunTypes, type RunHandle, type RunHandleFromTypes, type Task, type TaskIdentifier, type TaskOptions, type TaskOptionsWithSchema, type TaskOutput, type TaskPayload, type TaskRunResult, type TaskSchema, type TaskWithSchema, type TaskWithSchemaOptions, type TaskWithToolOptions, type ToolTask, type ToolTaskParameters, type TriggerAndSubscribeOptions, type TriggerAndWaitOptions, type TriggerApiRequestOptions, type TriggerOptions } from "@trigger.dev/core/v3";
+import { type ApiRequestOptions, type InitOutput, type Queue, type QueueOptions, type TaskFromIdentifier, type TaskRunContext, ApiError, SubtaskUnwrapError, TaskRunPromise, type AnyRunHandle, type AnyTask, type BatchByIdAndWaitItem, type BatchByIdItem, type BatchByIdResult, type BatchByTaskAndWaitItem, type BatchByTaskItem, type BatchByTaskResult, type BatchItem, type BatchItemNDJSON, type BatchResult, type BatchRunHandle, type BatchRunHandleFromTypes, type BatchTasksRunHandleFromTypes, type BatchTriggerAndWaitOptions, type BatchTriggerOptions, type InferRunTypes, type RunHandle, type RunHandleFromTypes, type Task, type TaskIdentifier, type TaskOptions, type TaskOptionsWithSchema, type TaskOutput, type TaskPayload, type TaskRunResult, type TaskSchema, type TaskWithSchema, type TaskWithSchemaOptions, type TaskWithToolOptions, type ToolTask, type ToolTaskParameters, type TriggerAndSubscribeOptions, type TriggerAndWaitOptions, type TriggerApiRequestOptions, type TriggerOptions, type ConcurrencyLimitOptions, type ConcurrencyLimit } from "@trigger.dev/core/v3";
 export type { AnyRunHandle, AnyTask, BatchItem, BatchResult, BatchRunHandle, BatchTriggerOptions, Queue, RunHandle, Task, TaskFromIdentifier, TaskIdentifier, TaskOptions, TaskOptionsWithSchema, TaskOutput, TaskPayload, TaskRunResult, TaskSchema, TaskWithSchema, TaskWithSchemaOptions, TriggerOptions, };
 export { SubtaskUnwrapError, TaskRunPromise };
 export type Context = TaskRunContext;
 export declare function queue(options: QueueOptions): Queue;
+/**
+ * Declares a named, shareable concurrency limit. Tasks hold it via their `concurrency`
+ * option; every task holding the same limit draws from the same pools.
+ *
+ * @example
+ *
+ * ```ts
+ * export const openaiLimit = concurrencyLimit({ name: "openai", total: 25 });
+ *
+ * export const generateSummary = task({
+ *   id: "generate-summary",
+ *   concurrency: [{ total: 5 }, openaiLimit],
+ *   run: async (payload) => {},
+ * });
+ * ```
+ */
+export declare function concurrencyLimit(options: ConcurrencyLimitOptions): ConcurrencyLimit;
 export declare function createTask<TIdentifier extends string, TOutput = unknown, TInitOutput extends InitOutput = any>(params: TaskOptionsWithSchema<TIdentifier, TOutput, TInitOutput>): Task<TIdentifier, any, TOutput>;
 export declare function createTask<TIdentifier extends string, TInput = void, TOutput = unknown, TInitOutput extends InitOutput = any>(params: TaskOptions<TIdentifier, TInput, TOutput, TInitOutput>): Task<TIdentifier, TInput, TOutput>;
 /**

package/dist/commonjs/v3/shared.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BatchTriggerError = exports.TaskRunPromise = exports.SubtaskUnwrapError = void 0;
 exports.queue = queue;
+exports.concurrencyLimit = concurrencyLimit;
 exports.createTask = createTask;
 exports.createToolTask = createToolTask;
 exports.createSchemaTask = createSchemaTask;
@@ -23,30 +24,105 @@ Object.defineProperty(exports, "SubtaskUnwrapError", { enumerable: true, get: fu
 Object.defineProperty(exports, "TaskRunPromise", { enumerable: true, get: function () { return v3_1.TaskRunPromise; } });
 const externalDeploymentId_js_1 = require("./externalDeploymentId.js");
 const tracer_js_1 = require("./tracer.js");
+const concurrency_shared_js_1 = require("./concurrency-shared.js");
+/** A task's `queue` is a queue object or a string reference to a queue defined elsewhere. */
+function normalizeTaskQueue(queue) {
+    if (!queue) {
+        return {};
+    }
+    return { queue: typeof queue === "string" ? { name: queue } : queue };
+}
+/**
+ * Validates and normalizes the task `concurrency` option into its manifest shape:
+ * at most one inline limit (caps this task) plus up to two named limits (shared).
+ */
+function normalizeTaskConcurrency(taskId, concurrency) {
+    if (!concurrency) {
+        return undefined;
+    }
+    const items = Array.isArray(concurrency) ? concurrency : [concurrency];
+    const inline = [];
+    const limits = [];
+    for (const item of items) {
+        if (typeof item === "string") {
+            limits.push(item);
+        }
+        else if (item &&
+            typeof item === "object" &&
+            "name" in item &&
+            typeof item.name === "string") {
+            (0, concurrency_shared_js_1.validateConcurrencyLimitName)(item.name);
+            v3_1.resourceCatalog.registerConcurrencyLimitMetadata(item);
+            limits.push(item.name);
+        }
+        else if (item && typeof item === "object") {
+            inline.push({ perKey: item.perKey, total: item.total });
+        }
+    }
+    if (inline.length > 1) {
+        throw new Error(`Task "${taskId}": concurrency accepts at most one inline limit. Give shared limits a name with concurrencyLimit().`);
+    }
+    if (limits.length > 2) {
+        throw new Error(`Task "${taskId}": concurrency accepts at most two named limits.`);
+    }
+    return {
+        inline: inline[0],
+        limits: limits.length > 0 ? limits : undefined,
+    };
+}
+/** Builds the queue field of a trigger request body. */
+function triggerQueueBody(queue, fallbackQueueName) {
+    const name = queue ?? fallbackQueueName;
+    return { queue: name ? { name } : undefined };
+}
 function queue(options) {
     v3_1.resourceCatalog.registerQueueMetadata(options);
     // @ts-expect-error
     options[Symbol.for("trigger.dev/queue")] = true;
     return options;
 }
+/**
+ * Declares a named, shareable concurrency limit. Tasks hold it via their `concurrency`
+ * option; every task holding the same limit draws from the same pools.
+ *
+ * @example
+ *
+ * ```ts
+ * export const openaiLimit = concurrencyLimit({ name: "openai", total: 25 });
+ *
+ * export const generateSummary = task({
+ *   id: "generate-summary",
+ *   concurrency: [{ total: 5 }, openaiLimit],
+ *   run: async (payload) => {},
+ * });
+ * ```
+ */
+function concurrencyLimit(options) {
+    (0, concurrency_shared_js_1.validateConcurrencyLimitName)(options.name);
+    v3_1.resourceCatalog.registerConcurrencyLimitMetadata(options);
+    // @ts-expect-error
+    options[Symbol.for("trigger.dev/concurrencyLimit")] = true;
+    return options;
+}
 function createTask(params) {
+    const normalizedQueue = normalizeTaskQueue(params.queue);
     const task = {
         id: params.id,
         description: params.description,
         jsonSchema: params.jsonSchema,
         trigger: async (payload, options) => {
             return await trigger_internal("trigger()", params.id, payload, undefined, {
-                queue: params.queue?.name,
+                queue: normalizedQueue.queue?.name,
                 ...options,
             });
         },
         batchTrigger: async (items, options) => {
-            return await batchTrigger_internal("batchTrigger()", params.id, items, options, undefined, undefined, params.queue?.name);
+            return await batchTrigger_internal("batchTrigger()", params.id, items, options, undefined, undefined, normalizedQueue.queue?.name);
         },
         triggerAndWait: (payload, options, requestOptions) => {
             return new v3_1.TaskRunPromise((resolve, reject) => {
                 triggerAndWait_internal("triggerAndWait()", params.id, payload, undefined, {
-                    queue: params.queue?.name,
+                    queue: normalizedQueue.queue?.name,
                     ...options,
                 }, requestOptions)
                     .then((result) => {
@@ -60,7 +136,7 @@ function createTask(params) {
         triggerAndSubscribe: (payload, options) => {
             return new v3_1.TaskRunPromise((resolve, reject) => {
                 triggerAndSubscribe_internal("triggerAndSubscribe()", params.id, payload, undefined, {
-                    queue: params.queue?.name,
+                    queue: normalizedQueue.queue?.name,
                     ...options,
                 })
                     .then((result) => {
@@ -72,14 +148,15 @@ function createTask(params) {
             }, params.id);
         },
         batchTriggerAndWait: async (items, options) => {
-            return await batchTriggerAndWait_internal("batchTriggerAndWait()", params.id, items, undefined, options, undefined, params.queue?.name);
+            return await batchTriggerAndWait_internal("batchTriggerAndWait()", params.id, items, undefined, options, undefined, normalizedQueue.queue?.name);
         },
     };
     registerTaskLifecycleHooks(params.id, params);
     v3_1.resourceCatalog.registerTaskMetadata({
         id: params.id,
         description: params.description,
-        queue: params.queue,
+        queue: normalizedQueue.queue,
+        concurrency: normalizeTaskConcurrency(params.id, params.concurrency),
         retry: params.retry ? { ...v3_1.defaultRetryOptions, ...params.retry } : undefined,
         machine: typeof params.machine === "string" ? { preset: params.machine } : params.machine,
         triggerSource: params.triggerSource,
@@ -91,8 +168,14 @@ function createTask(params) {
             run: params.run,
         },
     });
-    const queue = params.queue;
-    if (queue && typeof queue.name === "string") {
+    const queue = normalizedQueue.queue;
+    /**
+     * A string queue name (bare or as a tuple's first element) is a REFERENCE to a
+     * queue defined elsewhere; registering it would create an empty definition that
+     * can shadow the real one depending on module evaluation order.
+     */
+    const homeIsReference = typeof params.queue === "string";
+    if (queue && typeof queue.name === "string" && !homeIsReference) {
         v3_1.resourceCatalog.registerQueueMetadata({
             name: queue.name,
             concurrencyLimit: queue.concurrencyLimit,
@@ -125,23 +208,24 @@ function createSchemaTask(params) {
     const parsePayload = params.schema
         ? (0, v3_1.getSchemaParseFn)(params.schema)
         : undefined;
+    const normalizedQueue = normalizeTaskQueue(params.queue);
     const task = {
         id: params.id,
         description: params.description,
         schema: params.schema,
         trigger: async (payload, options, requestOptions) => {
             return await trigger_internal("trigger()", params.id, payload, parsePayload, {
-                queue: params.queue?.name,
+                queue: normalizedQueue.queue?.name,
                 ...options,
             }, requestOptions);
         },
         batchTrigger: async (items, options, requestOptions) => {
-            return await batchTrigger_internal("batchTrigger()", params.id, items, options, parsePayload, requestOptions, params.queue?.name);
+            return await batchTrigger_internal("batchTrigger()", params.id, items, options, parsePayload, requestOptions, normalizedQueue.queue?.name);
         },
         triggerAndWait: (payload, options) => {
             return new v3_1.TaskRunPromise((resolve, reject) => {
                 triggerAndWait_internal("triggerAndWait()", params.id, payload, parsePayload, {
-                    queue: params.queue?.name,
+                    queue: normalizedQueue.queue?.name,
                     ...options,
                 })
                     .then((result) => {
@@ -155,7 +239,7 @@ function createSchemaTask(params) {
         triggerAndSubscribe: (payload, options) => {
             return new v3_1.TaskRunPromise((resolve, reject) => {
                 triggerAndSubscribe_internal("triggerAndSubscribe()", params.id, payload, parsePayload, {
-                    queue: params.queue?.name,
+                    queue: normalizedQueue.queue?.name,
                     ...options,
                 })
                     .then((result) => {
@@ -167,14 +251,15 @@ function createSchemaTask(params) {
             }, params.id);
         },
         batchTriggerAndWait: async (items, options) => {
-            return await batchTriggerAndWait_internal("batchTriggerAndWait()", params.id, items, parsePayload, options, undefined, params.queue?.name);
+            return await batchTriggerAndWait_internal("batchTriggerAndWait()", params.id, items, parsePayload, options, undefined, normalizedQueue.queue?.name);
         },
     };
     registerTaskLifecycleHooks(params.id, params);
     v3_1.resourceCatalog.registerTaskMetadata({
         id: params.id,
         description: params.description,
-        queue: params.queue,
+        queue: normalizedQueue.queue,
+        concurrency: normalizeTaskConcurrency(params.id, params.concurrency),
         retry: params.retry ? { ...v3_1.defaultRetryOptions, ...params.retry } : undefined,
         machine: typeof params.machine === "string" ? { preset: params.machine } : params.machine,
         triggerSource: params.triggerSource,
@@ -187,8 +272,14 @@ function createSchemaTask(params) {
         },
         schema: params.schema,
     });
-    const queue = params.queue;
-    if (queue && typeof queue.name === "string") {
+    const queue = normalizedQueue.queue;
+    /**
+     * A string queue name (bare or as a tuple's first element) is a REFERENCE to a
+     * queue defined elsewhere; registering it would create an empty definition that
+     * can shadow the real one depending on module evaluation order.
+     */
+    const homeIsReference = typeof params.queue === "string";
+    if (queue && typeof queue.name === "string" && !homeIsReference) {
         v3_1.resourceCatalog.registerQueueMetadata({
             name: queue.name,
             concurrencyLimit: queue.concurrencyLimit,
@@ -327,7 +418,8 @@ async function batchTriggerById(...args) {
                 task: item.id,
                 payload: payloadPacket.data,
                 options: {
-                    queue: item.options?.queue ? { name: item.options.queue } : undefined,
+                    ...triggerQueueBody(item.options?.queue),
+                    ...(0, concurrency_shared_js_1.triggerConcurrencyBody)(item.options?.concurrency),
                     concurrencyKey: item.options?.concurrencyKey,
                     test: v3_1.taskContext.ctx?.run.isTest,
                     payloadType: payloadPacket.dataType,
@@ -423,7 +515,8 @@ async function batchTriggerByIdAndWait(...args) {
                 payload: payloadPacket.data,
                 options: {
                     lockToVersion: v3_1.taskContext.worker?.version,
-                    queue: item.options?.queue ? { name: item.options.queue } : undefined,
+                    ...triggerQueueBody(item.options?.queue),
+                    ...(0, concurrency_shared_js_1.triggerConcurrencyBody)(item.options?.concurrency),
                     concurrencyKey: item.options?.concurrencyKey,
                     test: v3_1.taskContext.ctx?.run.isTest,
                     payloadType: payloadPacket.dataType,
@@ -520,7 +613,8 @@ async function batchTriggerTasks(...args) {
                 task: item.task.id,
                 payload: payloadPacket.data,
                 options: {
-                    queue: item.options?.queue ? { name: item.options.queue } : undefined,
+                    ...triggerQueueBody(item.options?.queue),
+                    ...(0, concurrency_shared_js_1.triggerConcurrencyBody)(item.options?.concurrency),
                     concurrencyKey: item.options?.concurrencyKey,
                     test: v3_1.taskContext.ctx?.run.isTest,
                     payloadType: payloadPacket.dataType,
@@ -617,7 +711,8 @@ async function batchTriggerAndWaitTasks(...args) {
                 payload: payloadPacket.data,
                 options: {
                     lockToVersion: v3_1.taskContext.worker?.version,
-                    queue: item.options?.queue ? { name: item.options.queue } : undefined,
+                    ...triggerQueueBody(item.options?.queue),
+                    ...(0, concurrency_shared_js_1.triggerConcurrencyBody)(item.options?.concurrency),
                     concurrencyKey: item.options?.concurrencyKey,
                     test: v3_1.taskContext.ctx?.run.isTest,
                     payloadType: payloadPacket.dataType,
@@ -976,7 +1071,8 @@ async function* transformBatchItemsStream(items, options) {
             task: item.id,
             payload: payloadPacket.data,
             options: {
-                queue: item.options?.queue ? { name: item.options.queue } : undefined,
+                ...triggerQueueBody(item.options?.queue),
+                ...(0, concurrency_shared_js_1.triggerConcurrencyBody)(item.options?.concurrency),
                 concurrencyKey: item.options?.concurrencyKey,
                 test: v3_1.taskContext.ctx?.run.isTest,
                 payloadType: payloadPacket.dataType,
@@ -1019,7 +1115,8 @@ async function* transformBatchItemsStreamForWait(items, options) {
             payload: payloadPacket.data,
             options: {
                 lockToVersion: v3_1.taskContext.worker?.version,
-                queue: item.options?.queue ? { name: item.options.queue } : undefined,
+                ...triggerQueueBody(item.options?.queue),
+                ...(0, concurrency_shared_js_1.triggerConcurrencyBody)(item.options?.concurrency),
                 concurrencyKey: item.options?.concurrencyKey,
                 test: v3_1.taskContext.ctx?.run.isTest,
                 payloadType: payloadPacket.dataType,
@@ -1058,7 +1155,8 @@ async function* transformBatchByTaskItemsStream(items, options) {
             task: item.task.id,
             payload: payloadPacket.data,
             options: {
-                queue: item.options?.queue ? { name: item.options.queue } : undefined,
+                ...triggerQueueBody(item.options?.queue),
+                ...(0, concurrency_shared_js_1.triggerConcurrencyBody)(item.options?.concurrency),
                 concurrencyKey: item.options?.concurrencyKey,
                 test: v3_1.taskContext.ctx?.run.isTest,
                 payloadType: payloadPacket.dataType,
@@ -1100,7 +1198,8 @@ async function* transformBatchByTaskItemsStreamForWait(items, options) {
             payload: payloadPacket.data,
             options: {
                 lockToVersion: v3_1.taskContext.worker?.version,
-                queue: item.options?.queue ? { name: item.options.queue } : undefined,
+                ...triggerQueueBody(item.options?.queue),
+                ...(0, concurrency_shared_js_1.triggerConcurrencyBody)(item.options?.concurrency),
                 concurrencyKey: item.options?.concurrencyKey,
                 test: v3_1.taskContext.ctx?.run.isTest,
                 payloadType: payloadPacket.dataType,
@@ -1136,11 +1235,8 @@ async function* transformSingleTaskBatchItemsStream(taskIdentifier, items, parse
             task: taskIdentifier,
             payload: payloadPacket.data,
             options: {
-                queue: item.options?.queue
-                    ? { name: item.options.queue }
-                    : queue
-                        ? { name: queue }
-                        : undefined,
+                ...triggerQueueBody(item.options?.queue, queue),
+                ...(0, concurrency_shared_js_1.triggerConcurrencyBody)(item.options?.concurrency),
                 concurrencyKey: item.options?.concurrencyKey,
                 test: v3_1.taskContext.ctx?.run.isTest,
                 payloadType: payloadPacket.dataType,
@@ -1185,11 +1281,8 @@ async function* transformSingleTaskBatchItemsStreamForWait(taskIdentifier, items
             payload: payloadPacket.data,
             options: {
                 lockToVersion: v3_1.taskContext.worker?.version,
-                queue: item.options?.queue
-                    ? { name: item.options.queue }
-                    : queue
-                        ? { name: queue }
-                        : undefined,
+                ...triggerQueueBody(item.options?.queue, queue),
+                ...(0, concurrency_shared_js_1.triggerConcurrencyBody)(item.options?.concurrency),
                 concurrencyKey: item.options?.concurrencyKey,
                 test: v3_1.taskContext.ctx?.run.isTest,
                 payloadType: payloadPacket.dataType,
@@ -1222,7 +1315,8 @@ async function trigger_internal(name, id, payload, parsePayload, options, reques
     const handle = await apiClient.triggerTask(id, {
         payload: triggerPayloadPacket.data,
         options: {
-            queue: options?.queue ? { name: options.queue } : undefined,
+            ...triggerQueueBody(options?.queue),
+            ...(0, concurrency_shared_js_1.triggerConcurrencyBody)(options?.concurrency),
             concurrencyKey: options?.concurrencyKey,
             test: v3_1.taskContext.ctx?.run.isTest,
             payloadType: triggerPayloadPacket.dataType,
@@ -1282,11 +1376,8 @@ async function batchTrigger_internal(name, taskIdentifier, items, options, parse
                 task: taskIdentifier,
                 payload: payloadPacket.data,
                 options: {
-                    queue: item.options?.queue
-                        ? { name: item.options.queue }
-                        : queue
-                            ? { name: queue }
-                            : undefined,
+                    ...triggerQueueBody(item.options?.queue, queue),
+                    ...(0, concurrency_shared_js_1.triggerConcurrencyBody)(item.options?.concurrency),
                     concurrencyKey: item.options?.concurrencyKey,
                     test: v3_1.taskContext.ctx?.run.isTest,
                     payloadType: payloadPacket.dataType,
@@ -1407,7 +1498,8 @@ async function triggerAndWait_internal(name, id, payload, parsePayload, options,
             payload: triggerPayloadPacket.data,
             options: {
                 lockToVersion: v3_1.taskContext.worker?.version, // Lock to current version because we're waiting for it to finish
-                queue: options?.queue ? { name: options.queue } : undefined,
+                ...triggerQueueBody(options?.queue),
+                ...(0, concurrency_shared_js_1.triggerConcurrencyBody)(options?.concurrency),
                 concurrencyKey: options?.concurrencyKey,
                 test: v3_1.taskContext.ctx?.run.isTest,
                 payloadType: triggerPayloadPacket.dataType,
@@ -1468,7 +1560,8 @@ async function triggerAndSubscribe_internal(name, id, payload, parsePayload, opt
             payload: triggerPayloadPacket.data,
             options: {
                 lockToVersion: v3_1.taskContext.worker?.version,
-                queue: options?.queue ? { name: options.queue } : undefined,
+                ...triggerQueueBody(options?.queue),
+                ...(0, concurrency_shared_js_1.triggerConcurrencyBody)(options?.concurrency),
                 concurrencyKey: options?.concurrencyKey,
                 test: v3_1.taskContext.ctx?.run.isTest,
                 payloadType: triggerPayloadPacket.dataType,
@@ -1535,13 +1628,16 @@ async function triggerAndSubscribe_internal(name, id, payload, parsePayload, opt
                     // INTERNAL_ERROR, STRING_ERROR) via the completion message and
                     // passes it through `createErrorTaskError` to preserve the
                     // discriminator. `subscribeToRun` only surfaces a
-                    // `SerializedError` (`{ name, message, stackTrace }`) because
-                    // `createJsonErrorObject` strips the discriminator before the
-                    // record hits the realtime stream. We can't reconstruct the
+                    // `SerializedError` (`{ name, message, stackTrace, causes }`)
+                    // because `createJsonErrorObject` strips the discriminator before
+                    // the record hits the realtime stream. We can't reconstruct the
                     // discriminator here without lossy guessing — callers that
                     // need exact error-type matching should use `triggerAndWait`
-                    // instead; subscribers get message + name only.
-                    const error = new Error(run.error?.message ?? `Task ${id} failed (${run.status})`);
+                    // instead; subscribers get message, name and the cause chain.
+                    const cause = run.error?.causes?.length
+                        ? (0, v3_1.createErrorFromCauses)(run.error.causes)
+                        : undefined;
+                    const error = new Error(run.error?.message ?? `Task ${id} failed (${run.status})`, cause ? { cause } : undefined);
                     if (run.error?.name)
                         error.name = run.error.name;
                     return {
@@ -1600,11 +1696,8 @@ async function batchTriggerAndWait_internal(name, id, items, parsePayload, optio
                 payload: payloadPacket.data,
                 options: {
                     lockToVersion: v3_1.taskContext.worker?.version,
-                    queue: item.options?.queue
-                        ? { name: item.options.queue }
-                        : queue
-                            ? { name: queue }
-                            : undefined,
+                    ...triggerQueueBody(item.options?.queue, queue),
+                    ...(0, concurrency_shared_js_1.triggerConcurrencyBody)(item.options?.concurrency),
                     concurrencyKey: item.options?.concurrencyKey,
                     test: v3_1.taskContext.ctx?.run.isTest,
                     payloadType: payloadPacket.dataType,