@trigger.dev/sdk 0.2.4 → 0.2.5

package/dist/index.js

@@ -6,9 +6,6 @@ var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-var __commonJS = (cb, mod) => function __require() {
-  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
-};
 var __export = (target, all) => {
   for (var name2 in all)
     __defProp(target, name2, { get: all[name2], enumerable: true });
@@ -49,195 +46,6 @@ var __privateMethod = (obj, member, method) => {
   return method;
 };
 
-// ../common-schemas/dist/index.js
-var require_dist = __commonJS({
-  "../common-schemas/dist/index.js"(exports, module2) {
-    "use strict";
-    var __defProp2 = Object.defineProperty;
-    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
-    var __getOwnPropNames2 = Object.getOwnPropertyNames;
-    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
-    var __export2 = /* @__PURE__ */ __name((target, all) => {
-      for (var name2 in all)
-        __defProp2(target, name2, {
-          get: all[name2],
-          enumerable: true
-        });
-    }, "__export");
-    var __copyProps2 = /* @__PURE__ */ __name((to, from, except, desc) => {
-      if (from && typeof from === "object" || typeof from === "function") {
-        for (let key of __getOwnPropNames2(from))
-          if (!__hasOwnProp2.call(to, key) && key !== except)
-            __defProp2(to, key, {
-              get: () => from[key],
-              enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable
-            });
-      }
-      return to;
-    }, "__copyProps");
-    var __toCommonJS2 = /* @__PURE__ */ __name((mod) => __copyProps2(__defProp2({}, "__esModule", {
-      value: true
-    }), mod), "__toCommonJS");
-    var src_exports2 = {};
-    __export2(src_exports2, {
-      CustomEventSchema: () => CustomEventSchema2,
-      CustomEventTriggerSchema: () => CustomEventTriggerSchema,
-      DelaySchema: () => DelaySchema,
-      ErrorSchema: () => ErrorSchema,
-      EventFilterSchema: () => EventFilterSchema,
-      HttpEventTriggerSchema: () => HttpEventTriggerSchema,
-      JsonSchema: () => JsonSchema2,
-      LogMessageSchema: () => LogMessageSchema,
-      ScheduleSourceCronSchema: () => ScheduleSourceCronSchema,
-      ScheduleSourceRateSchema: () => ScheduleSourceRateSchema,
-      ScheduleSourceSchema: () => ScheduleSourceSchema,
-      ScheduledEventPayloadSchema: () => ScheduledEventPayloadSchema2,
-      ScheduledEventTriggerSchema: () => ScheduledEventTriggerSchema,
-      ScheduledForSchema: () => ScheduledForSchema,
-      SerializableCustomEventSchema: () => SerializableCustomEventSchema,
-      SerializableJsonSchema: () => SerializableJsonSchema,
-      TriggerMetadataSchema: () => TriggerMetadataSchema2,
-      WaitSchema: () => WaitSchema2,
-      WebhookEventTriggerSchema: () => WebhookEventTriggerSchema
-    });
-    module2.exports = __toCommonJS2(src_exports2);
-    var import_zod5 = require("zod");
-    var LiteralSchema = import_zod5.z.union([
-      import_zod5.z.string(),
-      import_zod5.z.number(),
-      import_zod5.z.boolean(),
-      import_zod5.z.null()
-    ]);
-    var JsonSchema2 = import_zod5.z.lazy(() => import_zod5.z.union([
-      LiteralSchema,
-      import_zod5.z.array(JsonSchema2),
-      import_zod5.z.record(JsonSchema2)
-    ]));
-    var SerializableSchema = import_zod5.z.union([
-      import_zod5.z.string(),
-      import_zod5.z.number(),
-      import_zod5.z.boolean(),
-      import_zod5.z.null(),
-      import_zod5.z.date()
-    ]);
-    var SerializableJsonSchema = import_zod5.z.lazy(() => import_zod5.z.union([
-      SerializableSchema,
-      import_zod5.z.array(SerializableJsonSchema),
-      import_zod5.z.record(SerializableJsonSchema)
-    ]));
-    var import_zod22 = require("zod");
-    var ErrorSchema = import_zod22.z.object({
-      name: import_zod22.z.string(),
-      message: import_zod22.z.string(),
-      stackTrace: import_zod22.z.string().optional()
-    });
-    var import_zod32 = require("zod");
-    var LogMessageSchema = import_zod32.z.object({
-      level: import_zod32.z.enum([
-        "DEBUG",
-        "INFO",
-        "WARN",
-        "ERROR"
-      ]),
-      message: import_zod32.z.string(),
-      properties: JsonSchema2.default({})
-    });
-    var import_zod42 = require("zod");
-    var DelaySchema = import_zod42.z.object({
-      type: import_zod42.z.literal("DELAY"),
-      seconds: import_zod42.z.number().optional(),
-      minutes: import_zod42.z.number().optional(),
-      hours: import_zod42.z.number().optional(),
-      days: import_zod42.z.number().optional()
-    });
-    var ScheduledForSchema = import_zod42.z.object({
-      type: import_zod42.z.literal("SCHEDULE_FOR"),
-      scheduledFor: import_zod42.z.string().datetime()
-    });
-    var WaitSchema2 = import_zod42.z.discriminatedUnion("type", [
-      DelaySchema,
-      ScheduledForSchema
-    ]);
-    var import_zod52 = require("zod");
-    var CustomEventSchema2 = import_zod52.z.object({
-      name: import_zod52.z.string(),
-      payload: JsonSchema2,
-      context: JsonSchema2.optional(),
-      timestamp: import_zod52.z.string().datetime().optional()
-    });
-    var SerializableCustomEventSchema = import_zod52.z.object({
-      name: import_zod52.z.string(),
-      payload: SerializableJsonSchema,
-      context: SerializableJsonSchema.optional(),
-      timestamp: import_zod52.z.string().datetime().optional()
-    });
-    var EventMatcherSchema = import_zod52.z.union([
-      import_zod52.z.array(import_zod52.z.string()),
-      import_zod52.z.array(import_zod52.z.number()),
-      import_zod52.z.array(import_zod52.z.boolean())
-    ]);
-    var EventFilterSchema = import_zod52.z.lazy(() => import_zod52.z.record(import_zod52.z.union([
-      EventMatcherSchema,
-      EventFilterSchema
-    ])));
-    var ScheduledEventPayloadSchema2 = import_zod52.z.object({
-      scheduledTime: import_zod52.z.coerce.date()
-    });
-    var ScheduleSourceRateSchema = import_zod52.z.object({
-      rateOf: import_zod52.z.union([
-        import_zod52.z.object({
-          minutes: import_zod52.z.number().min(1).max(1440).int()
-        }),
-        import_zod52.z.object({
-          hours: import_zod52.z.number().min(1).max(720).int()
-        }),
-        import_zod52.z.object({
-          days: import_zod52.z.number().min(1).max(365).int()
-        })
-      ])
-    });
-    var ScheduleSourceCronSchema = import_zod52.z.object({
-      cron: import_zod52.z.string()
-    });
-    var ScheduleSourceSchema = import_zod52.z.union([
-      ScheduleSourceRateSchema,
-      ScheduleSourceCronSchema
-    ]);
-    var import_zod6 = require("zod");
-    var CustomEventTriggerSchema = import_zod6.z.object({
-      type: import_zod6.z.literal("CUSTOM_EVENT"),
-      service: import_zod6.z.literal("trigger"),
-      name: import_zod6.z.string(),
-      filter: EventFilterSchema
-    });
-    var WebhookEventTriggerSchema = import_zod6.z.object({
-      type: import_zod6.z.literal("WEBHOOK"),
-      service: import_zod6.z.string(),
-      name: import_zod6.z.string(),
-      filter: EventFilterSchema,
-      source: JsonSchema2
-    });
-    var HttpEventTriggerSchema = import_zod6.z.object({
-      type: import_zod6.z.literal("HTTP_ENDPOINT"),
-      service: import_zod6.z.literal("trigger"),
-      name: import_zod6.z.string(),
-      filter: EventFilterSchema
-    });
-    var ScheduledEventTriggerSchema = import_zod6.z.object({
-      type: import_zod6.z.literal("SCHEDULE"),
-      service: import_zod6.z.literal("scheduler"),
-      name: import_zod6.z.string(),
-      source: ScheduleSourceSchema
-    });
-    var TriggerMetadataSchema2 = import_zod6.z.discriminatedUnion("type", [
-      CustomEventTriggerSchema,
-      WebhookEventTriggerSchema,
-      HttpEventTriggerSchema,
-      ScheduledEventTriggerSchema
-    ]);
-  }
-});
-
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
@@ -249,8 +57,153 @@ __export(src_exports, {
 });
 module.exports = __toCommonJS(src_exports);
 
+// ../common-schemas/src/json.ts
+var import_zod = require("zod");
+var LiteralSchema = import_zod.z.union([
+  import_zod.z.string(),
+  import_zod.z.number(),
+  import_zod.z.boolean(),
+  import_zod.z.null()
+]);
+var JsonSchema = import_zod.z.lazy(() => import_zod.z.union([
+  LiteralSchema,
+  import_zod.z.array(JsonSchema),
+  import_zod.z.record(JsonSchema)
+]));
+var SerializableSchema = import_zod.z.union([
+  import_zod.z.string(),
+  import_zod.z.number(),
+  import_zod.z.boolean(),
+  import_zod.z.null(),
+  import_zod.z.date()
+]);
+var SerializableJsonSchema = import_zod.z.lazy(() => import_zod.z.union([
+  SerializableSchema,
+  import_zod.z.array(SerializableJsonSchema),
+  import_zod.z.record(SerializableJsonSchema)
+]));
+
+// ../common-schemas/src/error.ts
+var import_zod2 = require("zod");
+var ErrorSchema = import_zod2.z.object({
+  name: import_zod2.z.string(),
+  message: import_zod2.z.string(),
+  stackTrace: import_zod2.z.string().optional()
+});
+
+// ../common-schemas/src/logs.ts
+var import_zod3 = require("zod");
+var LogMessageSchema = import_zod3.z.object({
+  level: import_zod3.z.enum([
+    "DEBUG",
+    "INFO",
+    "WARN",
+    "ERROR"
+  ]),
+  message: import_zod3.z.string(),
+  properties: JsonSchema.default({})
+});
+
+// ../common-schemas/src/waits.ts
+var import_zod4 = require("zod");
+var DelaySchema = import_zod4.z.object({
+  type: import_zod4.z.literal("DELAY"),
+  seconds: import_zod4.z.number().optional(),
+  minutes: import_zod4.z.number().optional(),
+  hours: import_zod4.z.number().optional(),
+  days: import_zod4.z.number().optional()
+});
+var ScheduledForSchema = import_zod4.z.object({
+  type: import_zod4.z.literal("SCHEDULE_FOR"),
+  scheduledFor: import_zod4.z.string().datetime()
+});
+var WaitSchema = import_zod4.z.discriminatedUnion("type", [
+  DelaySchema,
+  ScheduledForSchema
+]);
+
+// ../common-schemas/src/events.ts
+var import_zod5 = require("zod");
+var CustomEventSchema = import_zod5.z.object({
+  name: import_zod5.z.string(),
+  payload: JsonSchema,
+  context: JsonSchema.optional(),
+  timestamp: import_zod5.z.string().datetime().optional()
+});
+var SerializableCustomEventSchema = import_zod5.z.object({
+  name: import_zod5.z.string(),
+  payload: SerializableJsonSchema,
+  context: SerializableJsonSchema.optional(),
+  timestamp: import_zod5.z.string().datetime().optional()
+});
+var EventMatcherSchema = import_zod5.z.union([
+  import_zod5.z.array(import_zod5.z.string()),
+  import_zod5.z.array(import_zod5.z.number()),
+  import_zod5.z.array(import_zod5.z.boolean())
+]);
+var EventFilterSchema = import_zod5.z.lazy(() => import_zod5.z.record(import_zod5.z.union([
+  EventMatcherSchema,
+  EventFilterSchema
+])));
+var ScheduledEventPayloadSchema = import_zod5.z.object({
+  scheduledTime: import_zod5.z.coerce.date()
+});
+var ScheduleSourceRateSchema = import_zod5.z.object({
+  rateOf: import_zod5.z.union([
+    import_zod5.z.object({
+      minutes: import_zod5.z.number().min(1).max(1440).int()
+    }),
+    import_zod5.z.object({
+      hours: import_zod5.z.number().min(1).max(720).int()
+    }),
+    import_zod5.z.object({
+      days: import_zod5.z.number().min(1).max(365).int()
+    })
+  ])
+});
+var ScheduleSourceCronSchema = import_zod5.z.object({
+  cron: import_zod5.z.string()
+});
+var ScheduleSourceSchema = import_zod5.z.union([
+  ScheduleSourceRateSchema,
+  ScheduleSourceCronSchema
+]);
+
+// ../common-schemas/src/triggers.ts
+var import_zod6 = require("zod");
+var CustomEventTriggerSchema = import_zod6.z.object({
+  type: import_zod6.z.literal("CUSTOM_EVENT"),
+  service: import_zod6.z.literal("trigger"),
+  name: import_zod6.z.string(),
+  filter: EventFilterSchema
+});
+var WebhookEventTriggerSchema = import_zod6.z.object({
+  type: import_zod6.z.literal("WEBHOOK"),
+  service: import_zod6.z.string(),
+  name: import_zod6.z.string(),
+  filter: EventFilterSchema,
+  source: JsonSchema
+});
+var HttpEventTriggerSchema = import_zod6.z.object({
+  type: import_zod6.z.literal("HTTP_ENDPOINT"),
+  service: import_zod6.z.literal("trigger"),
+  name: import_zod6.z.string(),
+  filter: EventFilterSchema
+});
+var ScheduledEventTriggerSchema = import_zod6.z.object({
+  type: import_zod6.z.literal("SCHEDULE"),
+  service: import_zod6.z.literal("scheduler"),
+  name: import_zod6.z.string(),
+  source: ScheduleSourceSchema
+});
+var TriggerMetadataSchema = import_zod6.z.discriminatedUnion("type", [
+  CustomEventTriggerSchema,
+  WebhookEventTriggerSchema,
+  HttpEventTriggerSchema,
+  ScheduledEventTriggerSchema
+]);
+
 // src/events.ts
-var import_common_schemas = __toESM(require_dist());
 function customEvent(options) {
   return {
     metadata: {
@@ -275,196 +228,194 @@ function scheduleEvent(options) {
       name: "scheduled-event",
       source: options
     },
-    schema: import_common_schemas.ScheduledEventPayloadSchema
+    schema: ScheduledEventPayloadSchema
   };
 }
 __name(scheduleEvent, "scheduleEvent");
 
 // ../internal-bridge/src/schemas/host.ts
-var import_zod = require("zod");
-var import_common_schemas2 = __toESM(require_dist());
+var import_zod7 = require("zod");
 var HostRPCSchema = {
   TRIGGER_WORKFLOW: {
-    request: import_zod.z.object({
-      id: import_zod.z.string(),
-      trigger: import_zod.z.object({
-        input: import_common_schemas2.JsonSchema.default({}),
-        context: import_common_schemas2.JsonSchema.default({})
+    request: import_zod7.z.object({
+      id: import_zod7.z.string(),
+      trigger: import_zod7.z.object({
+        input: JsonSchema.default({}),
+        context: JsonSchema.default({})
       }),
-      meta: import_zod.z.object({
-        environment: import_zod.z.string(),
-        workflowId: import_zod.z.string(),
-        organizationId: import_zod.z.string(),
-        apiKey: import_zod.z.string()
+      meta: import_zod7.z.object({
+        environment: import_zod7.z.string(),
+        workflowId: import_zod7.z.string(),
+        organizationId: import_zod7.z.string(),
+        apiKey: import_zod7.z.string()
       })
     }),
-    response: import_zod.z.boolean()
+    response: import_zod7.z.boolean()
   },
   RESOLVE_REQUEST: {
-    request: import_zod.z.object({
-      id: import_zod.z.string(),
-      key: import_zod.z.string(),
-      output: import_common_schemas2.JsonSchema.default({}),
-      meta: import_zod.z.object({
-        environment: import_zod.z.string(),
-        workflowId: import_zod.z.string(),
-        organizationId: import_zod.z.string(),
-        apiKey: import_zod.z.string(),
-        runId: import_zod.z.string()
+    request: import_zod7.z.object({
+      id: import_zod7.z.string(),
+      key: import_zod7.z.string(),
+      output: JsonSchema.default({}),
+      meta: import_zod7.z.object({
+        environment: import_zod7.z.string(),
+        workflowId: import_zod7.z.string(),
+        organizationId: import_zod7.z.string(),
+        apiKey: import_zod7.z.string(),
+        runId: import_zod7.z.string()
       })
     }),
-    response: import_zod.z.boolean()
+    response: import_zod7.z.boolean()
   },
   RESOLVE_DELAY: {
-    request: import_zod.z.object({
-      id: import_zod.z.string(),
-      key: import_zod.z.string(),
-      meta: import_zod.z.object({
-        environment: import_zod.z.string(),
-        workflowId: import_zod.z.string(),
-        organizationId: import_zod.z.string(),
-        apiKey: import_zod.z.string(),
-        runId: import_zod.z.string()
+    request: import_zod7.z.object({
+      id: import_zod7.z.string(),
+      key: import_zod7.z.string(),
+      meta: import_zod7.z.object({
+        environment: import_zod7.z.string(),
+        workflowId: import_zod7.z.string(),
+        organizationId: import_zod7.z.string(),
+        apiKey: import_zod7.z.string(),
+        runId: import_zod7.z.string()
       })
     }),
-    response: import_zod.z.boolean()
+    response: import_zod7.z.boolean()
   },
   REJECT_REQUEST: {
-    request: import_zod.z.object({
-      id: import_zod.z.string(),
-      key: import_zod.z.string(),
-      error: import_common_schemas2.JsonSchema.default({}),
-      meta: import_zod.z.object({
-        environment: import_zod.z.string(),
-        workflowId: import_zod.z.string(),
-        organizationId: import_zod.z.string(),
-        apiKey: import_zod.z.string(),
-        runId: import_zod.z.string()
+    request: import_zod7.z.object({
+      id: import_zod7.z.string(),
+      key: import_zod7.z.string(),
+      error: JsonSchema.default({}),
+      meta: import_zod7.z.object({
+        environment: import_zod7.z.string(),
+        workflowId: import_zod7.z.string(),
+        organizationId: import_zod7.z.string(),
+        apiKey: import_zod7.z.string(),
+        runId: import_zod7.z.string()
       })
     }),
-    response: import_zod.z.boolean()
+    response: import_zod7.z.boolean()
   }
 };
 
 // ../internal-bridge/src/schemas/server.ts
-var import_common_schemas3 = __toESM(require_dist());
-var import_zod2 = require("zod");
+var import_zod8 = require("zod");
 var ServerRPCSchema = {
   INITIALIZE_DELAY: {
-    request: import_zod2.z.object({
-      runId: import_zod2.z.string(),
-      key: import_zod2.z.string(),
-      wait: import_common_schemas3.WaitSchema,
-      timestamp: import_zod2.z.string()
+    request: import_zod8.z.object({
+      runId: import_zod8.z.string(),
+      key: import_zod8.z.string(),
+      wait: WaitSchema,
+      timestamp: import_zod8.z.string()
     }),
-    response: import_zod2.z.boolean()
+    response: import_zod8.z.boolean()
   },
   SEND_REQUEST: {
-    request: import_zod2.z.object({
-      runId: import_zod2.z.string(),
-      key: import_zod2.z.string(),
-      request: import_zod2.z.object({
-        service: import_zod2.z.string(),
-        endpoint: import_zod2.z.string(),
-        params: import_zod2.z.any()
+    request: import_zod8.z.object({
+      runId: import_zod8.z.string(),
+      key: import_zod8.z.string(),
+      request: import_zod8.z.object({
+        service: import_zod8.z.string(),
+        endpoint: import_zod8.z.string(),
+        params: import_zod8.z.any()
       }),
-      timestamp: import_zod2.z.string()
+      timestamp: import_zod8.z.string()
     }),
-    response: import_zod2.z.boolean()
+    response: import_zod8.z.boolean()
   },
   SEND_LOG: {
-    request: import_zod2.z.object({
-      runId: import_zod2.z.string(),
-      key: import_zod2.z.string(),
-      log: import_zod2.z.object({
-        message: import_zod2.z.string(),
-        level: import_zod2.z.enum([
+    request: import_zod8.z.object({
+      runId: import_zod8.z.string(),
+      key: import_zod8.z.string(),
+      log: import_zod8.z.object({
+        message: import_zod8.z.string(),
+        level: import_zod8.z.enum([
           "DEBUG",
           "INFO",
           "WARN",
           "ERROR"
         ]),
-        properties: import_zod2.z.string().optional()
+        properties: import_zod8.z.string().optional()
       }),
-      timestamp: import_zod2.z.string()
+      timestamp: import_zod8.z.string()
     }),
-    response: import_zod2.z.boolean()
+    response: import_zod8.z.boolean()
   },
   SEND_EVENT: {
-    request: import_zod2.z.object({
-      runId: import_zod2.z.string(),
-      key: import_zod2.z.string(),
-      event: import_common_schemas3.CustomEventSchema,
-      timestamp: import_zod2.z.string()
+    request: import_zod8.z.object({
+      runId: import_zod8.z.string(),
+      key: import_zod8.z.string(),
+      event: CustomEventSchema,
+      timestamp: import_zod8.z.string()
     }),
-    response: import_zod2.z.boolean()
+    response: import_zod8.z.boolean()
   },
   INITIALIZE_HOST: {
-    request: import_zod2.z.object({
-      apiKey: import_zod2.z.string(),
-      workflowId: import_zod2.z.string(),
-      workflowName: import_zod2.z.string(),
-      trigger: import_common_schemas3.TriggerMetadataSchema,
-      packageVersion: import_zod2.z.string(),
-      packageName: import_zod2.z.string(),
-      triggerTTL: import_zod2.z.number().optional()
+    request: import_zod8.z.object({
+      apiKey: import_zod8.z.string(),
+      workflowId: import_zod8.z.string(),
+      workflowName: import_zod8.z.string(),
+      trigger: TriggerMetadataSchema,
+      packageVersion: import_zod8.z.string(),
+      packageName: import_zod8.z.string(),
+      triggerTTL: import_zod8.z.number().optional()
     }),
-    response: import_zod2.z.discriminatedUnion("type", [
-      import_zod2.z.object({
-        type: import_zod2.z.literal("success")
+    response: import_zod8.z.discriminatedUnion("type", [
+      import_zod8.z.object({
+        type: import_zod8.z.literal("success")
       }),
-      import_zod2.z.object({
-        type: import_zod2.z.literal("error"),
-        message: import_zod2.z.string()
+      import_zod8.z.object({
+        type: import_zod8.z.literal("error"),
+        message: import_zod8.z.string()
       })
     ]).nullable()
   },
   START_WORKFLOW_RUN: {
-    request: import_zod2.z.object({
-      runId: import_zod2.z.string(),
-      timestamp: import_zod2.z.string()
+    request: import_zod8.z.object({
+      runId: import_zod8.z.string(),
+      timestamp: import_zod8.z.string()
     }),
-    response: import_zod2.z.boolean()
+    response: import_zod8.z.boolean()
   },
   COMPLETE_WORKFLOW_RUN: {
-    request: import_zod2.z.object({
-      runId: import_zod2.z.string(),
-      output: import_zod2.z.string().optional(),
-      timestamp: import_zod2.z.string()
+    request: import_zod8.z.object({
+      runId: import_zod8.z.string(),
+      output: import_zod8.z.string().optional(),
+      timestamp: import_zod8.z.string()
     }),
-    response: import_zod2.z.boolean()
+    response: import_zod8.z.boolean()
   },
   SEND_WORKFLOW_ERROR: {
-    request: import_zod2.z.object({
-      runId: import_zod2.z.string(),
-      error: import_zod2.z.object({
-        name: import_zod2.z.string(),
-        message: import_zod2.z.string(),
-        stackTrace: import_zod2.z.string().optional()
+    request: import_zod8.z.object({
+      runId: import_zod8.z.string(),
+      error: import_zod8.z.object({
+        name: import_zod8.z.string(),
+        message: import_zod8.z.string(),
+        stackTrace: import_zod8.z.string().optional()
       }),
-      timestamp: import_zod2.z.string()
+      timestamp: import_zod8.z.string()
     }),
-    response: import_zod2.z.boolean()
+    response: import_zod8.z.boolean()
   }
 };
 
 // ../internal-bridge/src/schemas/common.ts
-var import_zod3 = require("zod");
-var MESSAGE_META = import_zod3.z.object({
-  data: import_zod3.z.any(),
-  id: import_zod3.z.string(),
-  type: import_zod3.z.union([
-    import_zod3.z.literal("ACK"),
-    import_zod3.z.literal("MESSAGE")
+var import_zod9 = require("zod");
+var MESSAGE_META = import_zod9.z.object({
+  data: import_zod9.z.any(),
+  id: import_zod9.z.string(),
+  type: import_zod9.z.union([
+    import_zod9.z.literal("ACK"),
+    import_zod9.z.literal("MESSAGE")
   ])
 });
-var TriggerEnvironmentSchema = import_zod3.z.enum([
+var TriggerEnvironmentSchema = import_zod9.z.enum([
   "live",
   "development"
 ]);
 
 // ../internal-bridge/src/zodRPC.ts
-var import_zod4 = require("zod");
+var import_zod10 = require("zod");
 var import_node_crypto = require("crypto");
 
 // ../internal-bridge/src/logger.ts
@@ -528,11 +479,11 @@ function formattedDateTime() {
 __name(formattedDateTime, "formattedDateTime");
 
 // ../internal-bridge/src/zodRPC.ts
-var RPCMessageSchema = import_zod4.z.object({
-  id: import_zod4.z.string(),
-  methodName: import_zod4.z.string(),
-  data: import_zod4.z.any(),
-  kind: import_zod4.z.enum([
+var RPCMessageSchema = import_zod10.z.object({
+  id: import_zod10.z.string(),
+  methodName: import_zod10.z.string(),
+  data: import_zod10.z.any(),
+  kind: import_zod10.z.enum([
     "CALL",
     "RESPONSE"
   ])
@@ -608,7 +559,7 @@ onCall_fn = /* @__PURE__ */ __name(async function(message) {
   try {
     await __privateMethod(this, _handleCall, handleCall_fn).call(this, message);
   } catch (callError) {
-    if (callError instanceof import_zod4.ZodError) {
+    if (callError instanceof import_zod10.ZodError) {
       __privateGet(this, _logger).error(`[ZodRPC] Received invalid call:
 ${JSON.stringify(message)}: `, callError.errors);
     } else {
@@ -622,7 +573,7 @@ onResponse_fn = /* @__PURE__ */ __name(async function(message1) {
   try {
     await __privateMethod(this, _handleResponse, handleResponse_fn).call(this, message1);
   } catch (callError) {
-    if (callError instanceof import_zod4.ZodError) {
+    if (callError instanceof import_zod10.ZodError) {
       __privateGet(this, _logger).error(`[ZodRPC] Received invalid response
 
 ${JSON.stringify(message1)}: `, callError.flatten());
@@ -701,7 +652,7 @@ var import_ws = require("ws");
 
 // package.json
 var name = "@trigger.dev/sdk";
-var version = "0.2.4";
+var version = "0.2.5";
 
 // src/connection.ts
 var import_uuid = require("uuid");