@trigger.dev/sdk 2.0.0-next.9 → 2.0.1

package/dist/index.js

@@ -146,880 +146,13 @@ validate_fn = /* @__PURE__ */ __name(function() {
   }
 }, "#validate");
 
-// ../internal/src/logger.ts
-var logLevels = [
-  "log",
-  "error",
-  "warn",
-  "info",
-  "debug"
-];
-var _name, _level, _filteredKeys, _jsonReplacer;
-var _Logger = class {
-  constructor(name, level = "info", filteredKeys = [], jsonReplacer) {
-    __privateAdd(this, _name, void 0);
-    __privateAdd(this, _level, void 0);
-    __privateAdd(this, _filteredKeys, []);
-    __privateAdd(this, _jsonReplacer, void 0);
-    __privateSet(this, _name, name);
-    __privateSet(this, _level, logLevels.indexOf(process.env.TRIGGER_LOG_LEVEL ?? level));
-    __privateSet(this, _filteredKeys, filteredKeys);
-    __privateSet(this, _jsonReplacer, jsonReplacer);
-  }
-  filter(...keys) {
-    return new _Logger(__privateGet(this, _name), logLevels[__privateGet(this, _level)], keys, __privateGet(this, _jsonReplacer));
-  }
-  static satisfiesLogLevel(logLevel, setLevel) {
-    return logLevels.indexOf(logLevel) <= logLevels.indexOf(setLevel);
-  }
-  log(...args) {
-    if (__privateGet(this, _level) < 0)
-      return;
-    console.log(`[${formattedDateTime()}] [${__privateGet(this, _name)}] `, ...args);
-  }
-  error(...args) {
-    if (__privateGet(this, _level) < 1)
-      return;
-    console.error(`[${formattedDateTime()}] [${__privateGet(this, _name)}] `, ...args);
-  }
-  warn(...args) {
-    if (__privateGet(this, _level) < 2)
-      return;
-    console.warn(`[${formattedDateTime()}] [${__privateGet(this, _name)}] `, ...args);
-  }
-  info(...args) {
-    if (__privateGet(this, _level) < 3)
-      return;
-    console.info(`[${formattedDateTime()}] [${__privateGet(this, _name)}] `, ...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))));
-  }
-};
-var Logger = _Logger;
-__name(Logger, "Logger");
-_name = new WeakMap();
-_level = new WeakMap();
-_filteredKeys = new WeakMap();
-_jsonReplacer = new WeakMap();
-function createReplacer(replacer) {
-  return (key, value) => {
-    if (typeof value === "bigint") {
-      return value.toString();
-    }
-    if (replacer) {
-      return replacer(key, value);
-    }
-    return value;
-  };
-}
-__name(createReplacer, "createReplacer");
-function bigIntReplacer(_key, value) {
-  if (typeof value === "bigint") {
-    return value.toString();
-  }
-  return value;
-}
-__name(bigIntReplacer, "bigIntReplacer");
-function safeJsonClone(obj) {
-  try {
-    return JSON.parse(JSON.stringify(obj, bigIntReplacer));
-  } catch (e) {
-    return 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;
-  }
-  if (args.length === 1 && typeof args[0] === "object") {
-    return filterKeys(JSON.parse(JSON.stringify(args[0], bigIntReplacer)), filteredKeys);
-  }
-  return args;
-}
-__name(structureArgs, "structureArgs");
-function filterKeys(obj, keys) {
-  if (typeof obj !== "object" || obj === null) {
-    return obj;
-  }
-  if (Array.isArray(obj)) {
-    return obj.map((item) => filterKeys(item, keys));
-  }
-  const filteredObj = {};
-  for (const [key, value] of Object.entries(obj)) {
-    if (keys.includes(key)) {
-      continue;
-    }
-    filteredObj[key] = filterKeys(value, keys);
-  }
-  return filteredObj;
-}
-__name(filterKeys, "filterKeys");
-
-// ../internal/src/schemas/api.ts
-var import_ulid = require("ulid");
-var import_zod9 = require("zod");
-
-// ../internal/src/schemas/errors.ts
-var import_zod = require("zod");
-var ErrorWithStackSchema = import_zod.z.object({
-  message: import_zod.z.string(),
-  name: import_zod.z.string().optional(),
-  stack: import_zod.z.string().optional()
-});
-
-// ../internal/src/schemas/eventFilter.ts
-var import_zod2 = require("zod");
-var EventMatcherSchema = import_zod2.z.union([
-  import_zod2.z.array(import_zod2.z.string()),
-  import_zod2.z.array(import_zod2.z.number()),
-  import_zod2.z.array(import_zod2.z.boolean())
-]);
-var EventFilterSchema = import_zod2.z.lazy(() => import_zod2.z.record(import_zod2.z.union([
-  EventMatcherSchema,
-  EventFilterSchema
-])));
-var EventRuleSchema = import_zod2.z.object({
-  event: import_zod2.z.string(),
-  source: import_zod2.z.string(),
-  payload: EventFilterSchema.optional(),
-  context: EventFilterSchema.optional()
-});
-
-// ../internal/src/schemas/integrations.ts
-var import_zod3 = require("zod");
-var ConnectionAuthSchema = import_zod3.z.object({
-  type: import_zod3.z.enum([
-    "oauth2"
-  ]),
-  accessToken: import_zod3.z.string(),
-  scopes: import_zod3.z.array(import_zod3.z.string()).optional(),
-  additionalFields: import_zod3.z.record(import_zod3.z.string()).optional()
-});
-var IntegrationMetadataSchema = import_zod3.z.object({
-  id: import_zod3.z.string(),
-  name: import_zod3.z.string(),
-  instructions: import_zod3.z.string().optional()
-});
-var IntegrationConfigSchema = import_zod3.z.object({
-  id: import_zod3.z.string(),
-  metadata: IntegrationMetadataSchema,
-  authSource: import_zod3.z.enum([
-    "HOSTED",
-    "LOCAL"
-  ])
-});
-
-// ../internal/src/schemas/json.ts
-var import_zod4 = require("zod");
-var LiteralSchema = import_zod4.z.union([
-  import_zod4.z.string(),
-  import_zod4.z.number(),
-  import_zod4.z.boolean(),
-  import_zod4.z.null()
-]);
-var DeserializedJsonSchema = import_zod4.z.lazy(() => import_zod4.z.union([
-  LiteralSchema,
-  import_zod4.z.array(DeserializedJsonSchema),
-  import_zod4.z.record(DeserializedJsonSchema)
-]));
-var SerializableSchema = import_zod4.z.union([
-  import_zod4.z.string(),
-  import_zod4.z.number(),
-  import_zod4.z.boolean(),
-  import_zod4.z.null(),
-  import_zod4.z.date(),
-  import_zod4.z.undefined(),
-  import_zod4.z.symbol()
-]);
-var SerializableJsonSchema = import_zod4.z.lazy(() => import_zod4.z.union([
-  SerializableSchema,
-  import_zod4.z.array(SerializableJsonSchema),
-  import_zod4.z.record(SerializableJsonSchema)
-]));
-
-// ../internal/src/schemas/properties.ts
-var import_zod5 = require("zod");
-var DisplayPropertySchema = import_zod5.z.object({
-  label: import_zod5.z.string(),
-  text: import_zod5.z.string(),
-  url: import_zod5.z.string().optional()
-});
-var DisplayPropertiesSchema = import_zod5.z.array(DisplayPropertySchema);
-var StyleSchema = import_zod5.z.object({
-  style: import_zod5.z.enum([
-    "normal",
-    "minimal"
-  ]),
-  variant: import_zod5.z.string().optional()
-});
-
-// ../internal/src/schemas/schedules.ts
-var import_zod6 = require("zod");
-var ScheduledPayloadSchema = import_zod6.z.object({
-  ts: import_zod6.z.coerce.date(),
-  lastTimestamp: import_zod6.z.coerce.date().optional()
-});
-var IntervalOptionsSchema = import_zod6.z.object({
-  seconds: import_zod6.z.number().int().positive().min(60).max(86400)
-});
-var CronOptionsSchema = import_zod6.z.object({
-  cron: import_zod6.z.string()
-});
-var CronMetadataSchema = import_zod6.z.object({
-  type: import_zod6.z.literal("cron"),
-  options: CronOptionsSchema,
-  metadata: import_zod6.z.any()
-});
-var IntervalMetadataSchema = import_zod6.z.object({
-  type: import_zod6.z.literal("interval"),
-  options: IntervalOptionsSchema,
-  metadata: import_zod6.z.any()
-});
-var ScheduleMetadataSchema = import_zod6.z.discriminatedUnion("type", [
-  IntervalMetadataSchema,
-  CronMetadataSchema
-]);
-var RegisterDynamicSchedulePayloadSchema = import_zod6.z.object({
-  id: import_zod6.z.string(),
-  jobs: import_zod6.z.array(import_zod6.z.object({
-    id: import_zod6.z.string(),
-    version: import_zod6.z.string()
-  }))
-});
-
-// ../internal/src/schemas/tasks.ts
-var import_zod7 = require("zod");
-var TaskStatusSchema = import_zod7.z.enum([
-  "PENDING",
-  "WAITING",
-  "RUNNING",
-  "COMPLETED",
-  "ERRORED"
-]);
-var TaskSchema = import_zod7.z.object({
-  id: import_zod7.z.string(),
-  name: import_zod7.z.string(),
-  icon: import_zod7.z.string().optional().nullable(),
-  noop: import_zod7.z.boolean(),
-  startedAt: import_zod7.z.coerce.date().optional().nullable(),
-  completedAt: import_zod7.z.coerce.date().optional().nullable(),
-  delayUntil: import_zod7.z.coerce.date().optional().nullable(),
-  status: TaskStatusSchema,
-  description: import_zod7.z.string().optional().nullable(),
-  properties: import_zod7.z.array(DisplayPropertySchema).optional().nullable(),
-  params: DeserializedJsonSchema.optional().nullable(),
-  output: DeserializedJsonSchema.optional().nullable(),
-  error: import_zod7.z.string().optional().nullable(),
-  parentId: import_zod7.z.string().optional().nullable(),
-  style: StyleSchema.optional().nullable(),
-  operation: import_zod7.z.string().optional().nullable()
-});
-var ServerTaskSchema = TaskSchema.extend({
-  idempotencyKey: import_zod7.z.string(),
-  attempts: import_zod7.z.number()
-});
-var CachedTaskSchema = import_zod7.z.object({
-  id: import_zod7.z.string(),
-  idempotencyKey: import_zod7.z.string(),
-  status: TaskStatusSchema,
-  noop: import_zod7.z.boolean().default(false),
-  output: DeserializedJsonSchema.optional().nullable(),
-  parentId: import_zod7.z.string().optional().nullable()
-});
-
-// ../internal/src/schemas/triggers.ts
-var import_zod8 = require("zod");
-var EventExampleSchema = import_zod8.z.object({
-  id: import_zod8.z.string(),
-  icon: import_zod8.z.string().optional(),
-  name: import_zod8.z.string(),
-  payload: import_zod8.z.any()
-});
-var EventSpecificationSchema = import_zod8.z.object({
-  name: import_zod8.z.string(),
-  title: import_zod8.z.string(),
-  source: import_zod8.z.string(),
-  icon: import_zod8.z.string(),
-  filter: EventFilterSchema.optional(),
-  properties: import_zod8.z.array(DisplayPropertySchema).optional(),
-  schema: import_zod8.z.any().optional(),
-  examples: import_zod8.z.array(EventExampleSchema).optional()
-});
-var DynamicTriggerMetadataSchema = import_zod8.z.object({
-  type: import_zod8.z.literal("dynamic"),
-  id: import_zod8.z.string()
-});
-var StaticTriggerMetadataSchema = import_zod8.z.object({
-  type: import_zod8.z.literal("static"),
-  title: import_zod8.z.string(),
-  properties: import_zod8.z.array(DisplayPropertySchema).optional(),
-  rule: EventRuleSchema
-});
-var ScheduledTriggerMetadataSchema = import_zod8.z.object({
-  type: import_zod8.z.literal("scheduled"),
-  schedule: ScheduleMetadataSchema
-});
-var TriggerMetadataSchema = import_zod8.z.discriminatedUnion("type", [
-  DynamicTriggerMetadataSchema,
-  StaticTriggerMetadataSchema,
-  ScheduledTriggerMetadataSchema
-]);
-
-// ../internal/src/schemas/api.ts
-var UpdateTriggerSourceBodySchema = import_zod9.z.object({
-  registeredEvents: import_zod9.z.array(import_zod9.z.string()),
-  secret: import_zod9.z.string().optional(),
-  data: SerializableJsonSchema.optional()
-});
-var HttpEventSourceSchema = UpdateTriggerSourceBodySchema.extend({
-  id: import_zod9.z.string(),
-  active: import_zod9.z.boolean(),
-  url: import_zod9.z.string().url()
-});
-var RegisterHTTPTriggerSourceBodySchema = import_zod9.z.object({
-  type: import_zod9.z.literal("HTTP"),
-  url: import_zod9.z.string().url()
-});
-var RegisterSMTPTriggerSourceBodySchema = import_zod9.z.object({
-  type: import_zod9.z.literal("SMTP")
-});
-var RegisterSQSTriggerSourceBodySchema = import_zod9.z.object({
-  type: import_zod9.z.literal("SQS")
-});
-var RegisterSourceChannelBodySchema = import_zod9.z.discriminatedUnion("type", [
-  RegisterHTTPTriggerSourceBodySchema,
-  RegisterSMTPTriggerSourceBodySchema,
-  RegisterSQSTriggerSourceBodySchema
-]);
-var REGISTER_SOURCE_EVENT = "dev.trigger.source.register";
-var RegisterTriggerSourceSchema = import_zod9.z.object({
-  key: import_zod9.z.string(),
-  params: import_zod9.z.any(),
-  active: import_zod9.z.boolean(),
-  secret: import_zod9.z.string(),
-  data: DeserializedJsonSchema.optional(),
-  channel: RegisterSourceChannelBodySchema,
-  clientId: import_zod9.z.string().optional()
-});
-var RegisterSourceEventSchema = import_zod9.z.object({
-  id: import_zod9.z.string(),
-  source: RegisterTriggerSourceSchema,
-  events: import_zod9.z.array(import_zod9.z.string()),
-  missingEvents: import_zod9.z.array(import_zod9.z.string()),
-  orphanedEvents: import_zod9.z.array(import_zod9.z.string()),
-  dynamicTriggerId: import_zod9.z.string().optional()
-});
-var TriggerSourceSchema = import_zod9.z.object({
-  id: import_zod9.z.string(),
-  key: import_zod9.z.string()
-});
-var HandleTriggerSourceSchema = import_zod9.z.object({
-  key: import_zod9.z.string(),
-  secret: import_zod9.z.string(),
-  data: import_zod9.z.any(),
-  params: import_zod9.z.any()
-});
-var HttpSourceRequestSchema = import_zod9.z.object({
-  url: import_zod9.z.string().url(),
-  method: import_zod9.z.string(),
-  headers: import_zod9.z.record(import_zod9.z.string()),
-  rawBody: import_zod9.z.instanceof(Buffer).optional().nullable()
-});
-var HttpSourceRequestHeadersSchema = import_zod9.z.object({
-  "x-ts-key": import_zod9.z.string(),
-  "x-ts-dynamic-id": import_zod9.z.string().optional(),
-  "x-ts-secret": import_zod9.z.string(),
-  "x-ts-data": import_zod9.z.string().transform((s) => JSON.parse(s)),
-  "x-ts-params": import_zod9.z.string().transform((s) => JSON.parse(s)),
-  "x-ts-http-url": import_zod9.z.string(),
-  "x-ts-http-method": import_zod9.z.string(),
-  "x-ts-http-headers": import_zod9.z.string().transform((s) => import_zod9.z.record(import_zod9.z.string()).parse(JSON.parse(s)))
-});
-var PongSuccessResponseSchema = import_zod9.z.object({
-  ok: import_zod9.z.literal(true)
-});
-var PongErrorResponseSchema = import_zod9.z.object({
-  ok: import_zod9.z.literal(false),
-  error: import_zod9.z.string()
-});
-var PongResponseSchema = import_zod9.z.discriminatedUnion("ok", [
-  PongSuccessResponseSchema,
-  PongErrorResponseSchema
-]);
-var QueueOptionsSchema = import_zod9.z.object({
-  name: import_zod9.z.string(),
-  maxConcurrent: import_zod9.z.number().optional()
-});
-var JobMetadataSchema = import_zod9.z.object({
-  id: import_zod9.z.string(),
-  name: import_zod9.z.string(),
-  version: import_zod9.z.string(),
-  event: EventSpecificationSchema,
-  trigger: TriggerMetadataSchema,
-  integrations: import_zod9.z.record(IntegrationConfigSchema),
-  internal: import_zod9.z.boolean().default(false),
-  queue: import_zod9.z.union([
-    QueueOptionsSchema,
-    import_zod9.z.string()
-  ]).optional(),
-  startPosition: import_zod9.z.enum([
-    "initial",
-    "latest"
-  ]),
-  enabled: import_zod9.z.boolean(),
-  preprocessRuns: import_zod9.z.boolean()
-});
-var SourceMetadataSchema = import_zod9.z.object({
-  channel: import_zod9.z.enum([
-    "HTTP",
-    "SQS",
-    "SMTP"
-  ]),
-  integration: IntegrationConfigSchema,
-  key: import_zod9.z.string(),
-  params: import_zod9.z.any(),
-  events: import_zod9.z.array(import_zod9.z.string())
-});
-var DynamicTriggerEndpointMetadataSchema = import_zod9.z.object({
-  id: import_zod9.z.string(),
-  jobs: import_zod9.z.array(JobMetadataSchema.pick({
-    id: true,
-    version: true
-  }))
-});
-var IndexEndpointResponseSchema = import_zod9.z.object({
-  jobs: import_zod9.z.array(JobMetadataSchema),
-  sources: import_zod9.z.array(SourceMetadataSchema),
-  dynamicTriggers: import_zod9.z.array(DynamicTriggerEndpointMetadataSchema),
-  dynamicSchedules: import_zod9.z.array(RegisterDynamicSchedulePayloadSchema)
-});
-var RawEventSchema = import_zod9.z.object({
-  name: import_zod9.z.string(),
-  payload: import_zod9.z.any(),
-  context: import_zod9.z.any().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(),
-  name: import_zod9.z.string(),
-  payload: DeserializedJsonSchema,
-  context: DeserializedJsonSchema.optional().nullable(),
-  timestamp: import_zod9.z.coerce.date(),
-  deliverAt: import_zod9.z.coerce.date().optional().nullable(),
-  deliveredAt: import_zod9.z.coerce.date().optional().nullable()
-});
-var SendEventOptionsSchema = import_zod9.z.object({
-  deliverAt: import_zod9.z.coerce.date().optional(),
-  deliverAfter: import_zod9.z.number().int().optional(),
-  accountId: import_zod9.z.string().optional()
-});
-var SendEventBodySchema = import_zod9.z.object({
-  event: RawEventSchema,
-  options: SendEventOptionsSchema.optional()
-});
-var DeliverEventResponseSchema = import_zod9.z.object({
-  deliveredAt: import_zod9.z.string().datetime()
-});
-var RuntimeEnvironmentTypeSchema = import_zod9.z.enum([
-  "PRODUCTION",
-  "STAGING",
-  "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({
-    id: import_zod9.z.string(),
-    version: import_zod9.z.string()
-  }),
-  run: import_zod9.z.object({
-    id: import_zod9.z.string(),
-    isTest: import_zod9.z.boolean(),
-    startedAt: import_zod9.z.coerce.date()
-  }),
-  environment: import_zod9.z.object({
-    id: import_zod9.z.string(),
-    slug: import_zod9.z.string(),
-    type: RuntimeEnvironmentTypeSchema
-  }),
-  organization: import_zod9.z.object({
-    id: import_zod9.z.string(),
-    title: import_zod9.z.string(),
-    slug: import_zod9.z.string()
-  }),
-  account: 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()
-});
-var RunJobErrorSchema = import_zod9.z.object({
-  status: import_zod9.z.literal("ERROR"),
-  error: ErrorWithStackSchema,
-  task: TaskSchema.optional()
-});
-var RunJobResumeWithTaskSchema = import_zod9.z.object({
-  status: import_zod9.z.literal("RESUME_WITH_TASK"),
-  task: TaskSchema
-});
-var RunJobRetryWithTaskSchema = import_zod9.z.object({
-  status: import_zod9.z.literal("RETRY_WITH_TASK"),
-  task: TaskSchema,
-  error: ErrorWithStackSchema,
-  retryAt: import_zod9.z.coerce.date()
-});
-var RunJobSuccessSchema = import_zod9.z.object({
-  status: import_zod9.z.literal("SUCCESS"),
-  output: DeserializedJsonSchema.optional()
-});
-var RunJobResponseSchema = import_zod9.z.discriminatedUnion("status", [
-  RunJobErrorSchema,
-  RunJobResumeWithTaskSchema,
-  RunJobRetryWithTaskSchema,
-  RunJobSuccessSchema
-]);
-var PreprocessRunBodySchema = import_zod9.z.object({
-  event: ApiEventLogSchema,
-  job: import_zod9.z.object({
-    id: import_zod9.z.string(),
-    version: import_zod9.z.string()
-  }),
-  run: import_zod9.z.object({
-    id: import_zod9.z.string(),
-    isTest: import_zod9.z.boolean()
-  }),
-  environment: import_zod9.z.object({
-    id: import_zod9.z.string(),
-    slug: import_zod9.z.string(),
-    type: RuntimeEnvironmentTypeSchema
-  }),
-  organization: import_zod9.z.object({
-    id: import_zod9.z.string(),
-    title: import_zod9.z.string(),
-    slug: import_zod9.z.string()
-  }),
-  account: import_zod9.z.object({
-    id: import_zod9.z.string(),
-    metadata: import_zod9.z.any()
-  }).optional()
-});
-var PreprocessRunResponseSchema = import_zod9.z.object({
-  abort: import_zod9.z.boolean(),
-  properties: import_zod9.z.array(DisplayPropertySchema).optional()
-});
-var CreateRunBodySchema = import_zod9.z.object({
-  client: import_zod9.z.string(),
-  job: JobMetadataSchema,
-  event: ApiEventLogSchema,
-  properties: import_zod9.z.array(DisplayPropertySchema).optional()
-});
-var CreateRunResponseOkSchema = import_zod9.z.object({
-  ok: import_zod9.z.literal(true),
-  data: import_zod9.z.object({
-    id: import_zod9.z.string()
-  })
-});
-var CreateRunResponseErrorSchema = import_zod9.z.object({
-  ok: import_zod9.z.literal(false),
-  error: import_zod9.z.string()
-});
-var CreateRunResponseBodySchema = import_zod9.z.discriminatedUnion("ok", [
-  CreateRunResponseOkSchema,
-  CreateRunResponseErrorSchema
-]);
-var RedactStringSchema = import_zod9.z.object({
-  __redactedString: import_zod9.z.literal(true),
-  strings: import_zod9.z.array(import_zod9.z.string()),
-  interpolations: import_zod9.z.array(import_zod9.z.string())
-});
-var LogMessageSchema = import_zod9.z.object({
-  level: import_zod9.z.enum([
-    "DEBUG",
-    "INFO",
-    "WARN",
-    "ERROR"
-  ]),
-  message: import_zod9.z.string(),
-  data: SerializableJsonSchema.optional()
-});
-var RedactSchema = import_zod9.z.object({
-  paths: import_zod9.z.array(import_zod9.z.string())
-});
-var RetryOptionsSchema = import_zod9.z.object({
-  limit: import_zod9.z.number().optional(),
-  factor: import_zod9.z.number().optional(),
-  minTimeoutInMs: import_zod9.z.number().optional(),
-  maxTimeoutInMs: import_zod9.z.number().optional(),
-  randomize: import_zod9.z.boolean().optional()
-});
-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(),
-  description: import_zod9.z.string().optional(),
-  properties: import_zod9.z.array(DisplayPropertySchema).optional(),
-  params: import_zod9.z.any(),
-  style: StyleSchema.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(),
-  parentId: import_zod9.z.string().optional()
-});
-var RunTaskBodyOutputSchema = RunTaskBodyInputSchema.extend({
-  params: DeserializedJsonSchema.optional().nullable()
-});
-var CompleteTaskBodyInputSchema = RunTaskBodyInputSchema.pick({
-  properties: true,
-  description: true,
-  params: true
-}).extend({
-  output: SerializableJsonSchema.optional().transform((v) => v ? DeserializedJsonSchema.parse(JSON.parse(JSON.stringify(v))) : {})
-});
-var FailTaskBodyInputSchema = import_zod9.z.object({
-  error: ErrorWithStackSchema
-});
-var NormalizedRequestSchema = import_zod9.z.object({
-  headers: import_zod9.z.record(import_zod9.z.string()),
-  method: import_zod9.z.string(),
-  query: import_zod9.z.record(import_zod9.z.string()),
-  url: import_zod9.z.string(),
-  body: import_zod9.z.any()
-});
-var NormalizedResponseSchema = import_zod9.z.object({
-  status: import_zod9.z.number(),
-  body: import_zod9.z.any(),
-  headers: import_zod9.z.record(import_zod9.z.string()).optional()
-});
-var HttpSourceResponseSchema = import_zod9.z.object({
-  response: NormalizedResponseSchema,
-  events: import_zod9.z.array(RawEventSchema)
-});
-var RegisterTriggerBodySchema = import_zod9.z.object({
-  rule: EventRuleSchema,
-  source: SourceMetadataSchema
-});
-var InitializeTriggerBodySchema = import_zod9.z.object({
-  id: import_zod9.z.string(),
-  params: import_zod9.z.any(),
-  accountId: import_zod9.z.string().optional(),
-  metadata: import_zod9.z.any().optional()
-});
-var RegisterCommonScheduleBodySchema = import_zod9.z.object({
-  id: import_zod9.z.string(),
-  metadata: import_zod9.z.any(),
-  accountId: import_zod9.z.string().optional()
-});
-var RegisterIntervalScheduleBodySchema = RegisterCommonScheduleBodySchema.merge(IntervalMetadataSchema);
-var InitializeCronScheduleBodySchema = RegisterCommonScheduleBodySchema.merge(CronMetadataSchema);
-var RegisterScheduleBodySchema = import_zod9.z.discriminatedUnion("type", [
-  RegisterIntervalScheduleBodySchema,
-  InitializeCronScheduleBodySchema
-]);
-var RegisterScheduleResponseBodySchema = import_zod9.z.object({
-  id: import_zod9.z.string(),
-  schedule: ScheduleMetadataSchema,
-  metadata: import_zod9.z.any(),
-  active: import_zod9.z.boolean()
-});
-var CreateExternalConnectionBodySchema = import_zod9.z.object({
-  accessToken: import_zod9.z.string(),
-  type: import_zod9.z.enum([
-    "oauth2"
-  ]),
-  scopes: import_zod9.z.array(import_zod9.z.string()).optional(),
-  metadata: import_zod9.z.any()
-});
-
-// ../internal/src/schemas/notifications.ts
-var import_zod10 = require("zod");
-var MISSING_CONNECTION_NOTIFICATION = "dev.trigger.notifications.missingConnection";
-var MISSING_CONNECTION_RESOLVED_NOTIFICATION = "dev.trigger.notifications.missingConnectionResolved";
-var CommonMissingConnectionNotificationPayloadSchema = import_zod10.z.object({
-  id: import_zod10.z.string(),
-  client: import_zod10.z.object({
-    id: import_zod10.z.string(),
-    title: import_zod10.z.string(),
-    scopes: import_zod10.z.array(import_zod10.z.string()),
-    createdAt: import_zod10.z.coerce.date(),
-    updatedAt: import_zod10.z.coerce.date()
-  }),
-  authorizationUrl: import_zod10.z.string()
-});
-var MissingDeveloperConnectionNotificationPayloadSchema = CommonMissingConnectionNotificationPayloadSchema.extend({
-  type: import_zod10.z.literal("DEVELOPER")
-});
-var MissingExternalConnectionNotificationPayloadSchema = CommonMissingConnectionNotificationPayloadSchema.extend({
-  type: import_zod10.z.literal("EXTERNAL"),
-  account: import_zod10.z.object({
-    id: import_zod10.z.string(),
-    metadata: import_zod10.z.any()
-  })
-});
-var MissingConnectionNotificationPayloadSchema = import_zod10.z.discriminatedUnion("type", [
-  MissingDeveloperConnectionNotificationPayloadSchema,
-  MissingExternalConnectionNotificationPayloadSchema
-]);
-var CommonMissingConnectionNotificationResolvedPayloadSchema = import_zod10.z.object({
-  id: import_zod10.z.string(),
-  client: import_zod10.z.object({
-    id: import_zod10.z.string(),
-    title: import_zod10.z.string(),
-    scopes: import_zod10.z.array(import_zod10.z.string()),
-    createdAt: import_zod10.z.coerce.date(),
-    updatedAt: import_zod10.z.coerce.date(),
-    integrationIdentifier: import_zod10.z.string(),
-    integrationAuthMethod: import_zod10.z.string()
-  }),
-  expiresAt: import_zod10.z.coerce.date()
-});
-var MissingDeveloperConnectionResolvedNotificationPayloadSchema = CommonMissingConnectionNotificationResolvedPayloadSchema.extend({
-  type: import_zod10.z.literal("DEVELOPER")
-});
-var MissingExternalConnectionResolvedNotificationPayloadSchema = CommonMissingConnectionNotificationResolvedPayloadSchema.extend({
-  type: import_zod10.z.literal("EXTERNAL"),
-  account: import_zod10.z.object({
-    id: import_zod10.z.string(),
-    metadata: import_zod10.z.any()
-  })
-});
-var MissingConnectionResolvedNotificationPayloadSchema = import_zod10.z.discriminatedUnion("type", [
-  MissingDeveloperConnectionResolvedNotificationPayloadSchema,
-  MissingExternalConnectionResolvedNotificationPayloadSchema
-]);
-
-// ../internal/src/schemas/fetch.ts
-var import_zod11 = require("zod");
-var FetchRetryHeadersStrategySchema = import_zod11.z.object({
-  strategy: import_zod11.z.literal("headers"),
-  limitHeader: import_zod11.z.string(),
-  remainingHeader: import_zod11.z.string(),
-  resetHeader: import_zod11.z.string()
-});
-var FetchRetryBackoffStrategySchema = RetryOptionsSchema.extend({
-  strategy: import_zod11.z.literal("backoff")
-});
-var FetchRetryStrategySchema = import_zod11.z.discriminatedUnion("strategy", [
-  FetchRetryHeadersStrategySchema,
-  FetchRetryBackoffStrategySchema
-]);
-var FetchRequestInitSchema = import_zod11.z.object({
-  method: import_zod11.z.string().optional(),
-  headers: import_zod11.z.record(import_zod11.z.union([
-    import_zod11.z.string(),
-    RedactStringSchema
-  ])).optional(),
-  body: import_zod11.z.union([
-    import_zod11.z.string(),
-    import_zod11.z.instanceof(ArrayBuffer)
-  ]).optional()
-});
-var FetchRetryOptionsSchema = import_zod11.z.record(FetchRetryStrategySchema);
-var FetchOperationSchema = import_zod11.z.object({
-  url: import_zod11.z.string(),
-  requestInit: FetchRequestInitSchema.optional(),
-  retry: import_zod11.z.record(FetchRetryStrategySchema).optional()
-});
-
-// ../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) {
-        const filterValue = filter[key];
-        if (filterValue && typeof filterValue === "object" && !Array.isArray(filterValue)) {
-          result[key] = deepMergeFilters(filterValue, otherValue);
-        } else {
-          result[key] = {
-            ...other[key]
-          };
-        }
-      } else {
-        result[key] = other[key];
-      }
-    }
-  }
-  return result;
-}
-__name(deepMergeFilters, "deepMergeFilters");
-
-// ../internal/src/retry.ts
-var DEFAULT_RETRY_OPTIONS = {
-  limit: 5,
-  factor: 1.8,
-  minTimeoutInMs: 1e3,
-  maxTimeoutInMs: 6e4,
-  randomize: true
-};
-function calculateRetryAt(retryOptions, attempts) {
-  const options = {
-    ...DEFAULT_RETRY_OPTIONS,
-    ...retryOptions
-  };
-  const retryCount = attempts + 1;
-  if (retryCount >= options.limit) {
-    return;
-  }
-  const random = options.randomize ? Math.random() + 1 : 1;
-  let timeoutInMs = Math.round(random * Math.max(options.minTimeoutInMs, 1) * Math.pow(options.factor, Math.max(attempts - 1, 0)));
-  timeoutInMs = Math.min(timeoutInMs, options.maxTimeoutInMs);
-  return new Date(Date.now() + timeoutInMs);
-}
-__name(calculateRetryAt, "calculateRetryAt");
-
-// ../internal/src/replacements.ts
-var currentDate = {
-  marker: "__CURRENT_DATE__",
-  replace({ data: { now } }) {
-    return now.toISOString();
-  }
-};
+// src/triggerClient.ts
+var import_core5 = require("@trigger.dev/core");
 
 // src/apiClient.ts
-var import_zod12 = require("zod");
+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 {
   constructor(options) {
@@ -1029,7 +162,7 @@ var ApiClient = class {
     __privateAdd(this, _logger, void 0);
     __privateSet(this, _options, options);
     __privateSet(this, _apiUrl, __privateGet(this, _options).apiUrl ?? process.env.TRIGGER_API_URL ?? "https://api.trigger.dev");
-    __privateSet(this, _logger, new Logger("trigger.dev", __privateGet(this, _options).logLevel));
+    __privateSet(this, _logger, new import_core.Logger("trigger.dev", __privateGet(this, _options).logLevel));
   }
   async registerEndpoint(options) {
     const apiKey = await __privateMethod(this, _apiKey, apiKey_fn).call(this);
@@ -1037,7 +170,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",
@@ -1062,7 +195,7 @@ var ApiClient = class {
     __privateGet(this, _logger).debug("Creating run", {
       params
     });
-    return await zodfetch(CreateRunResponseBodySchema, `${__privateGet(this, _apiUrl)}/api/v1/runs`, {
+    return await zodfetch(import_core.CreateRunResponseBodySchema, `${__privateGet(this, _apiUrl)}/api/v1/runs`, {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
@@ -1076,7 +209,7 @@ var ApiClient = class {
     __privateGet(this, _logger).debug("Running Task", {
       task
     });
-    return await zodfetch(ServerTaskSchema, `${__privateGet(this, _apiUrl)}/api/v1/runs/${runId}/tasks`, {
+    return await zodfetch(import_core.ServerTaskSchema, `${__privateGet(this, _apiUrl)}/api/v1/runs/${runId}/tasks`, {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
@@ -1091,7 +224,7 @@ var ApiClient = class {
     __privateGet(this, _logger).debug("Complete Task", {
       task
     });
-    return await zodfetch(ServerTaskSchema, `${__privateGet(this, _apiUrl)}/api/v1/runs/${runId}/tasks/${id}/complete`, {
+    return await zodfetch(import_core.ServerTaskSchema, `${__privateGet(this, _apiUrl)}/api/v1/runs/${runId}/tasks/${id}/complete`, {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
@@ -1107,7 +240,7 @@ var ApiClient = class {
       runId,
       body
     });
-    return await zodfetch(ServerTaskSchema, `${__privateGet(this, _apiUrl)}/api/v1/runs/${runId}/tasks/${id}/fail`, {
+    return await zodfetch(import_core.ServerTaskSchema, `${__privateGet(this, _apiUrl)}/api/v1/runs/${runId}/tasks/${id}/fail`, {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
@@ -1121,7 +254,7 @@ var ApiClient = class {
     __privateGet(this, _logger).debug("Sending event", {
       event
     });
-    return await zodfetch(ApiEventLogSchema, `${__privateGet(this, _apiUrl)}/api/v1/events`, {
+    return await zodfetch(import_core.ApiEventLogSchema, `${__privateGet(this, _apiUrl)}/api/v1/events`, {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
@@ -1138,7 +271,7 @@ var ApiClient = class {
     __privateGet(this, _logger).debug("activating http source", {
       source
     });
-    const response = await zodfetch(TriggerSourceSchema, `${__privateGet(this, _apiUrl)}/api/v1/${client}/sources/${key}`, {
+    const response = await zodfetch(import_core.TriggerSourceSchema, `${__privateGet(this, _apiUrl)}/api/v1/${client}/sources/${key}`, {
       method: "PUT",
       headers: {
         "Content-Type": "application/json",
@@ -1154,7 +287,7 @@ var ApiClient = class {
       id,
       payload
     });
-    const response = await zodfetch(RegisterSourceEventSchema, `${__privateGet(this, _apiUrl)}/api/v1/${client}/triggers/${id}/registrations/${key}`, {
+    const response = await zodfetch(import_core.RegisterSourceEventSchema, `${__privateGet(this, _apiUrl)}/api/v1/${client}/triggers/${id}/registrations/${key}`, {
       method: "PUT",
       headers: {
         "Content-Type": "application/json",
@@ -1170,7 +303,7 @@ var ApiClient = class {
       id,
       payload
     });
-    const response = await zodfetch(RegisterScheduleResponseBodySchema, `${__privateGet(this, _apiUrl)}/api/v1/${client}/schedules/${id}/registrations`, {
+    const response = await zodfetch(import_core.RegisterScheduleResponseBodySchema, `${__privateGet(this, _apiUrl)}/api/v1/${client}/schedules/${id}/registrations`, {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
@@ -1188,8 +321,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_zod.z.object({
+      ok: import_zod.z.boolean()
     }), `${__privateGet(this, _apiUrl)}/api/v1/${client}/schedules/${id}/registrations/${encodeURIComponent(key)}`, {
       method: "DELETE",
       headers: {
@@ -1204,7 +337,7 @@ var ApiClient = class {
     __privateGet(this, _logger).debug("getting auth", {
       id
     });
-    const response = await zodfetch(ConnectionAuthSchema, `${__privateGet(this, _apiUrl)}/api/v1/${client}/auth/${id}`, {
+    const response = await zodfetch(import_core.ConnectionAuthSchema, `${__privateGet(this, _apiUrl)}/api/v1/${client}/auth/${id}`, {
       method: "GET",
       headers: {
         Accept: "application/json",
@@ -1215,6 +348,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(import_core.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(import_core.GetRunSchema, (0, import_core.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(import_core.GetRunsSchema, (0, import_core.urlWithSearchParams)(`${__privateGet(this, _apiUrl)}/api/v1/jobs/${jobSlug}/runs`, options), {
+      method: "GET",
+      headers: {
+        Authorization: `Bearer ${apiKey}`
+      }
+    });
+  }
 };
 __name(ApiClient, "ApiClient");
 _apiUrl = new WeakMap();
@@ -1251,7 +420,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;
   }
@@ -1282,12 +451,19 @@ 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");
 
 // src/io.ts
+var import_core3 = require("@trigger.dev/core");
 var import_node_async_hooks = require("async_hooks");
 var import_node_crypto = require("crypto");
 
@@ -1306,6 +482,22 @@ 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,
+        retry: {
+          limit: 10,
+          minTimeoutInMs: 1e3,
+          maxTimeoutInMs: 3e4,
+          factor: 2,
+          randomize: true
+        },
+        ...options
+      }, async (ioTask) => {
+        return await callback(client, ioTask, io);
+      });
+    };
     if (integration.client.tasks) {
       const tasks = integration.client.tasks;
       Object.keys(tasks).forEach((taskName) => {
@@ -1337,6 +529,9 @@ function createIOWithIntegrations(io, auths, integrations) {
 }
 __name(createIOWithIntegrations, "createIOWithIntegrations");
 
+// src/retry.ts
+var import_core2 = require("@trigger.dev/core");
+
 // src/io.ts
 var _addToCachedTasks, addToCachedTasks_fn;
 var IO = class {
@@ -1345,7 +540,7 @@ var IO = class {
     this._id = options.id;
     this._apiClient = options.apiClient;
     this._triggerClient = options.client;
-    this._logger = options.logger ?? new Logger("trigger.dev", options.logLevel);
+    this._logger = options.logger ?? new import_core3.Logger("trigger.dev", options.logLevel);
     this._cachedTasks = /* @__PURE__ */ new Map();
     this._jobLogger = options.jobLogger;
     this._jobLogLevel = options.jobLogLevel;
@@ -1387,7 +582,7 @@ var IO = class {
           break;
         }
       }
-      if (Logger.satisfiesLogLevel(logLevel, this._jobLogLevel)) {
+      if (import_core3.Logger.satisfiesLogLevel(logLevel, this._jobLogLevel)) {
         await this.runTask([
           message,
           level
@@ -1484,13 +679,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"
@@ -1663,6 +859,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,
@@ -1699,26 +902,41 @@ 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 = import_core3.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);
+        const parsedError = import_core3.ErrorWithStackSchema.safeParse(error);
         if (options.retry) {
-          const retryAt = calculateRetryAt(options.retry, task.attempts - 1);
+          const retryAt = (0, import_core2.calculateRetryAt)(options.retry, task.attempts - 1);
           if (retryAt) {
             throw new RetryWithTaskError(parsedError.success ? parsedError.data : {
               message: "Unknown error"
@@ -1815,6 +1033,7 @@ var IOLogger = class {
 __name(IOLogger, "IOLogger");
 
 // src/triggers/eventTrigger.ts
+var import_core4 = require("@trigger.dev/core");
 var _options2;
 var EventTrigger = class {
   constructor(options) {
@@ -1828,7 +1047,7 @@ var EventTrigger = class {
       rule: {
         event: __privateGet(this, _options2).name ?? __privateGet(this, _options2).event.name,
         source: __privateGet(this, _options2).source ?? "trigger.dev",
-        payload: deepMergeFilters(__privateGet(this, _options2).filter ?? {}, __privateGet(this, _options2).event.filter ?? {})
+        payload: (0, import_core4.deepMergeFilters)(__privateGet(this, _options2).filter ?? {}, __privateGet(this, _options2).event.filter ?? {})
       }
     };
   }
@@ -1852,6 +1071,7 @@ function eventTrigger(options) {
       title: "Event",
       source: options.source ?? "trigger.dev",
       icon: "custom-event",
+      examples: options.examples,
       parsePayload: (rawPayload) => {
         if (options.schema) {
           return options.schema.parse(rawPayload);
@@ -1865,11 +1085,11 @@ __name(eventTrigger, "eventTrigger");
 
 // src/triggerClient.ts
 var registerSourceEvent = {
-  name: REGISTER_SOURCE_EVENT,
+  name: import_core5.REGISTER_SOURCE_EVENT,
   title: "Register Source",
   source: "internal",
   icon: "register-source",
-  parsePayload: RegisterSourceEventSchema.parse
+  parsePayload: import_core5.RegisterSourceEventSchema.parse
 };
 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 {
@@ -1891,7 +1111,7 @@ var TriggerClient = class {
     this.id = options.id;
     __privateSet(this, _options3, options);
     __privateSet(this, _client, new ApiClient(__privateGet(this, _options3)));
-    __privateSet(this, _internalLogger, new Logger("trigger.dev", __privateGet(this, _options3).verbose ? "debug" : "log"));
+    __privateSet(this, _internalLogger, new import_core5.Logger("trigger.dev", __privateGet(this, _options3).verbose ? "debug" : "log"));
   }
   async handleRequest(request) {
     __privateGet(this, _internalLogger).debug("handling request", {
@@ -1925,7 +1145,7 @@ var TriggerClient = class {
         return {
           status: 401,
           body: {
-            message: `Forbidden: client apiKey mismatch: Expected ${__privateGet(this, _options3).apiKey}, got ${apiKey}`
+            message: `Forbidden: client apiKey mismatch: Make sure you are using the correct API Key for your environment`
           }
         };
       }
@@ -1997,7 +1217,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,
@@ -2011,7 +1235,7 @@ var TriggerClient = class {
       }
       case "INITIALIZE_TRIGGER": {
         const json = await request.json();
-        const body = InitializeTriggerBodySchema.safeParse(json);
+        const body = import_core5.InitializeTriggerBodySchema.safeParse(json);
         if (!body.success) {
           return {
             status: 400,
@@ -2036,7 +1260,7 @@ var TriggerClient = class {
       }
       case "EXECUTE_JOB": {
         const json = await request.json();
-        const execution = RunJobBodySchema.safeParse(json);
+        const execution = import_core5.RunJobBodySchema.safeParse(json);
         if (!execution.success) {
           return {
             status: 400,
@@ -2062,7 +1286,7 @@ var TriggerClient = class {
       }
       case "PREPROCESS_RUN": {
         const json = await request.json();
-        const body = PreprocessRunBodySchema.safeParse(json);
+        const body = import_core5.PreprocessRunBodySchema.safeParse(json);
         if (!body.success) {
           return {
             status: 400,
@@ -2090,7 +1314,7 @@ var TriggerClient = class {
         };
       }
       case "DELIVER_HTTP_SOURCE_REQUEST": {
-        const headers = HttpSourceRequestHeadersSchema.safeParse(Object.fromEntries(request.headers.entries()));
+        const headers = import_core5.HttpSourceRequestHeadersSchema.safeParse(Object.fromEntries(request.headers.entries()));
         if (!headers.success) {
           return {
             status: 400,
@@ -2099,11 +1323,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"];
@@ -2143,7 +1375,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({
@@ -2193,12 +1425,18 @@ 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
         }
       };
     }
     registeredSource.events = Array.from(/* @__PURE__ */ new Set([
       ...registeredSource.events,
-      options.event.name
+      ...typeof options.event.name === "string" ? [
+        options.event.name
+      ] : options.event.name
     ]));
     __privateGet(this, _registeredSources)[options.key] = registeredSource;
     new Job(this, {
@@ -2259,6 +1497,15 @@ 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";
@@ -2272,6 +1519,9 @@ var TriggerClient = class {
   apiKey() {
     return __privateGet(this, _options3).apiKey ?? process.env.TRIGGER_API_KEY;
   }
+  defineJob(options) {
+    return new Job(this, options);
+  }
 };
 __name(TriggerClient, "TriggerClient");
 _options3 = new WeakMap();
@@ -2308,7 +1558,7 @@ executeJob_fn = /* @__PURE__ */ __name(async function(body1, job1) {
     client: this,
     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
+    jobLogger: __privateGet(this, _options3).ioLogLocalEnabled ? new import_core5.Logger(job1.id, job1.logLevel ?? __privateGet(this, _options3).logLevel ?? "info") : void 0
   });
   const ioWithConnections = createIOWithIntegrations(io, body1.connections, job1.options.integrations);
   try {
@@ -2332,8 +1582,14 @@ 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);
+      const errorWithStack2 = import_core5.ErrorWithStackSchema.safeParse(error.cause);
       if (errorWithStack2.success) {
         return {
           status: "ERROR",
@@ -2349,7 +1605,7 @@ executeJob_fn = /* @__PURE__ */ __name(async function(body1, job1) {
         task: error.task
       };
     }
-    const errorWithStack = ErrorWithStackSchema.safeParse(error);
+    const errorWithStack = import_core5.ErrorWithStackSchema.safeParse(error);
     if (errorWithStack.success) {
       return {
         status: "ERROR",
@@ -2479,6 +1735,10 @@ handleHttpSourceRequest_fn = /* @__PURE__ */ __name(async function(source, sourc
     }
   };
 }, "#handleHttpSourceRequest");
+function dynamicTriggerRegisterSourceJobId(id) {
+  return `register-dynamic-trigger-${id}`;
+}
+__name(dynamicTriggerRegisterSourceJobId, "dynamicTriggerRegisterSourceJobId");
 
 // src/integrations.ts
 function authenticatedTask(options) {
@@ -2487,6 +1747,7 @@ function authenticatedTask(options) {
 __name(authenticatedTask, "authenticatedTask");
 
 // src/triggers/externalSource.ts
+var import_core6 = require("@trigger.dev/core");
 var ExternalSource = class {
   constructor(channel, options) {
     this.options = options;
@@ -2502,7 +1763,7 @@ var ExternalSource = class {
     }, logger);
   }
   filter(params) {
-    return this.options.filter(params);
+    return this.options.filter?.(params) ?? {};
   }
   properties(params) {
     return this.options.properties?.(params) ?? [];
@@ -2560,7 +1821,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: (0, import_core6.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)
@@ -2594,6 +1855,7 @@ function omit(obj, key) {
 __name(omit, "omit");
 
 // src/triggers/dynamic.ts
+var import_core7 = require("@trigger.dev/core");
 var _client2, _options4;
 var DynamicTrigger = class {
   constructor(client, options) {
@@ -2617,19 +1879,20 @@ var DynamicTrigger = class {
     return __privateGet(this, _options4).event;
   }
   registeredTriggerForParams(params) {
+    const key = slugifyId(this.source.key(params));
     return {
       rule: {
         event: this.event.name,
         source: this.event.source,
-        payload: deepMergeFilters(this.source.filter(params), this.event.filter ?? {})
+        payload: (0, import_core7.deepMergeFilters)(this.source.filter(params), this.event.filter ?? {})
       },
       source: {
-        key: slugifyId(this.source.key(params)),
+        key,
         channel: this.source.channel,
         params,
-        events: [
+        events: typeof this.event.name === "string" ? [
           this.event.name
-        ],
+        ] : this.event.name,
         integration: {
           id: this.source.integration.id,
           metadata: this.source.integration.metadata,
@@ -2653,6 +1916,7 @@ _client2 = new WeakMap();
 _options4 = new WeakMap();
 
 // src/triggers/scheduled.ts
+var import_core8 = require("@trigger.dev/core");
 var import_cronstrue = __toESM(require("cronstrue"));
 var examples = [
   {
@@ -2660,8 +1924,8 @@ var examples = [
     name: "Now",
     icon: "clock",
     payload: {
-      ts: currentDate.marker,
-      lastTimestamp: currentDate.marker
+      ts: import_core8.currentDate.marker,
+      lastTimestamp: import_core8.currentDate.marker
     }
   }
 ];
@@ -2676,7 +1940,7 @@ var IntervalTrigger = class {
       source: "trigger.dev",
       icon: "schedule-interval",
       examples,
-      parsePayload: ScheduledPayloadSchema.parse,
+      parsePayload: import_core8.ScheduledPayloadSchema.parse,
       properties: [
         {
           label: "Interval",
@@ -2721,7 +1985,7 @@ var CronTrigger = class {
       source: "trigger.dev",
       icon: "schedule-cron",
       examples,
-      parsePayload: ScheduledPayloadSchema.parse,
+      parsePayload: import_core8.ScheduledPayloadSchema.parse,
       properties: [
         {
           label: "cron",
@@ -2771,7 +2035,7 @@ var DynamicSchedule = class {
       source: "trigger.dev",
       icon: "schedule-dynamic",
       examples,
-      parsePayload: ScheduledPayloadSchema.parse
+      parsePayload: import_core8.ScheduledPayloadSchema.parse
     };
   }
   async register(key, metadata) {
@@ -2796,6 +2060,7 @@ var DynamicSchedule = class {
 __name(DynamicSchedule, "DynamicSchedule");
 
 // src/triggers/notifications.ts
+var import_core9 = require("@trigger.dev/core");
 function missingConnectionNotification(integrations) {
   return new MissingConnectionNotification({
     integrations
@@ -2814,11 +2079,11 @@ var MissingConnectionNotification = class {
   }
   get event() {
     return {
-      name: MISSING_CONNECTION_NOTIFICATION,
+      name: import_core9.MISSING_CONNECTION_NOTIFICATION,
       title: "Missing Connection Notification",
       source: "trigger.dev",
       icon: "connection-alert",
-      parsePayload: MissingConnectionNotificationPayloadSchema.parse,
+      parsePayload: import_core9.MissingConnectionNotificationPayloadSchema.parse,
       properties: [
         {
           label: "Integrations",
@@ -2855,11 +2120,11 @@ var MissingConnectionResolvedNotification = class {
   }
   get event() {
     return {
-      name: MISSING_CONNECTION_RESOLVED_NOTIFICATION,
+      name: import_core9.MISSING_CONNECTION_RESOLVED_NOTIFICATION,
       title: "Missing Connection Resolved Notification",
       source: "trigger.dev",
       icon: "connection-alert",
-      parsePayload: MissingConnectionResolvedNotificationPayloadSchema.parse,
+      parsePayload: import_core9.MissingConnectionResolvedNotificationPayloadSchema.parse,
       properties: [
         {
           label: "Integrations",