@trigger.dev/sdk 0.2.11 → 0.2.12

package/dist/index.js

@@ -213,10 +213,19 @@ var ManualWebhookSourceSchema = import_zod5.z.object({
   }),
   event: import_zod5.z.string()
 });
-var SlackInteractionSourceSchema = import_zod5.z.object({
+var SlackBlockInteractionSourceSchema = import_zod5.z.object({
+  type: import_zod5.z.literal("block_action"),
   blockId: import_zod5.z.string(),
   actionIds: import_zod5.z.array(import_zod5.z.string())
 });
+var SlackViewSubmissionInteractionSourceSchema = import_zod5.z.object({
+  type: import_zod5.z.literal("view_submission"),
+  callbackIds: import_zod5.z.array(import_zod5.z.string())
+});
+var SlackInteractionSourceSchema = import_zod5.z.discriminatedUnion("type", [
+  SlackBlockInteractionSourceSchema,
+  SlackViewSubmissionInteractionSourceSchema
+]);
 
 // ../common-schemas/src/triggers.ts
 var import_zod6 = require("zod");
@@ -224,7 +233,8 @@ 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
+  filter: EventFilterSchema,
+  schema: JsonSchema.optional()
 });
 var WebhookEventTriggerSchema = import_zod6.z.object({
   type: import_zod6.z.literal("WEBHOOK"),
@@ -232,7 +242,8 @@ var WebhookEventTriggerSchema = import_zod6.z.object({
   name: import_zod6.z.string(),
   filter: EventFilterSchema,
   source: JsonSchema.optional(),
-  manualRegistration: import_zod6.z.boolean().default(false)
+  manualRegistration: import_zod6.z.boolean().default(false),
+  schema: JsonSchema.optional()
 });
 var HttpEventTriggerSchema = import_zod6.z.object({
   type: import_zod6.z.literal("HTTP_ENDPOINT"),
@@ -314,8 +325,31 @@ var FetchResponseSchema = import_zod7.z.object({
   body: import_zod7.z.any().optional()
 });
 
+// ../common-schemas/src/runOnce.ts
+var import_zod8 = require("zod");
+var InitializeRunOnceSchema = import_zod8.z.object({
+  type: import_zod8.z.enum([
+    "REMOTE",
+    "LOCAL_ONLY"
+  ])
+});
+var CompleteRunOnceSchema = import_zod8.z.object({
+  type: import_zod8.z.enum([
+    "REMOTE",
+    "LOCAL_ONLY"
+  ]),
+  idempotencyKey: import_zod8.z.string(),
+  output: import_zod8.z.string().optional()
+});
+var ResolveRunOnceOuputSchema = import_zod8.z.object({
+  idempotencyKey: import_zod8.z.string(),
+  hasRun: import_zod8.z.boolean(),
+  output: SerializableJsonSchema.optional()
+});
+
 // src/events.ts
 var import_slug = __toESM(require("slug"));
+var import_zod_to_json_schema = __toESM(require("zod-to-json-schema"));
 function customEvent(options) {
   return {
     metadata: {
@@ -327,7 +361,8 @@ function customEvent(options) {
           options.name
         ],
         payload: options.filter ?? {}
-      }
+      },
+      schema: (0, import_zod_to_json_schema.default)(options.schema)
     },
     schema: options.schema
   };
@@ -366,7 +401,8 @@ function webhookEvent(options) {
         },
         event: options.eventName
       },
-      manualRegistration: true
+      manualRegistration: true,
+      schema: (0, import_zod_to_json_schema.default)(options.schema)
     },
     schema: options.schema
   };
@@ -374,228 +410,262 @@ function webhookEvent(options) {
 __name(webhookEvent, "webhookEvent");
 
 // ../internal-bridge/src/schemas/host.ts
-var import_zod8 = require("zod");
+var import_zod9 = require("zod");
 var HostRPCSchema = {
   TRIGGER_WORKFLOW: {
-    request: import_zod8.z.object({
-      id: import_zod8.z.string(),
-      trigger: import_zod8.z.object({
+    request: import_zod9.z.object({
+      id: import_zod9.z.string(),
+      trigger: import_zod9.z.object({
         input: JsonSchema.default({}),
         context: 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(),
-        isTest: import_zod8.z.boolean().default(false)
+      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()
       })
     }),
-    response: import_zod8.z.boolean()
+    response: import_zod9.z.boolean()
   },
   RESOLVE_REQUEST: {
-    request: import_zod8.z.object({
-      id: import_zod8.z.string(),
-      key: import_zod8.z.string(),
+    request: import_zod9.z.object({
+      id: import_zod9.z.string(),
+      key: import_zod9.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()
+      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()
       })
     }),
-    response: import_zod8.z.boolean()
+    response: import_zod9.z.boolean()
   },
   RESOLVE_DELAY: {
-    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()
+    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()
       })
     }),
-    response: import_zod8.z.boolean()
+    response: import_zod9.z.boolean()
   },
   REJECT_REQUEST: {
-    request: import_zod8.z.object({
-      id: import_zod8.z.string(),
-      key: import_zod8.z.string(),
+    request: import_zod9.z.object({
+      id: import_zod9.z.string(),
+      key: import_zod9.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()
+      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()
       })
     }),
-    response: import_zod8.z.boolean()
+    response: import_zod9.z.boolean()
   },
   RESOLVE_FETCH_REQUEST: {
-    request: import_zod8.z.object({
-      id: import_zod8.z.string(),
-      key: import_zod8.z.string(),
+    request: import_zod9.z.object({
+      id: import_zod9.z.string(),
+      key: import_zod9.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()
+      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()
       })
     }),
-    response: import_zod8.z.boolean()
+    response: import_zod9.z.boolean()
   },
   REJECT_FETCH_REQUEST: {
-    request: import_zod8.z.object({
-      id: import_zod8.z.string(),
-      key: import_zod8.z.string(),
+    request: import_zod9.z.object({
+      id: import_zod9.z.string(),
+      key: import_zod9.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()
+      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()
+      })
+    }),
+    response: import_zod9.z.boolean()
+  },
+  RESOLVE_RUN_ONCE: {
+    request: import_zod9.z.object({
+      id: import_zod9.z.string(),
+      key: import_zod9.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()
       })
     }),
-    response: import_zod8.z.boolean()
+    response: import_zod9.z.boolean()
   }
 };
 
 // ../internal-bridge/src/schemas/server.ts
-var import_zod9 = require("zod");
+var import_zod10 = require("zod");
 var ServerRPCSchema = {
   INITIALIZE_DELAY: {
-    request: import_zod9.z.object({
-      runId: import_zod9.z.string(),
-      key: import_zod9.z.string(),
+    request: import_zod10.z.object({
+      runId: import_zod10.z.string(),
+      key: import_zod10.z.string(),
       wait: WaitSchema,
-      timestamp: import_zod9.z.string()
+      timestamp: import_zod10.z.string()
     }),
-    response: import_zod9.z.boolean()
+    response: import_zod10.z.boolean()
   },
   SEND_REQUEST: {
-    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()
+    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()
       }),
-      timestamp: import_zod9.z.string()
+      timestamp: import_zod10.z.string()
     }),
-    response: import_zod9.z.boolean()
+    response: import_zod10.z.boolean()
   },
   SEND_FETCH: {
-    request: import_zod9.z.object({
-      runId: import_zod9.z.string(),
-      key: import_zod9.z.string(),
+    request: import_zod10.z.object({
+      runId: import_zod10.z.string(),
+      key: import_zod10.z.string(),
       fetch: FetchRequestSchema,
-      timestamp: import_zod9.z.string()
+      timestamp: import_zod10.z.string()
     }),
-    response: import_zod9.z.boolean()
+    response: import_zod10.z.boolean()
   },
   SEND_LOG: {
-    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([
+    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([
           "DEBUG",
           "INFO",
           "WARN",
           "ERROR"
         ]),
-        properties: import_zod9.z.string().optional()
+        properties: import_zod10.z.string().optional()
       }),
-      timestamp: import_zod9.z.string()
+      timestamp: import_zod10.z.string()
     }),
-    response: import_zod9.z.boolean()
+    response: import_zod10.z.boolean()
   },
   SEND_EVENT: {
-    request: import_zod9.z.object({
-      runId: import_zod9.z.string(),
-      key: import_zod9.z.string(),
+    request: import_zod10.z.object({
+      runId: import_zod10.z.string(),
+      key: import_zod10.z.string(),
       event: CustomEventSchema,
-      timestamp: import_zod9.z.string()
+      timestamp: import_zod10.z.string()
     }),
-    response: import_zod9.z.boolean()
+    response: import_zod10.z.boolean()
   },
   INITIALIZE_HOST: {
-    request: import_zod9.z.object({
-      apiKey: import_zod9.z.string(),
-      workflowId: import_zod9.z.string(),
-      workflowName: import_zod9.z.string(),
+    request: import_zod10.z.object({
+      apiKey: import_zod10.z.string(),
+      workflowId: import_zod10.z.string(),
+      workflowName: import_zod10.z.string(),
       trigger: TriggerMetadataSchema,
-      packageVersion: import_zod9.z.string(),
-      packageName: import_zod9.z.string(),
-      triggerTTL: import_zod9.z.number().optional()
+      packageVersion: import_zod10.z.string(),
+      packageName: import_zod10.z.string(),
+      triggerTTL: import_zod10.z.number().optional()
     }),
-    response: import_zod9.z.discriminatedUnion("type", [
-      import_zod9.z.object({
-        type: import_zod9.z.literal("success")
+    response: import_zod10.z.discriminatedUnion("type", [
+      import_zod10.z.object({
+        type: import_zod10.z.literal("success")
       }),
-      import_zod9.z.object({
-        type: import_zod9.z.literal("error"),
-        message: import_zod9.z.string()
+      import_zod10.z.object({
+        type: import_zod10.z.literal("error"),
+        message: import_zod10.z.string()
       })
     ]).nullable()
   },
   START_WORKFLOW_RUN: {
-    request: import_zod9.z.object({
-      runId: import_zod9.z.string(),
-      timestamp: import_zod9.z.string()
+    request: import_zod10.z.object({
+      runId: import_zod10.z.string(),
+      timestamp: import_zod10.z.string()
     }),
-    response: import_zod9.z.boolean()
+    response: import_zod10.z.boolean()
   },
   COMPLETE_WORKFLOW_RUN: {
-    request: import_zod9.z.object({
-      runId: import_zod9.z.string(),
-      output: import_zod9.z.string().optional(),
-      timestamp: import_zod9.z.string()
+    request: import_zod10.z.object({
+      runId: import_zod10.z.string(),
+      output: import_zod10.z.string().optional(),
+      timestamp: import_zod10.z.string()
     }),
-    response: import_zod9.z.boolean()
+    response: import_zod10.z.boolean()
   },
   SEND_WORKFLOW_ERROR: {
-    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()
+    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()
       }),
-      timestamp: import_zod9.z.string()
+      timestamp: import_zod10.z.string()
     }),
-    response: import_zod9.z.boolean()
+    response: import_zod10.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(),
+      runOnce: InitializeRunOnceSchema
+    }),
+    response: import_zod10.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(),
+      runOnce: CompleteRunOnceSchema
+    }),
+    response: import_zod10.z.boolean()
   }
 };
 
 // ../internal-bridge/src/schemas/common.ts
-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 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 TriggerEnvironmentSchema = import_zod10.z.enum([
+var TriggerEnvironmentSchema = import_zod11.z.enum([
   "live",
   "development"
 ]);
 
 // ../internal-bridge/src/zodRPC.ts
-var import_zod11 = require("zod");
+var import_zod12 = require("zod");
 var import_node_crypto = require("crypto");
 
 // ../internal-bridge/src/logger.ts
@@ -659,11 +729,11 @@ function formattedDateTime() {
 __name(formattedDateTime, "formattedDateTime");
 
 // ../internal-bridge/src/zodRPC.ts
-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([
+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([
     "CALL",
     "RESPONSE"
   ])
@@ -743,7 +813,7 @@ onCall_fn = /* @__PURE__ */ __name(async function(message) {
   try {
     await __privateMethod(this, _handleCall, handleCall_fn).call(this, message);
   } catch (callError) {
-    if (callError instanceof import_zod11.ZodError) {
+    if (callError instanceof import_zod12.ZodError) {
       __privateGet(this, _logger).error(`[ZodRPC] Received invalid call:
 ${JSON.stringify(message)}: `, callError.errors);
     } else {
@@ -757,7 +827,7 @@ onResponse_fn = /* @__PURE__ */ __name(async function(message1) {
   try {
     await __privateMethod(this, _handleResponse, handleResponse_fn).call(this, message1);
   } catch (callError) {
-    if (callError instanceof import_zod11.ZodError) {
+    if (callError instanceof import_zod12.ZodError) {
       __privateGet(this, _logger).error(`[ZodRPC] Received invalid response
 
 ${JSON.stringify(message1)}: `, callError.flatten());
@@ -833,11 +903,11 @@ __name(packageResponse, "packageResponse");
 // src/client.ts
 var import_uuid2 = require("uuid");
 var import_ws = require("ws");
-var import_zod12 = require("zod");
+var import_zod13 = require("zod");
 
 // package.json
 var name = "@trigger.dev/sdk";
-var version = "0.2.11";
+var version = "0.2.12";
 
 // src/connection.ts
 var import_uuid = require("uuid");
@@ -1095,7 +1165,7 @@ var zodErrorMessageOptions = {
     error: " \u{1F525} "
   }
 };
-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 _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 TriggerClient = class {
   constructor(trigger, options) {
     __privateAdd(this, _initializeConnection);
@@ -1115,6 +1185,7 @@ var TriggerClient = class {
     __privateAdd(this, _responseCompleteCallbacks, /* @__PURE__ */ new Map());
     __privateAdd(this, _waitForCallbacks, /* @__PURE__ */ new Map());
     __privateAdd(this, _fetchCallbacks, /* @__PURE__ */ new Map());
+    __privateAdd(this, _runOnceCallbacks, /* @__PURE__ */ new Map());
     __privateSet(this, _trigger, trigger);
     __privateSet(this, _options, options);
     const apiKey = __privateGet(this, _options).apiKey ?? process.env.TRIGGER_API_KEY;
@@ -1153,6 +1224,7 @@ _closedByUser = new WeakMap();
 _responseCompleteCallbacks = new WeakMap();
 _waitForCallbacks = new WeakMap();
 _fetchCallbacks = new WeakMap();
+_runOnceCallbacks = new WeakMap();
 _initializeConnection = new WeakSet();
 initializeConnection_fn = /* @__PURE__ */ __name(async function(instanceId) {
   const id = instanceId ?? (0, import_uuid2.v4)();
@@ -1222,6 +1294,17 @@ initializeRPC_fn = /* @__PURE__ */ __name(async function() {
         resolve();
         return true;
       },
+      RESOLVE_RUN_ONCE: async (data) => {
+        __privateGet(this, _logger3).debug("Handling RESOLVE_RUN_ONCE", data);
+        const runOnceCallbacks = __privateGet(this, _runOnceCallbacks).get(messageKey(data.meta.runId, data.key));
+        if (!runOnceCallbacks) {
+          __privateGet(this, _logger3).debug(`Could not find runOnce callbacks for request ID ${messageKey(data.meta.runId, data.key)}. This can happen when a workflow run is resumed`);
+          return true;
+        }
+        const { resolve } = runOnceCallbacks;
+        resolve(data.output);
+        return true;
+      },
       RESOLVE_REQUEST: async (data) => {
         __privateGet(this, _logger3).debug("Handling RESOLVE_REQUEST", data);
         const requestCallbacks = __privateGet(this, _responseCompleteCallbacks).get(messageKey(data.meta.runId, data.key));
@@ -1304,7 +1387,7 @@ initializeRPC_fn = /* @__PURE__ */ __name(async function() {
             status: response.status,
             ok: response.ok,
             headers: response.headers,
-            body: response.body ? (options.responseSchema ?? import_zod12.z.any()).parse(response.body) : void 0
+            body: response.body ? (options.responseSchema ?? import_zod13.z.any()).parse(response.body) : void 0
           };
         }, "fetchFunction");
         const ctx = {
@@ -1374,6 +1457,56 @@ initializeRPC_fn = /* @__PURE__ */ __name(async function() {
             await result;
             return;
           },
+          runOnce: async (key, callback) => {
+            const result = new Promise((resolve, reject) => {
+              __privateGet(this, _runOnceCallbacks).set(messageKey(data.id, key), {
+                resolve,
+                reject
+              });
+            });
+            await serverRPC.send("INITIALIZE_RUN_ONCE", {
+              runId: data.id,
+              key,
+              runOnce: {
+                type: "REMOTE"
+              },
+              timestamp: String(highPrecisionTimestamp())
+            });
+            const { idempotencyKey, hasRun, output } = await result;
+            if (hasRun) {
+              return output;
+            }
+            const callbackResult = await callback(idempotencyKey);
+            await serverRPC.send("COMPLETE_RUN_ONCE", {
+              runId: data.id,
+              key,
+              runOnce: {
+                type: "REMOTE",
+                idempotencyKey,
+                output: callbackResult ? JSON.stringify(callbackResult) : void 0
+              },
+              timestamp: String(highPrecisionTimestamp())
+            });
+            return callbackResult;
+          },
+          runOnceLocalOnly: async (key, callback) => {
+            const result = new Promise((resolve, reject) => {
+              __privateGet(this, _runOnceCallbacks).set(messageKey(data.id, key), {
+                resolve,
+                reject
+              });
+            });
+            await serverRPC.send("INITIALIZE_RUN_ONCE", {
+              runId: data.id,
+              key,
+              runOnce: {
+                type: "LOCAL_ONLY"
+              },
+              timestamp: String(highPrecisionTimestamp())
+            });
+            const { idempotencyKey } = await result;
+            return callback(idempotencyKey);
+          },
           fetch: fetchFunction
         };
         const eventData = parsedEventData.data;
@@ -1407,7 +1540,10 @@ initializeRPC_fn = /* @__PURE__ */ __name(async function() {
               timestamp: String(highPrecisionTimestamp())
             });
           },
-          fetch: fetchFunction
+          fetch: fetchFunction,
+          workflowId: data.meta.workflowId,
+          appOrigin: data.meta.appOrigin,
+          id: data.id
         }, () => {
           __privateGet(this, _logger3).debug("Running trigger...");
           serverRPC.send("START_WORKFLOW_RUN", {
@@ -1430,9 +1566,9 @@ initializeRPC_fn = /* @__PURE__ */ __name(async function() {
                     stackTrace: error2.stack
                   };
                 }
-                const parsedError = import_zod12.z.object({
-                  name: import_zod12.z.string(),
-                  message: import_zod12.z.string()
+                const parsedError = import_zod13.z.object({
+                  name: import_zod13.z.string(),
+                  message: import_zod13.z.string()
                 }).passthrough().safeParse(error2);
                 if (parsedError.success) {
                   return parsedError.data;