@zapier/zapier-sdk 0.97.1 → 0.98.1

package/dist/{chunk-X7NGRS4I.mjs → chunk-CHT6AJG3.mjs}

@@ -66,6 +66,13 @@ function getNegatable(schema) {
 function openEnum(values, description) {
   return z.union([z.enum(values), z.string()]).describe(description);
 }
+var STABILITY_LEVELS = ["stable", "beta", "experimental"];
+function normalizeStability(meta) {
+  if (meta.stability !== void 0) {
+    return STABILITY_LEVELS.includes(meta.stability) ? meta.stability : "experimental";
+  }
+  return meta.experimental ? "experimental" : "stable";
+}
 function resolveCategoryDefinition(ref) {
   const def = typeof ref === "string" ? { key: ref } : ref;
   const title = def.title ?? toTitleCase(def.key);
@@ -109,6 +116,7 @@ function buildRegistry({
     return typeof rootProperty === "object" && rootProperty !== null;
   }).map((key) => {
     const m = meta[key];
+    const stability = normalizeStability(m);
     return {
       name: key,
       description: m.description,
@@ -124,7 +132,11 @@ function buildRegistry({
       ),
       resolvers: resolvers?.[key],
       formatter: formatters?.[key],
-      experimental: m.experimental,
+      stability,
+      // Deprecated derived read, literal by name: only the experimental
+      // tier reads true. Beta reads false — the "not stable" warning duty
+      // lives in `stability` and the runtime notice, not this boolean.
+      experimental: stability === "experimental",
       packages: m.packages,
       confirm: m.confirm ?? (m.type === "delete" ? "delete" : void 0),
       deprecation: m.deprecation,
@@ -209,6 +221,20 @@ function createDeprecationLogger(tag) {
   };
 }
 var { logDeprecation} = createDeprecationLogger("core");
+function createStabilityNoticeLogger(tag) {
+  const loggedNotices = /* @__PURE__ */ new Set();
+  return {
+    logStabilityNotice(message) {
+      if (loggedNotices.has(message)) return;
+      loggedNotices.add(message);
+      console.warn(`[${tag}] ${message}`);
+    },
+    resetStabilityNotices() {
+      loggedNotices.clear();
+    }
+  };
+}
+var { logStabilityNotice} = createStabilityNoticeLogger("core");
 var CORE_ERROR_SYMBOL = Symbol.for("kitcore.error");
 var CoreErrorCode = {
   Validation: "VALIDATION_ERROR",
@@ -620,6 +646,19 @@ function defaultLogDeprecation({
 }) {
   logDeprecation(`${methodName}() is deprecated. ${deprecation.message}`);
 }
+var STABILITY_NOTICE_DETAILS = {
+  beta: "Its API shape is settled, but it is not yet covered by stable-tier guarantees.",
+  experimental: "It may change shape or disappear without notice."
+};
+function defaultLogStabilityNotice({
+  methodName,
+  stability
+}) {
+  if (stability === "stable") return;
+  logStabilityNotice(
+    `${methodName}() is a ${stability} API. ${STABILITY_NOTICE_DETAILS[stability]}`
+  );
+}
 var CORE_OPTIONS_ID = "kitcore/coreOptions";
 function resolveCoreOptions(context) {
   const entry = context.plugins?.[CORE_OPTIONS_ID];
@@ -666,6 +705,18 @@ function signalDeprecation(context, methodName, getDeprecation) {
   const handler = resolveCoreOptions(context)?.logDeprecation ?? defaultLogDeprecation;
   runIsolatedObserver(() => handler(warning));
 }
+function signalStability(context, methodName, getStability) {
+  if (isInsideObserver()) return;
+  const stability = getStability?.();
+  if (!stability || stability === "stable") return;
+  const notice = {
+    type: "stability",
+    methodName,
+    stability
+  };
+  const handler = resolveCoreOptions(context)?.logStabilityNotice ?? defaultLogStabilityNotice;
+  runIsolatedObserver(() => handler(notice));
+}
 function normalizeError(error, adaptError) {
   if (error instanceof Error) return error;
   const message = typeof error === "object" && error !== null && "message" in error && typeof error.message === "string" ? error.message : String(error);
@@ -679,7 +730,7 @@ function normalizeError(error, adaptError) {
   );
 }
 function createFunction(coreFn, options) {
-  const { sdk, schema, name, annotator, getDeprecation } = options;
+  const { sdk, schema, name, annotator, getDeprecation, getStability } = options;
   const functionName = name || coreFn.name;
   const namedFunctions = {
     [functionName]: async function(callOptions) {
@@ -687,6 +738,7 @@ function createFunction(coreFn, options) {
       const context = resolveCallContext(internal);
       if (!isCallContext(internal) && internal !== INTERNAL_CALL) {
         signalDeprecation(sdk.context, functionName, getDeprecation);
+        signalStability(sdk.context, functionName, getStability);
       }
       return runInMethodScope(async () => {
         const startTime = Date.now();
@@ -753,12 +805,21 @@ function createFunction(coreFn, options) {
   return namedFunctions[functionName];
 }
 function createRawFunction(coreFn, options) {
-  const { sdk, name, schema, positional, annotator, getDeprecation } = options;
+  const {
+    sdk,
+    name,
+    schema,
+    positional,
+    annotator,
+    getDeprecation,
+    getStability
+  } = options;
   return function(rawInput) {
     const internal = arguments[1];
     const context = resolveCallContext(internal);
     if (!isCallContext(internal) && internal !== INTERNAL_CALL) {
       signalDeprecation(sdk.context, name, getDeprecation);
+      signalStability(sdk.context, name, getStability);
     }
     return runInMethodScope(() => {
       const startTime = Date.now();
@@ -864,7 +925,8 @@ function createPaginatedFunction(coreFn, options) {
     adaptPage,
     annotator,
     finalizePage,
-    getDeprecation
+    getDeprecation,
+    getStability
   } = options;
   const pageFunction = createPageFunction(coreFn, {
     sdk,
@@ -878,6 +940,7 @@ function createPaginatedFunction(coreFn, options) {
       const context = resolveCallContext(internal);
       if (!isCallContext(internal) && internal !== INTERNAL_CALL) {
         signalDeprecation(sdk.context, functionName, getDeprecation);
+        signalStability(sdk.context, functionName, getStability);
       }
       return runInMethodScope(() => {
         const startTime = Date.now();
@@ -1316,6 +1379,7 @@ var LEAF_META_KEYS = [
   "returnType",
   "outputSchema",
   "packages",
+  "stability",
   "experimental",
   "confirm",
   "deprecation",
@@ -2153,8 +2217,9 @@ function bindValue({
   frameworkOrigin = false
 }) {
   if (entry.pluginType === "property" && entry.getValue) {
+    const getValue = entry.getValue;
     Object.defineProperty(target, key, {
-      get: entry.getValue,
+      get: ctx ? () => getValue(ctx) : getValue,
       enumerable: true,
       configurable: true
     });
@@ -2541,7 +2606,8 @@ function buildMethodEntries(descriptors, context, states) {
           // (item mode's sibling); dropped paths surface as `[].x` in the page's
           // `meta`, unioned across items.
           finalizePage: (page) => applyListOutputPolicy(page, outputPolicy()),
-          getDeprecation: () => entry.meta?.deprecation
+          getDeprecation: () => entry.meta?.deprecation,
+          getStability: () => entry.meta ? normalizeStability(entry.meta) : void 0
         }
       );
     } else if (out.type === "item") {
@@ -2553,7 +2619,8 @@ function buildMethodEntries(descriptors, context, states) {
           schema: descriptor.inputSchema,
           name: descriptor.name,
           annotator: boundAnnotator,
-          getDeprecation: () => entry.meta?.deprecation
+          getDeprecation: () => entry.meta?.deprecation,
+          getStability: () => entry.meta ? normalizeStability(entry.meta) : void 0
         }
       );
     } else {
@@ -2567,8 +2634,10 @@ function buildMethodEntries(descriptors, context, states) {
           annotator: boundAnnotator,
           // The boundary reads the deprecation LIVE off the entry, so a
           // deprecation merged after build (defineMethodOverride, addPlugin)
-          // fires too.
-          getDeprecation: () => entry.meta?.deprecation
+          // fires too. Same for the stability level, normalized from the
+          // entry meta (declared level or legacy `experimental` boolean).
+          getDeprecation: () => entry.meta?.deprecation,
+          getStability: () => entry.meta ? normalizeStability(entry.meta) : void 0
         }
       );
     }
@@ -2688,9 +2757,14 @@ function buildEagerArtifacts(descriptors, context, states) {
         plugins[id] = {
           pluginType: "property",
           name: descriptor.name,
-          getValue: () => get({
-            imports: buildImports({ plugins, importBindings }),
-            state: states.get(id)
+          getValue: (callContext) => get({
+            imports: buildImports({
+              plugins,
+              importBindings,
+              ctx: callContext
+            }),
+            state: states.get(id),
+            callContext
           }),
           meta: descriptor.meta,
           dynamicMembers: descriptor.dynamicMembers
@@ -5596,6 +5670,11 @@ function createSemaphore(maxPermits) {
     }
   };
 }
+
+// src/api/correlation.ts
+var CORRELATION_CALL_ID = Symbol(
+  "zapier.correlationCallId"
+);
 var ClientCredentialsObjectSchema = z.object({
   type: z.enum(["client_credentials"]).optional().meta({ internal: true }),
   clientId: z.string().describe("OAuth client ID for authentication.").meta({ valueHint: "id" }),
@@ -6512,7 +6591,7 @@ function parseDeprecationDate(value) {
 }
 
 // src/sdk-version.ts
-var SDK_VERSION = (typeof process !== "undefined" && process.env ? "0.97.1" : void 0) || "unknown";
+var SDK_VERSION = (typeof process !== "undefined" && process.env ? "0.98.1" : void 0) || "unknown";
 
 // src/utils/open-url.ts
 var nodePrefix = "node:";
@@ -6774,14 +6853,15 @@ var ZapierApiClient = class {
      * directly and drifting.
      */
     this.rawFetchUrl = async (url, init, pathConfig2) => {
-      if (init?.body && (isPlainObject(init.body) || Array.isArray(init.body))) {
-        init.body = JSON.stringify(init.body);
+      const { [CORRELATION_CALL_ID]: callId, ...fetchInit } = init ?? {};
+      if (fetchInit.body && (isPlainObject(fetchInit.body) || Array.isArray(fetchInit.body))) {
+        fetchInit.body = JSON.stringify(fetchInit.body);
       }
       const builtHeaders = await this.buildHeaders(
-        init,
+        fetchInit,
         pathConfig2
       );
-      const inputHeaders = new Headers(init?.headers ?? {});
+      const inputHeaders = new Headers(fetchInit.headers ?? {});
       const mergedHeaders = new Headers();
       builtHeaders.forEach((value, key) => {
         mergedHeaders.set(key, value);
@@ -6789,11 +6869,11 @@ var ZapierApiClient = class {
       inputHeaders.forEach((value, key) => {
         mergedHeaders.set(key, value);
       });
-      this.applyTelemetryHeaders(mergedHeaders);
+      this.applyTelemetryHeaders({ headers: mergedHeaders, callId });
       let retries = 0;
       while (true) {
         const response = await this.options.fetch(url, {
-          ...init,
+          ...fetchInit,
           headers: mergedHeaders
         });
         if (response.status !== 429) {
@@ -6914,12 +6994,13 @@ var ZapierApiClient = class {
         );
         const askStatementIds = askStatementIdsHeader ? JSON.parse(askStatementIdsHeader) : void 0;
         try {
-          await this.runOneApprovalRound(
-            approvalContext,
-            approvalMode,
-            init?.signal ?? void 0,
-            askStatementIds
-          );
+          await this.runOneApprovalRound({
+            buildContext: approvalContext,
+            mode: approvalMode,
+            signal: init?.signal ?? void 0,
+            askStatementIds,
+            callId: init?.[CORRELATION_CALL_ID]
+          });
         } catch (error) {
           return { response, approvalRoundError: error };
         }
@@ -7061,7 +7142,8 @@ var ZapierApiClient = class {
           method: "GET",
           searchParams: options.searchParams,
           authRequired: options.authRequired,
-          signal: options.signal
+          signal: options.signal,
+          [CORRELATION_CALL_ID]: options[CORRELATION_CALL_ID]
         }),
         initialDelay: options.initialDelayMilliseconds ?? options.initialDelay,
         timeoutMs: options.timeoutMilliseconds ?? options.timeoutMs,
@@ -7356,7 +7438,10 @@ var ZapierApiClient = class {
   // gateway now expects) and the legacy `x-zapier-*` names. The legacy names are
   // kept for backward compatibility with consumers that haven't migrated yet;
   // they can be removed once nothing reads them.
-  applyTelemetryHeaders(headers) {
+  applyTelemetryHeaders({
+    headers,
+    callId
+  }) {
     headers.set("zapier-sdk-version", SDK_VERSION);
     headers.set("x-zapier-sdk-version", SDK_VERSION);
     const sdkService = getZapierSdkService();
@@ -7379,6 +7464,11 @@ var ZapierApiClient = class {
         headers.set("zapier-sdk-package-operation", packageOperation);
       }
     }
+    if (callId) {
+      headers.set("zapier-correlation-id", callId);
+    } else {
+      headers.delete("zapier-correlation-id");
+    }
   }
   // Helper to perform HTTP requests with JSON handling
   async fetchJson(method, path, data, options = {}) {
@@ -7521,7 +7611,13 @@ var ZapierApiClient = class {
    * Caller is responsible for passing a non-"disabled" mode; this method
    * unconditionally creates an approval.
    */
-  async runOneApprovalRound(buildContext, mode, signal, askStatementIds) {
+  async runOneApprovalRound({
+    buildContext,
+    mode,
+    signal,
+    askStatementIds,
+    callId
+  }) {
     const context = buildContext();
     let approvalResponse;
     try {
@@ -7535,7 +7631,8 @@ var ZapierApiClient = class {
           context,
           ...askStatementIds?.length ? { ask_statement_ids: askStatementIds } : {}
         }),
-        signal
+        signal,
+        [CORRELATION_CALL_ID]: callId
       });
     } catch (err) {
       if (isAbortError(err)) throw err;
@@ -7671,7 +7768,10 @@ var ZapierApiClient = class {
         approvalId: approval.id,
         streamUrl,
         signal: streamAbortController.signal,
-        stream: (url, streamInit) => this.streamTrustedJsonUrl(url, streamInit),
+        stream: (url, streamInit) => this.streamTrustedJsonUrl(url, {
+          ...streamInit,
+          [CORRELATION_CALL_ID]: callId
+        }),
         emitEvent: (type, payload) => this.emitEvent(type, payload)
       });
     }
@@ -7680,7 +7780,8 @@ var ZapierApiClient = class {
       () => this.rawFetchUrl(approval.poll_url, {
         method: "GET",
         headers: { Accept: "application/json" },
-        signal
+        signal,
+        [CORRELATION_CALL_ID]: callId
       })
     );
     const pollApprovalUntilComplete = async (isPending, deadlineMs = approvalDeadline) => {
@@ -7872,6 +7973,23 @@ var API_ID = "zapier/api";
 var apiPluginRef = declareProperty({
   id: API_ID
 });
+function withCorrelationId({
+  client,
+  callId
+}) {
+  const stamp = (options) => ({ ...options, [CORRELATION_CALL_ID]: callId });
+  return {
+    get: (path, options) => client.get(path, stamp(options)),
+    post: (path, data, options) => client.post(path, data, stamp(options)),
+    put: (path, data, options) => client.put(path, data, stamp(options)),
+    patch: (path, data, options) => client.patch(path, data, stamp(options)),
+    delete: (path, data, options) => client.delete(path, data, stamp(options)),
+    poll: (path, options) => client.poll(path, stamp(options)),
+    fetch: (path, init) => client.fetch(path, stamp(init)),
+    fetchStream: (path, init) => client.fetchStream(path, stamp(init)),
+    fetchJsonStream: (path, init) => client.fetchJsonStream(path, stamp(init))
+  };
+}
 var apiPlugin = defineProperty({
   namespace: "zapier",
   name: "api",
@@ -7912,7 +8030,7 @@ var apiPlugin = defineProperty({
       callerPackage
     });
   },
-  get: ({ state }) => state
+  get: ({ state, callContext }) => callContext?.callId ? withCorrelationId({ client: state, callId: callContext.callId }) : state
 });
 var RESOLVE_CREDENTIALS_ID = "zapier/resolveCredentials";
 var resolveCredentialsPluginRef = declareProperty({ id: RESOLVE_CREDENTIALS_ID });
@@ -8473,8 +8591,11 @@ var manifestPlugin = defineProperty({
   namespace: "zapier",
   name: "manifest",
   imports: [sdkOptionsPluginRef, apiPluginRef],
+  // Deliberately does not read `imports.api`: at build time that resolves to the
+  // bare shared client, and capturing it here would strip the correlation id off
+  // every slug-resolution request. `get` supplies the reading call's client
+  // instead.
   setup: ({ imports }) => {
-    const api = imports.api;
     const { manifestPath = DEFAULT_CONFIG_PATH, manifest } = imports.sdkOptions ?? {};
     let resolvedManifest;
     async function resolveManifest() {
@@ -8492,7 +8613,10 @@ var manifestPlugin = defineProperty({
       }
       return resolvedManifest;
     };
-    const getVersionedImplementationId = async (appKey) => {
+    const getVersionedImplementationId = async ({
+      appKey,
+      api
+    }) => {
       const resolvedApps = await resolveAppKeys({
         appKeys: [appKey],
         api,
@@ -8502,14 +8626,14 @@ var manifestPlugin = defineProperty({
       if (!resolvedApp) return null;
       return `${resolvedApp.implementationName}@${resolvedApp.version || "latest"}`;
     };
-    const updateManifestEntry = async (options) => {
-      const {
-        appKey,
-        entry,
-        configPath = DEFAULT_CONFIG_PATH,
-        skipWrite = false,
-        manifest: inputManifest
-      } = options;
+    const updateManifestEntry = async ({
+      api,
+      appKey,
+      entry,
+      configPath = DEFAULT_CONFIG_PATH,
+      skipWrite = false,
+      manifest: inputManifest
+    }) => {
       const manifest2 = inputManifest || await readManifestFromFile(configPath) || { apps: {} };
       let existingEntry = findManifestEntry({
         appKey,
@@ -8560,7 +8684,7 @@ var manifestPlugin = defineProperty({
     };
     return {
       getVersionedImplementationId,
-      resolveAppKeys: async ({ appKeys }) => resolveAppKeys({
+      resolveAppKeys: async ({ appKeys, api }) => resolveAppKeys({
         appKeys,
         api,
         manifest: await getResolvedManifest() ?? { apps: {} }
@@ -8573,7 +8697,19 @@ var manifestPlugin = defineProperty({
       updateManifestEntry
     };
   },
-  get: ({ state }) => state
+  // Bind the reading call's API client onto the slug-resolving entry points so
+  // their requests carry that call's correlation id. The manifest-only reads pass
+  // straight through.
+  get: ({ imports, state }) => {
+    const api = imports.api;
+    return {
+      getVersionedImplementationId: (appKey) => state.getVersionedImplementationId({ appKey, api }),
+      resolveAppKeys: ({ appKeys }) => state.resolveAppKeys({ appKeys, api }),
+      getResolvedManifest: state.getResolvedManifest,
+      getManifestConnections: state.getManifestConnections,
+      updateManifestEntry: (options) => state.updateManifestEntry({ ...options, api })
+    };
+  }
 });
 
 // src/plugins/connections/index.ts
@@ -11862,14 +11998,24 @@ var ListConnectionsQuerySchema = ListConnectionsQuerySchema$1.omit({
   includeShared: z.boolean().optional().describe(
     "Include connections shared with you. By default, only your own connections are returned (owner=me). Set to true to also include shared connections."
   ),
-  /** @deprecated Use `expired` instead */
+  // Filters on connection expiry. Not a mirror of a server-side status
+  // field: the API expresses this as the is_expired filter, which we send as
+  // false for "active", true for "expired", and omit for "all".
+  status: z.enum(["active", "expired", "all"]).optional().describe(
+    "Filter connections by expiry: 'active' (default) returns only non-expired connections, 'expired' only expired ones, and 'all' returns both."
+  ),
+  /** @deprecated Use `status` instead */
   isExpired: z.boolean().optional().describe("Filter by expired status").meta({
     deprecated: true,
-    deprecationMessage: "Use --expired instead to show only expired connections."
+    deprecationMessage: "Use --status expired instead to show only expired connections, or --status all for both."
   }),
+  /** @deprecated Use `status` instead */
   expired: z.boolean().optional().describe(
     "Show only expired connections (default: only non-expired connections are returned)"
-  ),
+  ).meta({
+    deprecated: true,
+    deprecationMessage: "Use --status expired instead to show only expired connections, or --status all for both."
+  }),
   // Override pageSize to make optional
   pageSize: z.number().min(1).optional().describe("Number of connections per page"),
   // SDK specific property for pagination/iterable helpers
@@ -11995,10 +12141,15 @@ var listConnectionsPlugin = defineMethod({
     if (owner) {
       searchParams.owner = owner;
     }
-    if (input.isExpired !== void 0) {
-      searchParams.is_expired = input.isExpired.toString();
-    } else {
-      searchParams.is_expired = (input.expired ?? false).toString();
+    const expiredFilter = input.isExpired ?? input.expired;
+    if (input.status !== void 0 && expiredFilter !== void 0) {
+      throw new ZapierValidationError(
+        'The "status" option replaces "expired" and "isExpired", so it cannot be combined with either.'
+      );
+    }
+    const status = input.status ?? (expiredFilter ? "expired" : "active");
+    if (status !== "all") {
+      searchParams.is_expired = (status === "expired").toString();
     }
     if (input.cursor) {
       searchParams.offset = input.cursor;
@@ -15659,6 +15810,7 @@ function buildErrorEventWithContext(data, context = {}) {
 function buildMethodCalledEvent(data, context = {}) {
   return {
     ...createBaseEvent(context),
+    correlation_id: data.correlation_id ?? context.correlation_id ?? null,
     method_name: data.method_name ?? null,
     method_module: data.method_module ?? null,
     execution_duration_ms: data.execution_duration_ms,
@@ -15716,6 +15868,7 @@ function makeMethodEndHook(emitMethodCalled) {
     args,
     isPaginated,
     depth,
+    callId,
     callOrigin,
     annotations,
     durationMs,
@@ -15725,6 +15878,9 @@ function makeMethodEndHook(emitMethodCalled) {
     const metadata = readMethodMetadata(annotations);
     emitMethodCalled({
       method_name: methodName,
+      // The per-call correlation id (also the `zapier-correlation-id` header on
+      // this call's requests). Not the `call_context` surface label.
+      correlation_id: callId ?? null,
       execution_duration_ms: durationMs,
       success_flag: !error,
       error_message: error?.message ?? null,