@trigger.dev/sdk 0.2.20 → 0.2.22-next.0

package/dist/index.js

@@ -348,12 +348,28 @@ var ResolveRunOnceOuputSchema = import_zod8.z.object({
   output: SerializableJsonSchema.optional()
 });
 
-// src/events.ts
+// ../common-schemas/src/kv.ts
 var import_zod9 = require("zod");
+var KVGetSchema = import_zod9.z.object({
+  key: import_zod9.z.string(),
+  namespace: import_zod9.z.string()
+});
+var KVDeleteSchema = import_zod9.z.object({
+  key: import_zod9.z.string(),
+  namespace: import_zod9.z.string()
+});
+var KVSetSchema = import_zod9.z.object({
+  key: import_zod9.z.string(),
+  namespace: import_zod9.z.string(),
+  value: SerializableJsonSchema
+});
+
+// src/events.ts
+var import_zod10 = 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();
+  const schema = options.schema ?? import_zod10.z.any();
   return {
     metadata: {
       type: "CUSTOM_EVENT",
@@ -384,7 +400,7 @@ function scheduleEvent(options) {
 }
 __name(scheduleEvent, "scheduleEvent");
 function webhookEvent(options) {
-  const schema = options.schema ?? import_zod9.z.any();
+  const schema = options.schema ?? import_zod10.z.any();
   return {
     metadata: {
       type: "WEBHOOK",
@@ -414,301 +430,378 @@ function webhookEvent(options) {
 __name(webhookEvent, "webhookEvent");
 
 // ../internal-bridge/src/schemas/host.ts
-var import_zod10 = require("zod");
+var import_zod11 = require("zod");
 var HostRPCSchema = {
   TRIGGER_WORKFLOW: {
-    request: import_zod10.z.object({
-      id: import_zod10.z.string(),
-      trigger: import_zod10.z.object({
+    request: import_zod11.z.object({
+      id: import_zod11.z.string(),
+      trigger: import_zod11.z.object({
         input: JsonSchema.default({}),
         context: JsonSchema.default({})
       }),
-      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(),
-        attempt: import_zod10.z.number().optional()
+      meta: import_zod11.z.object({
+        environment: import_zod11.z.string(),
+        workflowId: import_zod11.z.string(),
+        organizationId: import_zod11.z.string(),
+        apiKey: import_zod11.z.string(),
+        isTest: import_zod11.z.boolean().default(false),
+        appOrigin: import_zod11.z.string(),
+        attempt: import_zod11.z.number().optional()
       })
     }),
-    response: import_zod10.z.boolean()
+    response: import_zod11.z.boolean()
   },
   RESOLVE_REQUEST: {
-    request: import_zod10.z.object({
-      id: import_zod10.z.string(),
-      key: import_zod10.z.string(),
+    request: import_zod11.z.object({
+      id: import_zod11.z.string(),
+      key: import_zod11.z.string(),
       output: JsonSchema.default({}),
-      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()
+      meta: import_zod11.z.object({
+        environment: import_zod11.z.string(),
+        workflowId: import_zod11.z.string(),
+        organizationId: import_zod11.z.string(),
+        apiKey: import_zod11.z.string(),
+        runId: import_zod11.z.string()
       })
     }),
-    response: import_zod10.z.boolean()
+    response: import_zod11.z.boolean()
   },
   RESOLVE_DELAY: {
-    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()
+    request: import_zod11.z.object({
+      id: import_zod11.z.string(),
+      key: import_zod11.z.string(),
+      meta: import_zod11.z.object({
+        environment: import_zod11.z.string(),
+        workflowId: import_zod11.z.string(),
+        organizationId: import_zod11.z.string(),
+        apiKey: import_zod11.z.string(),
+        runId: import_zod11.z.string()
       })
     }),
-    response: import_zod10.z.boolean()
+    response: import_zod11.z.boolean()
   },
   REJECT_REQUEST: {
-    request: import_zod10.z.object({
-      id: import_zod10.z.string(),
-      key: import_zod10.z.string(),
+    request: import_zod11.z.object({
+      id: import_zod11.z.string(),
+      key: import_zod11.z.string(),
       error: JsonSchema.default({}),
-      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()
+      meta: import_zod11.z.object({
+        environment: import_zod11.z.string(),
+        workflowId: import_zod11.z.string(),
+        organizationId: import_zod11.z.string(),
+        apiKey: import_zod11.z.string(),
+        runId: import_zod11.z.string()
       })
     }),
-    response: import_zod10.z.boolean()
+    response: import_zod11.z.boolean()
   },
   RESOLVE_FETCH_REQUEST: {
-    request: import_zod10.z.object({
-      id: import_zod10.z.string(),
-      key: import_zod10.z.string(),
+    request: import_zod11.z.object({
+      id: import_zod11.z.string(),
+      key: import_zod11.z.string(),
       output: FetchOutputSchema,
-      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()
+      meta: import_zod11.z.object({
+        environment: import_zod11.z.string(),
+        workflowId: import_zod11.z.string(),
+        organizationId: import_zod11.z.string(),
+        apiKey: import_zod11.z.string(),
+        runId: import_zod11.z.string()
       })
     }),
-    response: import_zod10.z.boolean()
+    response: import_zod11.z.boolean()
   },
   REJECT_FETCH_REQUEST: {
-    request: import_zod10.z.object({
-      id: import_zod10.z.string(),
-      key: import_zod10.z.string(),
+    request: import_zod11.z.object({
+      id: import_zod11.z.string(),
+      key: import_zod11.z.string(),
       error: JsonSchema.default({}),
-      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()
+      meta: import_zod11.z.object({
+        environment: import_zod11.z.string(),
+        workflowId: import_zod11.z.string(),
+        organizationId: import_zod11.z.string(),
+        apiKey: import_zod11.z.string(),
+        runId: import_zod11.z.string()
       })
     }),
-    response: import_zod10.z.boolean()
+    response: import_zod11.z.boolean()
   },
   RESOLVE_RUN_ONCE: {
-    request: import_zod10.z.object({
-      id: import_zod10.z.string(),
-      key: import_zod10.z.string(),
+    request: import_zod11.z.object({
+      id: import_zod11.z.string(),
+      key: import_zod11.z.string(),
       output: ResolveRunOnceOuputSchema,
-      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()
+      meta: import_zod11.z.object({
+        environment: import_zod11.z.string(),
+        workflowId: import_zod11.z.string(),
+        organizationId: import_zod11.z.string(),
+        apiKey: import_zod11.z.string(),
+        runId: import_zod11.z.string()
       })
     }),
-    response: import_zod10.z.boolean()
+    response: import_zod11.z.boolean()
+  },
+  RESOLVE_KV_GET: {
+    request: import_zod11.z.object({
+      key: import_zod11.z.string(),
+      output: SerializableJsonSchema,
+      meta: import_zod11.z.object({
+        environment: import_zod11.z.string(),
+        workflowId: import_zod11.z.string(),
+        organizationId: import_zod11.z.string(),
+        apiKey: import_zod11.z.string(),
+        runId: import_zod11.z.string()
+      })
+    }),
+    response: import_zod11.z.boolean()
+  },
+  RESOLVE_KV_SET: {
+    request: import_zod11.z.object({
+      key: import_zod11.z.string(),
+      meta: import_zod11.z.object({
+        environment: import_zod11.z.string(),
+        workflowId: import_zod11.z.string(),
+        organizationId: import_zod11.z.string(),
+        apiKey: import_zod11.z.string(),
+        runId: import_zod11.z.string()
+      })
+    }),
+    response: import_zod11.z.boolean()
+  },
+  RESOLVE_KV_DELETE: {
+    request: import_zod11.z.object({
+      key: import_zod11.z.string(),
+      meta: import_zod11.z.object({
+        environment: import_zod11.z.string(),
+        workflowId: import_zod11.z.string(),
+        organizationId: import_zod11.z.string(),
+        apiKey: import_zod11.z.string(),
+        runId: import_zod11.z.string()
+      })
+    }),
+    response: import_zod11.z.boolean()
   }
 };
 
 // ../internal-bridge/src/schemas/server.ts
-var import_zod11 = require("zod");
+var import_zod12 = require("zod");
 var ServerRPCSchema = {
   INITIALIZE_DELAY: {
-    request: import_zod11.z.object({
-      runId: import_zod11.z.string(),
-      key: import_zod11.z.string(),
+    request: import_zod12.z.object({
+      runId: import_zod12.z.string(),
+      key: import_zod12.z.string(),
       wait: WaitSchema,
-      timestamp: import_zod11.z.string()
+      timestamp: import_zod12.z.string()
     }),
-    response: import_zod11.z.boolean()
+    response: import_zod12.z.boolean()
   },
   SEND_REQUEST: {
-    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()
+    request: import_zod12.z.object({
+      runId: import_zod12.z.string(),
+      key: import_zod12.z.string(),
+      request: import_zod12.z.object({
+        service: import_zod12.z.string(),
+        endpoint: import_zod12.z.string(),
+        params: import_zod12.z.any(),
+        version: import_zod12.z.string().optional()
       }),
-      timestamp: import_zod11.z.string()
+      timestamp: import_zod12.z.string()
     }),
-    response: import_zod11.z.boolean()
+    response: import_zod12.z.boolean()
   },
   SEND_FETCH: {
-    request: import_zod11.z.object({
-      runId: import_zod11.z.string(),
-      key: import_zod11.z.string(),
+    request: import_zod12.z.object({
+      runId: import_zod12.z.string(),
+      key: import_zod12.z.string(),
       fetch: FetchRequestSchema,
-      timestamp: import_zod11.z.string()
+      timestamp: import_zod12.z.string()
     }),
-    response: import_zod11.z.boolean()
+    response: import_zod12.z.boolean()
   },
   SEND_LOG: {
-    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([
+    request: import_zod12.z.object({
+      runId: import_zod12.z.string(),
+      key: import_zod12.z.string(),
+      log: import_zod12.z.object({
+        message: import_zod12.z.string(),
+        level: import_zod12.z.enum([
           "DEBUG",
           "INFO",
           "WARN",
           "ERROR"
         ]),
-        properties: import_zod11.z.string().optional()
+        properties: import_zod12.z.string().optional()
       }),
-      timestamp: import_zod11.z.string()
+      timestamp: import_zod12.z.string()
     }),
-    response: import_zod11.z.boolean()
+    response: import_zod12.z.boolean()
   },
   SEND_EVENT: {
-    request: import_zod11.z.object({
-      runId: import_zod11.z.string(),
-      key: import_zod11.z.string(),
+    request: import_zod12.z.object({
+      runId: import_zod12.z.string(),
+      key: import_zod12.z.string(),
       event: CustomEventSchema,
-      timestamp: import_zod11.z.string()
+      timestamp: import_zod12.z.string()
     }),
-    response: import_zod11.z.boolean()
+    response: import_zod12.z.boolean()
   },
   INITIALIZE_HOST: {
-    request: import_zod11.z.object({
-      apiKey: import_zod11.z.string(),
-      workflowId: import_zod11.z.string(),
-      workflowName: import_zod11.z.string(),
+    request: import_zod12.z.object({
+      apiKey: import_zod12.z.string(),
+      workflowId: import_zod12.z.string(),
+      workflowName: import_zod12.z.string(),
       trigger: TriggerMetadataSchema,
-      packageVersion: import_zod11.z.string(),
-      packageName: import_zod11.z.string(),
-      triggerTTL: import_zod11.z.number().optional()
+      packageVersion: import_zod12.z.string(),
+      packageName: import_zod12.z.string(),
+      triggerTTL: import_zod12.z.number().optional()
     }),
-    response: import_zod11.z.discriminatedUnion("type", [
-      import_zod11.z.object({
-        type: import_zod11.z.literal("success")
+    response: import_zod12.z.discriminatedUnion("type", [
+      import_zod12.z.object({
+        type: import_zod12.z.literal("success")
       }),
-      import_zod11.z.object({
-        type: import_zod11.z.literal("error"),
-        message: import_zod11.z.string()
+      import_zod12.z.object({
+        type: import_zod12.z.literal("error"),
+        message: import_zod12.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(),
+    request: import_zod12.z.object({
+      apiKey: import_zod12.z.string(),
+      workflowId: import_zod12.z.string(),
+      workflowName: import_zod12.z.string(),
       trigger: TriggerMetadataSchema,
-      packageVersion: import_zod11.z.string(),
-      packageName: import_zod11.z.string(),
-      triggerTTL: import_zod11.z.number().optional(),
+      packageVersion: import_zod12.z.string(),
+      packageName: import_zod12.z.string(),
+      triggerTTL: import_zod12.z.number().optional(),
       metadata: SerializableJsonSchema.optional()
     }),
-    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()
+    response: import_zod12.z.discriminatedUnion("type", [
+      import_zod12.z.object({
+        type: import_zod12.z.literal("success"),
+        data: import_zod12.z.object({
+          workflow: import_zod12.z.object({
+            id: import_zod12.z.string(),
+            slug: import_zod12.z.string()
           }),
-          environment: import_zod11.z.object({
-            id: import_zod11.z.string(),
-            slug: import_zod11.z.string()
+          environment: import_zod12.z.object({
+            id: import_zod12.z.string(),
+            slug: import_zod12.z.string()
           }),
-          organization: import_zod11.z.object({
-            id: import_zod11.z.string(),
-            slug: import_zod11.z.string()
+          organization: import_zod12.z.object({
+            id: import_zod12.z.string(),
+            slug: import_zod12.z.string()
           }),
-          isNew: import_zod11.z.boolean(),
-          url: import_zod11.z.string()
+          isNew: import_zod12.z.boolean(),
+          url: import_zod12.z.string()
         })
       }),
-      import_zod11.z.object({
-        type: import_zod11.z.literal("error"),
-        message: import_zod11.z.string()
+      import_zod12.z.object({
+        type: import_zod12.z.literal("error"),
+        message: import_zod12.z.string()
       })
     ]).nullable()
   },
   START_WORKFLOW_RUN: {
-    request: import_zod11.z.object({
-      runId: import_zod11.z.string(),
-      timestamp: import_zod11.z.string()
+    request: import_zod12.z.object({
+      runId: import_zod12.z.string(),
+      timestamp: import_zod12.z.string()
     }),
-    response: import_zod11.z.boolean()
+    response: import_zod12.z.boolean()
   },
   COMPLETE_WORKFLOW_RUN: {
-    request: import_zod11.z.object({
-      runId: import_zod11.z.string(),
-      output: import_zod11.z.string().optional(),
-      timestamp: import_zod11.z.string()
+    request: import_zod12.z.object({
+      runId: import_zod12.z.string(),
+      output: import_zod12.z.string().optional(),
+      timestamp: import_zod12.z.string()
     }),
-    response: import_zod11.z.boolean()
+    response: import_zod12.z.boolean()
   },
   SEND_WORKFLOW_ERROR: {
-    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()
+    request: import_zod12.z.object({
+      runId: import_zod12.z.string(),
+      error: import_zod12.z.object({
+        name: import_zod12.z.string(),
+        message: import_zod12.z.string(),
+        stackTrace: import_zod12.z.string().optional()
       }),
-      timestamp: import_zod11.z.string()
+      timestamp: import_zod12.z.string()
     }),
-    response: import_zod11.z.boolean()
+    response: import_zod12.z.boolean()
   },
   INITIALIZE_RUN_ONCE: {
-    request: import_zod11.z.object({
-      runId: import_zod11.z.string(),
-      key: import_zod11.z.string(),
-      timestamp: import_zod11.z.string(),
+    request: import_zod12.z.object({
+      runId: import_zod12.z.string(),
+      key: import_zod12.z.string(),
+      timestamp: import_zod12.z.string(),
       runOnce: InitializeRunOnceSchema
     }),
-    response: import_zod11.z.boolean()
+    response: import_zod12.z.boolean()
   },
   COMPLETE_RUN_ONCE: {
-    request: import_zod11.z.object({
-      runId: import_zod11.z.string(),
-      key: import_zod11.z.string(),
-      timestamp: import_zod11.z.string(),
+    request: import_zod12.z.object({
+      runId: import_zod12.z.string(),
+      key: import_zod12.z.string(),
+      timestamp: import_zod12.z.string(),
       runOnce: CompleteRunOnceSchema
     }),
-    response: import_zod11.z.boolean()
+    response: import_zod12.z.boolean()
+  },
+  SEND_KV_GET: {
+    request: import_zod12.z.object({
+      runId: import_zod12.z.string(),
+      key: import_zod12.z.string(),
+      timestamp: import_zod12.z.string(),
+      get: import_zod12.z.object({
+        namespace: import_zod12.z.string(),
+        key: import_zod12.z.string()
+      })
+    }),
+    response: import_zod12.z.boolean()
+  },
+  SEND_KV_SET: {
+    request: import_zod12.z.object({
+      runId: import_zod12.z.string(),
+      key: import_zod12.z.string(),
+      timestamp: import_zod12.z.string(),
+      set: import_zod12.z.object({
+        namespace: import_zod12.z.string(),
+        key: import_zod12.z.string(),
+        value: SerializableJsonSchema
+      })
+    }),
+    response: import_zod12.z.boolean()
+  },
+  SEND_KV_DELETE: {
+    request: import_zod12.z.object({
+      runId: import_zod12.z.string(),
+      key: import_zod12.z.string(),
+      timestamp: import_zod12.z.string(),
+      delete: import_zod12.z.object({
+        namespace: import_zod12.z.string(),
+        key: import_zod12.z.string()
+      })
+    }),
+    response: import_zod12.z.boolean()
   }
 };
 
 // ../internal-bridge/src/schemas/common.ts
-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 import_zod13 = require("zod");
+var MESSAGE_META = import_zod13.z.object({
+  data: import_zod13.z.any(),
+  id: import_zod13.z.string(),
+  type: import_zod13.z.union([
+    import_zod13.z.literal("ACK"),
+    import_zod13.z.literal("MESSAGE")
   ])
 });
-var TriggerEnvironmentSchema = import_zod12.z.enum([
+var TriggerEnvironmentSchema = import_zod13.z.enum([
   "live",
   "development"
 ]);
 
 // ../internal-bridge/src/zodRPC.ts
-var import_zod13 = require("zod");
+var import_zod14 = require("zod");
 var import_node_crypto = require("crypto");
 
 // ../internal-bridge/src/logger.ts
@@ -814,11 +907,11 @@ function formattedDateTime() {
 __name(formattedDateTime, "formattedDateTime");
 
 // ../internal-bridge/src/zodRPC.ts
-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([
+var RPCMessageSchema = import_zod14.z.object({
+  id: import_zod14.z.string(),
+  methodName: import_zod14.z.string(),
+  data: import_zod14.z.any(),
+  kind: import_zod14.z.enum([
     "CALL",
     "RESPONSE"
   ])
@@ -898,7 +991,7 @@ onCall_fn = /* @__PURE__ */ __name(async function(message) {
   try {
     await __privateMethod(this, _handleCall, handleCall_fn).call(this, message);
   } catch (callError) {
-    if (callError instanceof import_zod13.ZodError) {
+    if (callError instanceof import_zod14.ZodError) {
       __privateGet(this, _logger).error(`[ZodRPC] Received invalid call:
 ${JSON.stringify(message)}: `, callError.errors);
     } else {
@@ -912,7 +1005,7 @@ onResponse_fn = /* @__PURE__ */ __name(async function(message1) {
   try {
     await __privateMethod(this, _handleResponse, handleResponse_fn).call(this, message1);
   } catch (callError) {
-    if (callError instanceof import_zod13.ZodError) {
+    if (callError instanceof import_zod14.ZodError) {
       __privateGet(this, _logger).error(`[ZodRPC] Received invalid response
 
 ${JSON.stringify(message1)}: `, callError.flatten());
@@ -988,11 +1081,11 @@ __name(packageResponse, "packageResponse");
 // src/client.ts
 var import_uuid2 = require("uuid");
 var import_ws = require("ws");
-var import_zod14 = require("zod");
+var import_zod15 = require("zod");
 
 // package.json
 var name = "@trigger.dev/sdk";
-var version = "0.2.20";
+var version = "0.2.22-next.0";
 
 // src/connection.ts
 var import_uuid = require("uuid");
@@ -1176,7 +1269,7 @@ startPingInterval_fn = /* @__PURE__ */ __name(function() {
         __privateGet(this, _logger2).error(err);
       }
       if (lastSuccessfulPing.getTime() < new Date().getTime() - __privateGet(this, _closeUnresponsiveConnectionTimeoutMs)) {
-        __privateGet(this, _logger2).error("No pong received in last three minutes, closing connection to Interval and retrying...");
+        __privateGet(this, _logger2).error("No pong received in last three minutes, closing connection to Trigger.dev and retrying...");
         if (__privateGet(this, _pingIntervalHandle)) {
           clearInterval(__privateGet(this, _pingIntervalHandle));
           __privateSet(this, _pingIntervalHandle, void 0);
@@ -1245,16 +1338,54 @@ __name(ContextLogger, "ContextLogger");
 
 // src/client.ts
 var import_zod_error = require("zod-error");
-var import_terminal_link = __toESM(require("terminal-link"));
-var import_chalk = __toESM(require("chalk"));
-var import_git_repo_info = __toESM(require("git-repo-info"));
-var import_git_remote_origin_url = __toESM(require("git-remote-origin-url"));
+var import_promises = require("fs/promises");
+
+// src/keyValueStorage.ts
+var ContextKeyValueStorage = class {
+  constructor(namespace, onGet, onSet, onDelete) {
+    this.namespace = namespace;
+    this.onGet = onGet;
+    this.onSet = onSet;
+    this.onDelete = onDelete;
+    this.getCount = 0;
+    this.setCount = 0;
+    this.deleteCount = 0;
+  }
+  get(key) {
+    const operation = {
+      key,
+      namespace: this.namespace,
+      idempotencyKey: `get:${this.namespace}:${key}:${this.getCount++}`
+    };
+    return this.onGet(operation);
+  }
+  set(key, value) {
+    const operation = {
+      key,
+      namespace: this.namespace,
+      idempotencyKey: `set:${this.namespace}:${key}:${this.setCount++}`,
+      value
+    };
+    return this.onSet(operation);
+  }
+  delete(key) {
+    const operation = {
+      key,
+      namespace: this.namespace,
+      idempotencyKey: `delete:${this.namespace}:${key}:${this.deleteCount++}`
+    };
+    return this.onDelete(operation);
+  }
+};
+__name(ContextKeyValueStorage, "ContextKeyValueStorage");
+
+// src/client.ts
 var zodErrorMessageOptions = {
   delimiter: {
     error: " \u{1F525} "
   }
 };
-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 _trigger, _options, _connection2, _serverRPC, _apiKey, _endpoint, _isConnected, _retryIntervalMs, _logger3, _closedByUser, _registerResponse, _responseCompleteCallbacks, _waitForCallbacks, _fetchCallbacks, _runOnceCallbacks, _kvGetCallbacks, _kvSetCallbacks, _kvDeleteCallbacks, _initializeConnection, initializeConnection_fn, _initializeRPC, initializeRPC_fn, _initializeHost, initializeHost_fn, _send, send_fn;
 var TriggerClient = class {
   constructor(trigger, options) {
     __privateAdd(this, _initializeConnection);
@@ -1276,6 +1407,9 @@ var TriggerClient = class {
     __privateAdd(this, _waitForCallbacks, /* @__PURE__ */ new Map());
     __privateAdd(this, _fetchCallbacks, /* @__PURE__ */ new Map());
     __privateAdd(this, _runOnceCallbacks, /* @__PURE__ */ new Map());
+    __privateAdd(this, _kvGetCallbacks, /* @__PURE__ */ new Map());
+    __privateAdd(this, _kvSetCallbacks, /* @__PURE__ */ new Map());
+    __privateAdd(this, _kvDeleteCallbacks, /* @__PURE__ */ new Map());
     __privateSet(this, _trigger, trigger);
     __privateSet(this, _options, options);
     const apiKey = __privateGet(this, _options).apiKey ?? process.env.TRIGGER_API_KEY;
@@ -1294,12 +1428,13 @@ 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);
+      const terminalLink = (await import("terminal-link")).default;
       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, {
+        __privateGet(this, _logger3).logClean(`\u{1F389} Successfully registered "${__privateGet(this, _trigger).name}" to trigger.dev \u{1F449} ${terminalLink("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, {
+        __privateGet(this, _logger3).log(`\u2728 Connected and listening for events \u{1F449} ${terminalLink("View on dashboard", __privateGet(this, _registerResponse).url, {
           fallback: (text, url) => `${text}: (${url})`
         })}`);
       }
@@ -1333,6 +1468,9 @@ _responseCompleteCallbacks = new WeakMap();
 _waitForCallbacks = new WeakMap();
 _fetchCallbacks = new WeakMap();
 _runOnceCallbacks = new WeakMap();
+_kvGetCallbacks = new WeakMap();
+_kvSetCallbacks = new WeakMap();
+_kvDeleteCallbacks = new WeakMap();
 _initializeConnection = new WeakSet();
 initializeConnection_fn = /* @__PURE__ */ __name(async function(instanceId) {
   const id = instanceId ?? (0, import_uuid2.v4)();
@@ -1355,7 +1493,8 @@ initializeConnection_fn = /* @__PURE__ */ __name(async function(instanceId) {
       __privateSet(this, _closedByUser, false);
       return;
     }
-    __privateGet(this, _logger3).error(`${import_chalk.default.red("error")} Could not connect to trigger.dev${reason ? `: ${reason}` : `(code ${code})`}`);
+    const chalk = (await import("chalk")).default;
+    __privateGet(this, _logger3).error(`${chalk.red("error")} Could not connect to trigger.dev${reason ? `: ${reason}` : `(code ${code})`}`);
     if (!__privateGet(this, _isConnected))
       return;
     __privateGet(this, _logger3).log("\u{1F50C} Reconnecting to trigger.dev...");
@@ -1454,6 +1593,39 @@ initializeRPC_fn = /* @__PURE__ */ __name(async function() {
         reject(data.error);
         return true;
       },
+      RESOLVE_KV_GET: async (data) => {
+        __privateGet(this, _logger3).debug("Handling RESOLVE_KV_GET", data);
+        const getCallbacks = __privateGet(this, _kvGetCallbacks).get(messageKey(data.meta.runId, data.key));
+        if (!getCallbacks) {
+          __privateGet(this, _logger3).debug(`Could not find kvGet callbacks for request ID ${messageKey(data.meta.runId, data.key)}. This can happen when a workflow run is resumed`);
+          return true;
+        }
+        const { resolve } = getCallbacks;
+        resolve(data.output);
+        return true;
+      },
+      RESOLVE_KV_SET: async (data) => {
+        __privateGet(this, _logger3).debug("Handling RESOLVE_KV_SET", data);
+        const setCallbacks = __privateGet(this, _kvSetCallbacks).get(messageKey(data.meta.runId, data.key));
+        if (!setCallbacks) {
+          __privateGet(this, _logger3).debug(`Could not find kvSet callbacks for request ID ${messageKey(data.meta.runId, data.key)}. This can happen when a workflow run is resumed`);
+          return true;
+        }
+        const { resolve } = setCallbacks;
+        resolve();
+        return true;
+      },
+      RESOLVE_KV_DELETE: async (data) => {
+        __privateGet(this, _logger3).debug("Handling RESOLVE_KV_DELETE", data);
+        const deleteCallbacks = __privateGet(this, _kvDeleteCallbacks).get(messageKey(data.meta.runId, data.key));
+        if (!deleteCallbacks) {
+          __privateGet(this, _logger3).debug(`Could not find kvDelete callbacks for request ID ${messageKey(data.meta.runId, data.key)}. This can happen when a workflow run is resumed`);
+          return true;
+        }
+        const { resolve } = deleteCallbacks;
+        resolve();
+        return true;
+      },
       TRIGGER_WORKFLOW: async (data) => {
         __privateGet(this, _logger3).debug("Handling TRIGGER_WORKFLOW", data);
         const parsedEventData = __privateGet(this, _options).on.schema.safeParse(data.trigger.input);
@@ -1492,15 +1664,76 @@ initializeRPC_fn = /* @__PURE__ */ __name(async function() {
             status: response.status,
             ok: response.ok,
             headers: response.headers,
-            body: response.body ? (options.responseSchema ?? import_zod14.z.any()).parse(response.body) : void 0
+            body: response.body ? (options.responseSchema ?? import_zod15.z.any()).parse(response.body) : void 0
           };
         }, "fetchFunction");
+        const kvGetFunction = /* @__PURE__ */ __name(async (op) => {
+          const result = new Promise((resolve, reject) => {
+            __privateGet(this, _kvGetCallbacks).set(messageKey(data.id, op.idempotencyKey), {
+              resolve,
+              reject
+            });
+          });
+          await serverRPC.send("SEND_KV_GET", {
+            runId: data.id,
+            key: op.idempotencyKey,
+            get: {
+              namespace: op.namespace,
+              key: op.key
+            },
+            timestamp: String(highPrecisionTimestamp())
+          });
+          const output = await result;
+          return output;
+        }, "kvGetFunction");
+        const kvSetFunction = /* @__PURE__ */ __name(async (op) => {
+          const result = new Promise((resolve, reject) => {
+            __privateGet(this, _kvSetCallbacks).set(messageKey(data.id, op.idempotencyKey), {
+              resolve,
+              reject
+            });
+          });
+          await serverRPC.send("SEND_KV_SET", {
+            runId: data.id,
+            key: op.idempotencyKey,
+            set: {
+              namespace: op.namespace,
+              key: op.key,
+              value: op.value
+            },
+            timestamp: String(highPrecisionTimestamp())
+          });
+          await result;
+          return;
+        }, "kvSetFunction");
+        const kvDeleteFunction = /* @__PURE__ */ __name(async (op) => {
+          const result = new Promise((resolve, reject) => {
+            __privateGet(this, _kvDeleteCallbacks).set(messageKey(data.id, op.idempotencyKey), {
+              resolve,
+              reject
+            });
+          });
+          await serverRPC.send("SEND_KV_DELETE", {
+            runId: data.id,
+            key: op.idempotencyKey,
+            delete: {
+              namespace: op.namespace,
+              key: op.key
+            },
+            timestamp: String(highPrecisionTimestamp())
+          });
+          await result;
+          return;
+        }, "kvDeleteFunction");
         const ctx = {
           id: data.id,
           environment: data.meta.environment,
           apiKey: data.meta.apiKey,
           organizationId: data.meta.organizationId,
           isTest: data.meta.isTest,
+          kv: new ContextKeyValueStorage(`workflow:${data.meta.workflowId}`, kvGetFunction, kvSetFunction, kvDeleteFunction),
+          globalKv: new ContextKeyValueStorage(`org:${data.meta.organizationId}`, kvGetFunction, kvSetFunction, kvDeleteFunction),
+          runKv: new ContextKeyValueStorage(`run:${data.id}`, kvGetFunction, kvSetFunction, kvDeleteFunction),
           logger: new ContextLogger(async (level, message, properties) => {
             await serverRPC.send("SEND_LOG", {
               runId: data.id,
@@ -1616,6 +1849,7 @@ initializeRPC_fn = /* @__PURE__ */ __name(async function() {
         };
         const eventData = parsedEventData.data;
         __privateGet(this, _logger3).debug("Parsed event data", eventData);
+        const terminalLink = (await import("terminal-link")).default;
         triggerRunLocalStorage.run({
           performRequest: async (key, options) => {
             const result = new Promise((resolve, reject) => {
@@ -1656,7 +1890,7 @@ initializeRPC_fn = /* @__PURE__ */ __name(async function() {
         }, () => {
           __privateGet(this, _logger3).debug("Running trigger...");
           if (typeof data.meta.attempt === "number" && data.meta.attempt === 0) {
-            __privateGet(this, _logger3).log(`Run ${data.id} started \u{1F449} ${(0, import_terminal_link.default)("View on dashboard", `${__privateGet(this, _registerResponse).url}/runs/${data.id}`, {
+            __privateGet(this, _logger3).log(`Run ${data.id} started \u{1F449} ${terminalLink("View on dashboard", `${__privateGet(this, _registerResponse).url}/runs/${data.id}`, {
               fallback: (text, url) => `${text}: (${url})`
             })}`);
           }
@@ -1665,7 +1899,7 @@ 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{1F449} ${(0, import_terminal_link.default)("View on dashboard", `${__privateGet(this, _registerResponse).url}/runs/${data.id}`, {
+              __privateGet(this, _logger3).log(`Run ${data.id} complete \u{1F449} ${terminalLink("View on dashboard", `${__privateGet(this, _registerResponse).url}/runs/${data.id}`, {
                 fallback: (text, url) => `${text}: (${url})`
               })}`);
               return serverRPC.send("COMPLETE_WORKFLOW_RUN", {
@@ -1682,9 +1916,9 @@ initializeRPC_fn = /* @__PURE__ */ __name(async function() {
                     stackTrace: error2.stack
                   };
                 }
-                const parsedError = import_zod14.z.object({
-                  name: import_zod14.z.string(),
-                  message: import_zod14.z.string()
+                const parsedError = import_zod15.z.object({
+                  name: import_zod15.z.string(),
+                  message: import_zod15.z.string()
                 }).passthrough().safeParse(error2);
                 if (parsedError.success) {
                   return parsedError.data;
@@ -1724,9 +1958,9 @@ initializeHost_fn = /* @__PURE__ */ __name(async function() {
   if (!__privateGet(this, _serverRPC)) {
     throw new Error("Cannot initialize host without an RPC connection");
   }
-  const repoInfo = safeGetRepoInfo();
+  const repoInfo = await safeGetRepoInfo();
   const remoteUrl = repoInfo ? await getRemoteUrl(repoInfo.commonGitDir) : void 0;
-  const packageMetadata = getTriggerPackageEnvVars(process.env);
+  const packageMetadata = await getTriggerPackageEnvVars(process.env);
   const response = await __privateMethod(this, _send, send_fn).call(this, "INITIALIZE_HOST_V2", {
     apiKey: __privateGet(this, _apiKey),
     workflowId: __privateGet(this, _trigger).id,
@@ -1744,7 +1978,8 @@ initializeHost_fn = /* @__PURE__ */ __name(async function() {
         commitMessage: repoInfo.commitMessage,
         origin: remoteUrl
       } : void 0,
-      packageMetadata
+      packageMetadata,
+      env: gatherEnvVars(process.env)
     }
   });
   if (!response) {
@@ -1782,10 +2017,19 @@ function highPrecisionTimestamp() {
   return seconds * 1e9 + nanoseconds;
 }
 __name(highPrecisionTimestamp, "highPrecisionTimestamp");
-function getTriggerPackageEnvVars(env) {
+async function getTriggerPackageEnvVars(env) {
   if (!env) {
     return {};
   }
+  if (env.npm_package_json) {
+    try {
+      const packageJson = JSON.parse(await (0, import_promises.readFile)(env.npm_package_json, "utf8"));
+      if (packageJson.triggerdotdev) {
+        return packageJson.triggerdotdev;
+      }
+    } catch (err) {
+    }
+  }
   const envVars = Object.entries(env).filter(([key]) => key.startsWith("npm_package_triggerdotdev_")).map(([key, value]) => [
     key.replace("npm_package_triggerdotdev_", ""),
     value
@@ -1795,7 +2039,8 @@ function getTriggerPackageEnvVars(env) {
 __name(getTriggerPackageEnvVars, "getTriggerPackageEnvVars");
 async function getRemoteUrl(cwd) {
   try {
-    return await (0, import_git_remote_origin_url.default)({
+    const gitRemoteOriginUrl = (await import("git-remote-origin-url")).default;
+    return await gitRemoteOriginUrl({
       cwd
     });
   } catch (err) {
@@ -1803,18 +2048,28 @@ async function getRemoteUrl(cwd) {
   }
 }
 __name(getRemoteUrl, "getRemoteUrl");
-function safeGetRepoInfo() {
+async function safeGetRepoInfo() {
   try {
-    return (0, import_git_repo_info.default)();
+    const gitRepoInfo = (await import("git-repo-info")).default;
+    return gitRepoInfo();
   } catch (err) {
     return;
   }
 }
 __name(safeGetRepoInfo, "safeGetRepoInfo");
+function gatherEnvVars(env) {
+  if (!env) {
+    return {};
+  }
+  const envVars = Object.entries(env).filter(([key]) => key.startsWith("TRIGGER_") && key !== "TRIGGER_API_KEY").map(([key, value]) => [
+    key.replace("TRIGGER_", ""),
+    `${value}`
+  ]);
+  return Object.fromEntries(envVars);
+}
+__name(gatherEnvVars, "gatherEnvVars");
 
 // src/trigger/index.ts
-var import_chalk2 = __toESM(require("chalk"));
-var import_terminal_link2 = __toESM(require("terminal-link"));
 var _client, _getApiKey, getApiKey_fn;
 var Trigger = class {
   constructor(options) {
@@ -1824,15 +2079,17 @@ var Trigger = class {
   }
   async listen() {
     const apiKey = __privateMethod(this, _getApiKey, getApiKey_fn).call(this);
+    const chalk = (await import("chalk")).default;
+    const terminalLink = (await import("terminal-link")).default;
     if (apiKey.status === "invalid") {
-      console.log(`${import_chalk2.default.red("Trigger.dev error")}: ${import_chalk2.default.bold(this.id)} is has an invalid API key ("${import_chalk2.default.italic(apiKey.apiKey)}"), please set the TRIGGER_API_KEY environment variable or pass the apiKey option to a valid value. ${(0, import_terminal_link2.default)("Get your API key here", "https://app.trigger.dev", {
+      console.log(`${chalk.red("Trigger.dev error")}: ${chalk.bold(this.id)} is has an invalid API key ("${chalk.italic(apiKey.apiKey)}"), please set the TRIGGER_API_KEY environment variable or pass the apiKey option to a valid value. ${terminalLink("Get your API key here", "https://app.trigger.dev", {
         fallback(text, url) {
           return `${text} \u{1F449} ${url}`;
         }
       })}`);
       return;
     } else if (apiKey.status === "missing") {
-      console.log(`${import_chalk2.default.red("Trigger.dev error")}: ${import_chalk2.default.bold(this.id)} is missing an API key, please set the TRIGGER_API_KEY environment variable or pass the apiKey option to the Trigger constructor. ${(0, import_terminal_link2.default)("Get your API key here", "https://app.trigger.dev", {
+      console.log(`${chalk.red("Trigger.dev error")}: ${chalk.bold(this.id)} is missing an API key, please set the TRIGGER_API_KEY environment variable or pass the apiKey option to the Trigger constructor. ${terminalLink("Get your API key here", "https://app.trigger.dev", {
         fallback(text, url) {
           return `${text} \u{1F449} ${url}`;
         }