@trigger.dev/sdk 2.0.0-next.2 → 2.0.0-next.21

package/dist/index.js

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 var __export = (target, all) => {
@@ -16,6 +18,10 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var __accessCheck = (obj, member, msg) => {
   if (!member.has(obj))
@@ -112,6 +118,9 @@ var Job = class {
       return acc;
     }, {});
   }
+  get logLevel() {
+    return this.options.logLevel;
+  }
   toJSON() {
     const internal = this.options.__internal;
     return {
@@ -145,9 +154,10 @@ var logLevels = [
   "info",
   "debug"
 ];
-var _name, _level, _filteredKeys, _jsonReplacer;
+var _name, _level, _filteredKeys, _jsonReplacer, _structuredLog, structuredLog_fn;
 var _Logger = class {
   constructor(name, level = "info", filteredKeys = [], jsonReplacer) {
+    __privateAdd(this, _structuredLog);
     __privateAdd(this, _name, void 0);
     __privateAdd(this, _level, void 0);
     __privateAdd(this, _filteredKeys, []);
@@ -160,36 +170,33 @@ var _Logger = class {
   filter(...keys) {
     return new _Logger(__privateGet(this, _name), logLevels[__privateGet(this, _level)], keys, __privateGet(this, _jsonReplacer));
   }
-  log(...args) {
+  static satisfiesLogLevel(logLevel, setLevel) {
+    return logLevels.indexOf(logLevel) <= logLevels.indexOf(setLevel);
+  }
+  log(message, ...args) {
     if (__privateGet(this, _level) < 0)
       return;
-    console.log(`[${formattedDateTime()}] [${__privateGet(this, _name)}] `, ...args);
+    __privateMethod(this, _structuredLog, structuredLog_fn).call(this, console.log, message, ...args);
   }
-  error(...args) {
+  error(message, ...args) {
     if (__privateGet(this, _level) < 1)
       return;
-    console.error(`[${formattedDateTime()}] [${__privateGet(this, _name)}] `, ...args);
+    __privateMethod(this, _structuredLog, structuredLog_fn).call(this, console.error, message, ...args);
   }
-  warn(...args) {
+  warn(message, ...args) {
     if (__privateGet(this, _level) < 2)
       return;
-    console.warn(`[${formattedDateTime()}] [${__privateGet(this, _name)}] `, ...args);
+    __privateMethod(this, _structuredLog, structuredLog_fn).call(this, console.warn, message, ...args);
   }
-  info(...args) {
+  info(message, ...args) {
     if (__privateGet(this, _level) < 3)
       return;
-    console.info(`[${formattedDateTime()}] [${__privateGet(this, _name)}] `, ...args);
+    __privateMethod(this, _structuredLog, structuredLog_fn).call(this, console.info, message, ...args);
   }
   debug(message, ...args) {
     if (__privateGet(this, _level) < 4)
       return;
-    const structuredLog = {
-      timestamp: new Date(),
-      name: __privateGet(this, _name),
-      message,
-      args: structureArgs(safeJsonClone(args), __privateGet(this, _filteredKeys))
-    };
-    console.debug(JSON.stringify(structuredLog, createReplacer(__privateGet(this, _jsonReplacer))));
+    __privateMethod(this, _structuredLog, structuredLog_fn).call(this, console.debug, message, ...args);
   }
 };
 var Logger = _Logger;
@@ -198,6 +205,16 @@ _name = new WeakMap();
 _level = new WeakMap();
 _filteredKeys = new WeakMap();
 _jsonReplacer = new WeakMap();
+_structuredLog = new WeakSet();
+structuredLog_fn = /* @__PURE__ */ __name(function(loggerFunction, message, ...args) {
+  const structuredLog = {
+    ...structureArgs(safeJsonClone(args), __privateGet(this, _filteredKeys)),
+    timestamp: new Date(),
+    name: __privateGet(this, _name),
+    message
+  };
+  loggerFunction(JSON.stringify(structuredLog, createReplacer(__privateGet(this, _jsonReplacer))));
+}, "#structuredLog");
 function createReplacer(replacer) {
   return (key, value) => {
     if (typeof value === "bigint") {
@@ -225,19 +242,6 @@ function safeJsonClone(obj) {
   }
 }
 __name(safeJsonClone, "safeJsonClone");
-function formattedDateTime() {
-  const date = new Date();
-  const hours = date.getHours();
-  const minutes = date.getMinutes();
-  const seconds = date.getSeconds();
-  const milliseconds = date.getMilliseconds();
-  const formattedHours = hours < 10 ? `0${hours}` : hours;
-  const formattedMinutes = minutes < 10 ? `0${minutes}` : minutes;
-  const formattedSeconds = seconds < 10 ? `0${seconds}` : seconds;
-  const formattedMilliseconds = milliseconds < 10 ? `00${milliseconds}` : milliseconds < 100 ? `0${milliseconds}` : milliseconds;
-  return `${formattedHours}:${formattedMinutes}:${formattedSeconds}.${formattedMilliseconds}`;
-}
-__name(formattedDateTime, "formattedDateTime");
 function structureArgs(args, filteredKeys = []) {
   if (args.length === 0) {
     return;
@@ -405,7 +409,8 @@ var TaskStatusSchema = import_zod7.z.enum([
   "WAITING",
   "RUNNING",
   "COMPLETED",
-  "ERRORED"
+  "ERRORED",
+  "CANCELED"
 ]);
 var TaskSchema = import_zod7.z.object({
   id: import_zod7.z.string(),
@@ -418,6 +423,7 @@ var TaskSchema = import_zod7.z.object({
   status: TaskStatusSchema,
   description: import_zod7.z.string().optional().nullable(),
   properties: import_zod7.z.array(DisplayPropertySchema).optional().nullable(),
+  outputProperties: import_zod7.z.array(DisplayPropertySchema).optional().nullable(),
   params: DeserializedJsonSchema.optional().nullable(),
   output: DeserializedJsonSchema.optional().nullable(),
   error: import_zod7.z.string().optional().nullable(),
@@ -589,14 +595,22 @@ var SourceMetadataSchema = import_zod9.z.object({
   integration: IntegrationConfigSchema,
   key: import_zod9.z.string(),
   params: import_zod9.z.any(),
-  events: import_zod9.z.array(import_zod9.z.string())
+  events: import_zod9.z.array(import_zod9.z.string()),
+  registerSourceJob: import_zod9.z.object({
+    id: import_zod9.z.string(),
+    version: import_zod9.z.string()
+  }).optional()
 });
 var DynamicTriggerEndpointMetadataSchema = import_zod9.z.object({
   id: import_zod9.z.string(),
   jobs: import_zod9.z.array(JobMetadataSchema.pick({
     id: true,
     version: true
-  }))
+  })),
+  registerSourceJob: import_zod9.z.object({
+    id: import_zod9.z.string(),
+    version: import_zod9.z.string()
+  }).optional()
 });
 var IndexEndpointResponseSchema = import_zod9.z.object({
   jobs: import_zod9.z.array(JobMetadataSchema),
@@ -605,12 +619,12 @@ var IndexEndpointResponseSchema = import_zod9.z.object({
   dynamicSchedules: import_zod9.z.array(RegisterDynamicSchedulePayloadSchema)
 });
 var RawEventSchema = import_zod9.z.object({
-  id: import_zod9.z.string().default(() => (0, import_ulid.ulid)()),
   name: import_zod9.z.string(),
-  source: import_zod9.z.string().optional(),
   payload: import_zod9.z.any(),
   context: import_zod9.z.any().optional(),
-  timestamp: import_zod9.z.string().datetime().optional()
+  id: import_zod9.z.string().default(() => (0, import_ulid.ulid)()),
+  timestamp: import_zod9.z.coerce.date().optional(),
+  source: import_zod9.z.string().optional()
 });
 var ApiEventLogSchema = import_zod9.z.object({
   id: import_zod9.z.string(),
@@ -622,7 +636,7 @@ var ApiEventLogSchema = import_zod9.z.object({
   deliveredAt: import_zod9.z.coerce.date().optional().nullable()
 });
 var SendEventOptionsSchema = import_zod9.z.object({
-  deliverAt: import_zod9.z.string().datetime().optional(),
+  deliverAt: import_zod9.z.coerce.date().optional(),
   deliverAfter: import_zod9.z.number().int().optional(),
   accountId: import_zod9.z.string().optional()
 });
@@ -639,6 +653,10 @@ var RuntimeEnvironmentTypeSchema = import_zod9.z.enum([
   "DEVELOPMENT",
   "PREVIEW"
 ]);
+var RunSourceContextSchema = import_zod9.z.object({
+  id: import_zod9.z.string(),
+  metadata: import_zod9.z.any()
+});
 var RunJobBodySchema = import_zod9.z.object({
   event: ApiEventLogSchema,
   job: import_zod9.z.object({
@@ -648,6 +666,7 @@ var RunJobBodySchema = import_zod9.z.object({
   run: import_zod9.z.object({
     id: import_zod9.z.string(),
     isTest: import_zod9.z.boolean(),
+    isRetry: import_zod9.z.boolean().default(false),
     startedAt: import_zod9.z.coerce.date()
   }),
   environment: import_zod9.z.object({
@@ -664,6 +683,7 @@ var RunJobBodySchema = import_zod9.z.object({
     id: import_zod9.z.string(),
     metadata: import_zod9.z.any()
   }).optional(),
+  source: RunSourceContextSchema.optional(),
   tasks: import_zod9.z.array(CachedTaskSchema).optional(),
   connections: import_zod9.z.record(ConnectionAuthSchema).optional()
 });
@@ -682,6 +702,10 @@ var RunJobRetryWithTaskSchema = import_zod9.z.object({
   error: ErrorWithStackSchema,
   retryAt: import_zod9.z.coerce.date()
 });
+var RunJobCanceledWithTaskSchema = import_zod9.z.object({
+  status: import_zod9.z.literal("CANCELED"),
+  task: TaskSchema
+});
 var RunJobSuccessSchema = import_zod9.z.object({
   status: import_zod9.z.literal("SUCCESS"),
   output: DeserializedJsonSchema.optional()
@@ -690,6 +714,7 @@ var RunJobResponseSchema = import_zod9.z.discriminatedUnion("status", [
   RunJobErrorSchema,
   RunJobResumeWithTaskSchema,
   RunJobRetryWithTaskSchema,
+  RunJobCanceledWithTaskSchema,
   RunJobSuccessSchema
 ]);
 var PreprocessRunBodySchema = import_zod9.z.object({
@@ -768,21 +793,21 @@ var RetryOptionsSchema = import_zod9.z.object({
 });
 var RunTaskOptionsSchema = import_zod9.z.object({
   name: import_zod9.z.string(),
+  delayUntil: import_zod9.z.coerce.date().optional(),
+  retry: RetryOptionsSchema.optional(),
   icon: import_zod9.z.string().optional(),
   displayKey: import_zod9.z.string().optional(),
-  noop: import_zod9.z.boolean().default(false),
-  operation: import_zod9.z.enum([
-    "fetch"
-  ]).optional(),
-  delayUntil: import_zod9.z.coerce.date().optional(),
   description: import_zod9.z.string().optional(),
   properties: import_zod9.z.array(DisplayPropertySchema).optional(),
   params: import_zod9.z.any(),
-  trigger: TriggerMetadataSchema.optional(),
-  redact: RedactSchema.optional(),
-  connectionKey: import_zod9.z.string().optional(),
   style: StyleSchema.optional(),
-  retry: RetryOptionsSchema.optional()
+  connectionKey: import_zod9.z.string().optional(),
+  operation: import_zod9.z.enum([
+    "fetch"
+  ]).optional(),
+  noop: import_zod9.z.boolean().default(false),
+  redact: RedactSchema.optional(),
+  trigger: TriggerMetadataSchema.optional()
 });
 var RunTaskBodyInputSchema = RunTaskOptionsSchema.extend({
   idempotencyKey: import_zod9.z.string(),
@@ -824,7 +849,8 @@ var RegisterTriggerBodySchema = import_zod9.z.object({
 var InitializeTriggerBodySchema = import_zod9.z.object({
   id: import_zod9.z.string(),
   params: import_zod9.z.any(),
-  accountId: import_zod9.z.string().optional()
+  accountId: import_zod9.z.string().optional(),
+  metadata: import_zod9.z.any().optional()
 });
 var RegisterCommonScheduleBodySchema = import_zod9.z.object({
   id: import_zod9.z.string(),
@@ -942,25 +968,88 @@ var FetchOperationSchema = import_zod11.z.object({
   retry: import_zod11.z.record(FetchRetryStrategySchema).optional()
 });
 
+// ../internal/src/schemas/events.ts
+var import_zod13 = require("zod");
+
+// ../internal/src/schemas/runs.ts
+var import_zod12 = require("zod");
+var RunStatusSchema = import_zod12.z.union([
+  import_zod12.z.literal("PENDING"),
+  import_zod12.z.literal("QUEUED"),
+  import_zod12.z.literal("WAITING_ON_CONNECTIONS"),
+  import_zod12.z.literal("PREPROCESSING"),
+  import_zod12.z.literal("STARTED"),
+  import_zod12.z.literal("SUCCESS"),
+  import_zod12.z.literal("FAILURE"),
+  import_zod12.z.literal("TIMED_OUT"),
+  import_zod12.z.literal("ABORTED"),
+  import_zod12.z.literal("CANCELED")
+]);
+var RunTaskSchema = import_zod12.z.object({
+  id: import_zod12.z.string(),
+  displayKey: import_zod12.z.string().nullable(),
+  status: TaskStatusSchema,
+  name: import_zod12.z.string(),
+  icon: import_zod12.z.string().nullable(),
+  startedAt: import_zod12.z.coerce.date().nullable(),
+  completedAt: import_zod12.z.coerce.date().nullable()
+});
+var GetRunOptionsSchema = import_zod12.z.object({
+  subtasks: import_zod12.z.boolean().optional(),
+  cursor: import_zod12.z.string().optional(),
+  take: import_zod12.z.number().optional()
+});
+var GetRunOptionsWithTaskDetailsSchema = GetRunOptionsSchema.extend({
+  taskdetails: import_zod12.z.boolean().optional()
+});
+var RunSchema = import_zod12.z.object({
+  id: import_zod12.z.string(),
+  status: RunStatusSchema,
+  startedAt: import_zod12.z.coerce.date().nullable(),
+  updatedAt: import_zod12.z.coerce.date().nullable(),
+  completedAt: import_zod12.z.coerce.date().nullable()
+});
+var GetRunSchema = RunSchema.extend({
+  output: import_zod12.z.any().optional(),
+  tasks: import_zod12.z.array(RunTaskSchema),
+  nextCursor: import_zod12.z.string().optional()
+});
+var GetRunsOptionsSchema = import_zod12.z.object({
+  cursor: import_zod12.z.string().optional(),
+  take: import_zod12.z.number().optional()
+});
+var GetRunsSchema = import_zod12.z.object({
+  runs: RunSchema.array(),
+  nextCursor: import_zod12.z.string().optional()
+});
+
+// ../internal/src/schemas/events.ts
+var GetEventSchema = import_zod13.z.object({
+  id: import_zod13.z.string(),
+  name: import_zod13.z.string(),
+  createdAt: import_zod13.z.coerce.date(),
+  updatedAt: import_zod13.z.coerce.date(),
+  runs: import_zod13.z.array(import_zod13.z.object({
+    id: import_zod13.z.string(),
+    status: RunStatusSchema,
+    startedAt: import_zod13.z.coerce.date().optional().nullable(),
+    completedAt: import_zod13.z.coerce.date().optional().nullable()
+  }))
+});
+
 // ../internal/src/utils.ts
-function deepMergeFilters(filter, other) {
-  const result = {
-    ...filter
-  };
-  for (const key in other) {
-    if (other.hasOwnProperty(key)) {
-      const otherValue = other[key];
-      if (typeof otherValue === "object" && !Array.isArray(otherValue) && otherValue !== null) {
+function deepMergeFilters(...filters) {
+  const result = {};
+  for (const filter of filters) {
+    for (const key in filter) {
+      if (filter.hasOwnProperty(key)) {
         const filterValue = filter[key];
-        if (filterValue && typeof filterValue === "object" && !Array.isArray(filterValue)) {
-          result[key] = deepMergeFilters(filterValue, otherValue);
+        const existingValue = result[key];
+        if (existingValue && typeof existingValue === "object" && typeof filterValue === "object" && !Array.isArray(existingValue) && !Array.isArray(filterValue) && existingValue !== null && filterValue !== null) {
+          result[key] = deepMergeFilters(existingValue, filterValue);
         } else {
-          result[key] = {
-            ...other[key]
-          };
+          result[key] = filterValue;
         }
-      } else {
-        result[key] = other[key];
       }
     }
   }
@@ -1000,8 +1089,22 @@ var currentDate = {
   }
 };
 
+// ../internal/src/searchParams.ts
+function urlWithSearchParams(url, params) {
+  if (!params) {
+    return url;
+  }
+  const urlObj = new URL(url);
+  for (const [key, value] of Object.entries(params)) {
+    urlObj.searchParams.append(key, String(value));
+  }
+  return urlObj.toString();
+}
+__name(urlWithSearchParams, "urlWithSearchParams");
+
 // src/apiClient.ts
-var import_zod12 = require("zod");
+var import_node_fetch = __toESM(require("node-fetch"));
+var import_zod14 = require("zod");
 var _apiUrl, _options, _logger, _apiKey, apiKey_fn;
 var ApiClient = class {
   constructor(options) {
@@ -1019,7 +1122,7 @@ var ApiClient = class {
       url: options.url,
       name: options.name
     });
-    const response = await fetch(`${__privateGet(this, _apiUrl)}/api/v1/endpoints`, {
+    const response = await (0, import_node_fetch.default)(`${__privateGet(this, _apiUrl)}/api/v1/endpoints`, {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
@@ -1170,8 +1273,8 @@ var ApiClient = class {
     __privateGet(this, _logger).debug("unregistering schedule", {
       id
     });
-    const response = await zodfetch(import_zod12.z.object({
-      ok: import_zod12.z.boolean()
+    const response = await zodfetch(import_zod14.z.object({
+      ok: import_zod14.z.boolean()
     }), `${__privateGet(this, _apiUrl)}/api/v1/${client}/schedules/${id}/registrations/${encodeURIComponent(key)}`, {
       method: "DELETE",
       headers: {
@@ -1197,6 +1300,42 @@ var ApiClient = class {
     });
     return response;
   }
+  async getEvent(eventId) {
+    const apiKey = await __privateMethod(this, _apiKey, apiKey_fn).call(this);
+    __privateGet(this, _logger).debug("Getting Event", {
+      eventId
+    });
+    return await zodfetch(GetEventSchema, `${__privateGet(this, _apiUrl)}/api/v1/events/${eventId}`, {
+      method: "GET",
+      headers: {
+        Authorization: `Bearer ${apiKey}`
+      }
+    });
+  }
+  async getRun(runId, options) {
+    const apiKey = await __privateMethod(this, _apiKey, apiKey_fn).call(this);
+    __privateGet(this, _logger).debug("Getting Run", {
+      runId
+    });
+    return await zodfetch(GetRunSchema, urlWithSearchParams(`${__privateGet(this, _apiUrl)}/api/v1/runs/${runId}`, options), {
+      method: "GET",
+      headers: {
+        Authorization: `Bearer ${apiKey}`
+      }
+    });
+  }
+  async getRuns(jobSlug, options) {
+    const apiKey = await __privateMethod(this, _apiKey, apiKey_fn).call(this);
+    __privateGet(this, _logger).debug("Getting Runs", {
+      jobSlug
+    });
+    return await zodfetch(GetRunsSchema, urlWithSearchParams(`${__privateGet(this, _apiUrl)}/api/v1/jobs/${jobSlug}/runs`, options), {
+      method: "GET",
+      headers: {
+        Authorization: `Bearer ${apiKey}`
+      }
+    });
+  }
 };
 __name(ApiClient, "ApiClient");
 _apiUrl = new WeakMap();
@@ -1233,7 +1372,7 @@ function getApiKey(key) {
 }
 __name(getApiKey, "getApiKey");
 async function zodfetch(schema, url, requestInit, options) {
-  const response = await fetch(url, requestInit);
+  const response = await (0, import_node_fetch.default)(url, requestInit);
   if ((!requestInit || requestInit.method === "GET") && response.status === 404 && options?.optional) {
     return;
   }
@@ -1264,8 +1403,14 @@ var RetryWithTaskError = class {
   }
 };
 __name(RetryWithTaskError, "RetryWithTaskError");
+var CanceledWithTaskError = class {
+  constructor(task) {
+    this.task = task;
+  }
+};
+__name(CanceledWithTaskError, "CanceledWithTaskError");
 function isTriggerError(err) {
-  return err instanceof ResumeWithTaskError || err instanceof RetryWithTaskError;
+  return err instanceof ResumeWithTaskError || err instanceof RetryWithTaskError || err instanceof CanceledWithTaskError;
 }
 __name(isTriggerError, "isTriggerError");
 
@@ -1288,6 +1433,15 @@ function createIOWithIntegrations(io, auths, integrations) {
     const ioConnection = {
       client
     };
+    ioConnection.runTask = async (key, callback, options) => {
+      return await io.runTask(key, {
+        name: "Task",
+        icon: integration.metadata.id,
+        ...options
+      }, async (ioTask) => {
+        return await callback(client, ioTask, io);
+      });
+    };
     if (integration.client.tasks) {
       const tasks = integration.client.tasks;
       Object.keys(tasks).forEach((taskName) => {
@@ -1329,6 +1483,8 @@ var IO = class {
     this._triggerClient = options.client;
     this._logger = options.logger ?? new Logger("trigger.dev", options.logLevel);
     this._cachedTasks = /* @__PURE__ */ new Map();
+    this._jobLogger = options.jobLogger;
+    this._jobLogLevel = options.jobLogLevel;
     if (options.cachedTasks) {
       options.cachedTasks.forEach((task) => {
         this._cachedTasks.set(task.id, task);
@@ -1339,45 +1495,57 @@ var IO = class {
   }
   get logger() {
     return new IOLogger(async (level, message, data) => {
+      let logLevel = "info";
       switch (level) {
+        case "LOG": {
+          this._jobLogger?.log(message, data);
+          logLevel = "log";
+          break;
+        }
         case "DEBUG": {
-          this._logger.debug(message, data);
+          this._jobLogger?.debug(message, data);
+          logLevel = "debug";
           break;
         }
         case "INFO": {
-          this._logger.info(message, data);
+          this._jobLogger?.info(message, data);
+          logLevel = "info";
           break;
         }
         case "WARN": {
-          this._logger.warn(message, data);
+          this._jobLogger?.warn(message, data);
+          logLevel = "warn";
           break;
         }
         case "ERROR": {
-          this._logger.error(message, data);
+          this._jobLogger?.error(message, data);
+          logLevel = "error";
           break;
         }
       }
-      await this.runTask([
-        message,
-        level
-      ], {
-        name: "log",
-        icon: "log",
-        description: message,
-        params: data,
-        properties: [
-          {
-            label: "Level",
-            text: level
-          }
-        ],
-        style: {
-          style: "minimal",
-          variant: level.toLowerCase()
-        },
-        noop: true
-      }, async (task) => {
-      });
+      if (Logger.satisfiesLogLevel(logLevel, this._jobLogLevel)) {
+        await this.runTask([
+          message,
+          level
+        ], {
+          name: "log",
+          icon: "log",
+          description: message,
+          params: data,
+          properties: [
+            {
+              label: "Level",
+              text: level
+            }
+          ],
+          style: {
+            style: "minimal",
+            variant: level.toLowerCase()
+          },
+          noop: true
+        }, async (task) => {
+        });
+      }
     });
   }
   async wait(key, seconds) {
@@ -1432,7 +1600,19 @@ var IO = class {
       params: {
         event,
         options
-      }
+      },
+      properties: [
+        {
+          label: "name",
+          text: event.name
+        },
+        ...event?.id ? [
+          {
+            label: "ID",
+            text: event.id
+          }
+        ] : []
+      ]
     }, async (task) => {
       return await this._triggerClient.sendEvent(event, options);
     });
@@ -1440,13 +1620,14 @@ var IO = class {
   async updateSource(key, options) {
     return this.runTask(key, {
       name: "Update Source",
-      description: `Update Source ${options.key}`,
+      description: "Update Source",
       properties: [
         {
           label: "key",
           text: options.key
         }
       ],
+      params: options,
       redact: {
         paths: [
           "secret"
@@ -1619,6 +1800,13 @@ var IO = class {
       ...options,
       parentId
     });
+    if (task.status === "CANCELED") {
+      this._logger.debug("Task canceled", {
+        idempotencyKey,
+        task
+      });
+      throw new CanceledWithTaskError(task);
+    }
     if (task.status === "COMPLETED") {
       this._logger.debug("Using task output", {
         idempotencyKey,
@@ -1655,21 +1843,36 @@ var IO = class {
           idempotencyKey,
           task
         });
-        await this._apiClient.completeTask(this._id, task.id, {
-          output: result ?? void 0
+        const completedTask = await this._apiClient.completeTask(this._id, task.id, {
+          output: result ?? void 0,
+          properties: task.outputProperties ?? void 0
         });
+        if (completedTask.status === "CANCELED") {
+          throw new CanceledWithTaskError(completedTask);
+        }
         return result;
       } catch (error) {
         if (isTriggerError(error)) {
           throw error;
         }
         if (onError) {
-          const onErrorResult = onError(error, task, this);
-          if (onErrorResult) {
-            const parsedError2 = ErrorWithStackSchema.safeParse(onErrorResult.error);
-            throw new RetryWithTaskError(parsedError2.success ? parsedError2.data : {
-              message: "Unknown error"
-            }, task, onErrorResult.retryAt);
+          try {
+            const onErrorResult = onError(error, task, this);
+            if (onErrorResult) {
+              if (onErrorResult instanceof Error) {
+                error = onErrorResult;
+              } else {
+                const parsedError2 = ErrorWithStackSchema.safeParse(onErrorResult.error);
+                throw new RetryWithTaskError(parsedError2.success ? parsedError2.data : {
+                  message: "Unknown error"
+                }, task, onErrorResult.retryAt);
+              }
+            }
+          } catch (innerError) {
+            if (isTriggerError(innerError)) {
+              throw innerError;
+            }
+            error = innerError;
           }
         }
         const parsedError = ErrorWithStackSchema.safeParse(error);
@@ -1752,6 +1955,9 @@ var IOLogger = class {
   constructor(callback) {
     this.callback = callback;
   }
+  log(message, properties) {
+    return this.callback("LOG", message, properties);
+  }
   debug(message, properties) {
     return this.callback("DEBUG", message, properties);
   }
@@ -1824,7 +2030,7 @@ var registerSourceEvent = {
   icon: "register-source",
   parsePayload: RegisterSourceEventSchema.parse
 };
-var _options3, _registeredJobs, _registeredSources, _registeredHttpSourceHandlers, _registeredDynamicTriggers, _jobMetadataByDynamicTriggers, _registeredSchedules, _client, _logger2, _preprocessRun, preprocessRun_fn, _executeJob, executeJob_fn, _createRunContext, createRunContext_fn, _createPreprocessRunContext, createPreprocessRunContext_fn, _handleHttpSourceRequest, handleHttpSourceRequest_fn;
+var _options3, _registeredJobs, _registeredSources, _registeredHttpSourceHandlers, _registeredDynamicTriggers, _jobMetadataByDynamicTriggers, _registeredSchedules, _client, _internalLogger, _preprocessRun, preprocessRun_fn, _executeJob, executeJob_fn, _createRunContext, createRunContext_fn, _createPreprocessRunContext, createPreprocessRunContext_fn, _handleHttpSourceRequest, handleHttpSourceRequest_fn;
 var TriggerClient = class {
   constructor(options) {
     __privateAdd(this, _preprocessRun);
@@ -1840,36 +2046,54 @@ var TriggerClient = class {
     __privateAdd(this, _jobMetadataByDynamicTriggers, {});
     __privateAdd(this, _registeredSchedules, {});
     __privateAdd(this, _client, void 0);
-    __privateAdd(this, _logger2, void 0);
+    __privateAdd(this, _internalLogger, void 0);
     this.id = options.id;
-    this._url = buildClientUrl(options.url);
     __privateSet(this, _options3, options);
     __privateSet(this, _client, new ApiClient(__privateGet(this, _options3)));
-    __privateSet(this, _logger2, new Logger("trigger.dev", __privateGet(this, _options3).logLevel));
-  }
-  get url() {
-    return `${this._url}${this.path ? `${this.path.startsWith("/") ? "" : "/"}${this.path}` : ""}`;
+    __privateSet(this, _internalLogger, new Logger("trigger.dev", __privateGet(this, _options3).verbose ? "debug" : "log"));
   }
   async handleRequest(request) {
-    __privateGet(this, _logger2).debug("handling request", {
+    __privateGet(this, _internalLogger).debug("handling request", {
       url: request.url,
       headers: Object.fromEntries(request.headers.entries()),
       method: request.method
     });
     const apiKey = request.headers.get("x-trigger-api-key");
-    if (!this.authorized(apiKey)) {
-      return {
-        status: 401,
-        body: {
-          message: "Unauthorized"
-        }
-      };
+    const authorization = this.authorized(apiKey);
+    switch (authorization) {
+      case "authorized": {
+        break;
+      }
+      case "missing-client": {
+        return {
+          status: 401,
+          body: {
+            message: "Unauthorized: client missing apiKey"
+          }
+        };
+      }
+      case "missing-header": {
+        return {
+          status: 401,
+          body: {
+            message: "Unauthorized: missing x-trigger-api-key header"
+          }
+        };
+      }
+      case "unauthorized": {
+        return {
+          status: 401,
+          body: {
+            message: `Forbidden: client apiKey mismatch: Make sure you are using the correct API Key for your environment`
+          }
+        };
+      }
     }
     if (request.method !== "POST") {
       return {
         status: 405,
         body: {
-          message: "Method not allowed"
+          message: "Method not allowed (only POST is allowed)"
         }
       };
     }
@@ -1890,7 +2114,7 @@ var TriggerClient = class {
             status: 200,
             body: {
               ok: false,
-              message: "Missing endpoint ID"
+              error: "Missing endpoint ID"
             }
           };
         }
@@ -1899,7 +2123,7 @@ var TriggerClient = class {
             status: 200,
             body: {
               ok: false,
-              message: `Endpoint ID mismatch error. Expected ${this.id}, got ${endpointId}`
+              error: `Endpoint ID mismatch error. Expected ${this.id}, got ${endpointId}`
             }
           };
         }
@@ -1932,7 +2156,11 @@ var TriggerClient = class {
           sources: Object.values(__privateGet(this, _registeredSources)),
           dynamicTriggers: Object.values(__privateGet(this, _registeredDynamicTriggers)).map((trigger) => ({
             id: trigger.id,
-            jobs: __privateGet(this, _jobMetadataByDynamicTriggers)[trigger.id] ?? []
+            jobs: __privateGet(this, _jobMetadataByDynamicTriggers)[trigger.id] ?? [],
+            registerSourceJob: {
+              id: dynamicTriggerRegisterSourceJobId(trigger.id),
+              version: trigger.source.version
+            }
           })),
           dynamicSchedules: Object.entries(__privateGet(this, _registeredSchedules)).map(([id, jobs]) => ({
             id,
@@ -2034,11 +2262,19 @@ var TriggerClient = class {
             }
           };
         }
-        const sourceRequest = new Request(headers.data["x-ts-http-url"], {
+        const sourceRequestNeedsBody = headers.data["x-ts-http-method"] !== "GET";
+        const sourceRequestInit = {
           method: headers.data["x-ts-http-method"],
           headers: headers.data["x-ts-http-headers"],
-          body: headers.data["x-ts-http-method"] !== "GET" ? request.body : void 0
-        });
+          body: sourceRequestNeedsBody ? request.body : void 0
+        };
+        if (sourceRequestNeedsBody) {
+          try {
+            sourceRequestInit.duplex = "half";
+          } catch (error) {
+          }
+        }
+        const sourceRequest = new Request(headers.data["x-ts-http-url"], sourceRequestInit);
         const key = headers.data["x-ts-key"];
         const dynamicId = headers.data["x-ts-dynamic-id"];
         const secret = headers.data["x-ts-secret"];
@@ -2078,7 +2314,7 @@ var TriggerClient = class {
   attachDynamicTrigger(trigger) {
     __privateGet(this, _registeredDynamicTriggers)[trigger.id] = trigger;
     new Job(this, {
-      id: `register-dynamic-trigger-${trigger.id}`,
+      id: dynamicTriggerRegisterSourceJobId(trigger.id),
       name: `Register dynamic trigger ${trigger.id}`,
       version: trigger.source.version,
       trigger: new EventTrigger({
@@ -2115,7 +2351,7 @@ var TriggerClient = class {
   }
   attachSource(options) {
     __privateGet(this, _registeredHttpSourceHandlers)[options.key] = async (s, r) => {
-      return await options.source.handle(s, r, __privateGet(this, _logger2));
+      return await options.source.handle(s, r, __privateGet(this, _internalLogger));
     };
     let registeredSource = __privateGet(this, _registeredSources)[options.key];
     if (!registeredSource) {
@@ -2128,6 +2364,10 @@ var TriggerClient = class {
           id: options.source.integration.id,
           metadata: options.source.integration.metadata,
           authSource: options.source.integration.client.usesLocalAuth ? "LOCAL" : "HOSTED"
+        },
+        registerSourceJob: {
+          id: options.key,
+          version: options.source.version
         }
       };
     }
@@ -2194,16 +2434,31 @@ var TriggerClient = class {
   async unregisterSchedule(id, key) {
     return __privateGet(this, _client).unregisterSchedule(this.id, id, key);
   }
+  async getEvent(eventId) {
+    return __privateGet(this, _client).getEvent(eventId);
+  }
+  async getRun(runId, options) {
+    return __privateGet(this, _client).getRun(runId, options);
+  }
+  async getRuns(jobSlug, options) {
+    return __privateGet(this, _client).getRuns(jobSlug, options);
+  }
   authorized(apiKey) {
+    if (typeof apiKey !== "string") {
+      return "missing-header";
+    }
     const localApiKey = __privateGet(this, _options3).apiKey ?? process.env.TRIGGER_API_KEY;
     if (!localApiKey) {
-      return false;
+      return "missing-client";
     }
-    return apiKey === localApiKey;
+    return apiKey === localApiKey ? "authorized" : "unauthorized";
   }
   apiKey() {
     return __privateGet(this, _options3).apiKey ?? process.env.TRIGGER_API_KEY;
   }
+  defineJob(options) {
+    return new Job(this, options);
+  }
 };
 __name(TriggerClient, "TriggerClient");
 _options3 = new WeakMap();
@@ -2214,7 +2469,7 @@ _registeredDynamicTriggers = new WeakMap();
 _jobMetadataByDynamicTriggers = new WeakMap();
 _registeredSchedules = new WeakMap();
 _client = new WeakMap();
-_logger2 = new WeakMap();
+_internalLogger = new WeakMap();
 _preprocessRun = new WeakSet();
 preprocessRun_fn = /* @__PURE__ */ __name(async function(body, job) {
   const context = __privateMethod(this, _createPreprocessRunContext, createPreprocessRunContext_fn).call(this, body);
@@ -2227,7 +2482,7 @@ preprocessRun_fn = /* @__PURE__ */ __name(async function(body, job) {
 }, "#preprocessRun");
 _executeJob = new WeakSet();
 executeJob_fn = /* @__PURE__ */ __name(async function(body1, job1) {
-  __privateGet(this, _logger2).debug("executing job", {
+  __privateGet(this, _internalLogger).debug("executing job", {
     execution: body1,
     job: job1.toJSON()
   });
@@ -2236,9 +2491,11 @@ executeJob_fn = /* @__PURE__ */ __name(async function(body1, job1) {
     id: body1.run.id,
     cachedTasks: body1.tasks,
     apiClient: __privateGet(this, _client),
-    logger: __privateGet(this, _logger2),
+    logger: __privateGet(this, _internalLogger),
     client: this,
-    context
+    context,
+    jobLogLevel: job1.logLevel ?? __privateGet(this, _options3).logLevel ?? "info",
+    jobLogger: __privateGet(this, _options3).ioLogLocalEnabled ? new Logger(job1.id, job1.logLevel ?? __privateGet(this, _options3).logLevel ?? "info") : void 0
   });
   const ioWithConnections = createIOWithIntegrations(io, body1.connections, job1.options.integrations);
   try {
@@ -2262,6 +2519,12 @@ executeJob_fn = /* @__PURE__ */ __name(async function(body1, job1) {
         retryAt: error.retryAt
       };
     }
+    if (error instanceof CanceledWithTaskError) {
+      return {
+        status: "CANCELED",
+        task: error.task
+      };
+    }
     if (error instanceof RetryWithTaskError) {
       const errorWithStack2 = ErrorWithStackSchema.safeParse(error.cause);
       if (errorWithStack2.success) {
@@ -2296,7 +2559,7 @@ executeJob_fn = /* @__PURE__ */ __name(async function(body1, job1) {
 }, "#executeJob");
 _createRunContext = new WeakSet();
 createRunContext_fn = /* @__PURE__ */ __name(function(execution) {
-  const { event, organization, environment, job, run } = execution;
+  const { event, organization, environment, job, run, source } = execution;
   return {
     event: {
       id: event.id,
@@ -2308,7 +2571,8 @@ createRunContext_fn = /* @__PURE__ */ __name(function(execution) {
     environment,
     job,
     run,
-    account: execution.account
+    account: execution.account,
+    source
   };
 }, "#createRunContext");
 _createPreprocessRunContext = new WeakSet();
@@ -2330,13 +2594,13 @@ createPreprocessRunContext_fn = /* @__PURE__ */ __name(function(body2) {
 }, "#createPreprocessRunContext");
 _handleHttpSourceRequest = new WeakSet();
 handleHttpSourceRequest_fn = /* @__PURE__ */ __name(async function(source, sourceRequest) {
-  __privateGet(this, _logger2).debug("Handling HTTP source request", {
+  __privateGet(this, _internalLogger).debug("Handling HTTP source request", {
     source
   });
   if (source.dynamicId) {
     const dynamicTrigger = __privateGet(this, _registeredDynamicTriggers)[source.dynamicId];
     if (!dynamicTrigger) {
-      __privateGet(this, _logger2).debug("No dynamic trigger registered for HTTP source", {
+      __privateGet(this, _internalLogger).debug("No dynamic trigger registered for HTTP source", {
         source
       });
       return {
@@ -2349,7 +2613,7 @@ handleHttpSourceRequest_fn = /* @__PURE__ */ __name(async function(source, sourc
         events: []
       };
     }
-    const results2 = await dynamicTrigger.source.handle(source, sourceRequest, __privateGet(this, _logger2));
+    const results2 = await dynamicTrigger.source.handle(source, sourceRequest, __privateGet(this, _internalLogger));
     if (!results2) {
       return {
         events: [],
@@ -2373,7 +2637,7 @@ handleHttpSourceRequest_fn = /* @__PURE__ */ __name(async function(source, sourc
   }
   const handler = __privateGet(this, _registeredHttpSourceHandlers)[source.key];
   if (!handler) {
-    __privateGet(this, _logger2).debug("No handler registered for HTTP source", {
+    __privateGet(this, _internalLogger).debug("No handler registered for HTTP source", {
       source
     });
     return {
@@ -2408,20 +2672,10 @@ handleHttpSourceRequest_fn = /* @__PURE__ */ __name(async function(source, sourc
     }
   };
 }, "#handleHttpSourceRequest");
-function buildClientUrl(url) {
-  if (!url) {
-    const host = process.env.TRIGGER_CLIENT_HOST ?? process.env.HOST ?? process.env.HOSTNAME ?? process.env.NOW_URL ?? process.env.VERCEL_URL;
-    if (host) {
-      return "https://" + host;
-    }
-    throw new Error("Could not determine the url for this TriggerClient. Please set the TRIGGER_CLIENT_HOST environment variable or pass in the `url` option to the TriggerClient constructor.");
-  }
-  if (!url.startsWith("http")) {
-    return "https://" + url;
-  }
-  return url;
+function dynamicTriggerRegisterSourceJobId(id) {
+  return `register-dynamic-trigger-${id}`;
 }
-__name(buildClientUrl, "buildClientUrl");
+__name(dynamicTriggerRegisterSourceJobId, "dynamicTriggerRegisterSourceJobId");
 
 // src/integrations.ts
 function authenticatedTask(options) {
@@ -2445,7 +2699,7 @@ var ExternalSource = class {
     }, logger);
   }
   filter(params) {
-    return this.options.filter(params);
+    return this.options.filter?.(params) ?? {};
   }
   properties(params) {
     return this.options.properties?.(params) ?? [];
@@ -2503,7 +2757,7 @@ var ExternalSourceTrigger = class {
       title: "External Source",
       rule: {
         event: this.event.name,
-        payload: deepMergeFilters(this.options.source.filter(this.options.params), this.event.filter ?? {}),
+        payload: deepMergeFilters(this.options.source.filter(this.options.params), this.event.filter ?? {}, this.options.params.filter ?? {}),
         source: this.event.source
       },
       properties: this.options.source.properties(this.options.params)
@@ -2560,6 +2814,7 @@ var DynamicTrigger = class {
     return __privateGet(this, _options4).event;
   }
   registeredTriggerForParams(params) {
+    const key = slugifyId(this.source.key(params));
     return {
       rule: {
         event: this.event.name,
@@ -2567,7 +2822,7 @@ var DynamicTrigger = class {
         payload: deepMergeFilters(this.source.filter(params), this.event.filter ?? {})
       },
       source: {
-        key: slugifyId(this.source.key(params)),
+        key,
         channel: this.source.channel,
         params,
         events: [
@@ -2588,7 +2843,7 @@ var DynamicTrigger = class {
     triggerClient.attachJobToDynamicTrigger(job, this);
   }
   get preprocessRuns() {
-    return false;
+    return true;
   }
 };
 __name(DynamicTrigger, "DynamicTrigger");
@@ -2596,6 +2851,7 @@ _client2 = new WeakMap();
 _options4 = new WeakMap();
 
 // src/triggers/scheduled.ts
+var import_cronstrue = __toESM(require("cronstrue"));
 var examples = [
   {
     id: "now",
@@ -2654,6 +2910,9 @@ var CronTrigger = class {
     this.options = options;
   }
   get event() {
+    const humanReadable = import_cronstrue.default.toString(this.options.cron, {
+      throwExceptionOnParseError: false
+    });
     return {
       name: "trigger.scheduled",
       title: "Cron Schedule",
@@ -2663,8 +2922,12 @@ var CronTrigger = class {
       parsePayload: ScheduledPayloadSchema.parse,
       properties: [
         {
-          label: "Expression",
+          label: "cron",
           text: this.options.cron
+        },
+        {
+          label: "Schedule",
+          text: humanReadable
         }
       ]
     };