@zapier/zapier-sdk 0.88.0 → 0.89.0

package/dist/{chunk-AVB4LBN5.cjs → chunk-UBI5FOL5.cjs}

@@ -173,12 +173,19 @@ function composeVoid(existing, added) {
   isolated.add(composed);
   return composed;
 }
+function composeAnnotators(existing, added) {
+  if (!existing) return added;
+  if (!added) return existing;
+  return (ctx) => ({ ...existing(ctx), ...added(ctx) });
+}
 function buildHooks(existing, added) {
   const result = {};
   const start2 = composeVoid(existing.onMethodStart, added.onMethodStart);
   if (start2) result.onMethodStart = start2;
   const end = composeVoid(existing.onMethodEnd, added.onMethodEnd);
   if (end) result.onMethodEnd = end;
+  const annotator = composeAnnotators(existing.annotator, added.annotator);
+  if (annotator) result.annotator = annotator;
   return result;
 }
 function createDeprecationLogger(tag) {
@@ -580,11 +587,14 @@ function generateCallId() {
   }
   return null;
 }
-function rootCallContext() {
+function rootCallContext({
+  callOrigin = "surface"
+} = {}) {
   return {
     callId: generateCallId(),
     depth: 0,
     annotations: {},
+    callOrigin,
     [CALL_CONTEXT_BRAND]: true
   };
 }
@@ -593,6 +603,7 @@ function childCallContext(parent) {
     callId: parent.callId,
     depth: parent.depth + 1,
     annotations: {},
+    callOrigin: parent.callOrigin,
     [CALL_CONTEXT_BRAND]: true
   };
 }
@@ -614,6 +625,28 @@ var INTERNAL_CALL = Symbol("kitcore.internalCall");
 function resolveCallContext(secondArg) {
   return isCallContext(secondArg) ? secondArg : rootCallContext();
 }
+var hookAnnotatorReentrancy = 0;
+function applyAnnotations({
+  context,
+  methodName,
+  input,
+  hookAnnotator,
+  methodAnnotator
+}) {
+  if (hookAnnotator && !isInsideObserver() && context.depth === 0 && context.callOrigin !== "internal" && hookAnnotatorReentrancy === 0) {
+    hookAnnotatorReentrancy++;
+    try {
+      Object.assign(context.annotations, hookAnnotator({ methodName, input }));
+    } catch {
+    } finally {
+      hookAnnotatorReentrancy--;
+    }
+  }
+  try {
+    Object.assign(context.annotations, methodAnnotator?.(input));
+  } catch {
+  }
+}
 function signalDeprecation(context, methodName, getDeprecation) {
   if (isInsideObserver()) return;
   const deprecation = getDeprecation?.();
@@ -639,7 +672,7 @@ function normalizeError(error, adaptError) {
   );
 }
 function createFunction(coreFn, options) {
-  const { sdk, schema, name, getDeprecation } = options;
+  const { sdk, schema, name, annotator, getDeprecation } = options;
   const functionName = name || coreFn.name;
   const namedFunctions = {
     [functionName]: async function(callOptions) {
@@ -653,14 +686,26 @@ function createFunction(coreFn, options) {
         const normalizedOptions = callOptions ?? {};
         const args = [normalizedOptions];
         const depth = Math.max(context.depth, getCurrentDepth());
-        const hooks = isInsideObserver() ? void 0 : sdk.context.hooks;
+        const insideObserver = isInsideObserver();
+        const hooks = insideObserver ? void 0 : sdk.context.hooks;
         const adaptError = resolveCoreOptions(sdk.context)?.adaptError;
-        hooks?.onMethodStart?.({
+        applyAnnotations({
+          context,
+          methodName: functionName,
+          input: normalizedOptions,
+          hookAnnotator: hooks?.annotator,
+          methodAnnotator: annotator
+        });
+        const hookBase = {
           methodName: functionName,
           args,
           isPaginated: false,
-          depth
-        });
+          depth,
+          callId: context.callId,
+          callOrigin: context.callOrigin,
+          annotations: context.annotations
+        };
+        hooks?.onMethodStart?.({ ...hookBase });
         try {
           let result;
           if (schema) {
@@ -682,20 +727,14 @@ function createFunction(coreFn, options) {
             result = await coreFn(normalizedOptions, context);
           }
           hooks?.onMethodEnd?.({
-            methodName: functionName,
-            args,
-            isPaginated: false,
-            depth,
+            ...hookBase,
             durationMs: Date.now() - startTime
           });
           return result;
         } catch (error) {
           const normalizedError = normalizeError(error, adaptError);
           hooks?.onMethodEnd?.({
-            methodName: functionName,
-            args,
-            isPaginated: false,
-            depth,
+            ...hookBase,
             durationMs: Date.now() - startTime,
             error: normalizedError
           });
@@ -707,7 +746,7 @@ function createFunction(coreFn, options) {
   return namedFunctions[functionName];
 }
 function createRawFunction(coreFn, options) {
-  const { sdk, name, schema, positional, getDeprecation } = options;
+  const { sdk, name, schema, positional, annotator, getDeprecation } = options;
   return function(rawInput) {
     const internal = arguments[1];
     const context = resolveCallContext(internal);
@@ -717,23 +756,32 @@ function createRawFunction(coreFn, options) {
     return runInMethodScope(() => {
       const startTime = Date.now();
       const depth = Math.max(context.depth, getCurrentDepth());
-      const hooks = isInsideObserver() ? void 0 : sdk.context.hooks;
+      const insideObserver = isInsideObserver();
+      const hooks = insideObserver ? void 0 : sdk.context.hooks;
       const adaptError = resolveCoreOptions(sdk.context)?.adaptError;
       const input = schema ? rawInput ?? {} : rawInput;
+      applyAnnotations({
+        context,
+        methodName: name,
+        input,
+        hookAnnotator: hooks?.annotator,
+        methodAnnotator: annotator
+      });
       const record = input;
       const args = positional ? positional.filter((key) => record?.[key] !== void 0).map((key) => record?.[key]) : [input];
-      hooks?.onMethodStart?.({
+      const hookBase = {
         methodName: name,
         args,
         isPaginated: false,
-        depth
-      });
+        depth,
+        callId: context.callId,
+        callOrigin: context.callOrigin,
+        annotations: context.annotations
+      };
+      hooks?.onMethodStart?.({ ...hookBase });
       const fireEnd = (error) => {
         hooks?.onMethodEnd?.({
-          methodName: name,
-          args,
-          isPaginated: false,
-          depth,
+          ...hookBase,
           durationMs: Date.now() - startTime,
           ...error ? { error } : {}
         });
@@ -800,7 +848,15 @@ function createPageFunction(coreFn, {
   return namedFunctions[functionName];
 }
 function createPaginatedFunction(coreFn, options) {
-  const { sdk, schema, name, defaultPageSize, adaptPage, getDeprecation } = options;
+  const {
+    sdk,
+    schema,
+    name,
+    defaultPageSize,
+    adaptPage,
+    annotator,
+    getDeprecation
+  } = options;
   const pageFunction = createPageFunction(coreFn, { sdk, adaptPage });
   const functionName = name || coreFn.name;
   const namedFunctions = {
@@ -815,14 +871,26 @@ function createPaginatedFunction(coreFn, options) {
         const normalizedOptions = callOptions ?? {};
         const args = [normalizedOptions];
         const depth = Math.max(context.depth, getCurrentDepth());
-        const hooks = isInsideObserver() ? void 0 : sdk.context.hooks;
+        const insideObserver = isInsideObserver();
+        const hooks = insideObserver ? void 0 : sdk.context.hooks;
         const adaptError = resolveCoreOptions(sdk.context)?.adaptError;
-        hooks?.onMethodStart?.({
+        applyAnnotations({
+          context,
+          methodName: functionName,
+          input: normalizedOptions,
+          hookAnnotator: hooks?.annotator,
+          methodAnnotator: annotator
+        });
+        const hookBase = {
           methodName: functionName,
           args,
           isPaginated: true,
-          depth
-        });
+          depth,
+          callId: context.callId,
+          callOrigin: context.callOrigin,
+          annotations: context.annotations
+        };
+        hooks?.onMethodStart?.({ ...hookBase });
         try {
           const validatedOptions = {
             ...normalizedOptions,
@@ -848,19 +916,13 @@ function createPaginatedFunction(coreFn, options) {
             firstPagePromise.then(
               () => {
                 hooks.onMethodEnd({
-                  methodName: functionName,
-                  args,
-                  isPaginated: true,
-                  depth,
+                  ...hookBase,
                   durationMs: Date.now() - startTime
                 });
               },
               (error) => {
                 hooks.onMethodEnd({
-                  methodName: functionName,
-                  args,
-                  isPaginated: true,
-                  depth,
+                  ...hookBase,
                   durationMs: Date.now() - startTime,
                   error: error instanceof Error ? error : new Error(String(error))
                 });
@@ -899,10 +961,7 @@ function createPaginatedFunction(coreFn, options) {
         } catch (error) {
           const normalizedError = normalizeError(error, adaptError);
           hooks?.onMethodEnd?.({
-            methodName: functionName,
-            args,
-            isPaginated: true,
-            depth,
+            ...hookBase,
             durationMs: Date.now() - startTime,
             error: normalizedError
           });
@@ -1318,6 +1377,7 @@ function defineMethod(config) {
     meta: collectLeafMeta(config),
     resolvers: config.resolvers,
     formatter: config.formatter,
+    annotator: config.annotator,
     output: config.output,
     positional: config.positional,
     setup: config.setup,
@@ -1477,7 +1537,8 @@ function defineHook(config) {
     setup: config.setup,
     dispose: config.dispose,
     wrap: config.wrap,
-    observe: config.observe
+    observe: config.observe,
+    annotator: config.annotator
   };
 }
 function declarePlugin(config) {
@@ -1903,7 +1964,14 @@ function collectPlugins(root, materialized = /* @__PURE__ */ new Set(), configur
   }
   return byId;
 }
-function bindValue(target, key, entry, callType = "surface", ctx) {
+function bindValue({
+  target,
+  key,
+  entry,
+  bindMode = "surface",
+  ctx,
+  frameworkOrigin = false
+}) {
   if (entry.pluginType === "property" && entry.getValue) {
     Object.defineProperty(target, key, {
       get: entry.getValue,
@@ -1911,7 +1979,7 @@ function bindValue(target, key, entry, callType = "surface", ctx) {
       configurable: true
     });
   } else {
-    const value = callType === "internal" && entry.pluginType === "method" ? entry.bindInternal?.(ctx) ?? entry.internalValue ?? entry.value : entry.value;
+    const value = bindMode === "internal" && entry.pluginType === "method" ? entry.bindInternal?.({ ctx, frameworkOrigin }) ?? entry.internalValue ?? entry.value : entry.value;
     Object.defineProperty(target, key, {
       value,
       writable: true,
@@ -1929,7 +1997,12 @@ function buildSurface(context, ...maps) {
   sdk[CONTEXT] = context;
   return sdk;
 }
-function buildImports(plugins, importBindings, ctx) {
+function buildImports({
+  plugins,
+  importBindings,
+  ctx,
+  frameworkOrigin = false
+}) {
   const imports = {};
   for (const { binding, id, optional } of importBindings) {
     const entry = plugins[id];
@@ -1942,10 +2015,31 @@ function buildImports(plugins, importBindings, ctx) {
       });
       continue;
     }
-    bindValue(imports, binding, entry, "internal", ctx);
+    bindValue({
+      target: imports,
+      key: binding,
+      entry,
+      bindMode: "internal",
+      ctx,
+      frameworkOrigin
+    });
   }
   return imports;
 }
+function bindInternalTwin({
+  ctx,
+  frameworkOrigin,
+  withContext,
+  internalValue
+}) {
+  if (ctx) {
+    return (...args) => withContext(childCallContext(ctx))(...args);
+  }
+  if (frameworkOrigin) {
+    return (...args) => withContext(rootCallContext({ callOrigin: "internal" }))(...args);
+  }
+  return internalValue;
+}
 function mirrorLegacyRootKeys(context, rootKeys, meta) {
   const exports = {};
   for (const [name, value] of Object.entries(rootKeys)) {
@@ -2009,7 +2103,11 @@ function bindResolver(resolver, plugins) {
     case "info":
       return { type: "info", text: resolver.text };
     case "object": {
-      const imports = buildImports(plugins, resolver.importBindings);
+      const imports = buildImports({
+        plugins,
+        importBindings: resolver.importBindings,
+        frameworkOrigin: true
+      });
       const bound = {
         type: "object",
         requireParameters: resolver.requireParameters
@@ -2050,7 +2148,11 @@ function bindResolver(resolver, plugins) {
       return bound;
     }
     case "dynamic": {
-      const imports = buildImports(plugins, resolver.importBindings);
+      const imports = buildImports({
+        plugins,
+        importBindings: resolver.importBindings,
+        frameworkOrigin: true
+      });
       const {
         getContext: getContext2,
         listItems,
@@ -2105,7 +2207,11 @@ function bindDefinitions(definitions, plugins) {
   return out;
 }
 function bindFormatter(formatter, plugins) {
-  const imports = buildImports(plugins, formatter.importBindings);
+  const imports = buildImports({
+    plugins,
+    importBindings: formatter.importBindings,
+    frameworkOrigin: true
+  });
   const bound = { format: formatter.format };
   const { getContext: getContext2 } = formatter;
   if (getContext2)
@@ -2192,17 +2298,32 @@ function buildMethodEntries(descriptors, context, states) {
       // Replaced below; never called.
       value: () => void 0
     };
-    const callRun = (input, ctx) => descriptor.run({
-      imports: buildImports(plugins, descriptor.importBindings, ctx),
-      state: states.get(id),
-      input
-    });
+    const callRun = (input, ctx) => {
+      const callContext = ctx ?? rootCallContext();
+      return descriptor.run({
+        imports: buildImports({
+          plugins,
+          importBindings: descriptor.importBindings,
+          ctx: callContext
+        }),
+        state: states.get(id),
+        input,
+        callContext,
+        annotate: (metadata) => {
+          Object.assign(callContext.annotations, metadata);
+        }
+      });
+    };
     const fold = (coreFn) => (input, ctx) => {
       let next = (i) => coreFn(i, ctx);
       for (const wrap of entry.chain) {
         const inner = next;
         next = (i) => wrap.run({
-          imports: buildImports(plugins, wrap.owner.importBindings, ctx),
+          imports: buildImports({
+            plugins,
+            importBindings: wrap.owner.importBindings,
+            ctx
+          }),
           next: inner,
           input: i,
           // Overwritten by the chain item's own closure with the owning
@@ -2213,6 +2334,8 @@ function buildMethodEntries(descriptors, context, states) {
       return next(input);
     };
     const sdk = { context };
+    const methodAnnotator = descriptor.annotator;
+    const boundAnnotator = methodAnnotator ? (input) => methodAnnotator({ input }) : void 0;
     if (out.type === "list") {
       entry.value = createPaginatedFunction(
         fold(callRun),
@@ -2222,6 +2345,7 @@ function buildMethodEntries(descriptors, context, states) {
           name: descriptor.name,
           defaultPageSize: out.defaultPageSize,
           adaptPage: out.adaptPage,
+          annotator: boundAnnotator,
           getDeprecation: () => entry.meta?.deprecation
         }
       );
@@ -2233,6 +2357,7 @@ function buildMethodEntries(descriptors, context, states) {
           sdk,
           schema: descriptor.inputSchema,
           name: descriptor.name,
+          annotator: boundAnnotator,
           getDeprecation: () => entry.meta?.deprecation
         }
       );
@@ -2244,6 +2369,7 @@ function buildMethodEntries(descriptors, context, states) {
           name: descriptor.name,
           schema: descriptor.skipInputValidation ? void 0 : descriptor.inputSchema,
           positional: descriptor.positional,
+          annotator: boundAnnotator,
           // The boundary reads the deprecation LIVE off the entry, so a
           // deprecation merged after build (defineMethodOverride, addPlugin)
           // fires too.
@@ -2264,12 +2390,22 @@ function buildMethodEntries(descriptors, context, states) {
       const internalValue = (...args) => canonicalValue(pack(args), INTERNAL_CALL);
       entry.value = (...args) => canonicalValue(pack(args));
       entry.internalValue = internalValue;
-      entry.bindInternal = (ctx) => ctx ? (...args) => canonicalValue(pack(args), childCallContext(ctx)) : internalValue;
+      entry.bindInternal = (opts) => bindInternalTwin({
+        ...opts,
+        withContext: (context2) => {
+          return (...args) => canonicalValue(pack(args), context2);
+        },
+        internalValue
+      });
       entry.positional = names;
     } else {
       const internalValue = (input) => canonicalValue(input, INTERNAL_CALL);
       entry.internalValue = internalValue;
-      entry.bindInternal = (ctx) => ctx ? (input) => canonicalValue(input, childCallContext(ctx)) : internalValue;
+      entry.bindInternal = (opts) => bindInternalTwin({
+        ...opts,
+        withContext: (context2) => (input) => canonicalValue(input, context2),
+        internalValue
+      });
     }
     plugins[id] = entry;
   }
@@ -2295,8 +2431,14 @@ function buildEagerArtifacts(descriptors, context, states) {
       if (!dispose) return;
       context.disposers?.push({
         id,
+        // Teardown is framework-internal: an SDK method a `dispose` calls runs
+        // on an internal-origin root (dropped from telemetry).
         dispose: (input) => dispose({
-          imports: buildImports(plugins, descriptor.importBindings),
+          imports: buildImports({
+            plugins,
+            importBindings: descriptor.importBindings,
+            frameworkOrigin: true
+          }),
           state: states.get(id),
           input
         })
@@ -2306,7 +2448,10 @@ function buildEagerArtifacts(descriptors, context, states) {
       states.set(
         id,
         descriptor.setup ? descriptor.setup({
-          imports: buildImports(plugins, descriptor.importBindings)
+          imports: buildImports({
+            plugins,
+            importBindings: descriptor.importBindings
+          })
         }) : void 0
       );
       recordDisposer();
@@ -2318,14 +2463,20 @@ function buildEagerArtifacts(descriptors, context, states) {
       states.set(
         id,
         descriptor.setup ? descriptor.setup({
-          imports: buildImports(plugins, descriptor.importBindings)
+          imports: buildImports({
+            plugins,
+            importBindings: descriptor.importBindings
+          })
         }) : void 0
       );
     } else {
       states.set(
         id,
         descriptor.setup ? descriptor.setup({
-          imports: buildImports(plugins, descriptor.importBindings)
+          imports: buildImports({
+            plugins,
+            importBindings: descriptor.importBindings
+          })
         }) : void 0
       );
       if (descriptor.privileged) {
@@ -2343,7 +2494,7 @@ function buildEagerArtifacts(descriptors, context, states) {
           pluginType: "property",
           name: descriptor.name,
           getValue: () => get({
-            imports: buildImports(plugins, importBindings),
+            imports: buildImports({ plugins, importBindings }),
             state: states.get(id)
           }),
           meta: descriptor.meta,
@@ -2379,7 +2530,7 @@ function resolvePlugin(sdk, ref) {
     return entry.getValue();
   }
   if (entry.pluginType === "method" && entry.internalValue) {
-    return entry.internalValue;
+    return entry.bindInternal?.({ frameworkOrigin: true }) ?? entry.internalValue;
   }
   return entry.value;
 }
@@ -2414,7 +2565,7 @@ function resolveAggregates(descriptors, context) {
     if (descriptor.pluginType !== "aggregate") continue;
     const exports = {};
     for (const [binding, child] of Object.entries(descriptor.exports)) {
-      bindValue(exports, binding, plugins[child.id]);
+      bindValue({ target: exports, key: binding, entry: plugins[child.id] });
     }
     plugins[id] = { pluginType: "aggregate", name: descriptor.name, exports };
   }
@@ -2457,23 +2608,39 @@ function assembleHooks(descriptors, context, states) {
   const plugins = context.plugins;
   for (const id of topoOrder(descriptors)) {
     const descriptor = descriptors.get(id);
-    if (!descriptor || descriptor.pluginType !== "hook" || !descriptor.observe) {
+    if (!descriptor || descriptor.pluginType !== "hook" || !descriptor.observe && !descriptor.annotator) {
       continue;
     }
-    const { observe } = descriptor;
-    const imports = buildImports(plugins, descriptor.importBindings);
+    const { observe, annotator } = descriptor;
     const state = states.get(id);
     const contributed = {};
-    if (observe.onMethodStart) {
-      const onStart = observe.onMethodStart;
-      contributed.onMethodStart = (input) => {
-        runIsolatedObserver(() => onStart({ imports, input, state }));
-      };
+    if (observe?.onMethodStart || observe?.onMethodEnd) {
+      const imports = buildImports({
+        plugins,
+        importBindings: descriptor.importBindings,
+        frameworkOrigin: true
+      });
+      if (observe.onMethodStart) {
+        const onStart = observe.onMethodStart;
+        contributed.onMethodStart = (input) => {
+          runIsolatedObserver(() => onStart({ imports, input, state }));
+        };
+      }
+      if (observe.onMethodEnd) {
+        const onEnd = observe.onMethodEnd;
+        contributed.onMethodEnd = (input) => {
+          runIsolatedObserver(() => onEnd({ imports, input, state }));
+        };
+      }
     }
-    if (observe.onMethodEnd) {
-      const onEnd = observe.onMethodEnd;
-      contributed.onMethodEnd = (input) => {
-        runIsolatedObserver(() => onEnd({ imports, input, state }));
+    if (annotator) {
+      const annotatorFn = annotator;
+      contributed.annotator = ({ methodName, input }) => {
+        try {
+          return annotatorFn({ methodName, input, state });
+        } catch {
+          return {};
+        }
       };
     }
     context.hooks = buildHooks(context.hooks, contributed);
@@ -2507,7 +2674,11 @@ function createSdk(root, options) {
       pluginSurface = plugins2[plugin.id].exports;
     } else {
       pluginSurface = {};
-      bindValue(pluginSurface, plugin.name, plugins2[plugin.id]);
+      bindValue({
+        target: pluginSurface,
+        key: plugin.name,
+        entry: plugins2[plugin.id]
+      });
     }
     for (const key of Object.keys(legacyExports)) context.surface[key] = key;
     if (plugin.pluginType === "aggregate") {
@@ -2524,7 +2695,7 @@ function createSdk(root, options) {
   if (root.pluginType === "method" || root.pluginType === "property") {
     context.surface[root.name] = root.id;
     const sdk = buildSurface(context);
-    bindValue(sdk, root.name, plugins[root.id]);
+    bindValue({ target: sdk, key: root.name, entry: plugins[root.id] });
     return sdk;
   }
   if (root.pluginType === "aggregate")
@@ -2556,7 +2727,7 @@ function addModelPlugin(sdk, plugin, options = {}) {
       context.surface[binding] = child.id;
     }
   } else {
-    bindValue(sdk, plugin.name, entry);
+    bindValue({ target: sdk, key: plugin.name, entry });
     context.surface[plugin.name] = plugin.id;
   }
 }
@@ -5828,7 +5999,7 @@ function parseDeprecationDate(value) {
 }
 
 // src/sdk-version.ts
-var SDK_VERSION = (typeof process !== "undefined" && process.env ? "0.88.0" : void 0) || "unknown";
+var SDK_VERSION = (typeof process !== "undefined" && process.env ? "0.89.0" : void 0) || "unknown";
 
 // src/utils/open-url.ts
 var nodePrefix = "node:";
@@ -9086,6 +9257,29 @@ var workflowVersionIdResolver = defineResolver({
   })
 });
 
+// src/resolvers/workflowDraftId.ts
+var listWorkflowDraftsRef = declareMethod({ id: "listWorkflowDrafts" });
+var workflowDraftIdResolver = defineResolver({
+  imports: [listWorkflowDraftsRef],
+  requireParameters: ["workflow"],
+  listItems: ({
+    imports,
+    input,
+    cursor
+  }) => imports.listWorkflowDrafts({
+    workflow: input.workflow,
+    cursor
+  }),
+  prompt: ({ items }) => ({
+    type: "list",
+    message: "Select a workflow draft:",
+    choices: items.map((d) => ({
+      label: `${d.slug} \u2014 last edited ${d.last_edited_at ?? "never"}`,
+      value: d.id
+    }))
+  })
+});
+
 // src/resolvers/workflowRunId.ts
 var listWorkflowRunsRef = declareMethod({ id: "listWorkflowRuns" });
 var workflowRunIdResolver = defineResolver({
@@ -9758,18 +9952,6 @@ var tableSortResolver = defineResolver({
   }
 });
 
-// src/plugins/eventEmission/method-metadata.ts
-var SCOPE_KEY = "methodMetadata";
-function setMethodMetadata(metadata) {
-  const scope2 = getCurrentScope();
-  if (!scope2) return;
-  const existing = scope2[SCOPE_KEY];
-  scope2[SCOPE_KEY] = { ...existing, ...metadata };
-}
-function getMethodMetadata() {
-  return getCurrentScope()?.[SCOPE_KEY];
-}
-
 // src/plugins/listActions/index.ts
 var listActionsPlugin = defineMethod({
   name: "listActions",
@@ -9787,7 +9969,7 @@ var listActionsPlugin = defineMethod({
   // of listing every action. `getAction` (where `actionType` is required) keeps
   // the resolver.
   resolvers: { app: appKeyResolver },
-  run: async ({ imports, input }) => {
+  run: async ({ imports, input, annotate }) => {
     const api = imports.api;
     const getVersionedImplementationId = imports.manifest.getVersionedImplementationId;
     const appKey = "app" in input ? input.app : input.appKey;
@@ -9798,10 +9980,7 @@ var listActionsPlugin = defineMethod({
         { configType: "current_implementation_id" }
       );
     }
-    setMethodMetadata({
-      selectedApi,
-      operationType: input.actionType ?? null
-    });
+    annotate({ selectedApi });
     const data = await api.get(
       "/zapier/api/v4/implementations/",
       {
@@ -9856,10 +10035,6 @@ var getActionPlugin = defineMethod({
     const appKey = "app" in input ? input.app : input.appKey;
     const actionKey = "action" in input ? input.action : input.actionKey;
     const { actionType } = input;
-    setMethodMetadata({
-      operationType: actionType,
-      operationKey: actionKey
-    });
     for await (const action of imports.listActions({ app: appKey }).items()) {
       if ((action.key === actionKey || action.id === actionKey) && action.action_type === actionType) {
         return { data: action };
@@ -9952,9 +10127,10 @@ var runActionPlugin = defineMethod({
     inputs: inputsResolver
   },
   // A per-SDK-instance TTL cache of resolved (selectedApi, actionId), built once
-  // in setup so it persists across calls. Reads getVersionedImplementationId
-  // (`imports.manifest`) and getAction (an import).
-  setup: ({ imports }) => {
+  // in setup so it persists across calls. The imports it resolves through
+  // (`manifest.getVersionedImplementationId`, `getAction`) are threaded in per
+  // call from `run`, not captured here.
+  setup: () => {
     const cache = /* @__PURE__ */ new Map();
     function evictIfNeeded() {
       if (cache.size < CONTEXT_CACHE_MAX_SIZE) return;
@@ -9974,7 +10150,7 @@ var runActionPlugin = defineMethod({
       if (!evictedAny && oldestKey) cache.delete(oldestKey);
     }
     async function resolveRunActionContext(options) {
-      const { appKey, actionKey, actionType } = options;
+      const { imports, appKey, actionKey, actionType } = options;
       const getVersionedImplementationId = imports.manifest.getVersionedImplementationId;
       const selectedApi = await getVersionedImplementationId(appKey);
       if (!selectedApi) {
@@ -10013,7 +10189,7 @@ var runActionPlugin = defineMethod({
     }
     return { getRunActionContext };
   },
-  run: async ({ imports, input, state }) => {
+  run: async ({ imports, input, state, annotate }) => {
     const api = imports.api;
     const resolveConnection = imports.connections.resolveConnection;
     const appKey = "app" in input ? input.app : input.appKey;
@@ -10034,15 +10210,12 @@ var runActionPlugin = defineMethod({
       resolveConnection
     });
     const { selectedApi, actionId } = await state.getRunActionContext({
+      imports,
       appKey,
       actionKey,
       actionType
     });
-    setMethodMetadata({
-      selectedApi,
-      operationType: actionType,
-      operationKey: actionKey
-    });
+    annotate({ selectedApi });
     const result = await executeAction({
       api,
       selectedApi,
@@ -10678,7 +10851,11 @@ var listActionInputFieldsPlugin = defineMethod({
     // metadata; the engine permits a resolver importing its host.
     inputs: inputsAllOptionalResolver
   },
-  run: async ({ imports, input }) => {
+  run: async ({
+    imports,
+    input,
+    annotate
+  }) => {
     const api = imports.api;
     const getVersionedImplementationId = imports.manifest.getVersionedImplementationId;
     const resolveConnection = imports.connections.resolveConnection;
@@ -10698,11 +10875,7 @@ var listActionInputFieldsPlugin = defineMethod({
         { configType: "current_implementation_id" }
       );
     }
-    setMethodMetadata({
-      selectedApi,
-      operationType: actionType,
-      operationKey: actionKey
-    });
+    annotate({ selectedApi });
     const { data: action } = await imports.getAction({
       app: appKey,
       actionType,
@@ -10813,7 +10986,11 @@ var listActionInputFieldChoicesPlugin = defineMethod({
     inputField: inputFieldKeyResolver,
     inputs: inputsAllOptionalResolver
   },
-  run: async ({ imports, input }) => {
+  run: async ({
+    imports,
+    input,
+    annotate
+  }) => {
     const api = imports.api;
     const getVersionedImplementationId = imports.manifest.getVersionedImplementationId;
     const resolveConnection = imports.connections.resolveConnection;
@@ -10842,11 +11019,7 @@ var listActionInputFieldChoicesPlugin = defineMethod({
         { configType: "current_implementation_id" }
       );
     }
-    setMethodMetadata({
-      selectedApi,
-      operationType: actionType,
-      operationKey: actionKey
-    });
+    annotate({ selectedApi });
     const { data: action } = await imports.getAction({
       app: appKey,
       actionType,
@@ -10975,7 +11148,8 @@ var getActionInputFieldsSchemaPlugin = defineMethod({
   },
   run: async ({
     imports,
-    input
+    input,
+    annotate
   }) => {
     const api = imports.api;
     const getVersionedImplementationId = imports.manifest.getVersionedImplementationId;
@@ -10996,11 +11170,7 @@ var getActionInputFieldsSchemaPlugin = defineMethod({
         { configType: "current_implementation_id" }
       );
     }
-    setMethodMetadata({
-      selectedApi,
-      operationType: actionType,
-      operationKey: actionKey
-    });
+    annotate({ selectedApi });
     const { data: action } = await imports.getAction({
       app: appKey,
       actionType,
@@ -11123,7 +11293,11 @@ var listConnectionsPlugin = defineMethod({
     adaptPage: adaptZapierPage,
     defaultPageSize: DEFAULT_PAGE_SIZE
   },
-  run: async ({ imports, input }) => {
+  run: async ({
+    imports,
+    input,
+    annotate
+  }) => {
     const resolveConnection = imports.connections.resolveConnection;
     const api = imports.api;
     const getVersionedImplementationId = imports.manifest.getVersionedImplementationId;
@@ -11138,7 +11312,7 @@ var listConnectionsPlugin = defineMethod({
     if (appKey) {
       const implementationId = await getVersionedImplementationId(appKey);
       if (implementationId) {
-        setMethodMetadata({ selectedApi: implementationId });
+        annotate({ selectedApi: implementationId });
         const [versionlessSelectedApi] = splitVersionedKey(implementationId);
         searchParams.app_key = versionlessSelectedApi;
       } else {
@@ -11654,12 +11828,12 @@ var getConnectionStartUrlPlugin = defineMethod({
   outputSchema: GetConnectionStartUrlItemSchema,
   output: "item",
   resolvers: { app: appKeyResolver },
-  run: async ({ imports, input }) => {
+  run: async ({ imports, input, annotate }) => {
     const api = imports.api;
     const getVersionedImplementationId = imports.manifest.getVersionedImplementationId;
     const versionedKey = await getVersionedImplementationId(input.app);
     const selectedApi = versionedKey ? versionedKey.split("@")[0] : input.app;
-    setMethodMetadata({ selectedApi });
+    annotate({ selectedApi });
     const response = await api.post(
       START_PATH,
       { selected_api: selectedApi },
@@ -11718,12 +11892,12 @@ var waitForNewConnectionPlugin = defineMethod({
   outputSchema: WaitForNewConnectionItemSchema,
   output: "item",
   resolvers: { app: appKeyResolver },
-  run: async ({ imports, input }) => {
+  run: async ({ imports, input, annotate }) => {
     const api = imports.api;
     const getVersionedImplementationId = imports.manifest.getVersionedImplementationId;
     const versionedKey = await getVersionedImplementationId(input.app);
     const appKey = versionedKey ? versionedKey.split("@")[0] : input.app;
-    setMethodMetadata({ selectedApi: appKey });
+    annotate({ selectedApi: appKey });
     try {
       const top = await api.poll(CONNECTIONS_PATH, {
         searchParams: {
@@ -11841,11 +12015,11 @@ var createConnectionPlugin = defineMethod({
       ]
     })
   }),
-  run: async ({ imports, input }) => {
+  run: async ({ imports, input, annotate }) => {
     const { data: start2 } = await imports.getConnectionStartUrl({
       app: input.app
     });
-    setMethodMetadata({ selectedApi: start2.app });
+    annotate({ selectedApi: start2.app });
     console.error(
       `
 Open this URL to complete the connection:
@@ -12100,6 +12274,10 @@ var triggerInboxItemFormatter = defineFormatter({
 
 // src/plugins/triggers/shared.ts
 var triggerCategories = ["trigger"];
+function deriveReadOperation() {
+  const annotations = { operationType: "read" };
+  return { ...annotations };
+}
 
 // src/plugins/triggers/utils.ts
 var UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
@@ -12145,6 +12323,7 @@ var createTriggerInboxPlugin = defineMethod({
   outputSchema: TriggerInboxItemSchema,
   output: "item",
   formatter: triggerInboxItemFormatter,
+  annotator: deriveReadOperation,
   // actionKeyResolver and inputsResolver depend on actionType, which is always
   // "read" for triggers. Pin it as a constant resolver so it's seeded into
   // resolvedParams without polluting the user-facing schema (where it would
@@ -12249,6 +12428,7 @@ var ensureTriggerInboxPlugin = defineMethod({
   outputSchema: TriggerInboxItemSchema,
   output: "item",
   formatter: triggerInboxItemFormatter,
+  annotator: deriveReadOperation,
   // actionKeyResolver and inputsResolver depend on actionType, which is always
   // "read" for triggers. Pin it as a constant resolver so it's seeded into
   // resolvedParams without polluting the user-facing schema.
@@ -13553,6 +13733,7 @@ var listTriggerInputFieldsPlugin = defineMethod({
   outputSchema: RootFieldItemSchema,
   output: { type: "list", defaultPageSize: DEFAULT_PAGE_SIZE },
   formatter: rootFieldItemFormatter,
+  annotator: deriveReadOperation,
   // actionKeyResolver and inputsAllOptionalResolver depend on actionType. Pin it
   // to "read" so they resolve correctly without the user setting it.
   resolvers: {
@@ -13599,6 +13780,7 @@ var listTriggerInputFieldChoicesPlugin = defineMethod({
   outputSchema: InputFieldChoiceItemSchema,
   output: { type: "list", defaultPageSize: DEFAULT_PAGE_SIZE },
   formatter: inputFieldChoiceItemFormatter,
+  annotator: deriveReadOperation,
   resolvers: {
     app: appKeyResolver,
     action: actionKeyResolver,
@@ -13642,6 +13824,7 @@ var getTriggerInputFieldsSchemaPlugin = defineMethod({
   // Passthrough: getActionInputFieldsSchema already returns `{ data }`, so
   // `output: "raw"` surfaces that envelope unchanged.
   output: "raw",
+  annotator: deriveReadOperation,
   resolvers: {
     app: appKeyResolver,
     action: actionKeyResolver,
@@ -14759,6 +14942,14 @@ function buildMethodCalledEvent(data, context = {}) {
 }
 
 // src/plugins/eventEmission/event-emission-hook.ts
+function readMethodMetadata(annotations) {
+  const readString = (value) => typeof value === "string" ? value : null;
+  return {
+    selectedApi: readString(annotations.selectedApi),
+    operationType: readString(annotations.operationType),
+    operationKey: readString(annotations.operationKey)
+  };
+}
 function computeArgumentCount(args) {
   if (args.length === 1) {
     const arg0 = args[0];
@@ -14769,9 +14960,18 @@ function computeArgumentCount(args) {
   return args.filter((a) => a !== void 0).length;
 }
 function makeMethodEndHook(emitMethodCalled) {
-  return ({ methodName, args, isPaginated, depth, durationMs, error }) => {
-    if (depth > 0) return;
-    const metadata = getMethodMetadata();
+  return ({
+    methodName,
+    args,
+    isPaginated,
+    depth,
+    callOrigin,
+    annotations,
+    durationMs,
+    error
+  }) => {
+    if (callOrigin === "internal" || depth > 0) return;
+    const metadata = readMethodMetadata(annotations);
     emitMethodCalled({
       method_name: methodName,
       execution_duration_ms: durationMs,
@@ -14780,13 +14980,34 @@ function makeMethodEndHook(emitMethodCalled) {
       error_type: error?.constructor.name ?? null,
       argument_count: computeArgumentCount(args),
       is_paginated: isPaginated,
-      selected_api: metadata?.selectedApi ?? null,
-      operation_type: metadata?.operationType ?? null,
-      operation_key: metadata?.operationKey ?? null
+      selected_api: metadata.selectedApi ?? null,
+      operation_type: metadata.operationType ?? null,
+      operation_key: metadata.operationKey ?? null
     });
   };
 }
 
+// src/plugins/eventEmission/annotator.ts
+function zapierAnnotate({ input }) {
+  const annotations = {};
+  if (typeof input === "object" && input !== null) {
+    const record = input;
+    if (typeof record.actionType === "string") {
+      annotations.operationType = record.actionType;
+    }
+    const operationKey = record.action ?? record.actionKey;
+    if (typeof operationKey === "string") {
+      annotations.operationKey = operationKey;
+    }
+  }
+  return { ...annotations };
+}
+var operationAnnotatorPlugin = defineHook({
+  namespace: "zapier",
+  name: "operationAnnotator",
+  annotator: ({ input }) => zapierAnnotate({ input })
+});
+
 // src/plugins/eventEmission/index.ts
 var TELEMETRY_EMIT_TIMEOUT_MILLISECONDS = 300;
 var registeredListeners = {};
@@ -15187,7 +15408,8 @@ var zapierSdkPlugin = definePlugin({
     connectionsPlugin,
     capabilitiesPlugin,
     eventEmissionPlugin,
-    eventEmissionHookPlugin
+    eventEmissionHookPlugin,
+    operationAnnotatorPlugin
   ],
   exports: [
     // The registry reporter: previously synthesized by the legacy merge,
@@ -15669,6 +15891,7 @@ exports.manifestPlugin = manifestPlugin;
 exports.manifestPluginRef = manifestPluginRef;
 exports.omitExports = omitExports;
 exports.openEnum = openEnum;
+exports.operationAnnotatorPlugin = operationAnnotatorPlugin;
 exports.parseConcurrencyEnvVar = parseConcurrencyEnvVar;
 exports.readManifestFromFile = readManifestFromFile;
 exports.registryPlugin = registryPlugin;
@@ -15702,6 +15925,7 @@ exports.toTitleCase = toTitleCase;
 exports.triggerInboxResolver = triggerInboxResolver;
 exports.triggerMessagesResolver = triggerMessagesResolver;
 exports.updateTableRecordsPlugin = updateTableRecordsPlugin;
+exports.workflowDraftIdResolver = workflowDraftIdResolver;
 exports.workflowIdResolver = workflowIdResolver;
 exports.workflowRunIdResolver = workflowRunIdResolver;
 exports.workflowVersionIdResolver = workflowVersionIdResolver;