@trigger.dev/sdk 0.0.0-dev-20231004120419 → 0.0.0-invoke-trigger-20231103104037

package/dist/index.js

@@ -63,6 +63,8 @@ __export(src_exports, {
   IO: () => IO,
   IOLogger: () => IOLogger,
   IntervalTrigger: () => IntervalTrigger,
+  InvokeTrigger: () => InvokeTrigger,
+  JSONOutputSerializer: () => JSONOutputSerializer,
   Job: () => Job,
   MissingConnectionNotification: () => MissingConnectionNotification,
   MissingConnectionResolvedNotification: () => MissingConnectionResolvedNotification,
@@ -70,6 +72,7 @@ __export(src_exports, {
   cronTrigger: () => cronTrigger,
   eventTrigger: () => eventTrigger,
   intervalTrigger: () => intervalTrigger,
+  invokeTrigger: () => invokeTrigger,
   isTriggerError: () => isTriggerError,
   missingConnectionNotification: () => missingConnectionNotification,
   missingConnectionResolvedNotification: () => missingConnectionResolvedNotification,
@@ -87,6 +90,24 @@ function slugifyId(input) {
 }
 __name(slugifyId, "slugifyId");
 
+// src/utils/typedAsyncLocalStorage.ts
+var import_node_async_hooks = require("async_hooks");
+var TypedAsyncLocalStorage = class {
+  constructor() {
+    this.storage = new import_node_async_hooks.AsyncLocalStorage();
+  }
+  runWith(context, fn) {
+    return this.storage.run(context, fn);
+  }
+  getStore() {
+    return this.storage.getStore();
+  }
+};
+__name(TypedAsyncLocalStorage, "TypedAsyncLocalStorage");
+
+// src/runLocalStorage.ts
+var runLocalStorage = new TypedAsyncLocalStorage();
+
 // src/job.ts
 var _validate, validate_fn;
 var Job = class {
@@ -141,6 +162,118 @@ var Job = class {
       internal
     };
   }
+  async invoke(param1, param2 = void 0, param3 = void 0) {
+    const runStore = runLocalStorage.getStore();
+    if (typeof param1 === "string") {
+      if (!runStore) {
+        throw new Error("Cannot invoke a job from outside of a run when passing a cacheKey. Make sure you are running the job from within a run or use the invoke method without the cacheKey.");
+      }
+      const options = param3 ?? {};
+      return await runStore.io.runTask(param1, async (task) => {
+        const result = await this.client.invokeJob(this.id, param2, {
+          idempotencyKey: task.idempotencyKey,
+          ...options
+        });
+        task.outputProperties = [
+          {
+            label: "Run",
+            text: result.id,
+            url: `/orgs/${runStore.ctx.organization.slug}/projects/${runStore.ctx.project.slug}/jobs/${this.id}/runs/${result.id}/trigger`
+          }
+        ];
+        return result;
+      }, {
+        name: `Manually Invoke '${this.name}'`,
+        params: param2,
+        properties: [
+          {
+            label: "Job",
+            text: this.id,
+            url: `/orgs/${runStore.ctx.organization.slug}/projects/${runStore.ctx.project.slug}/jobs/${this.id}`
+          },
+          {
+            label: "Env",
+            text: runStore.ctx.environment.slug
+          }
+        ]
+      });
+    }
+    if (runStore) {
+      throw new Error("Cannot invoke a job from within a run without a cacheKey.");
+    }
+    return await this.client.invokeJob(this.id, param1, param3);
+  }
+  async invokeAndWaitForCompletion(cacheKey, payload, timeoutInSeconds = 60 * 60, options = {}) {
+    const runStore = runLocalStorage.getStore();
+    if (!runStore) {
+      throw new Error("Cannot invoke a job from outside of a run using invokeAndWaitForCompletion. Make sure you are running the job from within a run or use the invoke method instead.");
+    }
+    const { io, ctx } = runStore;
+    return await io.runTask(cacheKey, async (task) => {
+      const parsedPayload = this.trigger.event.parseInvokePayload ? this.trigger.event.parseInvokePayload(payload) ? payload : void 0 : payload;
+      const result = await this.client.invokeJob(this.id, parsedPayload, {
+        idempotencyKey: task.idempotencyKey,
+        callbackUrl: task.callbackUrl ?? void 0,
+        ...options
+      });
+      task.outputProperties = [
+        {
+          label: "Run",
+          text: result.id,
+          url: `/orgs/${ctx.organization.slug}/projects/${ctx.project.slug}/jobs/${this.id}/runs/${result.id}/trigger`
+        }
+      ];
+      return {};
+    }, {
+      name: `Manually Invoke '${this.name}' and wait for completion`,
+      params: payload,
+      properties: [
+        {
+          label: "Job",
+          text: this.id,
+          url: `/orgs/${ctx.organization.slug}/projects/${ctx.project.slug}/jobs/${this.id}`
+        },
+        {
+          label: "Env",
+          text: ctx.environment.slug
+        }
+      ],
+      callback: {
+        enabled: true,
+        timeoutInSeconds
+      }
+    });
+  }
+  async batchInvokeAndWaitForCompletion(cacheKey, batch) {
+    const runStore = runLocalStorage.getStore();
+    if (!runStore) {
+      throw new Error("Cannot invoke a job from outside of a run using batchInvokeAndWaitForCompletion.");
+    }
+    if (batch.length === 0) {
+      return [];
+    }
+    if (batch.length > 25) {
+      throw new Error(`Cannot batch invoke more than 25 items. You tried to batch invoke ${batch.length} items.`);
+    }
+    const { io, ctx } = runStore;
+    const results = await io.parallel(cacheKey, batch, async (item, index) => {
+      return await this.invokeAndWaitForCompletion(String(index), item.payload, item.timeoutInSeconds ?? 60 * 60, item.options);
+    }, {
+      name: `Batch Invoke '${this.name}'`,
+      properties: [
+        {
+          label: "Job",
+          text: this.id,
+          url: `/orgs/${ctx.organization.slug}/projects/${ctx.project.slug}/jobs/${this.id}`
+        },
+        {
+          label: "Env",
+          text: ctx.environment.slug
+        }
+      ]
+    });
+    return results;
+  }
 };
 __name(Job, "Job");
 _validate = new WeakSet();
@@ -155,7 +288,6 @@ var import_core7 = require("@trigger.dev/core");
 
 // src/apiClient.ts
 var import_core = require("@trigger.dev/core");
-var import_node_fetch = __toESM(require("node-fetch"));
 var import_zod = require("zod");
 var _apiUrl, _options, _logger, _apiKey, apiKey_fn;
 var ApiClient = class {
@@ -174,7 +306,7 @@ var ApiClient = class {
       url: options.url,
       name: options.name
     });
-    const response = await (0, import_node_fetch.default)(`${__privateGet(this, _apiUrl)}/api/v1/endpoints`, {
+    const response = await fetch(`${__privateGet(this, _apiUrl)}/api/v1/endpoints`, {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
@@ -222,7 +354,8 @@ var ApiClient = class {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
-        Authorization: `Bearer ${apiKey}`
+        Authorization: `Bearer ${apiKey}`,
+        "Trigger-Version": import_core.API_VERSIONS.SERIALIZED_TASK_OUTPUT
       },
       body: JSON.stringify(task)
     });
@@ -273,6 +406,19 @@ var ApiClient = class {
       }
     });
   }
+  async cancelRunsForEvent(eventId) {
+    const apiKey = await __privateMethod(this, _apiKey, apiKey_fn).call(this);
+    __privateGet(this, _logger).debug("Cancelling runs for event", {
+      eventId
+    });
+    return await zodfetch(import_core.CancelRunsForEventSchema, `${__privateGet(this, _apiUrl)}/api/v1/events/${eventId}/cancel-runs`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${apiKey}`
+      }
+    });
+  }
   async updateStatus(runId, id, status) {
     const apiKey = await __privateMethod(this, _apiKey, apiKey_fn).call(this);
     __privateGet(this, _logger).debug("Update status", {
@@ -303,18 +449,22 @@ var ApiClient = class {
     });
     return response;
   }
-  async registerTrigger(client, id, key, payload) {
+  async registerTrigger(client, id, key, payload, idempotencyKey) {
     const apiKey = await __privateMethod(this, _apiKey, apiKey_fn).call(this);
     __privateGet(this, _logger).debug("registering trigger", {
       id,
       payload
     });
+    const headers = {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${apiKey}`
+    };
+    if (idempotencyKey) {
+      headers["Idempotency-Key"] = idempotencyKey;
+    }
     const response = await zodfetch(import_core.RegisterSourceEventSchemaV2, `${__privateGet(this, _apiUrl)}/api/v2/${client}/triggers/${id}/registrations/${key}`, {
       method: "PUT",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${apiKey}`
-      },
+      headers,
       body: JSON.stringify(payload)
     });
     return response;
@@ -394,6 +544,19 @@ var ApiClient = class {
       }
     });
   }
+  async cancelRun(runId) {
+    const apiKey = await __privateMethod(this, _apiKey, apiKey_fn).call(this);
+    __privateGet(this, _logger).debug("Cancelling Run", {
+      runId
+    });
+    return await zodfetch(import_core.GetRunSchema, `${__privateGet(this, _apiUrl)}/api/v1/runs/${runId}/cancel`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${apiKey}`
+      }
+    });
+  }
   async getRunStatuses(runId) {
     const apiKey = await __privateMethod(this, _apiKey, apiKey_fn).call(this);
     __privateGet(this, _logger).debug("Getting Run statuses", {
@@ -418,6 +581,31 @@ var ApiClient = class {
       }
     });
   }
+  async invokeJob(jobId, payload, options = {}) {
+    const apiKey = await __privateMethod(this, _apiKey, apiKey_fn).call(this);
+    __privateGet(this, _logger).debug("Invoking Job", {
+      jobId
+    });
+    const body = {
+      payload,
+      context: options.context ?? {},
+      options: {
+        accountId: options.accountId,
+        callbackUrl: options.callbackUrl
+      }
+    };
+    return await zodfetch(import_core.InvokeJobResponseSchema, `${__privateGet(this, _apiUrl)}/api/v1/jobs/${jobId}/invoke`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${apiKey}`,
+        ...options.idempotencyKey ? {
+          "Idempotency-Key": options.idempotencyKey
+        } : {}
+      },
+      body: JSON.stringify(body)
+    });
+  }
 };
 __name(ApiClient, "ApiClient");
 _apiUrl = new WeakMap();
@@ -453,8 +641,8 @@ function getApiKey(key) {
   };
 }
 __name(getApiKey, "getApiKey");
-async function zodfetchWithVersions(versionedSchemaMap, unversionedSchema, url, requestInit, options) {
-  const response = await (0, import_node_fetch.default)(url, requestInit);
+async function zodfetchWithVersions(versionedSchemaMap, unversionedSchema, url, requestInit, options, retryCount = 0) {
+  const response = await fetch(url, requestInit);
   if ((!requestInit || requestInit.method === "GET") && response.status === 404 && options?.optional) {
     return;
   }
@@ -462,29 +650,34 @@ async function zodfetchWithVersions(versionedSchemaMap, unversionedSchema, url,
     const body = await response.json();
     throw new Error(body.error);
   }
+  if (response.status >= 500 && retryCount < 6) {
+    const delay = exponentialBackoff(retryCount + 1, 2, 50, 1150, 50);
+    await new Promise((resolve) => setTimeout(resolve, delay));
+    return zodfetchWithVersions(versionedSchemaMap, unversionedSchema, url, requestInit, options, retryCount + 1);
+  }
   if (response.status !== 200) {
     throw new Error(options?.errorMessage ?? `Failed to fetch ${url}, got status code ${response.status}`);
   }
   const jsonBody = await response.json();
-  const version = response.headers.get("trigger-version");
-  if (!version) {
+  const version2 = response.headers.get("trigger-version");
+  if (!version2) {
     return {
       version: "unversioned",
       body: unversionedSchema.parse(jsonBody)
     };
   }
-  const versionedSchema = versionedSchemaMap[version];
+  const versionedSchema = versionedSchemaMap[version2];
   if (!versionedSchema) {
-    throw new Error(`Unknown version ${version}`);
+    throw new Error(`Unknown version ${version2}`);
   }
   return {
-    version,
+    version: version2,
     body: versionedSchema.parse(jsonBody)
   };
 }
 __name(zodfetchWithVersions, "zodfetchWithVersions");
-async function zodfetch(schema, url, requestInit, options) {
-  const response = await (0, import_node_fetch.default)(url, requestInit);
+async function zodfetch(schema, url, requestInit, options, retryCount = 0) {
+  const response = await fetch(url, requestInit);
   if ((!requestInit || requestInit.method === "GET") && response.status === 404 && options?.optional) {
     return;
   }
@@ -492,6 +685,11 @@ async function zodfetch(schema, url, requestInit, options) {
     const body = await response.json();
     throw new Error(body.error);
   }
+  if (response.status >= 500 && retryCount < 6) {
+    const delay = exponentialBackoff(retryCount + 1, 2, 50, 1150, 50);
+    await new Promise((resolve) => setTimeout(resolve, delay));
+    return zodfetch(schema, url, requestInit, options, retryCount + 1);
+  }
   if (response.status !== 200) {
     throw new Error(options?.errorMessage ?? `Failed to fetch ${url}, got status code ${response.status}`);
   }
@@ -499,6 +697,12 @@ async function zodfetch(schema, url, requestInit, options) {
   return schema.parse(jsonBody);
 }
 __name(zodfetch, "zodfetch");
+function exponentialBackoff(retryCount, exponential, minDelay, maxDelay, jitter) {
+  const delay = Math.min(Math.pow(exponential, retryCount) * minDelay, maxDelay);
+  const jitterValue = Math.random() * jitter;
+  return delay + jitterValue;
+}
+__name(exponentialBackoff, "exponentialBackoff");
 
 // src/errors.ts
 var ResumeWithTaskError = class {
@@ -507,6 +711,13 @@ var ResumeWithTaskError = class {
   }
 };
 __name(ResumeWithTaskError, "ResumeWithTaskError");
+var ResumeWithParallelTaskError = class {
+  constructor(task, childErrors) {
+    this.task = task;
+    this.childErrors = childErrors;
+  }
+};
+__name(ResumeWithParallelTaskError, "ResumeWithParallelTaskError");
 var RetryWithTaskError = class {
   constructor(cause, task, retryAt) {
     this.cause = cause;
@@ -527,6 +738,23 @@ var YieldExecutionError = class {
   }
 };
 __name(YieldExecutionError, "YieldExecutionError");
+var AutoYieldExecutionError = class {
+  constructor(location, timeRemaining, timeElapsed) {
+    this.location = location;
+    this.timeRemaining = timeRemaining;
+    this.timeElapsed = timeElapsed;
+  }
+};
+__name(AutoYieldExecutionError, "AutoYieldExecutionError");
+var AutoYieldWithCompletedTaskExecutionError = class {
+  constructor(id, properties, data, output) {
+    this.id = id;
+    this.properties = properties;
+    this.data = data;
+    this.output = output;
+  }
+};
+__name(AutoYieldWithCompletedTaskExecutionError, "AutoYieldWithCompletedTaskExecutionError");
 var ParsedPayloadSchemaError = class {
   constructor(schemaErrors) {
     this.schemaErrors = schemaErrors;
@@ -534,13 +762,21 @@ var ParsedPayloadSchemaError = class {
 };
 __name(ParsedPayloadSchemaError, "ParsedPayloadSchemaError");
 function isTriggerError(err) {
-  return err instanceof ResumeWithTaskError || err instanceof RetryWithTaskError || err instanceof CanceledWithTaskError || err instanceof YieldExecutionError;
+  return err instanceof ResumeWithTaskError || err instanceof RetryWithTaskError || err instanceof CanceledWithTaskError || err instanceof YieldExecutionError || err instanceof AutoYieldExecutionError || err instanceof AutoYieldWithCompletedTaskExecutionError || err instanceof ResumeWithParallelTaskError;
 }
 __name(isTriggerError, "isTriggerError");
+var ErrorWithTask = class extends Error {
+  constructor(cause, message) {
+    super(message);
+    this.cause = cause;
+  }
+};
+__name(ErrorWithTask, "ErrorWithTask");
 
 // src/io.ts
 var import_core3 = require("@trigger.dev/core");
-var import_node_async_hooks = require("async_hooks");
+var import_core_backend = require("@trigger.dev/core-backend");
+var import_node_async_hooks2 = require("async_hooks");
 var import_node_crypto = require("crypto");
 
 // src/retry.ts
@@ -590,10 +826,25 @@ var TriggerStatus = class {
 __name(TriggerStatus, "TriggerStatus");
 
 // src/io.ts
-var _addToCachedTasks, addToCachedTasks_fn;
+var JSONOutputSerializer = class {
+  serialize(value) {
+    return JSON.stringify(value);
+  }
+  deserialize(value) {
+    return value ? JSON.parse(value) : void 0;
+  }
+};
+__name(JSONOutputSerializer, "JSONOutputSerializer");
+var _addToCachedTasks, addToCachedTasks_fn, _detectAutoYield, detectAutoYield_fn, _forceYield, forceYield_fn, _getTimeElapsed, getTimeElapsed_fn, _getRemainingTimeInMillis, getRemainingTimeInMillis_fn;
 var IO = class {
   constructor(options) {
     __privateAdd(this, _addToCachedTasks);
+    __privateAdd(this, _detectAutoYield);
+    __privateAdd(this, _forceYield);
+    __privateAdd(this, _getTimeElapsed);
+    __privateAdd(this, _getRemainingTimeInMillis);
+    __publicField(this, "_outputSerializer", new JSONOutputSerializer());
+    __publicField(this, "_visitedCacheKeys", /* @__PURE__ */ new Set());
     __publicField(this, "brb", this.yield.bind(this));
     this._id = options.id;
     this._apiClient = options.apiClient;
@@ -602,6 +853,8 @@ var IO = class {
     this._cachedTasks = /* @__PURE__ */ new Map();
     this._jobLogger = options.jobLogger;
     this._jobLogLevel = options.jobLogLevel;
+    this._timeOrigin = options.timeOrigin;
+    this._executionTimeout = options.executionTimeout;
     this._stats = {
       initialCachedTasks: 0,
       lazyLoadedCachedTasks: 0,
@@ -617,11 +870,11 @@ var IO = class {
       });
       this._stats.initialCachedTasks = options.cachedTasks.length;
     }
-    this._taskStorage = new import_node_async_hooks.AsyncLocalStorage();
+    this._taskStorage = new import_node_async_hooks2.AsyncLocalStorage();
     this._context = options.context;
     this._yieldedExecutions = options.yieldedExecutions ?? [];
     if (options.noopTasksSet) {
-      this._noopTasksBloomFilter = import_core3.BloomFilter.deserialize(options.noopTasksSet, import_core3.BloomFilter.NOOP_TASK_SET_SIZE);
+      this._noopTasksBloomFilter = import_core_backend.BloomFilter.deserialize(options.noopTasksSet, import_core_backend.BloomFilter.NOOP_TASK_SET_SIZE);
     }
     this._cachedTasksCursor = options.cachedTasksCursor;
     this._serverVersion = options.serverVersion ?? "unversioned";
@@ -690,8 +943,8 @@ var IO = class {
       }
     });
   }
-  async wait(key, seconds) {
-    return await this.runTask(key, async (task) => {
+  async wait(cacheKey, seconds) {
+    return await this.runTask(cacheKey, async (task) => {
     }, {
       name: "wait",
       icon: "clock",
@@ -705,22 +958,23 @@ var IO = class {
       }
     });
   }
-  async createStatus(key, initialStatus) {
-    const id = typeof key === "string" ? key : key.join("-");
+  async createStatus(cacheKey, initialStatus) {
+    const id = typeof cacheKey === "string" ? cacheKey : cacheKey.join("-");
     const status = new TriggerStatus(id, this);
-    await status.update(key, initialStatus);
+    await status.update(cacheKey, initialStatus);
     return status;
   }
-  async backgroundFetch(key, url, requestInit, retry2) {
+  async backgroundFetch(cacheKey, url, requestInit, retry2, timeout) {
     const urlObject = new URL(url);
-    return await this.runTask(key, async (task) => {
+    return await this.runTask(cacheKey, async (task) => {
       return task.output;
     }, {
       name: `fetch ${urlObject.hostname}${urlObject.pathname}`,
       params: {
         url,
         requestInit,
-        retry: retry2
+        retry: retry2,
+        timeout
       },
       operation: "fetch",
       icon: "background",
@@ -738,12 +992,21 @@ var IO = class {
         {
           label: "background",
           text: "true"
-        }
-      ]
+        },
+        ...timeout ? [
+          {
+            label: "timeout",
+            text: `${timeout.durationInMs}ms`
+          }
+        ] : []
+      ],
+      retry: {
+        limit: 0
+      }
     });
   }
-  async sendEvent(key, event, options) {
-    return await this.runTask(key, async (task) => {
+  async sendEvent(cacheKey, event, options) {
+    return await this.runTask(cacheKey, async (task) => {
       return await this._triggerClient.sendEvent(event, options);
     }, {
       name: "sendEvent",
@@ -765,8 +1028,8 @@ var IO = class {
       ]
     });
   }
-  async getEvent(key, id) {
-    return await this.runTask(key, async (task) => {
+  async getEvent(cacheKey, id) {
+    return await this.runTask(cacheKey, async (task) => {
       return await this._triggerClient.getEvent(id);
     }, {
       name: "getEvent",
@@ -781,8 +1044,8 @@ var IO = class {
       ]
     });
   }
-  async cancelEvent(key, eventId) {
-    return await this.runTask(key, async (task) => {
+  async cancelEvent(cacheKey, eventId) {
+    return await this.runTask(cacheKey, async (task) => {
       return await this._triggerClient.cancelEvent(eventId);
     }, {
       name: "cancelEvent",
@@ -797,8 +1060,8 @@ var IO = class {
       ]
     });
   }
-  async updateSource(key, options) {
-    return this.runTask(key, async (task) => {
+  async updateSource(cacheKey, options) {
+    return this.runTask(cacheKey, async (task) => {
       return await this._apiClient.updateSource(this._triggerClient.id, options.key, options);
     }, {
       name: "Update Source",
@@ -817,8 +1080,8 @@ var IO = class {
       }
     });
   }
-  async registerInterval(key, dynamicSchedule, id, options) {
-    return await this.runTask(key, async (task) => {
+  async registerInterval(cacheKey, dynamicSchedule, id, options) {
+    return await this.runTask(cacheKey, async (task) => {
       return dynamicSchedule.register(id, {
         type: "interval",
         options
@@ -842,8 +1105,8 @@ var IO = class {
       params: options
     });
   }
-  async unregisterInterval(key, dynamicSchedule, id) {
-    return await this.runTask(key, async (task) => {
+  async unregisterInterval(cacheKey, dynamicSchedule, id) {
+    return await this.runTask(cacheKey, async (task) => {
       return dynamicSchedule.unregister(id);
     }, {
       name: "unregister-interval",
@@ -859,8 +1122,8 @@ var IO = class {
       ]
     });
   }
-  async registerCron(key, dynamicSchedule, id, options) {
-    return await this.runTask(key, async (task) => {
+  async registerCron(cacheKey, dynamicSchedule, id, options) {
+    return await this.runTask(cacheKey, async (task) => {
       return dynamicSchedule.register(id, {
         type: "cron",
         options
@@ -884,8 +1147,8 @@ var IO = class {
       params: options
     });
   }
-  async unregisterCron(key, dynamicSchedule, id) {
-    return await this.runTask(key, async (task) => {
+  async unregisterCron(cacheKey, dynamicSchedule, id) {
+    return await this.runTask(cacheKey, async (task) => {
       return dynamicSchedule.unregister(id);
     }, {
       name: "unregister-cron",
@@ -901,8 +1164,8 @@ var IO = class {
       ]
     });
   }
-  async registerTrigger(key, trigger, id, params) {
-    return await this.runTask(key, async (task) => {
+  async registerTrigger(cacheKey, trigger, id, params) {
+    return await this.runTask(cacheKey, async (task) => {
       const registration = await this.runTask("register-source", async (subtask1) => {
         return trigger.register(id, params);
       }, {
@@ -927,30 +1190,58 @@ var IO = class {
       params
     });
   }
-  async getAuth(key, clientId) {
+  async getAuth(cacheKey, clientId) {
     if (!clientId) {
       return;
     }
-    return this.runTask(key, async (task) => {
+    return this.runTask(cacheKey, async (task) => {
       return await this._triggerClient.getAuth(clientId);
     }, {
       name: "get-auth"
     });
   }
-  async runTask(key, callback, options, onError) {
+  async parallel(cacheKey, items, callback, options) {
+    const results = await this.runTask(cacheKey, async (task) => {
+      const outcomes = await Promise.allSettled(items.map((item, index) => spaceOut(() => callback(item, index), index, 15)));
+      if (outcomes.every((outcome) => outcome.status === "fulfilled")) {
+        return outcomes.map((outcome) => outcome.value);
+      }
+      const nonInternalErrors = outcomes.filter((outcome) => outcome.status === "rejected" && !isTriggerError(outcome.reason)).map((outcome) => outcome);
+      if (nonInternalErrors.length > 0) {
+        throw nonInternalErrors[0].reason;
+      }
+      const internalErrors = outcomes.filter((outcome) => outcome.status === "rejected" && isTriggerError(outcome.reason)).map((outcome) => outcome).map((outcome) => outcome.reason);
+      throw new ResumeWithParallelTaskError(task, internalErrors);
+    }, {
+      name: "parallel",
+      parallel: true,
+      ...options ?? {}
+    });
+    return results;
+  }
+  async runTask(cacheKey, callback, options, onError) {
+    __privateMethod(this, _detectAutoYield, detectAutoYield_fn).call(this, "start_task", 500);
     const parentId = this._taskStorage.getStore()?.taskId;
     if (parentId) {
       this._logger.debug("Using parent task", {
         parentId,
-        key,
+        cacheKey,
         options
       });
     }
     const idempotencyKey = await generateIdempotencyKey([
       this._id,
       parentId ?? "",
-      key
+      cacheKey
     ].flat());
+    if (this._visitedCacheKeys.has(idempotencyKey)) {
+      if (typeof cacheKey === "string") {
+        throw new Error(`Task with cacheKey "${cacheKey}" has already been executed in this run. Each task must have a unique cacheKey.`);
+      } else {
+        throw new Error(`Task with cacheKey "${cacheKey.join("-")}" has already been executed in this run. Each task must have a unique cacheKey.`);
+      }
+    }
+    this._visitedCacheKeys.add(idempotencyKey);
     const cachedTask = this._cachedTasks.get(idempotencyKey);
     if (cachedTask && cachedTask.status === "COMPLETED") {
       this._logger.debug("Using completed cached task", {
@@ -970,7 +1261,7 @@ var IO = class {
     }
     const response = await this._apiClient.runTask(this._id, {
       idempotencyKey,
-      displayKey: typeof key === "string" ? key : void 0,
+      displayKey: typeof cacheKey === "string" ? cacheKey : void 0,
       noop: false,
       ...options ?? {},
       parentId
@@ -978,6 +1269,12 @@ var IO = class {
       cachedTasksCursor: this._cachedTasksCursor
     });
     const task = response.version === import_core3.API_VERSIONS.LAZY_LOADED_CACHED_TASKS ? response.body.task : response.body;
+    if (task.forceYield) {
+      this._logger.debug("Forcing yield after run task", {
+        idempotencyKey
+      });
+      __privateMethod(this, _forceYield, forceYield_fn).call(this, "after_run_task");
+    }
     if (response.version === import_core3.API_VERSIONS.LAZY_LOADED_CACHED_TASKS) {
       this._cachedTasksCursor = response.body.cachedTasks?.cursor;
       for (const cachedTask2 of response.body.cachedTasks?.tasks ?? []) {
@@ -1017,8 +1314,9 @@ var IO = class {
         idempotencyKey,
         task
       });
-      throw new Error(task.error ?? task?.output ? JSON.stringify(task.output) : "Task errored");
+      throw new ErrorWithTask(task, task.error ?? task?.output ? JSON.stringify(task.output) : "Task errored");
     }
+    __privateMethod(this, _detectAutoYield, detectAutoYield_fn).call(this, "before_execute_task", 1500);
     const executeTask = /* @__PURE__ */ __name(async () => {
       try {
         const result = await callback(task, this);
@@ -1029,20 +1327,28 @@ var IO = class {
           });
           return {};
         }
-        const output = import_core3.SerializableJsonSchema.parse(result);
+        const output = this._outputSerializer.serialize(result);
         this._logger.debug("Completing using output", {
           idempotencyKey,
           task
         });
+        __privateMethod(this, _detectAutoYield, detectAutoYield_fn).call(this, "before_complete_task", 500, task, output);
         const completedTask = await this._apiClient.completeTask(this._id, task.id, {
-          output: output ?? void 0,
+          output,
           properties: task.outputProperties ?? void 0
         });
+        if (completedTask.forceYield) {
+          this._logger.debug("Forcing yield after task completed", {
+            idempotencyKey
+          });
+          __privateMethod(this, _forceYield, forceYield_fn).call(this, "after_complete_task");
+        }
         this._stats.executedTasks++;
         if (completedTask.status === "CANCELED") {
           throw new CanceledWithTaskError(completedTask);
         }
-        return output;
+        __privateMethod(this, _detectAutoYield, detectAutoYield_fn).call(this, "after_complete_task", 500);
+        return this._outputSerializer.deserialize(output);
       } catch (error) {
         if (isTriggerError(error)) {
           throw error;
@@ -1071,6 +1377,11 @@ var IO = class {
             error = innerError;
           }
         }
+        if (error instanceof ErrorWithTask) {
+          await this._apiClient.failTask(this._id, task.id, {
+            error: error.cause.output
+          });
+        }
         const parsedError = import_core3.ErrorWithStackSchema.safeParse(error);
         if (options?.retry && !skipRetrying) {
           const retryAt = (0, import_core2.calculateRetryAt)(options.retry, task.attempts - 1);
@@ -1085,10 +1396,11 @@ var IO = class {
             error: parsedError.data
           });
         } else {
+          const message = typeof error === "string" ? error : JSON.stringify(error);
           await this._apiClient.failTask(this._id, task.id, {
             error: {
-              message: JSON.stringify(error),
-              name: "Unknown Error"
+              name: "Unknown error",
+              message
             }
           });
         }
@@ -1118,15 +1430,15 @@ var IO = class {
       taskId: task.id
     }, executeTask);
   }
-  yield(key) {
+  yield(cacheKey) {
     if (!(0, import_core3.supportsFeature)("yieldExecution", this._serverVersion)) {
       console.warn("[trigger.dev] io.yield() is not support by the version of the Trigger.dev server you are using, you will need to upgrade your self-hosted Trigger.dev instance.");
       return;
     }
-    if (this._yieldedExecutions.includes(key)) {
+    if (this._yieldedExecutions.includes(cacheKey)) {
       return;
     }
-    throw new YieldExecutionError(key);
+    throw new YieldExecutionError(cacheKey);
   }
   async try(tryCallback, catchCallback) {
     try {
@@ -1144,6 +1456,39 @@ _addToCachedTasks = new WeakSet();
 addToCachedTasks_fn = /* @__PURE__ */ __name(function(task) {
   this._cachedTasks.set(task.idempotencyKey, task);
 }, "#addToCachedTasks");
+_detectAutoYield = new WeakSet();
+detectAutoYield_fn = /* @__PURE__ */ __name(function(location, threshold = 1500, task1, output) {
+  const timeRemaining = __privateMethod(this, _getRemainingTimeInMillis, getRemainingTimeInMillis_fn).call(this);
+  if (timeRemaining && timeRemaining < threshold) {
+    if (task1) {
+      throw new AutoYieldWithCompletedTaskExecutionError(task1.id, task1.outputProperties ?? [], {
+        location,
+        timeRemaining,
+        timeElapsed: __privateMethod(this, _getTimeElapsed, getTimeElapsed_fn).call(this)
+      }, output);
+    } else {
+      throw new AutoYieldExecutionError(location, timeRemaining, __privateMethod(this, _getTimeElapsed, getTimeElapsed_fn).call(this));
+    }
+  }
+}, "#detectAutoYield");
+_forceYield = new WeakSet();
+forceYield_fn = /* @__PURE__ */ __name(function(location1) {
+  const timeRemaining = __privateMethod(this, _getRemainingTimeInMillis, getRemainingTimeInMillis_fn).call(this);
+  if (timeRemaining) {
+    throw new AutoYieldExecutionError(location1, timeRemaining, __privateMethod(this, _getTimeElapsed, getTimeElapsed_fn).call(this));
+  }
+}, "#forceYield");
+_getTimeElapsed = new WeakSet();
+getTimeElapsed_fn = /* @__PURE__ */ __name(function() {
+  return performance.now() - this._timeOrigin;
+}, "#getTimeElapsed");
+_getRemainingTimeInMillis = new WeakSet();
+getRemainingTimeInMillis_fn = /* @__PURE__ */ __name(function() {
+  if (this._executionTimeout) {
+    return this._executionTimeout - (performance.now() - this._timeOrigin);
+  }
+  return void 0;
+}, "#getRemainingTimeInMillis");
 async function generateIdempotencyKey(keyMaterial) {
   const keys = keyMaterial.map((key2) => {
     if (typeof key2 === "string") {
@@ -1197,6 +1542,11 @@ var IOLogger = class {
   }
 };
 __name(IOLogger, "IOLogger");
+async function spaceOut(callback, index, delay) {
+  await new Promise((resolve) => setTimeout(resolve, index * delay));
+  return await callback();
+}
+__name(spaceOut, "spaceOut");
 
 // src/ioWithIntegrations.ts
 function createIOWithIntegrations(io, auths, integrations) {
@@ -1227,24 +1577,6 @@ function createIOWithIntegrations(io, auths, integrations) {
 }
 __name(createIOWithIntegrations, "createIOWithIntegrations");
 
-// src/utils/typedAsyncLocalStorage.ts
-var import_node_async_hooks2 = require("async_hooks");
-var TypedAsyncLocalStorage = class {
-  constructor() {
-    this.storage = new import_node_async_hooks2.AsyncLocalStorage();
-  }
-  runWith(context, fn) {
-    return this.storage.run(context, fn);
-  }
-  getStore() {
-    return this.storage.getStore();
-  }
-};
-__name(TypedAsyncLocalStorage, "TypedAsyncLocalStorage");
-
-// src/runLocalStorage.ts
-var runLocalStorage = new TypedAsyncLocalStorage();
-
 // src/triggers/dynamic.ts
 var import_core4 = require("@trigger.dev/core");
 var _client, _options2;
@@ -1306,7 +1638,7 @@ var DynamicTrigger = class {
       key,
       "register"
     ], async (task) => {
-      return __privateGet(this, _client).registerTrigger(this.id, key, this.registeredTriggerForParams(params, options));
+      return __privateGet(this, _client).registerTrigger(this.id, key, this.registeredTriggerForParams(params, options), task.idempotencyKey);
     }, {
       name: "Register Dynamic Trigger",
       properties: [
@@ -1594,6 +1926,9 @@ var DynamicSchedule = class {
 };
 __name(DynamicSchedule, "DynamicSchedule");
 
+// package.json
+var version = "0.0.0-invoke-trigger-20231103104037";
+
 // src/triggerClient.ts
 var registerSourceEvent = {
   name: import_core7.REGISTER_SOURCE_EVENT_V2,
@@ -1602,11 +1937,12 @@ var registerSourceEvent = {
   icon: "register-source",
   parsePayload: import_core7.RegisterSourceEventSchemaV2.parse
 };
-var _options4, _registeredJobs, _registeredSources, _registeredHttpSourceHandlers, _registeredDynamicTriggers, _jobMetadataByDynamicTriggers, _registeredSchedules, _authResolvers, _client2, _internalLogger, _preprocessRun, preprocessRun_fn, _executeJob, executeJob_fn, _createRunContext, createRunContext_fn, _createPreprocessRunContext, createPreprocessRunContext_fn, _handleHttpSourceRequest, handleHttpSourceRequest_fn, _resolveConnections, resolveConnections_fn, _resolveConnection, resolveConnection_fn, _buildJobsIndex, buildJobsIndex_fn, _buildJobIndex, buildJobIndex_fn, _buildJobIntegrations, buildJobIntegrations_fn, _buildJobIntegration, buildJobIntegration_fn, _logIOStats, logIOStats_fn, _standardResponseHeaders, standardResponseHeaders_get;
+var _options4, _registeredJobs, _registeredSources, _registeredHttpSourceHandlers, _registeredDynamicTriggers, _jobMetadataByDynamicTriggers, _registeredSchedules, _authResolvers, _client2, _internalLogger, _preprocessRun, preprocessRun_fn, _executeJob, executeJob_fn, _convertErrorToExecutionResponse, convertErrorToExecutionResponse_fn, _createRunContext, createRunContext_fn, _createPreprocessRunContext, createPreprocessRunContext_fn, _handleHttpSourceRequest, handleHttpSourceRequest_fn, _resolveConnections, resolveConnections_fn, _resolveConnection, resolveConnection_fn, _buildJobsIndex, buildJobsIndex_fn, _buildJobIndex, buildJobIndex_fn, _buildJobIntegrations, buildJobIntegrations_fn, _buildJobIntegration, buildJobIntegration_fn, _logIOStats, logIOStats_fn, _standardResponseHeaders, standardResponseHeaders_fn;
 var TriggerClient = class {
   constructor(options) {
     __privateAdd(this, _preprocessRun);
     __privateAdd(this, _executeJob);
+    __privateAdd(this, _convertErrorToExecutionResponse);
     __privateAdd(this, _createRunContext);
     __privateAdd(this, _createPreprocessRunContext);
     __privateAdd(this, _handleHttpSourceRequest);
@@ -1636,7 +1972,7 @@ var TriggerClient = class {
       "noopTasksSet"
     ]));
   }
-  async handleRequest(request) {
+  async handleRequest(request, timeOrigin = performance.now()) {
     __privateGet(this, _internalLogger).debug("handling request", {
       url: request.url,
       headers: Object.fromEntries(request.headers.entries()),
@@ -1655,7 +1991,7 @@ var TriggerClient = class {
           body: {
             message: "Unauthorized: client missing apiKey"
           },
-          headers: __privateGet(this, _standardResponseHeaders, standardResponseHeaders_get)
+          headers: __privateMethod(this, _standardResponseHeaders, standardResponseHeaders_fn).call(this, timeOrigin)
         };
       }
       case "missing-header": {
@@ -1664,7 +2000,7 @@ var TriggerClient = class {
           body: {
             message: "Unauthorized: missing x-trigger-api-key header"
           },
-          headers: __privateGet(this, _standardResponseHeaders, standardResponseHeaders_get)
+          headers: __privateMethod(this, _standardResponseHeaders, standardResponseHeaders_fn).call(this, timeOrigin)
         };
       }
       case "unauthorized": {
@@ -1673,7 +2009,7 @@ var TriggerClient = class {
           body: {
             message: `Forbidden: client apiKey mismatch: Make sure you are using the correct API Key for your environment`
           },
-          headers: __privateGet(this, _standardResponseHeaders, standardResponseHeaders_get)
+          headers: __privateMethod(this, _standardResponseHeaders, standardResponseHeaders_fn).call(this, timeOrigin)
         };
       }
     }
@@ -1683,7 +2019,7 @@ var TriggerClient = class {
         body: {
           message: "Method not allowed (only POST is allowed)"
         },
-        headers: __privateGet(this, _standardResponseHeaders, standardResponseHeaders_get)
+        headers: __privateMethod(this, _standardResponseHeaders, standardResponseHeaders_fn).call(this, timeOrigin)
       };
     }
     const action = request.headers.get("x-trigger-action");
@@ -1693,7 +2029,7 @@ var TriggerClient = class {
         body: {
           message: "Missing x-trigger-action header"
         },
-        headers: __privateGet(this, _standardResponseHeaders, standardResponseHeaders_get)
+        headers: __privateMethod(this, _standardResponseHeaders, standardResponseHeaders_fn).call(this, timeOrigin)
       };
     }
     switch (action) {
@@ -1706,7 +2042,7 @@ var TriggerClient = class {
               ok: false,
               error: "Missing endpoint ID"
             },
-            headers: __privateGet(this, _standardResponseHeaders, standardResponseHeaders_get)
+            headers: __privateMethod(this, _standardResponseHeaders, standardResponseHeaders_fn).call(this, timeOrigin)
           };
         }
         if (this.id !== endpointId) {
@@ -1716,7 +2052,7 @@ var TriggerClient = class {
               ok: false,
               error: `Endpoint ID mismatch error. Expected ${this.id}, got ${endpointId}`
             },
-            headers: __privateGet(this, _standardResponseHeaders, standardResponseHeaders_get)
+            headers: __privateMethod(this, _standardResponseHeaders, standardResponseHeaders_fn).call(this, timeOrigin)
           };
         }
         return {
@@ -1724,7 +2060,7 @@ var TriggerClient = class {
           body: {
             ok: true
           },
-          headers: __privateGet(this, _standardResponseHeaders, standardResponseHeaders_get)
+          headers: __privateMethod(this, _standardResponseHeaders, standardResponseHeaders_fn).call(this, timeOrigin)
         };
       }
       case "INDEX_ENDPOINT": {
@@ -1747,7 +2083,7 @@ var TriggerClient = class {
         return {
           status: 200,
           body,
-          headers: __privateGet(this, _standardResponseHeaders, standardResponseHeaders_get)
+          headers: __privateMethod(this, _standardResponseHeaders, standardResponseHeaders_fn).call(this, timeOrigin)
         };
       }
       case "INITIALIZE_TRIGGER": {
@@ -1773,7 +2109,7 @@ var TriggerClient = class {
         return {
           status: 200,
           body: dynamicTrigger.registeredTriggerForParams(body.data.params),
-          headers: __privateGet(this, _standardResponseHeaders, standardResponseHeaders_get)
+          headers: __privateMethod(this, _standardResponseHeaders, standardResponseHeaders_fn).call(this, timeOrigin)
         };
       }
       case "EXECUTE_JOB": {
@@ -1796,11 +2132,17 @@ var TriggerClient = class {
             }
           };
         }
-        const results = await __privateMethod(this, _executeJob, executeJob_fn).call(this, execution.data, job, triggerVersion);
+        const results = await __privateMethod(this, _executeJob, executeJob_fn).call(this, execution.data, job, timeOrigin, triggerVersion);
+        __privateGet(this, _internalLogger).debug("executed job", {
+          results,
+          job: job.id,
+          version: job.version,
+          triggerVersion
+        });
         return {
           status: 200,
           body: results,
-          headers: __privateGet(this, _standardResponseHeaders, standardResponseHeaders_get)
+          headers: __privateMethod(this, _standardResponseHeaders, standardResponseHeaders_fn).call(this, timeOrigin)
         };
       }
       case "PREPROCESS_RUN": {
@@ -1830,7 +2172,7 @@ var TriggerClient = class {
             abort: results.abort,
             properties: results.properties
           },
-          headers: __privateGet(this, _standardResponseHeaders, standardResponseHeaders_get)
+          headers: __privateMethod(this, _standardResponseHeaders, standardResponseHeaders_fn).call(this, timeOrigin)
         };
       }
       case "DELIVER_HTTP_SOURCE_REQUEST": {
@@ -1880,7 +2222,7 @@ var TriggerClient = class {
             response,
             metadata
           },
-          headers: __privateGet(this, _standardResponseHeaders, standardResponseHeaders_get)
+          headers: __privateMethod(this, _standardResponseHeaders, standardResponseHeaders_fn).call(this, timeOrigin)
         };
       }
       case "VALIDATE": {
@@ -1890,7 +2232,19 @@ var TriggerClient = class {
             ok: true,
             endpointId: this.id
           },
-          headers: __privateGet(this, _standardResponseHeaders, standardResponseHeaders_get)
+          headers: __privateMethod(this, _standardResponseHeaders, standardResponseHeaders_fn).call(this, timeOrigin)
+        };
+      }
+      case "PROBE_EXECUTION_TIMEOUT": {
+        const json = await request.json();
+        const timeout = json?.timeout ?? 15 * 60 * 1e3;
+        await new Promise((resolve) => setTimeout(resolve, timeout));
+        return {
+          status: 200,
+          body: {
+            ok: true
+          },
+          headers: __privateMethod(this, _standardResponseHeaders, standardResponseHeaders_fn).call(this, timeOrigin)
         };
       }
     }
@@ -1899,7 +2253,7 @@ var TriggerClient = class {
       body: {
         message: "Method not allowed"
       },
-      headers: __privateGet(this, _standardResponseHeaders, standardResponseHeaders_get)
+      headers: __privateMethod(this, _standardResponseHeaders, standardResponseHeaders_fn).call(this, timeOrigin)
     };
   }
   defineJob(options) {
@@ -2029,8 +2383,8 @@ var TriggerClient = class {
     });
     __privateGet(this, _registeredSchedules)[key] = jobs;
   }
-  async registerTrigger(id, key, options) {
-    return __privateGet(this, _client2).registerTrigger(this.id, id, key, options);
+  async registerTrigger(id, key, options, idempotencyKey) {
+    return __privateGet(this, _client2).registerTrigger(this.id, id, key, options, idempotencyKey);
   }
   async getAuth(id) {
     return __privateGet(this, _client2).getAuth(this.id, id);
@@ -2041,6 +2395,9 @@ var TriggerClient = class {
   async cancelEvent(eventId) {
     return __privateGet(this, _client2).cancelEvent(eventId);
   }
+  async cancelRunsForEvent(eventId) {
+    return __privateGet(this, _client2).cancelRunsForEvent(eventId);
+  }
   async updateStatus(runId, id, status) {
     return __privateGet(this, _client2).updateStatus(runId, id, status);
   }
@@ -2056,12 +2413,18 @@ var TriggerClient = class {
   async getRun(runId, options) {
     return __privateGet(this, _client2).getRun(runId, options);
   }
+  async cancelRun(runId) {
+    return __privateGet(this, _client2).cancelRun(runId);
+  }
   async getRuns(jobSlug, options) {
     return __privateGet(this, _client2).getRuns(jobSlug, options);
   }
   async getRunStatuses(runId) {
     return __privateGet(this, _client2).getRunStatuses(runId);
   }
+  async invokeJob(jobId, payload, options) {
+    return __privateGet(this, _client2).invokeJob(jobId, payload, options);
+  }
   authorized(apiKey) {
     if (typeof apiKey !== "string") {
       return "missing-header";
@@ -2098,7 +2461,7 @@ preprocessRun_fn = /* @__PURE__ */ __name(async function(body, job) {
   };
 }, "#preprocessRun");
 _executeJob = new WeakSet();
-executeJob_fn = /* @__PURE__ */ __name(async function(body1, job1, triggerVersion) {
+executeJob_fn = /* @__PURE__ */ __name(async function(body1, job1, timeOrigin, triggerVersion) {
   __privateGet(this, _internalLogger).debug("executing job", {
     execution: body1,
     job: job1.id,
@@ -2118,7 +2481,9 @@ executeJob_fn = /* @__PURE__ */ __name(async function(body1, job1, triggerVersio
     context,
     jobLogLevel: job1.logLevel ?? __privateGet(this, _options4).logLevel ?? "info",
     jobLogger: __privateGet(this, _options4).ioLogLocalEnabled ? new import_core7.Logger(job1.id, job1.logLevel ?? __privateGet(this, _options4).logLevel ?? "info") : void 0,
-    serverVersion: triggerVersion
+    serverVersion: triggerVersion,
+    timeOrigin,
+    executionTimeout: body1.runChunkExecutionLimit
   });
   const resolvedConnections = await __privateMethod(this, _resolveConnections, resolveConnections_fn).call(this, context, job1.options.integrations, body1.connections);
   if (!resolvedConnections.ok) {
@@ -2146,73 +2511,126 @@ executeJob_fn = /* @__PURE__ */ __name(async function(body1, job1, triggerVersio
     if (__privateGet(this, _options4).verbose) {
       __privateMethod(this, _logIOStats, logIOStats_fn).call(this, io.stats);
     }
-    if (error instanceof YieldExecutionError) {
-      return {
-        status: "YIELD_EXECUTION",
-        key: error.key
-      };
-    }
-    if (error instanceof ParsedPayloadSchemaError) {
-      return {
-        status: "INVALID_PAYLOAD",
-        errors: error.schemaErrors
-      };
-    }
-    if (error instanceof ResumeWithTaskError) {
-      return {
-        status: "RESUME_WITH_TASK",
-        task: error.task
-      };
-    }
-    if (error instanceof RetryWithTaskError) {
+    if (error instanceof ResumeWithParallelTaskError) {
       return {
-        status: "RETRY_WITH_TASK",
+        status: "RESUME_WITH_PARALLEL_TASK",
         task: error.task,
-        error: error.cause,
-        retryAt: error.retryAt
+        childErrors: error.childErrors.map((childError) => {
+          return __privateMethod(this, _convertErrorToExecutionResponse, convertErrorToExecutionResponse_fn).call(this, childError, body1);
+        })
       };
     }
-    if (error instanceof CanceledWithTaskError) {
-      return {
-        status: "CANCELED",
-        task: error.task
-      };
-    }
-    if (error instanceof RetryWithTaskError) {
-      const errorWithStack2 = import_core7.ErrorWithStackSchema.safeParse(error.cause);
-      if (errorWithStack2.success) {
-        return {
-          status: "ERROR",
-          error: errorWithStack2.data,
-          task: error.task
-        };
+    return __privateMethod(this, _convertErrorToExecutionResponse, convertErrorToExecutionResponse_fn).call(this, error, body1);
+  }
+}, "#executeJob");
+_convertErrorToExecutionResponse = new WeakSet();
+convertErrorToExecutionResponse_fn = /* @__PURE__ */ __name(function(error, body2) {
+  if (error instanceof AutoYieldExecutionError) {
+    return {
+      status: "AUTO_YIELD_EXECUTION",
+      location: error.location,
+      timeRemaining: error.timeRemaining,
+      timeElapsed: error.timeElapsed,
+      limit: body2.runChunkExecutionLimit
+    };
+  }
+  if (error instanceof AutoYieldWithCompletedTaskExecutionError) {
+    return {
+      status: "AUTO_YIELD_EXECUTION_WITH_COMPLETED_TASK",
+      id: error.id,
+      properties: error.properties,
+      output: error.output,
+      data: {
+        ...error.data,
+        limit: body2.runChunkExecutionLimit
       }
+    };
+  }
+  if (error instanceof YieldExecutionError) {
+    return {
+      status: "YIELD_EXECUTION",
+      key: error.key
+    };
+  }
+  if (error instanceof ParsedPayloadSchemaError) {
+    return {
+      status: "INVALID_PAYLOAD",
+      errors: error.schemaErrors
+    };
+  }
+  if (error instanceof ResumeWithTaskError) {
+    return {
+      status: "RESUME_WITH_TASK",
+      task: error.task
+    };
+  }
+  if (error instanceof RetryWithTaskError) {
+    return {
+      status: "RETRY_WITH_TASK",
+      task: error.task,
+      error: error.cause,
+      retryAt: error.retryAt
+    };
+  }
+  if (error instanceof CanceledWithTaskError) {
+    return {
+      status: "CANCELED",
+      task: error.task
+    };
+  }
+  if (error instanceof ErrorWithTask) {
+    const errorWithStack2 = import_core7.ErrorWithStackSchema.safeParse(error.cause.output);
+    if (errorWithStack2.success) {
       return {
         status: "ERROR",
-        error: {
-          message: "Unknown error"
-        },
-        task: error.task
+        error: errorWithStack2.data,
+        task: error.cause
       };
     }
-    const errorWithStack = import_core7.ErrorWithStackSchema.safeParse(error);
-    if (errorWithStack.success) {
+    return {
+      status: "ERROR",
+      error: {
+        message: JSON.stringify(error.cause.output)
+      },
+      task: error.cause
+    };
+  }
+  if (error instanceof RetryWithTaskError) {
+    const errorWithStack2 = import_core7.ErrorWithStackSchema.safeParse(error.cause);
+    if (errorWithStack2.success) {
       return {
         status: "ERROR",
-        error: errorWithStack.data
+        error: errorWithStack2.data,
+        task: error.task
       };
     }
     return {
       status: "ERROR",
       error: {
         message: "Unknown error"
-      }
+      },
+      task: error.task
     };
   }
-}, "#executeJob");
+  const errorWithStack = import_core7.ErrorWithStackSchema.safeParse(error);
+  if (errorWithStack.success) {
+    return {
+      status: "ERROR",
+      error: errorWithStack.data
+    };
+  }
+  const message = typeof error === "string" ? error : JSON.stringify(error);
+  return {
+    status: "ERROR",
+    error: {
+      name: "Unknown error",
+      message
+    }
+  };
+}, "#convertErrorToExecutionResponse");
 _createRunContext = new WeakSet();
 createRunContext_fn = /* @__PURE__ */ __name(function(execution) {
-  const { event, organization, environment, job, run, source } = execution;
+  const { event, organization, project, environment, job, run, source } = execution;
   return {
     event: {
       id: event.id,
@@ -2221,6 +2639,11 @@ createRunContext_fn = /* @__PURE__ */ __name(function(execution) {
       timestamp: event.timestamp
     },
     organization,
+    project: project ?? {
+      id: "unknown",
+      name: "unknown",
+      slug: "unknown"
+    },
     environment,
     job,
     run,
@@ -2229,8 +2652,8 @@ createRunContext_fn = /* @__PURE__ */ __name(function(execution) {
   };
 }, "#createRunContext");
 _createPreprocessRunContext = new WeakSet();
-createPreprocessRunContext_fn = /* @__PURE__ */ __name(function(body2) {
-  const { event, organization, environment, job, run, account } = body2;
+createPreprocessRunContext_fn = /* @__PURE__ */ __name(function(body3) {
+  const { event, organization, environment, job, run, account } = body3;
   return {
     event: {
       id: event.id,
@@ -2482,9 +2905,11 @@ logIOStats_fn = /* @__PURE__ */ __name(function(stats) {
   });
 }, "#logIOStats");
 _standardResponseHeaders = new WeakSet();
-standardResponseHeaders_get = /* @__PURE__ */ __name(function() {
+standardResponseHeaders_fn = /* @__PURE__ */ __name(function(start) {
   return {
-    "Trigger-Version": import_core7.API_VERSIONS.LAZY_LOADED_CACHED_TASKS
+    "Trigger-Version": import_core7.API_VERSIONS.LAZY_LOADED_CACHED_TASKS,
+    "Trigger-SDK-Version": version,
+    "X-Trigger-Request-Timing": `dur=${performance.now() - start / 1e3}`
   };
 }, "#standardResponseHeaders");
 function dynamicTriggerRegisterSourceJobId(id) {
@@ -2717,6 +3142,60 @@ var MissingConnectionResolvedNotification = class {
 };
 __name(MissingConnectionResolvedNotification, "MissingConnectionResolvedNotification");
 
+// src/triggers/invokeTrigger.ts
+var _options5;
+var InvokeTrigger = class {
+  constructor(options) {
+    __privateAdd(this, _options5, void 0);
+    __privateSet(this, _options5, options);
+  }
+  toJSON() {
+    return {
+      type: "invoke"
+    };
+  }
+  get event() {
+    return {
+      name: "invoke",
+      title: "Manual Invoke",
+      source: "trigger.dev",
+      examples: __privateGet(this, _options5).examples ?? [],
+      icon: "trigger",
+      parsePayload: (rawPayload) => {
+        if (__privateGet(this, _options5).schema) {
+          const results = __privateGet(this, _options5).schema.safeParse(rawPayload);
+          if (!results.success) {
+            throw new ParsedPayloadSchemaError(formatSchemaErrors(results.error.issues));
+          }
+          return results.data;
+        }
+        return rawPayload;
+      },
+      parseInvokePayload: (rawPayload) => {
+        if (__privateGet(this, _options5).schema) {
+          const results = __privateGet(this, _options5).schema.safeParse(rawPayload);
+          if (!results.success) {
+            throw new ParsedPayloadSchemaError(formatSchemaErrors(results.error.issues));
+          }
+          return results.data;
+        }
+        return rawPayload;
+      }
+    };
+  }
+  attachToJob(triggerClient, job) {
+  }
+  get preprocessRuns() {
+    return false;
+  }
+};
+__name(InvokeTrigger, "InvokeTrigger");
+_options5 = new WeakMap();
+function invokeTrigger(options) {
+  return new InvokeTrigger(options ?? {});
+}
+__name(invokeTrigger, "invokeTrigger");
+
 // src/index.ts
 function redactString(strings, ...interpolations) {
   return {
@@ -2737,6 +3216,8 @@ __name(redactString, "redactString");
   IO,
   IOLogger,
   IntervalTrigger,
+  InvokeTrigger,
+  JSONOutputSerializer,
   Job,
   MissingConnectionNotification,
   MissingConnectionResolvedNotification,
@@ -2744,6 +3225,7 @@ __name(redactString, "redactString");
   cronTrigger,
   eventTrigger,
   intervalTrigger,
+  invokeTrigger,
   isTriggerError,
   missingConnectionNotification,
   missingConnectionResolvedNotification,