@trigger.dev/sdk 0.2.4 → 0.2.6

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,208 +46,203 @@ 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, {
   Trigger: () => Trigger,
   customEvent: () => customEvent,
+  fetch: () => fetch2,
   getTriggerRun: () => getTriggerRun,
   scheduleEvent: () => scheduleEvent,
+  secureString: () => secureString,
   sendEvent: () => sendEvent
 });
 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
+]);
+
+// ../common-schemas/src/fetch.ts
+var import_zod7 = require("zod");
+var SecureStringSchema = import_zod7.z.object({
+  __secureString: import_zod7.z.literal(true),
+  strings: import_zod7.z.array(import_zod7.z.string()),
+  interpolations: import_zod7.z.array(import_zod7.z.string())
+});
+var FetchRequestSchema = import_zod7.z.object({
+  url: import_zod7.z.string(),
+  headers: import_zod7.z.record(import_zod7.z.union([
+    import_zod7.z.string(),
+    SecureStringSchema
+  ])).optional(),
+  method: import_zod7.z.enum([
+    "GET",
+    "POST",
+    "PUT",
+    "DELETE",
+    "PATCH",
+    "HEAD",
+    "OPTIONS",
+    "TRACE"
+  ]),
+  body: import_zod7.z.any()
+});
+var FetchOutputSchema = import_zod7.z.object({
+  status: import_zod7.z.number(),
+  ok: import_zod7.z.boolean(),
+  headers: import_zod7.z.record(import_zod7.z.string()),
+  body: import_zod7.z.any().optional()
+});
+var FetchResponseSchema = import_zod7.z.object({
+  status: import_zod7.z.number(),
+  headers: import_zod7.z.record(import_zod7.z.string()),
+  body: import_zod7.z.any().optional()
+});
+
 // src/events.ts
-var import_common_schemas = __toESM(require_dist());
 function customEvent(options) {
   return {
     metadata: {
@@ -275,196 +267,233 @@ 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_zod8 = 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_zod8.z.object({
+      id: import_zod8.z.string(),
+      trigger: import_zod8.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_zod8.z.object({
+        environment: import_zod8.z.string(),
+        workflowId: import_zod8.z.string(),
+        organizationId: import_zod8.z.string(),
+        apiKey: import_zod8.z.string()
       })
     }),
-    response: import_zod.z.boolean()
+    response: import_zod8.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_zod8.z.object({
+      id: import_zod8.z.string(),
+      key: import_zod8.z.string(),
+      output: JsonSchema.default({}),
+      meta: import_zod8.z.object({
+        environment: import_zod8.z.string(),
+        workflowId: import_zod8.z.string(),
+        organizationId: import_zod8.z.string(),
+        apiKey: import_zod8.z.string(),
+        runId: import_zod8.z.string()
       })
     }),
-    response: import_zod.z.boolean()
+    response: import_zod8.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_zod8.z.object({
+      id: import_zod8.z.string(),
+      key: import_zod8.z.string(),
+      meta: import_zod8.z.object({
+        environment: import_zod8.z.string(),
+        workflowId: import_zod8.z.string(),
+        organizationId: import_zod8.z.string(),
+        apiKey: import_zod8.z.string(),
+        runId: import_zod8.z.string()
       })
     }),
-    response: import_zod.z.boolean()
+    response: import_zod8.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_zod8.z.object({
+      id: import_zod8.z.string(),
+      key: import_zod8.z.string(),
+      error: JsonSchema.default({}),
+      meta: import_zod8.z.object({
+        environment: import_zod8.z.string(),
+        workflowId: import_zod8.z.string(),
+        organizationId: import_zod8.z.string(),
+        apiKey: import_zod8.z.string(),
+        runId: import_zod8.z.string()
       })
     }),
-    response: import_zod.z.boolean()
+    response: import_zod8.z.boolean()
+  },
+  RESOLVE_FETCH_REQUEST: {
+    request: import_zod8.z.object({
+      id: import_zod8.z.string(),
+      key: import_zod8.z.string(),
+      output: FetchOutputSchema,
+      meta: import_zod8.z.object({
+        environment: import_zod8.z.string(),
+        workflowId: import_zod8.z.string(),
+        organizationId: import_zod8.z.string(),
+        apiKey: import_zod8.z.string(),
+        runId: import_zod8.z.string()
+      })
+    }),
+    response: import_zod8.z.boolean()
+  },
+  REJECT_FETCH_REQUEST: {
+    request: import_zod8.z.object({
+      id: import_zod8.z.string(),
+      key: import_zod8.z.string(),
+      error: JsonSchema.default({}),
+      meta: import_zod8.z.object({
+        environment: import_zod8.z.string(),
+        workflowId: import_zod8.z.string(),
+        organizationId: import_zod8.z.string(),
+        apiKey: import_zod8.z.string(),
+        runId: import_zod8.z.string()
+      })
+    }),
+    response: import_zod8.z.boolean()
   }
 };
 
 // ../internal-bridge/src/schemas/server.ts
-var import_common_schemas3 = __toESM(require_dist());
-var import_zod2 = require("zod");
+var import_zod9 = 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_zod9.z.object({
+      runId: import_zod9.z.string(),
+      key: import_zod9.z.string(),
+      wait: WaitSchema,
+      timestamp: import_zod9.z.string()
     }),
-    response: import_zod2.z.boolean()
+    response: import_zod9.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_zod9.z.object({
+      runId: import_zod9.z.string(),
+      key: import_zod9.z.string(),
+      request: import_zod9.z.object({
+        service: import_zod9.z.string(),
+        endpoint: import_zod9.z.string(),
+        params: import_zod9.z.any()
       }),
-      timestamp: import_zod2.z.string()
+      timestamp: import_zod9.z.string()
+    }),
+    response: import_zod9.z.boolean()
+  },
+  SEND_FETCH: {
+    request: import_zod9.z.object({
+      runId: import_zod9.z.string(),
+      key: import_zod9.z.string(),
+      fetch: FetchRequestSchema,
+      timestamp: import_zod9.z.string()
     }),
-    response: import_zod2.z.boolean()
+    response: import_zod9.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_zod9.z.object({
+      runId: import_zod9.z.string(),
+      key: import_zod9.z.string(),
+      log: import_zod9.z.object({
+        message: import_zod9.z.string(),
+        level: import_zod9.z.enum([
           "DEBUG",
           "INFO",
           "WARN",
           "ERROR"
         ]),
-        properties: import_zod2.z.string().optional()
+        properties: import_zod9.z.string().optional()
       }),
-      timestamp: import_zod2.z.string()
+      timestamp: import_zod9.z.string()
     }),
-    response: import_zod2.z.boolean()
+    response: import_zod9.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_zod9.z.object({
+      runId: import_zod9.z.string(),
+      key: import_zod9.z.string(),
+      event: CustomEventSchema,
+      timestamp: import_zod9.z.string()
     }),
-    response: import_zod2.z.boolean()
+    response: import_zod9.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_zod9.z.object({
+      apiKey: import_zod9.z.string(),
+      workflowId: import_zod9.z.string(),
+      workflowName: import_zod9.z.string(),
+      trigger: TriggerMetadataSchema,
+      packageVersion: import_zod9.z.string(),
+      packageName: import_zod9.z.string(),
+      triggerTTL: import_zod9.z.number().optional()
     }),
-    response: import_zod2.z.discriminatedUnion("type", [
-      import_zod2.z.object({
-        type: import_zod2.z.literal("success")
+    response: import_zod9.z.discriminatedUnion("type", [
+      import_zod9.z.object({
+        type: import_zod9.z.literal("success")
       }),
-      import_zod2.z.object({
-        type: import_zod2.z.literal("error"),
-        message: import_zod2.z.string()
+      import_zod9.z.object({
+        type: import_zod9.z.literal("error"),
+        message: import_zod9.z.string()
       })
     ]).nullable()
   },
   START_WORKFLOW_RUN: {
-    request: import_zod2.z.object({
-      runId: import_zod2.z.string(),
-      timestamp: import_zod2.z.string()
+    request: import_zod9.z.object({
+      runId: import_zod9.z.string(),
+      timestamp: import_zod9.z.string()
     }),
-    response: import_zod2.z.boolean()
+    response: import_zod9.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_zod9.z.object({
+      runId: import_zod9.z.string(),
+      output: import_zod9.z.string().optional(),
+      timestamp: import_zod9.z.string()
     }),
-    response: import_zod2.z.boolean()
+    response: import_zod9.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_zod9.z.object({
+      runId: import_zod9.z.string(),
+      error: import_zod9.z.object({
+        name: import_zod9.z.string(),
+        message: import_zod9.z.string(),
+        stackTrace: import_zod9.z.string().optional()
       }),
-      timestamp: import_zod2.z.string()
+      timestamp: import_zod9.z.string()
     }),
-    response: import_zod2.z.boolean()
+    response: import_zod9.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_zod10 = require("zod");
+var MESSAGE_META = import_zod10.z.object({
+  data: import_zod10.z.any(),
+  id: import_zod10.z.string(),
+  type: import_zod10.z.union([
+    import_zod10.z.literal("ACK"),
+    import_zod10.z.literal("MESSAGE")
   ])
 });
-var TriggerEnvironmentSchema = import_zod3.z.enum([
+var TriggerEnvironmentSchema = import_zod10.z.enum([
   "live",
   "development"
 ]);
 
 // ../internal-bridge/src/zodRPC.ts
-var import_zod4 = require("zod");
+var import_zod11 = require("zod");
 var import_node_crypto = require("crypto");
 
 // ../internal-bridge/src/logger.ts
@@ -528,11 +557,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_zod11.z.object({
+  id: import_zod11.z.string(),
+  methodName: import_zod11.z.string(),
+  data: import_zod11.z.any(),
+  kind: import_zod11.z.enum([
     "CALL",
     "RESPONSE"
   ])
@@ -608,7 +637,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_zod11.ZodError) {
       __privateGet(this, _logger).error(`[ZodRPC] Received invalid call:
 ${JSON.stringify(message)}: `, callError.errors);
     } else {
@@ -622,7 +651,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_zod11.ZodError) {
       __privateGet(this, _logger).error(`[ZodRPC] Received invalid response
 
 ${JSON.stringify(message1)}: `, callError.flatten());
@@ -698,10 +727,11 @@ __name(packageResponse, "packageResponse");
 // src/client.ts
 var import_uuid2 = require("uuid");
 var import_ws = require("ws");
+var import_zod12 = require("zod");
 
 // package.json
 var name = "@trigger.dev/sdk";
-var version = "0.2.4";
+var version = "0.2.6";
 
 // src/connection.ts
 var import_uuid = require("uuid");
@@ -953,7 +983,7 @@ var ContextLogger = class {
 __name(ContextLogger, "ContextLogger");
 
 // src/client.ts
-var _trigger, _options, _connection2, _serverRPC, _apiKey, _endpoint, _isConnected, _retryIntervalMs, _logger3, _closedByUser, _responseCompleteCallbacks, _waitForCallbacks, _initializeConnection, initializeConnection_fn, _initializeRPC, initializeRPC_fn, _initializeHost, initializeHost_fn, _send, send_fn;
+var _trigger, _options, _connection2, _serverRPC, _apiKey, _endpoint, _isConnected, _retryIntervalMs, _logger3, _closedByUser, _responseCompleteCallbacks, _waitForCallbacks, _fetchCallbacks, _initializeConnection, initializeConnection_fn, _initializeRPC, initializeRPC_fn, _initializeHost, initializeHost_fn, _send, send_fn;
 var TriggerClient = class {
   constructor(trigger, options) {
     __privateAdd(this, _initializeConnection);
@@ -972,6 +1002,7 @@ var TriggerClient = class {
     __privateAdd(this, _closedByUser, false);
     __privateAdd(this, _responseCompleteCallbacks, /* @__PURE__ */ new Map());
     __privateAdd(this, _waitForCallbacks, /* @__PURE__ */ new Map());
+    __privateAdd(this, _fetchCallbacks, /* @__PURE__ */ new Map());
     __privateSet(this, _trigger, trigger);
     __privateSet(this, _options, options);
     const apiKey = __privateGet(this, _options).apiKey ?? process.env.TRIGGER_API_KEY;
@@ -1009,6 +1040,7 @@ _logger3 = new WeakMap();
 _closedByUser = new WeakMap();
 _responseCompleteCallbacks = new WeakMap();
 _waitForCallbacks = new WeakMap();
+_fetchCallbacks = new WeakMap();
 _initializeConnection = new WeakSet();
 initializeConnection_fn = /* @__PURE__ */ __name(async function(instanceId) {
   const id = instanceId ?? (0, import_uuid2.v4)();
@@ -1100,8 +1132,56 @@ initializeRPC_fn = /* @__PURE__ */ __name(async function() {
         reject(data.error);
         return true;
       },
+      RESOLVE_FETCH_REQUEST: async (data) => {
+        __privateGet(this, _logger3).debug("Handling RESOLVE_FETCH_REQUEST", data);
+        const fetchCallbacks = __privateGet(this, _fetchCallbacks).get(messageKey(data.meta.runId, data.key));
+        if (!fetchCallbacks) {
+          __privateGet(this, _logger3).debug(`Could not find fetch callbacks for request ID ${messageKey(data.meta.runId, data.key)}. This can happen when a workflow run is resumed`);
+          return true;
+        }
+        const { resolve } = fetchCallbacks;
+        resolve(data.output);
+        return true;
+      },
+      REJECT_FETCH_REQUEST: async (data) => {
+        __privateGet(this, _logger3).debug("Handling REJECT_FETCH_REQUEST", data);
+        const fetchCallbacks = __privateGet(this, _fetchCallbacks).get(messageKey(data.meta.runId, data.key));
+        if (!fetchCallbacks) {
+          __privateGet(this, _logger3).debug(`Could not find fetch callbacks for request ID ${messageKey(data.meta.runId, data.key)}. This can happen when a workflow run is resumed`);
+          return true;
+        }
+        const { reject } = fetchCallbacks;
+        reject(data.error);
+        return true;
+      },
       TRIGGER_WORKFLOW: async (data) => {
         __privateGet(this, _logger3).debug("Handling TRIGGER_WORKFLOW", data);
+        const fetchFunction = /* @__PURE__ */ __name(async (key, url, options) => {
+          const result = new Promise((resolve, reject) => {
+            __privateGet(this, _fetchCallbacks).set(messageKey(data.id, key), {
+              resolve,
+              reject
+            });
+          });
+          await serverRPC.send("SEND_FETCH", {
+            runId: data.id,
+            key,
+            fetch: {
+              url: url.toString(),
+              method: options.method ?? "GET",
+              headers: options.headers,
+              body: options.body
+            },
+            timestamp: String(highPrecisionTimestamp())
+          });
+          const response = await result;
+          return {
+            status: response.status,
+            ok: response.ok,
+            headers: response.headers,
+            body: response.body ? (options.responseSchema ?? import_zod12.z.any()).parse(response.body) : void 0
+          };
+        }, "fetchFunction");
         const ctx = {
           id: data.id,
           environment: data.meta.environment,
@@ -1167,7 +1247,8 @@ initializeRPC_fn = /* @__PURE__ */ __name(async function() {
             });
             await result;
             return;
-          }
+          },
+          fetch: fetchFunction
         };
         const eventData = __privateGet(this, _options).on.schema.parse(data.trigger.input);
         __privateGet(this, _logger3).debug("Parsed event data", eventData);
@@ -1199,7 +1280,8 @@ initializeRPC_fn = /* @__PURE__ */ __name(async function() {
               event: JSON.parse(JSON.stringify(event)),
               timestamp: String(highPrecisionTimestamp())
             });
-          }
+          },
+          fetch: fetchFunction
         }, () => {
           __privateGet(this, _logger3).debug("Running trigger...");
           serverRPC.send("START_WORKFLOW_RUN", {
@@ -1364,17 +1446,37 @@ async function sendEventFetch(event) {
 }
 __name(sendEventFetch, "sendEventFetch");
 
+// src/fetch.ts
+function fetch2(key, url, options) {
+  const triggerRun = triggerRunLocalStorage.getStore();
+  if (!triggerRun) {
+    throw new Error("Cannot call fetch outside of a trigger run");
+  }
+  return triggerRun.fetch(key, url, options);
+}
+__name(fetch2, "fetch");
+
 // src/index.ts
 function getTriggerRun() {
   return triggerRunLocalStorage.getStore();
 }
 __name(getTriggerRun, "getTriggerRun");
+function secureString(strings, ...interpolations) {
+  return {
+    __secureString: true,
+    strings: strings.raw,
+    interpolations
+  };
+}
+__name(secureString, "secureString");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   Trigger,
   customEvent,
+  fetch,
   getTriggerRun,
   scheduleEvent,
+  secureString,
   sendEvent
 });
 //# sourceMappingURL=index.js.map