@zapier/zapier-sdk 0.15.2 → 0.15.4

package/dist/index.mjs

@@ -2699,6 +2699,17 @@ async function readFile(filePath) {
   throw new Error(`File not found: ${filePath}`);
 }
 var DEFAULT_CONFIG_PATH = ".zapierrc";
+var ActionEntrySchema = z.object({
+  appKey: z.string().describe("App key (slug or implementation name)"),
+  actionKey: z.string().describe("Action key identifier"),
+  actionType: z.string().describe("Action type (e.g., 'read', 'write', 'search')"),
+  authenticationId: z.number().nullable().optional().describe("Authentication ID used"),
+  inputs: z.record(z.unknown()).optional().describe("Resolved input values"),
+  schema: z.record(z.unknown()).describe(
+    "Complete JSON Schema from getInputFieldsSchema (includes $schema, type, properties, required, etc.)"
+  ),
+  createdAt: z.string().describe("ISO 8601 timestamp when created")
+});
 var ManifestSchema = z.object({
   apps: z.record(
     z.string(),
@@ -2708,8 +2719,9 @@ var ManifestSchema = z.object({
       ),
       version: z.string().describe("Version string (e.g., '1.21.1')")
     })
-  )
-}).describe("Manifest mapping app keys to version information");
+  ),
+  actions: z.record(z.string(), ActionEntrySchema).optional().describe("Saved action configurations with their schemas")
+}).describe("Manifest for app version locking and action configurations");
 z.object({
   manifestPath: z.string().optional().describe("Path to manifest file"),
   manifest: z.record(
@@ -2980,7 +2992,81 @@ var manifestPlugin = (params) => {
       await writeManifestToFile(updatedManifest, configPath);
       resolvedManifest = void 0;
     }
-    return [manifestKey, entry, updatedManifest];
+    return {
+      key: manifestKey,
+      entry,
+      manifest: updatedManifest
+    };
+  };
+  const addActionEntry = async (options2) => {
+    const {
+      name,
+      entry,
+      configPath = DEFAULT_CONFIG_PATH,
+      skipWrite = false,
+      manifest: inputManifest
+    } = options2;
+    const manifest2 = inputManifest || await readManifestFromFile(configPath) || { apps: {} };
+    const actions = manifest2.actions || {};
+    if (actions[name] && !skipWrite) {
+      throw new Error(
+        `Action "${name}" already exists. Please choose a different name or remove the existing action first.`
+      );
+    }
+    const updatedManifest = {
+      ...manifest2,
+      actions: {
+        ...actions,
+        [name]: entry
+      }
+    };
+    if (!skipWrite) {
+      await writeManifestToFile(updatedManifest, configPath);
+      resolvedManifest = void 0;
+    }
+    return {
+      name,
+      entry,
+      manifest: updatedManifest
+    };
+  };
+  const findActionEntry = ({
+    name,
+    manifest: manifest2
+  }) => {
+    return manifest2.actions?.[name] || null;
+  };
+  const listActionEntries = async ({
+    configPath = DEFAULT_CONFIG_PATH
+  } = {}) => {
+    const manifest2 = await readManifestFromFile(configPath) || { };
+    return Object.entries(manifest2.actions || {});
+  };
+  const deleteActionEntry = async ({
+    name,
+    configPath = DEFAULT_CONFIG_PATH,
+    skipWrite = false
+  }) => {
+    const manifest2 = await readManifestFromFile(configPath) || { apps: {} };
+    if (!manifest2.actions?.[name]) {
+      throw new Error(`Action "${name}" does not exist.`);
+    }
+    const { [name]: removed, ...remainingActions } = manifest2.actions;
+    const updatedManifest = {
+      ...manifest2,
+      actions: remainingActions
+    };
+    if (!skipWrite) {
+      await writeManifestToFile(updatedManifest, configPath);
+      resolvedManifest = void 0;
+    }
+    return updatedManifest;
+  };
+  const hasActionEntry = ({
+    name,
+    manifest: manifest2
+  }) => {
+    return !!manifest2.actions?.[name];
   };
   return {
     context: {
@@ -2990,7 +3076,14 @@ var manifestPlugin = (params) => {
         api,
         manifest: await getResolvedManifest() ?? { apps: {} }
       }),
-      updateManifestEntry
+      updateManifestEntry,
+      addActionEntry,
+      findActionEntry,
+      listActionEntries,
+      deleteActionEntry,
+      hasActionEntry,
+      findManifestEntry,
+      readManifestFromFile
     }
   };
 };
@@ -3084,6 +3177,34 @@ function getAuthorizationHeader(token) {
   }
   return `Bearer ${token}`;
 }
+function extractUserIdsFromJwt(token) {
+  try {
+    const parts = token.split(".");
+    if (parts.length !== 3) {
+      return { customuser_id: null, account_id: null };
+    }
+    const payload = JSON.parse(
+      Buffer.from(parts[1], "base64url").toString("utf-8")
+    );
+    let actualPayload = payload;
+    if (payload.sub_type === "service" && payload.njwt) {
+      const nestedParts = payload.njwt.split(".");
+      if (nestedParts.length === 3) {
+        actualPayload = JSON.parse(
+          Buffer.from(nestedParts[1], "base64url").toString("utf-8")
+        );
+      }
+    }
+    const accountId = actualPayload["zap:acc"] != null ? parseInt(String(actualPayload["zap:acc"]), 10) : null;
+    const customUserId = actualPayload.sub_type === "customuser" && actualPayload.sub != null ? parseInt(String(actualPayload.sub), 10) : null;
+    return {
+      customuser_id: customUserId !== null && !isNaN(customUserId) ? customUserId : null,
+      account_id: accountId !== null && !isNaN(accountId) ? accountId : null
+    };
+  } catch {
+    return { customuser_id: null, account_id: null };
+  }
+}
 
 // src/api/debug.ts
 var utilModule = null;
@@ -4480,7 +4601,7 @@ function getCpuTime() {
 
 // package.json
 var package_default = {
-  version: "0.15.2"};
+  version: "0.15.4"};
 
 // src/plugins/eventEmission/builders.ts
 function createBaseEvent(context = {}) {
@@ -4551,17 +4672,26 @@ function buildErrorEventWithContext(data, context = {}) {
 }
 
 // src/plugins/eventEmission/index.ts
+var TELEMETRY_EMIT_TIMEOUT_MS = 300;
 var APPLICATION_LIFECYCLE_EVENT_SUBJECT = "platform.sdk.ApplicationLifecycleEvent";
 var ERROR_OCCURRED_EVENT_SUBJECT = "platform.sdk.ErrorOccurredEvent";
 var transportStates = /* @__PURE__ */ new WeakMap();
-async function silentEmit(transport, subject, event) {
+async function silentEmit(transport, subject, event, userContextPromise) {
   try {
     let state = transportStates.get(transport);
     if (!state) {
       state = { hasWorked: false, hasLoggedFailure: false };
       transportStates.set(transport, state);
     }
-    transport.emit(subject, event).then(() => {
+    let enrichedEvent = event;
+    if (userContextPromise) {
+      try {
+        const userContext = await userContextPromise;
+        enrichedEvent = Object.assign({}, event, userContext);
+      } catch {
+      }
+    }
+    transport.emit(subject, enrichedEvent).then(() => {
       state.hasWorked = true;
     }).catch((error) => {
       if (!state.hasWorked && !state.hasLoggedFailure) {
@@ -4609,6 +4739,19 @@ var eventEmissionPlugin = ({ context }) => {
       )
     )
   };
+  const getUserContext = (async () => {
+    try {
+      const { getToken } = await import('@zapier/zapier-sdk-cli-login');
+      const token = await getToken({
+        baseUrl: context.options.baseUrl
+      });
+      if (token) {
+        return extractUserIdsFromJwt(token);
+      }
+    } catch {
+    }
+    return { customuser_id: null, account_id: null };
+  })();
   const startupTime = Date.now();
   let shutdownStartTime = null;
   if (!config.enabled) {
@@ -4619,7 +4762,7 @@ var eventEmissionPlugin = ({ context }) => {
           config,
           emit: () => {
           },
-          createBaseEvent: () => ({
+          createBaseEvent: async () => ({
             event_id: generateEventId(),
             timestamp_ms: getCurrentTimestamp(),
             release_id: getReleaseId(),
@@ -4639,21 +4782,34 @@ var eventEmissionPlugin = ({ context }) => {
   } catch {
     transport = createTransport({ type: "noop" });
   }
-  const createBaseEventHelper = () => ({
-    event_id: generateEventId(),
-    timestamp_ms: getCurrentTimestamp(),
-    release_id: getReleaseId(),
-    customuser_id: null,
-    account_id: null,
-    identity_id: null,
-    visitor_id: null,
-    correlation_id: null
-  });
+  const createBaseEventHelper = async () => {
+    const baseEvent = {
+      event_id: generateEventId(),
+      timestamp_ms: getCurrentTimestamp(),
+      release_id: getReleaseId(),
+      customuser_id: null,
+      account_id: null,
+      identity_id: null,
+      visitor_id: null,
+      correlation_id: null
+    };
+    try {
+      const userContext = await getUserContext;
+      return { ...baseEvent, ...userContext };
+    } catch {
+      return baseEvent;
+    }
+  };
   if (config.enabled) {
     const startupEvent = buildApplicationLifecycleEvent({
       lifecycle_event_type: "startup"
     });
-    silentEmit(transport, APPLICATION_LIFECYCLE_EVENT_SUBJECT, startupEvent);
+    silentEmit(
+      transport,
+      APPLICATION_LIFECYCLE_EVENT_SUBJECT,
+      startupEvent,
+      getUserContext
+    );
     if (typeof process?.on === "function") {
       process.on("exit", (code) => {
         const uptime = Date.now() - startupTime;
@@ -4665,10 +4821,15 @@ var eventEmissionPlugin = ({ context }) => {
           is_graceful_shutdown: code === 0,
           shutdown_duration_ms: shutdownDuration
         });
-        silentEmit(transport, APPLICATION_LIFECYCLE_EVENT_SUBJECT, exitEvent);
+        silentEmit(
+          transport,
+          APPLICATION_LIFECYCLE_EVENT_SUBJECT,
+          exitEvent,
+          getUserContext
+        );
       });
       process.on("uncaughtException", async (error) => {
-        const errorEvent = buildErrorEventWithContext({
+        let errorEvent = buildErrorEventWithContext({
           error_message: error.message || "Unknown error",
           error_type: "UncaughtException",
           error_stack_trace: error.stack || null,
@@ -4677,10 +4838,17 @@ var eventEmissionPlugin = ({ context }) => {
           is_recoverable: false,
           execution_start_time: startupTime
         });
+        try {
+          const userContext = await getUserContext;
+          errorEvent = { ...errorEvent, ...userContext };
+        } catch {
+        }
         try {
           await Promise.race([
             transport.emit(ERROR_OCCURRED_EVENT_SUBJECT, errorEvent),
-            new Promise((resolve2) => setTimeout(resolve2, 300))
+            new Promise(
+              (resolve2) => setTimeout(resolve2, TELEMETRY_EMIT_TIMEOUT_MS)
+            )
           ]);
         } catch {
         }
@@ -4690,7 +4858,7 @@ var eventEmissionPlugin = ({ context }) => {
         async (reason, promise) => {
           const errorMessage = reason instanceof Error ? reason.message : typeof reason === "string" ? reason : "Unhandled promise rejection";
           const errorStack = reason instanceof Error ? reason.stack : null;
-          const errorEvent = buildErrorEventWithContext({
+          let errorEvent = buildErrorEventWithContext({
             error_message: errorMessage,
             error_type: "UnhandledRejection",
             error_stack_trace: errorStack,
@@ -4702,10 +4870,17 @@ var eventEmissionPlugin = ({ context }) => {
               promise: String(promise)
             }
           });
+          try {
+            const userContext = await getUserContext;
+            errorEvent = { ...errorEvent, ...userContext };
+          } catch {
+          }
           try {
             await Promise.race([
               transport.emit(ERROR_OCCURRED_EVENT_SUBJECT, errorEvent),
-              new Promise((resolve2) => setTimeout(resolve2, 300))
+              new Promise(
+                (resolve2) => setTimeout(resolve2, TELEMETRY_EMIT_TIMEOUT_MS)
+              )
             ]);
           } catch {
           }
@@ -4714,16 +4889,23 @@ var eventEmissionPlugin = ({ context }) => {
       const handleSignal = async (signal) => {
         shutdownStartTime = Date.now();
         const uptime = Date.now() - startupTime;
-        const signalEvent = buildApplicationLifecycleEvent({
+        let signalEvent = buildApplicationLifecycleEvent({
           lifecycle_event_type: "signal_termination",
           signal_name: signal,
           uptime_ms: uptime,
           is_graceful_shutdown: true
         });
+        try {
+          const userContext = await getUserContext;
+          signalEvent = { ...signalEvent, ...userContext };
+        } catch {
+        }
         try {
           await Promise.race([
             transport.emit(APPLICATION_LIFECYCLE_EVENT_SUBJECT, signalEvent),
-            new Promise((resolve2) => setTimeout(resolve2, 300))
+            new Promise(
+              (resolve2) => setTimeout(resolve2, TELEMETRY_EMIT_TIMEOUT_MS)
+            )
           ]);
         } catch {
         }
@@ -4739,7 +4921,7 @@ var eventEmissionPlugin = ({ context }) => {
         transport,
         config,
         emit: (subject, event) => {
-          silentEmit(transport, subject, event);
+          silentEmit(transport, subject, event, getUserContext);
         },
         createBaseEvent: createBaseEventHelper
       }

package/dist/plugins/eventEmission/index.d.ts

@@ -16,7 +16,7 @@ export interface EventEmissionContext {
         transport: EventTransport;
         config: EventEmissionConfig;
         emit<T extends any>(subject: string, event: T): void;
-        createBaseEvent(): BaseEvent;
+        createBaseEvent(): Promise<BaseEvent>;
     };
 }
 export interface EventEmissionProvides {

package/dist/plugins/eventEmission/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/plugins/eventEmission/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AACjD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,8BAA8B,CAAC;AAC9D,OAAO,KAAK,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAUnE,MAAM,WAAW,mBAAmB;IAClC,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,SAAS,CAAC,EAAE,eAAe,CAAC;CAC7B;AAGD,MAAM,WAAW,oBAAoB;IACnC,aAAa,EAAE;QACb,SAAS,EAAE,cAAc,CAAC;QAC1B,MAAM,EAAE,mBAAmB,CAAC;QAE5B,IAAI,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI,CAAC;QAErD,eAAe,IAAI,SAAS,CAAC;KAC9B,CAAC;CACH;AAED,MAAM,WAAW,qBAAqB;IACpC,OAAO,EAAE,oBAAoB,CAAC;CAC/B;AA+ED,eAAO,MAAM,mBAAmB,EAAE,MAAM,CACtC,EAAE,EACF;IACE,OAAO,EAAE;QACP,aAAa,CAAC,EAAE,mBAAmB,CAAC;QACpC,eAAe,CAAC,EAAE,MAAM,CAAC;QACzB,OAAO,CAAC,EAAE,MAAM,CAAC;KAClB,CAAC;CACH,EACD,qBAAqB,CAoMtB,CAAC;AAGF,YAAY,EACV,YAAY,EACZ,6BAA6B,EAC7B,sBAAsB,GACvB,MAAM,SAAS,CAAC;AACjB,OAAO,EACL,8BAA8B,EAC9B,0BAA0B,EAC1B,eAAe,EACf,eAAe,GAChB,MAAM,YAAY,CAAC;AACpB,YAAY,EAAE,SAAS,EAAE,MAAM,8BAA8B,CAAC;AAC9D,cAAc,SAAS,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/plugins/eventEmission/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AACjD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,8BAA8B,CAAC;AAC9D,OAAO,KAAK,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAenE,MAAM,WAAW,mBAAmB;IAClC,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,SAAS,CAAC,EAAE,eAAe,CAAC;CAC7B;AAGD,MAAM,WAAW,oBAAoB;IACnC,aAAa,EAAE;QACb,SAAS,EAAE,cAAc,CAAC;QAC1B,MAAM,EAAE,mBAAmB,CAAC;QAE5B,IAAI,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI,CAAC;QAErD,eAAe,IAAI,OAAO,CAAC,SAAS,CAAC,CAAC;KACvC,CAAC;CACH;AAED,MAAM,WAAW,qBAAqB;IACpC,OAAO,EAAE,oBAAoB,CAAC;CAC/B;AA4FD,eAAO,MAAM,mBAAmB,EAAE,MAAM,CACtC,EAAE,EACF;IACE,OAAO,EAAE;QACP,aAAa,CAAC,EAAE,mBAAmB,CAAC;QACpC,eAAe,CAAC,EAAE,MAAM,CAAC;QACzB,OAAO,CAAC,EAAE,MAAM,CAAC;KAClB,CAAC;CACH,EACD,qBAAqB,CAyQtB,CAAC;AAGF,YAAY,EACV,YAAY,EACZ,6BAA6B,EAC7B,sBAAsB,GACvB,MAAM,SAAS,CAAC;AACjB,OAAO,EACL,8BAA8B,EAC9B,0BAA0B,EAC1B,eAAe,EACf,eAAe,GAChB,MAAM,YAAY,CAAC;AACpB,YAAY,EAAE,SAAS,EAAE,MAAM,8BAA8B,CAAC;AAC9D,cAAc,SAAS,CAAC"}

package/dist/plugins/eventEmission/index.js

@@ -6,14 +6,17 @@
  */
 import { createTransport } from "./transport";
 import { generateEventId, getCurrentTimestamp, getReleaseId } from "./utils";
+import { extractUserIdsFromJwt } from "../../api/auth";
 import { buildApplicationLifecycleEvent, buildErrorEventWithContext, } from "./builders";
 import { getTrackingBaseUrl } from "../../utils/url-utils";
+// Maximum time to wait for telemetry emission before allowing process to exit
+const TELEMETRY_EMIT_TIMEOUT_MS = 300;
 const APPLICATION_LIFECYCLE_EVENT_SUBJECT = "platform.sdk.ApplicationLifecycleEvent";
 const ERROR_OCCURRED_EVENT_SUBJECT = "platform.sdk.ErrorOccurredEvent";
 // Track transport success/failure so we only log failure once.
 const transportStates = new WeakMap();
 // Silent emission wrapper with smart first-failure logging
-async function silentEmit(transport, subject, event) {
+async function silentEmit(transport, subject, event, userContextPromise) {
     try {
         // Get or initialize state for this transport
         let state = transportStates.get(transport);
@@ -21,9 +24,21 @@ async function silentEmit(transport, subject, event) {
             state = { hasWorked: false, hasLoggedFailure: false };
             transportStates.set(transport, state);
         }
+        // Resolve user context and merge into event
+        let enrichedEvent = event;
+        if (userContextPromise) {
+            try {
+                const userContext = await userContextPromise;
+                // Use Object.assign to safely merge user context into event
+                enrichedEvent = Object.assign({}, event, userContext);
+            }
+            catch {
+                // If user context promise fails, continue with original event
+            }
+        }
         // Fire and forget - don't await the transport
         transport
-            .emit(subject, event)
+            .emit(subject, enrichedEvent)
             .then(() => {
             // Mark as working if any emit succeeds
             state.hasWorked = true;
@@ -76,6 +91,24 @@ export const eventEmissionPlugin = ({ context }) => {
             : // Otherwise, use option transport or default
                 (context.options.eventEmission?.transport ?? defaultTransport),
     };
+    // Create getUserContext promise for dynamic user context injection
+    const getUserContext = (async () => {
+        try {
+            // Dynamically import the CLI login package if available
+            const { getToken } = await import("@zapier/zapier-sdk-cli-login");
+            // Pass baseUrl for potential token refresh operations
+            const token = await getToken({
+                baseUrl: context.options.baseUrl,
+            });
+            if (token) {
+                return extractUserIdsFromJwt(token);
+            }
+        }
+        catch {
+            // CLI login package not available or getToken failed, fall back to null context
+        }
+        return { customuser_id: null, account_id: null };
+    })();
     const startupTime = Date.now();
     let shutdownStartTime = null;
     // If disabled, return noop implementations
@@ -86,7 +119,7 @@ export const eventEmissionPlugin = ({ context }) => {
                     transport: createTransport({ type: "noop" }),
                     config,
                     emit: () => { },
-                    createBaseEvent: () => ({
+                    createBaseEvent: async () => ({
                         event_id: generateEventId(),
                         timestamp_ms: getCurrentTimestamp(),
                         release_id: getReleaseId(),
@@ -109,23 +142,34 @@ export const eventEmissionPlugin = ({ context }) => {
         transport = createTransport({ type: "noop" });
     }
     // Helper to create base event
-    const createBaseEventHelper = () => ({
-        event_id: generateEventId(),
-        timestamp_ms: getCurrentTimestamp(),
-        release_id: getReleaseId(),
-        customuser_id: null,
-        account_id: null,
-        identity_id: null,
-        visitor_id: null,
-        correlation_id: null,
-    });
+    const createBaseEventHelper = async () => {
+        const baseEvent = {
+            event_id: generateEventId(),
+            timestamp_ms: getCurrentTimestamp(),
+            release_id: getReleaseId(),
+            customuser_id: null,
+            account_id: null,
+            identity_id: null,
+            visitor_id: null,
+            correlation_id: null,
+        };
+        // Enrich with user context if available
+        try {
+            const userContext = await getUserContext;
+            return { ...baseEvent, ...userContext };
+        }
+        catch {
+            // Return base event if user context fails
+            return baseEvent;
+        }
+    };
     // Register lifecycle event handlers if enabled
     if (config.enabled) {
         // Emit startup event
         const startupEvent = buildApplicationLifecycleEvent({
             lifecycle_event_type: "startup",
         });
-        silentEmit(transport, APPLICATION_LIFECYCLE_EVENT_SUBJECT, startupEvent);
+        silentEmit(transport, APPLICATION_LIFECYCLE_EVENT_SUBJECT, startupEvent, getUserContext);
         // Register process event handlers (Node.js only)
         if (typeof process?.on === "function") {
             // Handle normal process exit
@@ -141,11 +185,11 @@ export const eventEmissionPlugin = ({ context }) => {
                     is_graceful_shutdown: code === 0,
                     shutdown_duration_ms: shutdownDuration,
                 });
-                silentEmit(transport, APPLICATION_LIFECYCLE_EVENT_SUBJECT, exitEvent);
+                silentEmit(transport, APPLICATION_LIFECYCLE_EVENT_SUBJECT, exitEvent, getUserContext);
             });
             // Handle uncaught exceptions
             process.on("uncaughtException", async (error) => {
-                const errorEvent = buildErrorEventWithContext({
+                let errorEvent = buildErrorEventWithContext({
                     error_message: error.message || "Unknown error",
                     error_type: "UncaughtException",
                     error_stack_trace: error.stack || null,
@@ -154,11 +198,19 @@ export const eventEmissionPlugin = ({ context }) => {
                     is_recoverable: false,
                     execution_start_time: startupTime,
                 });
+                // Enrich with user context if available
+                try {
+                    const userContext = await getUserContext;
+                    errorEvent = { ...errorEvent, ...userContext };
+                }
+                catch {
+                    // Continue with original event if user context fails
+                }
                 // Wait up to 300ms for telemetry to send before allowing process to exit
                 try {
                     await Promise.race([
                         transport.emit(ERROR_OCCURRED_EVENT_SUBJECT, errorEvent),
-                        new Promise((resolve) => setTimeout(resolve, 300)),
+                        new Promise((resolve) => setTimeout(resolve, TELEMETRY_EMIT_TIMEOUT_MS)),
                     ]);
                 }
                 catch {
@@ -174,7 +226,7 @@ export const eventEmissionPlugin = ({ context }) => {
                         ? reason
                         : "Unhandled promise rejection";
                 const errorStack = reason instanceof Error ? reason.stack : null;
-                const errorEvent = buildErrorEventWithContext({
+                let errorEvent = buildErrorEventWithContext({
                     error_message: errorMessage,
                     error_type: "UnhandledRejection",
                     error_stack_trace: errorStack,
@@ -186,11 +238,19 @@ export const eventEmissionPlugin = ({ context }) => {
                         promise: String(promise),
                     },
                 });
+                // Enrich with user context if available
+                try {
+                    const userContext = await getUserContext;
+                    errorEvent = { ...errorEvent, ...userContext };
+                }
+                catch {
+                    // Continue with original event if user context fails
+                }
                 // Wait up to 300ms for telemetry to send
                 try {
                     await Promise.race([
                         transport.emit(ERROR_OCCURRED_EVENT_SUBJECT, errorEvent),
-                        new Promise((resolve) => setTimeout(resolve, 300)),
+                        new Promise((resolve) => setTimeout(resolve, TELEMETRY_EMIT_TIMEOUT_MS)),
                     ]);
                 }
                 catch {
@@ -201,17 +261,25 @@ export const eventEmissionPlugin = ({ context }) => {
             const handleSignal = async (signal) => {
                 shutdownStartTime = Date.now();
                 const uptime = Date.now() - startupTime;
-                const signalEvent = buildApplicationLifecycleEvent({
+                let signalEvent = buildApplicationLifecycleEvent({
                     lifecycle_event_type: "signal_termination",
                     signal_name: signal,
                     uptime_ms: uptime,
                     is_graceful_shutdown: true,
                 });
+                // Enrich with user context if available
+                try {
+                    const userContext = await getUserContext;
+                    signalEvent = { ...signalEvent, ...userContext };
+                }
+                catch {
+                    // Continue with original event if user context fails
+                }
                 // Wait up to 300ms for telemetry to send
                 try {
                     await Promise.race([
                         transport.emit(APPLICATION_LIFECYCLE_EVENT_SUBJECT, signalEvent),
-                        new Promise((resolve) => setTimeout(resolve, 300)),
+                        new Promise((resolve) => setTimeout(resolve, TELEMETRY_EMIT_TIMEOUT_MS)),
                     ]);
                 }
                 catch {
@@ -231,7 +299,7 @@ export const eventEmissionPlugin = ({ context }) => {
                 transport,
                 config,
                 emit: (subject, event) => {
-                    silentEmit(transport, subject, event);
+                    silentEmit(transport, subject, event, getUserContext);
                 },
                 createBaseEvent: createBaseEventHelper,
             },