@trigger.dev/sdk 0.2.15-next.0 → 0.2.16-next.0

package/dist/index.js

@@ -348,9 +348,11 @@ var ResolveRunOnceOuputSchema = import_zod8.z.object({
 });
 
 // src/events.ts
+var import_zod9 = require("zod");
 var import_slug = __toESM(require("slug"));
 var import_zod_to_json_schema = __toESM(require("zod-to-json-schema"));
 function customEvent(options) {
+  const schema = options.schema ?? import_zod9.z.any();
   return {
     metadata: {
       type: "CUSTOM_EVENT",
@@ -362,9 +364,9 @@ function customEvent(options) {
         ],
         payload: options.filter ?? {}
       },
-      schema: (0, import_zod_to_json_schema.default)(options.schema)
+      schema: (0, import_zod_to_json_schema.default)(schema)
     },
-    schema: options.schema
+    schema
   };
 }
 __name(customEvent, "customEvent");
@@ -381,6 +383,7 @@ function scheduleEvent(options) {
 }
 __name(scheduleEvent, "scheduleEvent");
 function webhookEvent(options) {
+  const schema = options.schema ?? import_zod9.z.any();
   return {
     metadata: {
       type: "WEBHOOK",
@@ -402,7 +405,7 @@ function webhookEvent(options) {
         event: options.eventName
       },
       manualRegistration: true,
-      schema: (0, import_zod_to_json_schema.default)(options.schema)
+      schema: (0, import_zod_to_json_schema.default)(schema)
     },
     schema: options.schema
   };
@@ -410,263 +413,299 @@ function webhookEvent(options) {
 __name(webhookEvent, "webhookEvent");
 
 // ../internal-bridge/src/schemas/host.ts
-var import_zod9 = require("zod");
+var import_zod10 = require("zod");
 var HostRPCSchema = {
   TRIGGER_WORKFLOW: {
-    request: import_zod9.z.object({
-      id: import_zod9.z.string(),
-      trigger: import_zod9.z.object({
+    request: import_zod10.z.object({
+      id: import_zod10.z.string(),
+      trigger: import_zod10.z.object({
         input: JsonSchema.default({}),
         context: JsonSchema.default({})
       }),
-      meta: import_zod9.z.object({
-        environment: import_zod9.z.string(),
-        workflowId: import_zod9.z.string(),
-        organizationId: import_zod9.z.string(),
-        apiKey: import_zod9.z.string(),
-        isTest: import_zod9.z.boolean().default(false),
-        appOrigin: import_zod9.z.string()
+      meta: import_zod10.z.object({
+        environment: import_zod10.z.string(),
+        workflowId: import_zod10.z.string(),
+        organizationId: import_zod10.z.string(),
+        apiKey: import_zod10.z.string(),
+        isTest: import_zod10.z.boolean().default(false),
+        appOrigin: import_zod10.z.string()
       })
     }),
-    response: import_zod9.z.boolean()
+    response: import_zod10.z.boolean()
   },
   RESOLVE_REQUEST: {
-    request: import_zod9.z.object({
-      id: import_zod9.z.string(),
-      key: import_zod9.z.string(),
+    request: import_zod10.z.object({
+      id: import_zod10.z.string(),
+      key: import_zod10.z.string(),
       output: JsonSchema.default({}),
-      meta: import_zod9.z.object({
-        environment: import_zod9.z.string(),
-        workflowId: import_zod9.z.string(),
-        organizationId: import_zod9.z.string(),
-        apiKey: import_zod9.z.string(),
-        runId: import_zod9.z.string()
+      meta: import_zod10.z.object({
+        environment: import_zod10.z.string(),
+        workflowId: import_zod10.z.string(),
+        organizationId: import_zod10.z.string(),
+        apiKey: import_zod10.z.string(),
+        runId: import_zod10.z.string()
       })
     }),
-    response: import_zod9.z.boolean()
+    response: import_zod10.z.boolean()
   },
   RESOLVE_DELAY: {
-    request: import_zod9.z.object({
-      id: import_zod9.z.string(),
-      key: import_zod9.z.string(),
-      meta: import_zod9.z.object({
-        environment: import_zod9.z.string(),
-        workflowId: import_zod9.z.string(),
-        organizationId: import_zod9.z.string(),
-        apiKey: import_zod9.z.string(),
-        runId: import_zod9.z.string()
+    request: import_zod10.z.object({
+      id: import_zod10.z.string(),
+      key: import_zod10.z.string(),
+      meta: import_zod10.z.object({
+        environment: import_zod10.z.string(),
+        workflowId: import_zod10.z.string(),
+        organizationId: import_zod10.z.string(),
+        apiKey: import_zod10.z.string(),
+        runId: import_zod10.z.string()
       })
     }),
-    response: import_zod9.z.boolean()
+    response: import_zod10.z.boolean()
   },
   REJECT_REQUEST: {
-    request: import_zod9.z.object({
-      id: import_zod9.z.string(),
-      key: import_zod9.z.string(),
+    request: import_zod10.z.object({
+      id: import_zod10.z.string(),
+      key: import_zod10.z.string(),
       error: JsonSchema.default({}),
-      meta: import_zod9.z.object({
-        environment: import_zod9.z.string(),
-        workflowId: import_zod9.z.string(),
-        organizationId: import_zod9.z.string(),
-        apiKey: import_zod9.z.string(),
-        runId: import_zod9.z.string()
+      meta: import_zod10.z.object({
+        environment: import_zod10.z.string(),
+        workflowId: import_zod10.z.string(),
+        organizationId: import_zod10.z.string(),
+        apiKey: import_zod10.z.string(),
+        runId: import_zod10.z.string()
       })
     }),
-    response: import_zod9.z.boolean()
+    response: import_zod10.z.boolean()
   },
   RESOLVE_FETCH_REQUEST: {
-    request: import_zod9.z.object({
-      id: import_zod9.z.string(),
-      key: import_zod9.z.string(),
+    request: import_zod10.z.object({
+      id: import_zod10.z.string(),
+      key: import_zod10.z.string(),
       output: FetchOutputSchema,
-      meta: import_zod9.z.object({
-        environment: import_zod9.z.string(),
-        workflowId: import_zod9.z.string(),
-        organizationId: import_zod9.z.string(),
-        apiKey: import_zod9.z.string(),
-        runId: import_zod9.z.string()
+      meta: import_zod10.z.object({
+        environment: import_zod10.z.string(),
+        workflowId: import_zod10.z.string(),
+        organizationId: import_zod10.z.string(),
+        apiKey: import_zod10.z.string(),
+        runId: import_zod10.z.string()
       })
     }),
-    response: import_zod9.z.boolean()
+    response: import_zod10.z.boolean()
   },
   REJECT_FETCH_REQUEST: {
-    request: import_zod9.z.object({
-      id: import_zod9.z.string(),
-      key: import_zod9.z.string(),
+    request: import_zod10.z.object({
+      id: import_zod10.z.string(),
+      key: import_zod10.z.string(),
       error: JsonSchema.default({}),
-      meta: import_zod9.z.object({
-        environment: import_zod9.z.string(),
-        workflowId: import_zod9.z.string(),
-        organizationId: import_zod9.z.string(),
-        apiKey: import_zod9.z.string(),
-        runId: import_zod9.z.string()
+      meta: import_zod10.z.object({
+        environment: import_zod10.z.string(),
+        workflowId: import_zod10.z.string(),
+        organizationId: import_zod10.z.string(),
+        apiKey: import_zod10.z.string(),
+        runId: import_zod10.z.string()
       })
     }),
-    response: import_zod9.z.boolean()
+    response: import_zod10.z.boolean()
   },
   RESOLVE_RUN_ONCE: {
-    request: import_zod9.z.object({
-      id: import_zod9.z.string(),
-      key: import_zod9.z.string(),
+    request: import_zod10.z.object({
+      id: import_zod10.z.string(),
+      key: import_zod10.z.string(),
       output: ResolveRunOnceOuputSchema,
-      meta: import_zod9.z.object({
-        environment: import_zod9.z.string(),
-        workflowId: import_zod9.z.string(),
-        organizationId: import_zod9.z.string(),
-        apiKey: import_zod9.z.string(),
-        runId: import_zod9.z.string()
+      meta: import_zod10.z.object({
+        environment: import_zod10.z.string(),
+        workflowId: import_zod10.z.string(),
+        organizationId: import_zod10.z.string(),
+        apiKey: import_zod10.z.string(),
+        runId: import_zod10.z.string()
       })
     }),
-    response: import_zod9.z.boolean()
+    response: import_zod10.z.boolean()
   }
 };
 
 // ../internal-bridge/src/schemas/server.ts
-var import_zod10 = require("zod");
+var import_zod11 = require("zod");
 var ServerRPCSchema = {
   INITIALIZE_DELAY: {
-    request: import_zod10.z.object({
-      runId: import_zod10.z.string(),
-      key: import_zod10.z.string(),
+    request: import_zod11.z.object({
+      runId: import_zod11.z.string(),
+      key: import_zod11.z.string(),
       wait: WaitSchema,
-      timestamp: import_zod10.z.string()
+      timestamp: import_zod11.z.string()
     }),
-    response: import_zod10.z.boolean()
+    response: import_zod11.z.boolean()
   },
   SEND_REQUEST: {
-    request: import_zod10.z.object({
-      runId: import_zod10.z.string(),
-      key: import_zod10.z.string(),
-      request: import_zod10.z.object({
-        service: import_zod10.z.string(),
-        endpoint: import_zod10.z.string(),
-        params: import_zod10.z.any(),
-        version: import_zod10.z.string().optional()
+    request: import_zod11.z.object({
+      runId: import_zod11.z.string(),
+      key: import_zod11.z.string(),
+      request: import_zod11.z.object({
+        service: import_zod11.z.string(),
+        endpoint: import_zod11.z.string(),
+        params: import_zod11.z.any(),
+        version: import_zod11.z.string().optional()
       }),
-      timestamp: import_zod10.z.string()
+      timestamp: import_zod11.z.string()
     }),
-    response: import_zod10.z.boolean()
+    response: import_zod11.z.boolean()
   },
   SEND_FETCH: {
-    request: import_zod10.z.object({
-      runId: import_zod10.z.string(),
-      key: import_zod10.z.string(),
+    request: import_zod11.z.object({
+      runId: import_zod11.z.string(),
+      key: import_zod11.z.string(),
       fetch: FetchRequestSchema,
-      timestamp: import_zod10.z.string()
+      timestamp: import_zod11.z.string()
     }),
-    response: import_zod10.z.boolean()
+    response: import_zod11.z.boolean()
   },
   SEND_LOG: {
-    request: import_zod10.z.object({
-      runId: import_zod10.z.string(),
-      key: import_zod10.z.string(),
-      log: import_zod10.z.object({
-        message: import_zod10.z.string(),
-        level: import_zod10.z.enum([
+    request: import_zod11.z.object({
+      runId: import_zod11.z.string(),
+      key: import_zod11.z.string(),
+      log: import_zod11.z.object({
+        message: import_zod11.z.string(),
+        level: import_zod11.z.enum([
           "DEBUG",
           "INFO",
           "WARN",
           "ERROR"
         ]),
-        properties: import_zod10.z.string().optional()
+        properties: import_zod11.z.string().optional()
       }),
-      timestamp: import_zod10.z.string()
+      timestamp: import_zod11.z.string()
     }),
-    response: import_zod10.z.boolean()
+    response: import_zod11.z.boolean()
   },
   SEND_EVENT: {
-    request: import_zod10.z.object({
-      runId: import_zod10.z.string(),
-      key: import_zod10.z.string(),
+    request: import_zod11.z.object({
+      runId: import_zod11.z.string(),
+      key: import_zod11.z.string(),
       event: CustomEventSchema,
-      timestamp: import_zod10.z.string()
+      timestamp: import_zod11.z.string()
     }),
-    response: import_zod10.z.boolean()
+    response: import_zod11.z.boolean()
   },
   INITIALIZE_HOST: {
-    request: import_zod10.z.object({
-      apiKey: import_zod10.z.string(),
-      workflowId: import_zod10.z.string(),
-      workflowName: import_zod10.z.string(),
+    request: import_zod11.z.object({
+      apiKey: import_zod11.z.string(),
+      workflowId: import_zod11.z.string(),
+      workflowName: import_zod11.z.string(),
+      trigger: TriggerMetadataSchema,
+      packageVersion: import_zod11.z.string(),
+      packageName: import_zod11.z.string(),
+      triggerTTL: import_zod11.z.number().optional()
+    }),
+    response: import_zod11.z.discriminatedUnion("type", [
+      import_zod11.z.object({
+        type: import_zod11.z.literal("success")
+      }),
+      import_zod11.z.object({
+        type: import_zod11.z.literal("error"),
+        message: import_zod11.z.string()
+      })
+    ]).nullable()
+  },
+  INITIALIZE_HOST_V2: {
+    request: import_zod11.z.object({
+      apiKey: import_zod11.z.string(),
+      workflowId: import_zod11.z.string(),
+      workflowName: import_zod11.z.string(),
       trigger: TriggerMetadataSchema,
-      packageVersion: import_zod10.z.string(),
-      packageName: import_zod10.z.string(),
-      triggerTTL: import_zod10.z.number().optional()
+      packageVersion: import_zod11.z.string(),
+      packageName: import_zod11.z.string(),
+      triggerTTL: import_zod11.z.number().optional()
     }),
-    response: import_zod10.z.discriminatedUnion("type", [
-      import_zod10.z.object({
-        type: import_zod10.z.literal("success")
+    response: import_zod11.z.discriminatedUnion("type", [
+      import_zod11.z.object({
+        type: import_zod11.z.literal("success"),
+        data: import_zod11.z.object({
+          workflow: import_zod11.z.object({
+            id: import_zod11.z.string(),
+            slug: import_zod11.z.string()
+          }),
+          environment: import_zod11.z.object({
+            id: import_zod11.z.string(),
+            slug: import_zod11.z.string()
+          }),
+          organization: import_zod11.z.object({
+            id: import_zod11.z.string(),
+            slug: import_zod11.z.string()
+          }),
+          isNew: import_zod11.z.boolean(),
+          url: import_zod11.z.string()
+        })
       }),
-      import_zod10.z.object({
-        type: import_zod10.z.literal("error"),
-        message: import_zod10.z.string()
+      import_zod11.z.object({
+        type: import_zod11.z.literal("error"),
+        message: import_zod11.z.string()
       })
     ]).nullable()
   },
   START_WORKFLOW_RUN: {
-    request: import_zod10.z.object({
-      runId: import_zod10.z.string(),
-      timestamp: import_zod10.z.string()
+    request: import_zod11.z.object({
+      runId: import_zod11.z.string(),
+      timestamp: import_zod11.z.string()
     }),
-    response: import_zod10.z.boolean()
+    response: import_zod11.z.boolean()
   },
   COMPLETE_WORKFLOW_RUN: {
-    request: import_zod10.z.object({
-      runId: import_zod10.z.string(),
-      output: import_zod10.z.string().optional(),
-      timestamp: import_zod10.z.string()
+    request: import_zod11.z.object({
+      runId: import_zod11.z.string(),
+      output: import_zod11.z.string().optional(),
+      timestamp: import_zod11.z.string()
     }),
-    response: import_zod10.z.boolean()
+    response: import_zod11.z.boolean()
   },
   SEND_WORKFLOW_ERROR: {
-    request: import_zod10.z.object({
-      runId: import_zod10.z.string(),
-      error: import_zod10.z.object({
-        name: import_zod10.z.string(),
-        message: import_zod10.z.string(),
-        stackTrace: import_zod10.z.string().optional()
+    request: import_zod11.z.object({
+      runId: import_zod11.z.string(),
+      error: import_zod11.z.object({
+        name: import_zod11.z.string(),
+        message: import_zod11.z.string(),
+        stackTrace: import_zod11.z.string().optional()
       }),
-      timestamp: import_zod10.z.string()
+      timestamp: import_zod11.z.string()
     }),
-    response: import_zod10.z.boolean()
+    response: import_zod11.z.boolean()
   },
   INITIALIZE_RUN_ONCE: {
-    request: import_zod10.z.object({
-      runId: import_zod10.z.string(),
-      key: import_zod10.z.string(),
-      timestamp: import_zod10.z.string(),
+    request: import_zod11.z.object({
+      runId: import_zod11.z.string(),
+      key: import_zod11.z.string(),
+      timestamp: import_zod11.z.string(),
       runOnce: InitializeRunOnceSchema
     }),
-    response: import_zod10.z.boolean()
+    response: import_zod11.z.boolean()
   },
   COMPLETE_RUN_ONCE: {
-    request: import_zod10.z.object({
-      runId: import_zod10.z.string(),
-      key: import_zod10.z.string(),
-      timestamp: import_zod10.z.string(),
+    request: import_zod11.z.object({
+      runId: import_zod11.z.string(),
+      key: import_zod11.z.string(),
+      timestamp: import_zod11.z.string(),
       runOnce: CompleteRunOnceSchema
     }),
-    response: import_zod10.z.boolean()
+    response: import_zod11.z.boolean()
   }
 };
 
 // ../internal-bridge/src/schemas/common.ts
-var import_zod11 = require("zod");
-var MESSAGE_META = import_zod11.z.object({
-  data: import_zod11.z.any(),
-  id: import_zod11.z.string(),
-  type: import_zod11.z.union([
-    import_zod11.z.literal("ACK"),
-    import_zod11.z.literal("MESSAGE")
+var import_zod12 = require("zod");
+var MESSAGE_META = import_zod12.z.object({
+  data: import_zod12.z.any(),
+  id: import_zod12.z.string(),
+  type: import_zod12.z.union([
+    import_zod12.z.literal("ACK"),
+    import_zod12.z.literal("MESSAGE")
   ])
 });
-var TriggerEnvironmentSchema = import_zod11.z.enum([
+var TriggerEnvironmentSchema = import_zod12.z.enum([
   "live",
   "development"
 ]);
 
 // ../internal-bridge/src/zodRPC.ts
-var import_zod12 = require("zod");
+var import_zod13 = require("zod");
 var import_node_crypto = require("crypto");
 
 // ../internal-bridge/src/logger.ts
@@ -704,6 +743,11 @@ var Logger = class {
       ...__privateMethod(this, _formatTags, formatTags_fn).call(this)
     ]);
   }
+  logClean(...args) {
+    if (__privateGet(this, _level) < 1)
+      return;
+    console.log(`${__privateMethod(this, _formatName, formatName_fn).call(this)} `, ...args);
+  }
   error(...args) {
     if (__privateGet(this, _level) < 2)
       return;
@@ -767,11 +811,11 @@ function formattedDateTime() {
 __name(formattedDateTime, "formattedDateTime");
 
 // ../internal-bridge/src/zodRPC.ts
-var RPCMessageSchema = import_zod12.z.object({
-  id: import_zod12.z.string(),
-  methodName: import_zod12.z.string(),
-  data: import_zod12.z.any(),
-  kind: import_zod12.z.enum([
+var RPCMessageSchema = import_zod13.z.object({
+  id: import_zod13.z.string(),
+  methodName: import_zod13.z.string(),
+  data: import_zod13.z.any(),
+  kind: import_zod13.z.enum([
     "CALL",
     "RESPONSE"
   ])
@@ -851,7 +895,7 @@ onCall_fn = /* @__PURE__ */ __name(async function(message) {
   try {
     await __privateMethod(this, _handleCall, handleCall_fn).call(this, message);
   } catch (callError) {
-    if (callError instanceof import_zod12.ZodError) {
+    if (callError instanceof import_zod13.ZodError) {
       __privateGet(this, _logger).error(`[ZodRPC] Received invalid call:
 ${JSON.stringify(message)}: `, callError.errors);
     } else {
@@ -865,7 +909,7 @@ onResponse_fn = /* @__PURE__ */ __name(async function(message1) {
   try {
     await __privateMethod(this, _handleResponse, handleResponse_fn).call(this, message1);
   } catch (callError) {
-    if (callError instanceof import_zod12.ZodError) {
+    if (callError instanceof import_zod13.ZodError) {
       __privateGet(this, _logger).error(`[ZodRPC] Received invalid response
 
 ${JSON.stringify(message1)}: `, callError.flatten());
@@ -941,11 +985,11 @@ __name(packageResponse, "packageResponse");
 // src/client.ts
 var import_uuid2 = require("uuid");
 var import_ws = require("ws");
-var import_zod13 = require("zod");
+var import_zod14 = require("zod");
 
 // package.json
 var name = "@trigger.dev/sdk";
-var version = "0.2.15-next.0";
+var version = "0.2.16-next.0";
 
 // src/connection.ts
 var import_uuid = require("uuid");
@@ -1198,12 +1242,13 @@ __name(ContextLogger, "ContextLogger");
 
 // src/client.ts
 var import_zod_error = require("zod-error");
+var import_terminal_link = __toESM(require("terminal-link"));
 var zodErrorMessageOptions = {
   delimiter: {
     error: " \u{1F525} "
   }
 };
-var _trigger, _options, _connection2, _serverRPC, _apiKey, _endpoint, _isConnected, _retryIntervalMs, _logger3, _closedByUser, _responseCompleteCallbacks, _waitForCallbacks, _fetchCallbacks, _runOnceCallbacks, _initializeConnection, initializeConnection_fn, _initializeRPC, initializeRPC_fn, _initializeHost, initializeHost_fn, _send, send_fn;
+var _trigger, _options, _connection2, _serverRPC, _apiKey, _endpoint, _isConnected, _retryIntervalMs, _logger3, _closedByUser, _registerResponse, _responseCompleteCallbacks, _waitForCallbacks, _fetchCallbacks, _runOnceCallbacks, _initializeConnection, initializeConnection_fn, _initializeRPC, initializeRPC_fn, _initializeHost, initializeHost_fn, _send, send_fn;
 var TriggerClient = class {
   constructor(trigger, options) {
     __privateAdd(this, _initializeConnection);
@@ -1220,6 +1265,7 @@ var TriggerClient = class {
     __privateAdd(this, _retryIntervalMs, 3e3);
     __privateAdd(this, _logger3, void 0);
     __privateAdd(this, _closedByUser, false);
+    __privateAdd(this, _registerResponse, void 0);
     __privateAdd(this, _responseCompleteCallbacks, /* @__PURE__ */ new Map());
     __privateAdd(this, _waitForCallbacks, /* @__PURE__ */ new Map());
     __privateAdd(this, _fetchCallbacks, /* @__PURE__ */ new Map());
@@ -1242,7 +1288,15 @@ var TriggerClient = class {
       await __privateMethod(this, _initializeConnection, initializeConnection_fn).call(this, instanceId);
       __privateMethod(this, _initializeRPC, initializeRPC_fn).call(this);
       await __privateMethod(this, _initializeHost, initializeHost_fn).call(this);
-      __privateGet(this, _logger3).log(`\u2728 Connected and listening for events`);
+      if (__privateGet(this, _registerResponse)?.isNew) {
+        __privateGet(this, _logger3).logClean(`\u{1F389} Successfully registered "${__privateGet(this, _trigger).name}" to trigger.dev \u{1F449} ${(0, import_terminal_link.default)("View on dashboard", __privateGet(this, _registerResponse).url, {
+          fallback: (text, url) => `${text}: (${url})`
+        })}. Listening for events...`);
+      } else {
+        __privateGet(this, _logger3).log(`\u2728 Connected and listening for events \u{1F449} ${(0, import_terminal_link.default)("View on dashboard", __privateGet(this, _registerResponse).url, {
+          fallback: (text, url) => `${text}: (${url})`
+        })}`);
+      }
     } catch (error) {
       __privateGet(this, _logger3).log(`\u{1F6A9} Could not connect to trigger.dev`);
       this.close();
@@ -1268,6 +1322,7 @@ _isConnected = new WeakMap();
 _retryIntervalMs = new WeakMap();
 _logger3 = new WeakMap();
 _closedByUser = new WeakMap();
+_registerResponse = new WeakMap();
 _responseCompleteCallbacks = new WeakMap();
 _waitForCallbacks = new WeakMap();
 _fetchCallbacks = new WeakMap();
@@ -1434,7 +1489,7 @@ initializeRPC_fn = /* @__PURE__ */ __name(async function() {
             status: response.status,
             ok: response.ok,
             headers: response.headers,
-            body: response.body ? (options.responseSchema ?? import_zod13.z.any()).parse(response.body) : void 0
+            body: response.body ? (options.responseSchema ?? import_zod14.z.any()).parse(response.body) : void 0
           };
         }, "fetchFunction");
         const ctx = {
@@ -1602,7 +1657,9 @@ initializeRPC_fn = /* @__PURE__ */ __name(async function() {
             timestamp: String(highPrecisionTimestamp())
           }).then(() => {
             return __privateGet(this, _trigger).options.run(eventData, ctx).then((output) => {
-              __privateGet(this, _logger3).log(`Run ${data.id} complete \u{1F3C3}`);
+              __privateGet(this, _logger3).log(`Run ${data.id} complete \u{1F449} ${(0, import_terminal_link.default)("View on dashboard", `${__privateGet(this, _registerResponse).url}/runs/${data.id}`, {
+                fallback: (text, url) => `${text}: (${url})`
+              })}`);
               return serverRPC.send("COMPLETE_WORKFLOW_RUN", {
                 runId: data.id,
                 output: JSON.stringify(output),
@@ -1617,9 +1674,9 @@ initializeRPC_fn = /* @__PURE__ */ __name(async function() {
                     stackTrace: error2.stack
                   };
                 }
-                const parsedError = import_zod13.z.object({
-                  name: import_zod13.z.string(),
-                  message: import_zod13.z.string()
+                const parsedError = import_zod14.z.object({
+                  name: import_zod14.z.string(),
+                  message: import_zod14.z.string()
                 }).passthrough().safeParse(error2);
                 if (parsedError.success) {
                   return parsedError.data;
@@ -1659,7 +1716,7 @@ initializeHost_fn = /* @__PURE__ */ __name(async function() {
   if (!__privateGet(this, _serverRPC)) {
     throw new Error("Cannot initialize host without an RPC connection");
   }
-  const response = await __privateMethod(this, _send, send_fn).call(this, "INITIALIZE_HOST", {
+  const response = await __privateMethod(this, _send, send_fn).call(this, "INITIALIZE_HOST_V2", {
     apiKey: __privateGet(this, _apiKey),
     workflowId: __privateGet(this, _trigger).id,
     workflowName: __privateGet(this, _trigger).name,
@@ -1668,9 +1725,13 @@ initializeHost_fn = /* @__PURE__ */ __name(async function() {
     packageName: name,
     triggerTTL: __privateGet(this, _options).triggerTTL
   });
+  if (!response) {
+    throw new Error("Could not initialize workflow with server");
+  }
   if (response?.type === "error") {
     throw new Error(response.message);
   }
+  __privateSet(this, _registerResponse, response.data);
   __privateGet(this, _logger3).debug("Successfully initialized workflow with server");
 }, "#initializeHost");
 _send = new WeakSet();
@@ -1731,20 +1792,18 @@ _client = new WeakMap();
 
 // src/customEvents.ts
 var import_node_fetch = __toESM(require("node-fetch"));
-var import_ulid = require("ulid");
-function sendEvent(id, event) {
+function sendEvent(idOrKey, event) {
   const triggerRun = triggerRunLocalStorage.getStore();
   if (!triggerRun) {
-    return sendEventFetch(event);
+    return sendEventFetch(idOrKey, event);
   }
-  return triggerRun.sendEvent(id, event);
+  return triggerRun.sendEvent(idOrKey, event);
 }
 __name(sendEvent, "sendEvent");
-async function sendEventFetch(event) {
+async function sendEventFetch(id, event) {
   if (!process.env.TRIGGER_API_KEY) {
     throw new Error(`There was a problem sending a custom event: the TRIGGER_API_KEY environment variable is not set`);
   }
-  const id = (0, import_ulid.ulid)();
   const baseUrl = process.env.TRIGGER_API_URL || "https://app.trigger.dev";
   const url = `${baseUrl}/api/v1/events`;
   const response = await (0, import_node_fetch.default)(url, {