@zapier/zapier-sdk 0.79.0 → 0.80.1

package/dist/experimental.cjs

@@ -53,18 +53,20 @@ function buildRegistry({
   sdk,
   meta,
   formatters,
+  boundResolvers,
+  positional,
   packageFilter
 }) {
   const definitionsByKey = /* @__PURE__ */ new Map();
   const objectDeclaredKeys = /* @__PURE__ */ new Set();
   for (const m of Object.values(meta)) {
     for (const ref of m.categories ?? []) {
-      const key = typeof ref === "string" ? ref : ref.key;
+      const key2 = typeof ref === "string" ? ref : ref.key;
       if (typeof ref === "object") {
-        objectDeclaredKeys.add(key);
-        definitionsByKey.set(key, resolveCategoryDefinition(ref));
-      } else if (!objectDeclaredKeys.has(key)) {
-        definitionsByKey.set(key, resolveCategoryDefinition(ref));
+        objectDeclaredKeys.add(key2);
+        definitionsByKey.set(key2, resolveCategoryDefinition(ref));
+      } else if (!objectDeclaredKeys.has(key2)) {
+        definitionsByKey.set(key2, resolveCategoryDefinition(ref));
       }
     }
   }
@@ -72,16 +74,16 @@ function buildRegistry({
     definitionsByKey.set("other", resolveCategoryDefinition("other"));
   }
   const knownCategories = Array.from(definitionsByKey.keys());
-  const functions = Object.keys(meta).filter((key) => {
-    const property = sdk[key];
+  const functions = Object.keys(meta).filter((key2) => {
+    const property = sdk[key2];
     if (typeof property === "function") return true;
-    const [rootKey] = key.split(".");
+    const [rootKey] = key2.split(".");
     const rootProperty = sdk[rootKey];
     return typeof rootProperty === "object" && rootProperty !== null;
-  }).map((key) => {
-    const m = meta[key];
+  }).map((key2) => {
+    const m = meta[key2];
     return {
-      name: key,
+      name: key2,
       description: m.description,
       type: m.type,
       itemType: m.itemType,
@@ -89,11 +91,13 @@ function buildRegistry({
       inputSchema: canonicalInputSchema(m.inputSchema),
       inputParameters: m.inputParameters,
       outputSchema: m.outputSchema,
+      positional: positional?.[key2],
       categories: (m.categories ?? []).map(
         (c) => typeof c === "string" ? c : c.key
       ),
       resolvers: m.resolvers,
-      formatter: formatters?.[key],
+      boundResolvers: boundResolvers?.[key2],
+      formatter: formatters?.[key2],
       experimental: m.experimental,
       packages: m.packages,
       confirm: m.confirm ?? (m.type === "delete" ? "delete" : void 0),
@@ -131,8 +135,8 @@ function composeVoid(existing, added) {
 }
 function buildHooks(existing, added) {
   const result = {};
-  const start = composeVoid(existing.onMethodStart, added.onMethodStart);
-  if (start) result.onMethodStart = start;
+  const start2 = composeVoid(existing.onMethodStart, added.onMethodStart);
+  if (start2) result.onMethodStart = start2;
   const end = composeVoid(existing.onMethodEnd, added.onMethodEnd);
   if (end) result.onMethodEnd = end;
   return result;
@@ -765,11 +769,11 @@ var RESERVED_ROOT_KEYS = /* @__PURE__ */ new Set([
   "context",
   "getRegistry"
 ]);
-function hasOwn(obj, key) {
-  return Object.prototype.hasOwnProperty.call(obj, key);
+function hasOwn(obj, key2) {
+  return Object.prototype.hasOwnProperty.call(obj, key2);
 }
-function setOwn(target, key, value) {
-  Object.defineProperty(target, key, {
+function setOwn(target, key2, value) {
+  Object.defineProperty(target, key2, {
     value,
     enumerable: true,
     configurable: true,
@@ -781,31 +785,31 @@ function checkCollisions(target, source, kind, callerLabel, override) {
     checkRootKeyCollisions(target, Object.keys(source), override, callerLabel);
     return;
   }
-  for (const key of Object.keys(source)) {
-    if (!override && hasOwn(target, key)) {
+  for (const key2 of Object.keys(source)) {
+    if (!override && hasOwn(target, key2)) {
       throw new Error(
-        `${callerLabel}: duplicate ${kind} "${key}". If the override is intentional, pass { override: true } in the options.`
+        `${callerLabel}: duplicate ${kind} "${key2}". If the override is intentional, pass { override: true } in the options.`
       );
     }
   }
 }
 function checkRootKeyCollisions(target, keys, override, callerLabel) {
-  for (const key of keys) {
-    if (RESERVED_ROOT_KEYS.has(key)) {
+  for (const key2 of keys) {
+    if (RESERVED_ROOT_KEYS.has(key2)) {
       throw new Error(
-        `${callerLabel}: plugin attempted to register reserved root key "${key}". The SDK uses this key for its own accessor; rename the plugin's method.`
+        `${callerLabel}: plugin attempted to register reserved root key "${key2}". The SDK uses this key for its own accessor; rename the plugin's method.`
       );
     }
-    if (!override && hasOwn(target, key)) {
+    if (!override && hasOwn(target, key2)) {
       throw new Error(
-        `${callerLabel}: duplicate root key "${key}". If the override is intentional, pass { override: true } in the options.`
+        `${callerLabel}: duplicate root key "${key2}". If the override is intentional, pass { override: true } in the options.`
       );
     }
   }
 }
 function applyOwnProperties(target, source) {
-  for (const key of Object.keys(source)) {
-    setOwn(target, key, source[key]);
+  for (const key2 of Object.keys(source)) {
+    setOwn(target, key2, source[key2]);
   }
 }
 function createPluginAccumulator(initialProperties = {}, initialContext = {}) {
@@ -1053,8 +1057,8 @@ function normalizeImports(deps) {
 }
 function collectLeafMeta(config) {
   let meta;
-  for (const key of LEAF_META_KEYS) {
-    if (config[key] !== void 0) (meta ?? (meta = {}))[key] = config[key];
+  for (const key2 of LEAF_META_KEYS) {
+    if (config[key2] !== void 0) (meta ?? (meta = {}))[key2] = config[key2];
   }
   return meta;
 }
@@ -1077,12 +1081,66 @@ function defineMethod(config) {
     run: config.run
   };
 }
+function defineResolver(config) {
+  const deps = normalizeImports(config.imports);
+  const base = { imports: deps.plugins, importBindings: deps.bindings };
+  const gates = {
+    requireParameters: config.requireParameters
+  };
+  switch (config.type) {
+    case "static":
+      return {
+        ...base,
+        ...gates,
+        type: "static",
+        inputType: config.inputType,
+        placeholder: config.placeholder
+      };
+    case "constant":
+      return { ...base, ...gates, type: "constant", value: config.value };
+    case "info":
+      return { ...base, type: "info", text: config.text ?? "" };
+    case "object":
+      return {
+        ...base,
+        ...gates,
+        type: "object",
+        properties: config.properties,
+        definitions: config.definitions,
+        getProperties: config.getProperties
+      };
+    case "array":
+      return {
+        ...base,
+        ...gates,
+        type: "array",
+        items: config.items,
+        minItems: config.minItems,
+        maxItems: config.maxItems,
+        itemValueType: config.itemValueType,
+        definitions: config.definitions
+      };
+    default:
+      return {
+        ...base,
+        ...gates,
+        type: "dynamic",
+        inputType: config.inputType,
+        placeholder: config.placeholder,
+        getContext: config.getContext,
+        listItems: config.listItems,
+        prompt: config.prompt,
+        tryResolveWithoutPrompt: config.tryResolveWithoutPrompt,
+        tryResolveFromSearch: config.tryResolveFromSearch
+      };
+  }
+}
 function defineFormatter(config) {
   const deps = normalizeImports(config.imports);
   return {
     imports: deps.plugins,
     importBindings: deps.bindings,
-    fetchContext: config.fetchContext,
+    getContext: config.getContext,
     format: config.format
   };
 }
@@ -1211,7 +1269,7 @@ function legacyGraphEntry(name, value, pluginMeta) {
 function adaptLegacyFormatter(legacy, sdk) {
   const legacyFetch = legacy.fetch;
   return {
-    fetchContext: legacyFetch ? async ({ items, input, context }) => {
+    getContext: legacyFetch ? async ({ items, input, context }) => {
       let ctx = context;
       for (const item of items) {
         ctx = await legacyFetch(sdk, input, item, ctx);
@@ -1227,6 +1285,14 @@ function normalizeFormatter(entry, sdk) {
   const legacy = entry.meta?.formatter;
   return legacy ? adaptLegacyFormatter(legacy, sdk) : void 0;
 }
+function normalizeBoundResolvers(entry) {
+  if (entry.pluginType !== "method") return void 0;
+  return entry.resolvers;
+}
+function methodPositional(entry) {
+  if (entry.pluginType !== "method") return void 0;
+  return entry.positional;
+}
 function pluginEntryMeta(entry) {
   if (entry.pluginType === "method" && entry.meta) {
     return entry.inputSchema ? { ...entry.meta, inputSchema: entry.inputSchema } : entry.meta;
@@ -1247,11 +1313,24 @@ function buildSurfaceRegistry(context, packageFilter) {
     if (m) meta[binding] = m;
   }
   const formatters = {};
+  const boundResolvers = {};
+  const positional = {};
   for (const [binding, entry] of Object.entries(entries)) {
     const f = normalizeFormatter(entry, surface);
     if (f) formatters[binding] = f;
-  }
-  return buildRegistry({ sdk: surface, meta, formatters, packageFilter });
+    const r = normalizeBoundResolvers(entry);
+    if (r) boundResolvers[binding] = r;
+    const p = methodPositional(entry);
+    if (p) positional[binding] = p;
+  }
+  return buildRegistry({
+    sdk: surface,
+    meta,
+    formatters,
+    boundResolvers,
+    positional,
+    packageFilter
+  });
 }
 var dangerousContextPlugin = {
   pluginType: "property",
@@ -1368,15 +1447,15 @@ function collectPlugins(root, materialized = /* @__PURE__ */ new Set()) {
   }
   return byId;
 }
-function bindValue(target, key, entry) {
+function bindValue(target, key2, entry) {
   if (entry.pluginType === "property" && entry.getValue) {
-    Object.defineProperty(target, key, {
+    Object.defineProperty(target, key2, {
       get: entry.getValue,
       enumerable: true,
       configurable: true
     });
   } else {
-    Object.defineProperty(target, key, {
+    Object.defineProperty(target, key2, {
       value: entry.value,
       writable: true,
       enumerable: true,
@@ -1428,8 +1507,7 @@ function bindResolver(resolver, plugins) {
     case "static":
       return {
         type: "static",
-        requireParams: resolver.requireParams,
-        requireCapabilities: resolver.requireCapabilities,
+        requireParameters: resolver.requireParameters,
         inputType: resolver.inputType,
         placeholder: resolver.placeholder
       };
@@ -1437,8 +1515,7 @@ function bindResolver(resolver, plugins) {
       return {
         type: "constant",
         value: resolver.value,
-        requireParams: resolver.requireParams,
-        requireCapabilities: resolver.requireCapabilities
+        requireParameters: resolver.requireParameters
       };
     case "info":
       return { type: "info", text: resolver.text };
@@ -1446,24 +1523,24 @@ function bindResolver(resolver, plugins) {
       const imports = buildImports(plugins, resolver.importBindings);
       const bound = {
         type: "object",
-        requireParams: resolver.requireParams,
-        requireCapabilities: resolver.requireCapabilities
+        requireParameters: resolver.requireParameters
       };
       if (resolver.properties)
         bound.properties = bindFields(resolver.properties, plugins);
       if (resolver.definitions)
         bound.definitions = bindDefinitions(resolver.definitions, plugins);
-      const { fetch: fetch2 } = resolver;
-      if (fetch2) bound.fetch = ({ params }) => fetch2({ imports, params });
+      const { getProperties } = resolver;
+      if (getProperties)
+        bound.getProperties = ({ input }) => getProperties({ imports, input });
       return bound;
     }
     case "array": {
       const bound = {
         type: "array",
-        requireParams: resolver.requireParams,
-        requireCapabilities: resolver.requireCapabilities,
+        requireParameters: resolver.requireParameters,
         minItems: resolver.minItems,
         maxItems: resolver.maxItems,
+        itemValueType: resolver.itemValueType,
         items: isResolverRef(resolver.items) ? resolver.items : bindResolver(resolver.items, plugins)
       };
       if (resolver.definitions)
@@ -1474,17 +1551,26 @@ function bindResolver(resolver, plugins) {
       const imports = buildImports(plugins, resolver.importBindings);
       const bound = {
         type: "dynamic",
-        requireParams: resolver.requireParams,
-        requireCapabilities: resolver.requireCapabilities,
+        requireParameters: resolver.requireParameters,
         inputType: resolver.inputType,
         placeholder: resolver.placeholder,
         prompt: resolver.prompt
       };
-      const { fetch: fetch2, tryResolveWithoutPrompt } = resolver;
-      if (fetch2)
-        bound.fetch = ({ params, search }) => fetch2({ imports, params, search });
+      const {
+        getContext: getContext2,
+        listItems,
+        tryResolveWithoutPrompt,
+        tryResolveFromSearch
+      } = resolver;
+      if (getContext2)
+        bound.getContext = ({ input }) => getContext2({ imports, input });
+      if (listItems)
+        bound.listItems = ({ input, context, search, cursor }) => listItems({ imports, input, context, search, cursor });
       if (tryResolveWithoutPrompt) {
-        bound.tryResolveWithoutPrompt = ({ params }) => tryResolveWithoutPrompt({ imports, params });
+        bound.tryResolveWithoutPrompt = ({ input }) => tryResolveWithoutPrompt({ imports, input });
+      }
+      if (tryResolveFromSearch) {
+        bound.tryResolveFromSearch = ({ input, search }) => tryResolveFromSearch({ imports, input, search });
       }
       return bound;
     }
@@ -1492,8 +1578,8 @@ function bindResolver(resolver, plugins) {
 }
 function bindFields(fields, plugins) {
   const out = {};
-  for (const [key, field] of Object.entries(fields)) {
-    out[key] = {
+  for (const [key2, field] of Object.entries(fields)) {
+    out[key2] = {
       ...field,
       resolver: isResolverRef(field.resolver) ? field.resolver : bindResolver(field.resolver, plugins)
     };
@@ -1502,17 +1588,17 @@ function bindFields(fields, plugins) {
 }
 function bindDefinitions(definitions, plugins) {
   const out = {};
-  for (const [key, def] of Object.entries(definitions)) {
-    out[key] = bindResolver(def, plugins);
+  for (const [key2, def] of Object.entries(definitions)) {
+    out[key2] = bindResolver(def, plugins);
   }
   return out;
 }
 function bindFormatter(formatter, plugins) {
   const imports = buildImports(plugins, formatter.importBindings);
   const bound = { format: formatter.format };
-  const { fetchContext } = formatter;
-  if (fetchContext)
-    bound.fetchContext = ({ items, input, context }) => fetchContext({ imports, items, input, context });
+  const { getContext: getContext2 } = formatter;
+  if (getContext2)
+    bound.getContext = ({ items, input, context }) => getContext2({ imports, items, input, context });
   return bound;
 }
 function bindAttachments(descriptors, context) {
@@ -1560,6 +1646,7 @@ function runLegacyPass(descriptors, context) {
         const sdk = this ?? exports;
         const meta2 = {};
         const formatters = {};
+        const boundResolvers = {};
         for (const [binding, id2] of Object.entries(context.surface)) {
           const entry = context.plugins[id2];
           if (!entry || entry.pluginType === "aggregate") continue;
@@ -1567,12 +1654,15 @@ function runLegacyPass(descriptors, context) {
           if (m) meta2[binding] = m;
           const f = normalizeFormatter(entry, sdk);
           if (f) formatters[binding] = f;
+          const r = normalizeBoundResolvers(entry);
+          if (r) boundResolvers[binding] = r;
         }
         Object.assign(meta2, context.meta);
         return buildRegistry({
           sdk,
           meta: meta2,
           formatters,
+          boundResolvers,
           packageFilter: options?.package
         });
       };
@@ -1788,7 +1878,7 @@ function createSdk(root) {
       pluginSurface = {};
       bindValue(pluginSurface, plugin.name, plugins2[plugin.id]);
     }
-    for (const key of Object.keys(legacyExports)) context.surface[key] = key;
+    for (const key2 of Object.keys(legacyExports)) context.surface[key2] = key2;
     if (plugin.pluginType === "aggregate") {
       recordExportSurface(context, plugin.exports);
     } else {
@@ -1858,6 +1948,756 @@ function addPlugin(sdk, plugin, options) {
     options ?? {}
   );
 }
+var CORE_SIGNAL_SYMBOL = Symbol.for("kitcore.signal");
+var CoreSignal = class extends Error {
+  constructor(message) {
+    super(message);
+    Object.setPrototypeOf(this, new.target.prototype);
+    Object.defineProperty(this, CORE_SIGNAL_SYMBOL, {
+      value: true,
+      enumerable: false,
+      configurable: true,
+      writable: false
+    });
+  }
+};
+function isCoreSignal(value) {
+  return Boolean(
+    value && typeof value === "object" && value[CORE_SIGNAL_SYMBOL] === true
+  );
+}
+var CoreCancelledSignal = class extends CoreSignal {
+  constructor(message = "resolution cancelled") {
+    super(message);
+    this.name = "CoreCancelledSignal";
+    this.code = "CANCELLED";
+  }
+};
+function unwrap(schema) {
+  let inner = schema;
+  let required = true;
+  for (; ; ) {
+    if (inner instanceof zod.z.ZodOptional) {
+      required = false;
+      inner = inner._zod.def.innerType;
+    } else if (inner instanceof zod.z.ZodDefault) {
+      required = false;
+      inner = inner._zod.def.innerType;
+    } else if (inner instanceof zod.z.ZodNullable) {
+      inner = inner._zod.def.innerType;
+    } else {
+      break;
+    }
+  }
+  return { inner, required };
+}
+function valueTypeOf(inner) {
+  if (inner instanceof zod.z.ZodString) return "string";
+  if (inner instanceof zod.z.ZodNumber) return "number";
+  if (inner instanceof zod.z.ZodBoolean) return "boolean";
+  if (inner instanceof zod.z.ZodEnum) return "string";
+  if (inner instanceof zod.z.ZodArray) return "array";
+  if (inner instanceof zod.z.ZodObject) return "object";
+  return void 0;
+}
+function staticChoicesOf(inner) {
+  if (inner instanceof zod.z.ZodEnum) {
+    const values = inner.options;
+    return values.map((value) => ({ label: value, value }));
+  }
+  return void 0;
+}
+function objectShape(schema) {
+  const { inner } = schema ? unwrap(schema) : { inner: void 0 };
+  if (inner instanceof zod.z.ZodObject) {
+    return inner.shape;
+  }
+  return void 0;
+}
+function topoOrder2(specs) {
+  const byName = new Map(specs.map((s) => [s.name, s]));
+  const ordered = [];
+  const placed = /* @__PURE__ */ new Set();
+  let progressed = true;
+  while (ordered.length < specs.length && progressed) {
+    progressed = false;
+    for (const spec of specs) {
+      if (placed.has(spec.name)) continue;
+      const ready = spec.requires.every((r) => !byName.has(r) || placed.has(r));
+      if (ready) {
+        ordered.push(spec);
+        placed.add(spec.name);
+        progressed = true;
+      }
+    }
+  }
+  for (const spec of specs) if (!placed.has(spec.name)) ordered.push(spec);
+  return ordered;
+}
+function planParameters(entry) {
+  const shape = objectShape(entry.inputSchema);
+  const resolvers = entry.boundResolvers ?? {};
+  const names = shape ? Object.keys(shape) : Object.keys(resolvers);
+  const specs = names.map((name) => {
+    const field = shape?.[name];
+    const { inner, required } = field ? unwrap(field) : { inner: void 0, required: false };
+    const resolver = resolvers[name];
+    return {
+      name,
+      required,
+      valueType: inner ? valueTypeOf(inner) : void 0,
+      staticChoices: inner ? staticChoicesOf(inner) : void 0,
+      resolver,
+      requires: resolver?.requireParameters ?? []
+    };
+  });
+  return { parameters: topoOrder2(specs) };
+}
+function getAtPath(root, path) {
+  let node = root;
+  for (const seg of path) {
+    if (node == null || typeof node !== "object") return void 0;
+    node = node[seg];
+  }
+  return node;
+}
+function setAtPath(root, path, value) {
+  let node = root;
+  for (let i = 0; i < path.length - 1; i++) {
+    const seg = path[i];
+    if (node[seg] == null || typeof node[seg] !== "object") node[seg] = {};
+    node = node[seg];
+  }
+  node[path[path.length - 1]] = value;
+}
+var key = (path) => path.join(".");
+function isSettled(state, path) {
+  return state.settled.includes(key(path));
+}
+function settle(state, path) {
+  const k = key(path);
+  if (!state.settled.includes(k)) state.settled.push(k);
+}
+function clone(state) {
+  return JSON.parse(JSON.stringify(state));
+}
+function coerce(leaf, raw) {
+  if (typeof raw !== "string") return raw;
+  if (leaf.valueType === "number") {
+    const n = Number(raw);
+    return raw.trim() !== "" && !Number.isNaN(n) ? n : raw;
+  }
+  if (leaf.valueType === "boolean") {
+    if (raw === "true") return true;
+    if (raw === "false") return false;
+  }
+  return raw;
+}
+async function validationError(leaf, value, state) {
+  const context = await resolveContext(leaf, state.resolved);
+  const config = leaf.resolver?.prompt?.({
+    items: state.listing?.items ?? [],
+    input: mergeInput(state.resolved, leaf.extraInput),
+    context
+  });
+  if (!config?.validate) return null;
+  const verdict = config.validate(value);
+  if (verdict === true) return null;
+  return typeof verdict === "string" ? verdict : `${leaf.name}: invalid value`;
+}
+function toChoice(c) {
+  const label = "label" in c ? c.label : c.name;
+  const hint = Array.isArray(c.hint) ? c.hint.join(", ") : c.hint;
+  return { label, value: String(c.value), hint };
+}
+function isRef(r) {
+  return typeof r === "object" && r !== null && "ref" in r;
+}
+function toLeaf(name, field, definitions) {
+  let resolver;
+  let extraInput;
+  if (isRef(field.resolver)) {
+    resolver = definitions?.[field.resolver.ref];
+    extraInput = field.resolver.input;
+  } else {
+    resolver = field.resolver;
+  }
+  return {
+    name,
+    required: field.required ?? false,
+    resolver,
+    extraInput,
+    // Carry the field's value type so nested answers coerce (number/boolean)
+    // the same way top-level params do. Without this a nested `z.number()`
+    // field's typed answer stays a string and fails final validation.
+    valueType: field.valueType,
+    requires: resolver?.requireParameters ?? []
+  };
+}
+async function objectChildren(resolver, input) {
+  if (resolver.properties) {
+    return Object.entries(resolver.properties).map(
+      ([name, field]) => toLeaf(name, field, resolver.definitions)
+    );
+  }
+  if (!resolver.getProperties) return [];
+  const fields = await resolver.getProperties({ input });
+  return Object.entries(fields).map(([name, field]) => {
+    if (!isRef(field.resolver) && (field.resolver.imports?.length ?? 0) > 0) {
+      throw new Error(
+        `dynamic object field "${name}" inlines an import-bearing resolver; use { ref } into the object's definitions so its imports bind`
+      );
+    }
+    return toLeaf(name, field, resolver.definitions);
+  });
+}
+function arrayItem(resolver) {
+  const items = resolver.items;
+  const valueType = resolver.itemValueType;
+  if (isRef(items)) {
+    return {
+      name: "",
+      required: true,
+      resolver: resolver.definitions?.[items.ref],
+      extraInput: items.input,
+      valueType,
+      requires: []
+    };
+  }
+  return {
+    name: "",
+    required: true,
+    resolver: items,
+    valueType,
+    requires: []
+  };
+}
+function mergeInput(input, extra) {
+  return extra ? { ...input, ...extra } : input;
+}
+async function childrenAt(ctx, path, resolved) {
+  if (path.length === 0) return ctx.parameters;
+  const leaf = await leafAt(ctx, path, resolved);
+  if (!leaf?.resolver || leaf.resolver.type !== "object") return [];
+  return objectChildren(leaf.resolver, mergeInput(resolved, leaf.extraInput));
+}
+async function leafAt(ctx, path, resolved) {
+  let children = ctx.parameters;
+  let leaf;
+  for (let i = 0; i < path.length; i++) {
+    const seg = path[i];
+    if (typeof seg === "number") {
+      if (leaf?.resolver?.type !== "array") return void 0;
+      leaf = arrayItem(leaf.resolver);
+    } else {
+      leaf = children.find((c) => c.name === seg);
+      if (!leaf) return void 0;
+    }
+    if (i < path.length - 1 && typeof path[i + 1] === "string") {
+      if (leaf?.resolver?.type !== "object") return void 0;
+      children = await objectChildren(
+        leaf.resolver,
+        mergeInput(resolved, leaf.extraInput)
+      );
+    }
+  }
+  return leaf;
+}
+async function arrayInfoAt(ctx, path, resolved) {
+  const leaf = await leafAt(ctx, path, resolved);
+  const resolver = leaf?.resolver;
+  if (resolver?.type !== "array") {
+    throw new Error(`expected an array resolver at "${key(path)}"`);
+  }
+  return {
+    min: resolver.minItems ?? 0,
+    max: resolver.maxItems ?? Infinity,
+    item: { ...arrayItem(resolver), name: String(path[path.length - 1]) }
+  };
+}
+var AFFORDANCE = {
+  choose: { action: "choose", description: "Pick one of the listed options" },
+  custom: {
+    action: "custom",
+    description: "Provide a value directly",
+    supply: "value"
+  },
+  search: {
+    action: "search",
+    description: "Filter the options by a search term",
+    supply: "term"
+  },
+  more: { action: "more", description: "Load more options" },
+  skip: { action: "skip", description: "Omit this optional parameter" },
+  add: { action: "add", description: "Add another item" },
+  done: { action: "done", description: "Finish the list" },
+  retry: { action: "retry", description: "Retry loading the options" },
+  cancel: { action: "cancel", description: "Cancel resolution" }
+};
+async function firstPage(result) {
+  const page = await result;
+  return {
+    data: Array.isArray(page?.data) ? page.data : [],
+    nextCursor: page?.nextCursor
+  };
+}
+async function resolveContext(leaf, input) {
+  return leaf.resolver?.getContext?.({
+    input: mergeInput(input, leaf.extraInput)
+  });
+}
+async function fetchListing(leaf, input, opts = {}) {
+  const page = await firstPage(
+    leaf.resolver?.listItems?.({
+      input: mergeInput(input, leaf.extraInput),
+      context: opts.context,
+      search: opts.search,
+      cursor: opts.cursor
+    })
+  );
+  return {
+    items: [...opts.priorItems ?? [], ...page.data],
+    cursor: page.nextCursor,
+    search: opts.search,
+    exhausted: page.nextCursor == null
+  };
+}
+function selectActions(leaf, listing, multiple) {
+  const actions = multiple ? [AFFORDANCE.choose] : [AFFORDANCE.choose, AFFORDANCE.custom];
+  if (leaf.resolver?.inputType === "search") actions.push(AFFORDANCE.search);
+  if (listing.cursor) actions.push(AFFORDANCE.more);
+  if (!leaf.required) actions.push(AFFORDANCE.skip);
+  return actions;
+}
+function selectQuestion(leaf, input, listing, context) {
+  const config = leaf.resolver?.prompt?.({
+    items: listing.items,
+    input: mergeInput(input, leaf.extraInput),
+    context
+  });
+  const multiple = config?.type === "checkbox";
+  return {
+    type: "select",
+    message: config?.message ?? `Select ${leaf.name}:`,
+    choices: (config?.choices ?? []).map(toChoice),
+    ...multiple ? { multiple: true } : {},
+    ...config?.notes?.length ? { notes: config.notes } : {},
+    actions: selectActions(leaf, listing, multiple)
+  };
+}
+function toControllerError(error) {
+  if (error instanceof Error) {
+    const code = error.code;
+    return {
+      name: error.name,
+      message: error.message,
+      ...typeof code === "string" ? { code } : {}
+    };
+  }
+  return { name: "Error", message: String(error) };
+}
+function failedResult(state, name, error) {
+  return {
+    state,
+    result: {
+      status: "failed",
+      error: toControllerError(error),
+      question: {
+        type: "select",
+        message: `Could not load options for ${name}.`,
+        choices: [],
+        actions: [AFFORDANCE.retry, AFFORDANCE.cancel]
+      }
+    }
+  };
+}
+async function buildQuestion(leaf, input) {
+  const optional = !leaf.required;
+  const resolver = leaf.resolver;
+  if (resolver?.listItems) {
+    const context = await resolveContext(leaf, input);
+    const listing = await fetchListing(leaf, input, { context });
+    return {
+      question: selectQuestion(leaf, input, listing, context),
+      listing
+    };
+  }
+  if (leaf.staticChoices) {
+    const actions2 = [AFFORDANCE.choose];
+    if (optional) actions2.push(AFFORDANCE.skip);
+    return {
+      question: {
+        type: "select",
+        message: `Select ${leaf.name}:`,
+        choices: leaf.staticChoices,
+        actions: actions2
+      }
+    };
+  }
+  const inputType = resolver?.inputType && resolver.inputType !== "search" ? resolver.inputType : "text";
+  const actions = [AFFORDANCE.custom];
+  if (optional) actions.push(AFFORDANCE.skip);
+  return {
+    question: {
+      type: "input",
+      message: `Enter ${leaf.name}:`,
+      inputType,
+      placeholder: resolver?.placeholder,
+      actions
+    }
+  };
+}
+function finalize(ctx, resolved) {
+  if (!ctx.schema) return { status: "done", value: resolved };
+  const parsed = ctx.schema.safeParse(resolved);
+  if (parsed.success) {
+    return { status: "done", value: parsed.data };
+  }
+  const issues = parsed.error.issues.map((i) => ({
+    parameter: i.path.map(String).join(".") || void 0,
+    message: i.message
+  }));
+  return { status: "invalid", issues };
+}
+function collectionQuestion(t) {
+  const actions = [AFFORDANCE.add];
+  if (t.count >= t.min) actions.push(AFFORDANCE.done);
+  return {
+    type: "collection",
+    message: `Add another ${t.path[t.path.length - 1]}? (${t.count} so far)`,
+    count: t.count,
+    min: t.min,
+    // An unbounded array's max is Infinity, which JSON.stringify turns to null;
+    // omit it so the question round-trips across the wall as plain data.
+    ...Number.isFinite(t.max) ? { max: t.max } : {},
+    actions
+  };
+}
+async function findInArray(ctx, state, path) {
+  if (isSettled(state, path)) return null;
+  if (getAtPath(state.resolved, path) == null)
+    setAtPath(state.resolved, path, []);
+  if (!state.interactive) {
+    settle(state, path);
+    return null;
+  }
+  const { min, max, item } = await arrayInfoAt(ctx, path, state.resolved);
+  const items = getAtPath(state.resolved, path);
+  const len = items.length;
+  const itemType = item.resolver?.type;
+  if (len > 0 && (itemType === "object" || itemType === "array")) {
+    const inner = await findNext(ctx, state, [...path, len - 1]);
+    if (inner) return inner;
+  }
+  if (len < min) return descendItem(ctx, state, path, len, item);
+  if (len < max) return { kind: "array", path, count: len, min, max };
+  settle(state, path);
+  return null;
+}
+function seedItemSlot(state, itemPath, item) {
+  const type = item.resolver?.type;
+  if (type === "object") {
+    setAtPath(state.resolved, itemPath, {});
+    return "object";
+  }
+  if (type === "array") {
+    setAtPath(state.resolved, itemPath, []);
+    return "array";
+  }
+  return "leaf";
+}
+async function descendItem(ctx, state, arrayPath, index, item) {
+  const itemPath = [...arrayPath, index];
+  const kind = seedItemSlot(state, itemPath, item);
+  if (kind === "object") return findNext(ctx, state, itemPath);
+  if (kind === "array") return findInArray(ctx, state, itemPath);
+  return { kind: "leaf", path: itemPath, leaf: item };
+}
+async function findNext(ctx, state, path = []) {
+  const container = getAtPath(state.resolved, path) ?? {};
+  for (const leaf of await childrenAt(ctx, path, state.resolved)) {
+    const childPath = [...path, leaf.name];
+    if (!leaf.requires.every((r) => container[r] !== void 0)) continue;
+    if (leaf.resolver?.type === "object") {
+      if (getAtPath(state.resolved, childPath) == null)
+        setAtPath(state.resolved, childPath, {});
+      const inner = await findNext(ctx, state, childPath);
+      if (inner) return inner;
+      continue;
+    }
+    if (leaf.resolver?.type === "array") {
+      const inner = await findInArray(ctx, state, childPath);
+      if (inner) return inner;
+      continue;
+    }
+    if (container[leaf.name] !== void 0 || isSettled(state, childPath))
+      continue;
+    return { kind: "leaf", path: childPath, leaf };
+  }
+  return null;
+}
+async function askLeaf(state, path, leaf, opts = {}) {
+  state.current = path;
+  try {
+    const { question, listing } = await buildQuestion(leaf, state.resolved);
+    state.listing = listing;
+    return {
+      state,
+      result: {
+        status: "ask",
+        question,
+        ...opts.error ? { error: opts.error } : {}
+      }
+    };
+  } catch (error) {
+    state.listing = { items: [], exhausted: false };
+    return failedResult(state, leaf.name, error);
+  }
+}
+async function advance(ctx, state) {
+  for (; ; ) {
+    const target = await findNext(ctx, state);
+    if (!target) {
+      delete state.current;
+      delete state.listing;
+      return { state, result: finalize(ctx, state.resolved) };
+    }
+    if (target.kind === "array") {
+      state.current = target.path;
+      delete state.listing;
+      return {
+        state,
+        result: { status: "ask", question: collectionQuestion(target) }
+      };
+    }
+    const { path, leaf } = target;
+    const auto = await leaf.resolver?.tryResolveWithoutPrompt?.({
+      input: mergeInput(state.resolved, leaf.extraInput)
+    });
+    if (auto) {
+      if (auto.resolvedValue !== void 0)
+        setAtPath(state.resolved, path, auto.resolvedValue);
+      settle(state, path);
+      continue;
+    }
+    if (!state.interactive) {
+      if (!leaf.required) {
+        settle(state, path);
+        continue;
+      }
+    } else if (!leaf.required && !leaf.resolver) {
+      settle(state, path);
+      continue;
+    }
+    return askLeaf(state, path, leaf);
+  }
+}
+async function start(ctx, input = {}, interactive = true) {
+  const resolved = {};
+  for (const spec of ctx.parameters) {
+    if (spec.resolver?.type === "constant")
+      resolved[spec.name] = spec.resolver.value;
+  }
+  Object.assign(resolved, input);
+  return advance(ctx, {
+    method: ctx.method,
+    resolved,
+    settled: [],
+    interactive
+  });
+}
+async function step(ctx, prior, action) {
+  const state = clone(prior);
+  if (action.type === "cancel") {
+    delete state.current;
+    delete state.listing;
+    return { state, result: { status: "cancelled" } };
+  }
+  const path = state.current;
+  if (!path) throw new Error("step called with no outstanding question");
+  const leaf = await leafAt(ctx, path, state.resolved);
+  if (leaf && (action.type === "search" || action.type === "more" || action.type === "retry")) {
+    return refine(ctx, state, leaf, path, action);
+  }
+  if (action.type === "add" || action.type === "done") {
+    delete state.current;
+    delete state.listing;
+    if (action.type === "done") {
+      settle(state, path);
+      return advance(ctx, state);
+    }
+    const items = getAtPath(state.resolved, path) ?? [];
+    const { item } = await arrayInfoAt(ctx, path, state.resolved);
+    const itemPath = [...path, items.length];
+    if (seedItemSlot(state, itemPath, item) === "leaf")
+      return askLeaf(state, itemPath, item);
+    return advance(ctx, state);
+  }
+  switch (action.type) {
+    case "choose":
+    case "custom": {
+      if (leaf) {
+        const error = await validationError(leaf, action.value, state);
+        if (error) return askLeaf(state, path, leaf, { error });
+      }
+      setAtPath(
+        state.resolved,
+        path,
+        leaf ? coerce(leaf, action.value) : action.value
+      );
+      break;
+    }
+    case "skip":
+      settle(state, path);
+      break;
+    default:
+      throw new Error(`action "${action.type}" is not supported here`);
+  }
+  delete state.current;
+  delete state.listing;
+  return advance(ctx, state);
+}
+async function refine(ctx, state, leaf, path, action) {
+  const attempt = action.type === "search" ? { search: action.term, cursor: void 0, priorItems: [] } : {
+    search: state.listing?.search,
+    cursor: state.listing?.cursor,
+    priorItems: state.listing?.items ?? []
+  };
+  try {
+    if (action.type === "search") {
+      const exact = await leaf.resolver?.tryResolveFromSearch?.({
+        input: mergeInput(state.resolved, leaf.extraInput),
+        search: action.term
+      });
+      if (exact) {
+        setAtPath(state.resolved, path, coerce(leaf, exact.resolvedValue));
+        delete state.current;
+        delete state.listing;
+        return advance(ctx, state);
+      }
+    }
+    const context = await resolveContext(leaf, state.resolved);
+    state.listing = await fetchListing(leaf, state.resolved, {
+      ...attempt,
+      context
+    });
+    return {
+      state,
+      result: {
+        status: "ask",
+        question: selectQuestion(leaf, state.resolved, state.listing, context)
+      }
+    };
+  } catch (error) {
+    state.listing = {
+      items: attempt.priorItems,
+      search: attempt.search,
+      cursor: attempt.cursor,
+      exhausted: false
+    };
+    return failedResult(state, leaf.name, error);
+  }
+}
+function toJsonSchema(schema) {
+  if (!schema) return void 0;
+  try {
+    return zod.z.toJSONSchema(schema);
+  } catch {
+    return void 0;
+  }
+}
+function projectSummary(entry) {
+  return {
+    name: entry.name,
+    ...entry.description ? { description: entry.description } : {},
+    ...entry.categories?.length ? { categories: entry.categories } : {}
+  };
+}
+function projectMethod(entry) {
+  const inputProperties = toJsonSchema(entry.inputSchema)?.properties;
+  const parameters = {};
+  for (const spec of planParameters(entry).parameters) {
+    parameters[spec.name] = {
+      required: spec.required,
+      dynamic: Boolean(spec.resolver?.listItems),
+      ...spec.resolver?.inputType === "search" ? { searchable: true } : {},
+      ...inputProperties?.[spec.name] ? { schema: inputProperties[spec.name] } : {},
+      ...spec.staticChoices ? { choices: spec.staticChoices } : {},
+      ...spec.requires.length ? { requireParameters: spec.requires } : {}
+    };
+  }
+  const output = toJsonSchema(entry.outputSchema);
+  return {
+    name: entry.name,
+    ...entry.description ? { description: entry.description } : {},
+    ...entry.categories?.length ? { categories: entry.categories } : {},
+    parameters,
+    ...entry.positional?.length ? { positional: entry.positional } : {},
+    ...output ? { output } : {}
+  };
+}
+function createController(sdk) {
+  function entryFor(method) {
+    const entry = sdk.getRegistry().functions.find((f) => f.name === method);
+    if (!entry) throw new Error(`unknown method "${method}"`);
+    return entry;
+  }
+  function contextFor(method) {
+    const entry = entryFor(method);
+    return {
+      method,
+      schema: entry.inputSchema,
+      parameters: planParameters(entry).parameters
+    };
+  }
+  const start2 = ({ method, input, interactive }) => start(contextFor(method), input, interactive);
+  const step2 = ({ state, action }) => step(contextFor(state.method), state, action);
+  const resolve2 = async ({
+    method,
+    input,
+    answer,
+    interactive
+  }) => {
+    const ctx = contextFor(method);
+    let { state, result } = await start(ctx, input, interactive);
+    while (result.status === "ask" || result.status === "failed") {
+      const action = await answer({ state, result });
+      ({ state, result } = await step(ctx, state, action));
+    }
+    if (result.status === "done") return result.value;
+    if (result.status === "cancelled") {
+      throw new CoreCancelledSignal(`resolution cancelled for "${method}"`);
+    }
+    const detail = result.issues.map((i) => i.parameter ? `${i.parameter}: ${i.message}` : i.message).join("; ");
+    throw new Error(`invalid input for "${method}": ${detail}`);
+  };
+  const listMethods = () => ({
+    data: sdk.getRegistry().functions.map(projectSummary)
+  });
+  const getMethod = ({ method }) => ({
+    data: projectMethod(entryFor(method))
+  });
+  const listChoices = async ({
+    method,
+    parameter,
+    input = {},
+    search,
+    cursor
+  }) => {
+    const spec = contextFor(method).parameters.find(
+      (p) => p.name === parameter
+    );
+    if (!spec?.resolver?.listItems) return { data: [] };
+    const context = await spec.resolver.getContext?.({ input });
+    const page = await firstPage(
+      spec.resolver.listItems({ input, context, search, cursor })
+    );
+    const config = spec.resolver.prompt?.({ items: page.data, input, context });
+    const data = (config?.choices ?? []).map(toChoice);
+    return { data, nextCursor: page.nextCursor };
+  };
+  return { resolve: resolve2, start: start2, step: step2, listMethods, getMethod, listChoices };
+}
 function createCorePlugin(options) {
   return () => ({
     context: {
@@ -2825,8 +3665,8 @@ function normalizeHeaders(optionsHeaders) {
     return headers;
   }
   const headerEntries = optionsHeaders instanceof Headers ? Array.from(optionsHeaders.entries()) : Array.isArray(optionsHeaders) ? optionsHeaders : Object.entries(optionsHeaders);
-  for (const [key, value] of headerEntries) {
-    headers[key] = value;
+  for (const [key2, value] of headerEntries) {
+    headers[key2] = value;
   }
   return headers;
 }
@@ -3116,28 +3956,28 @@ function censorHeaders(headers) {
   if (!headers) return headers;
   const headersObj = new Headers(headers);
   const authKeys = ["authorization", "x-api-key"];
-  for (const [key, value] of headersObj.entries()) {
-    if (authKeys.some((authKey) => key.toLowerCase() === authKey)) {
+  for (const [key2, value] of headersObj.entries()) {
+    if (authKeys.some((authKey) => key2.toLowerCase() === authKey)) {
       const spaceIndex = value.indexOf(" ");
       if (spaceIndex > 0 && spaceIndex < value.length - 1) {
         const prefix = value.substring(0, spaceIndex + 1);
         const token = value.substring(spaceIndex + 1);
         if (token.length > 12) {
-          const start = token.substring(0, 4);
+          const start2 = token.substring(0, 4);
           const end = token.substring(token.length - 4);
-          headersObj.set(key, `${prefix}${start}...${end}`);
+          headersObj.set(key2, `${prefix}${start2}...${end}`);
         } else {
           const firstChar = token.charAt(0);
-          headersObj.set(key, `${prefix}${firstChar}...`);
+          headersObj.set(key2, `${prefix}${firstChar}...`);
         }
       } else {
         if (value.length > 12) {
-          const start = value.substring(0, 4);
+          const start2 = value.substring(0, 4);
           const end = value.substring(value.length - 4);
-          headersObj.set(key, `${start}...${end}`);
+          headersObj.set(key2, `${start2}...${end}`);
         } else {
           const firstChar = value.charAt(0);
-          headersObj.set(key, `${firstChar}...`);
+          headersObj.set(key2, `${firstChar}...`);
         }
       }
     }
@@ -3706,21 +4546,21 @@ function getClientIdFromCredentials(credentials) {
 function createMemoryCache() {
   const store = /* @__PURE__ */ new Map();
   return {
-    async get(key) {
-      const entry = store.get(key);
+    async get(key2) {
+      const entry = store.get(key2);
       if (!entry) return void 0;
       if (entry.expiresAt !== void 0 && entry.expiresAt <= Date.now()) {
-        store.delete(key);
+        store.delete(key2);
         return void 0;
       }
       return { value: entry.value, expiresAt: entry.expiresAt };
     },
-    async set(key, value, options) {
+    async set(key2, value, options) {
       const expiresAt = options?.ttl ? Date.now() + options.ttl * 1e3 : void 0;
-      store.set(key, { value, expiresAt });
+      store.set(key2, { value, expiresAt });
     },
-    async delete(key) {
-      store.delete(key);
+    async delete(key2) {
+      store.delete(key2);
     }
   };
 }
@@ -4211,14 +5051,14 @@ function createSseParserStream() {
     transform(chunk, controller) {
       buffer += chunk;
       const newline = /\r\n|\r|\n/g;
-      let start = 0;
+      let start2 = 0;
       let match;
       while ((match = newline.exec(buffer)) !== null) {
         if (match[0] === "\r" && match.index === buffer.length - 1) break;
-        processLine(buffer.slice(start, match.index), controller);
-        start = match.index + match[0].length;
+        processLine(buffer.slice(start2, match.index), controller);
+        start2 = match.index + match[0].length;
       }
-      buffer = buffer.slice(start);
+      buffer = buffer.slice(start2);
     },
     flush(controller) {
       if (buffer.endsWith("\r")) {
@@ -4376,7 +5216,7 @@ function parseDeprecationDate(value) {
 }
 
 // src/sdk-version.ts
-var SDK_VERSION = (typeof process !== "undefined" && process.env ? "0.79.0" : void 0) || "unknown";
+var SDK_VERSION = (typeof process !== "undefined" && process.env ? "0.80.1" : void 0) || "unknown";
 
 // src/utils/open-url.ts
 var nodePrefix = "node:";
@@ -4622,11 +5462,11 @@ var ZapierApiClient = class {
       );
       const inputHeaders = new Headers(init?.headers ?? {});
       const mergedHeaders = new Headers();
-      builtHeaders.forEach((value, key) => {
-        mergedHeaders.set(key, value);
+      builtHeaders.forEach((value, key2) => {
+        mergedHeaders.set(key2, value);
       });
-      inputHeaders.forEach((value, key) => {
-        mergedHeaders.set(key, value);
+      inputHeaders.forEach((value, key2) => {
+        mergedHeaders.set(key2, value);
       });
       this.applyTelemetryHeaders(mergedHeaders);
       let retries = 0;
@@ -5151,8 +5991,8 @@ var ZapierApiClient = class {
       canSendDeprecationMessaging
     } = this.applyPathConfiguration(path);
     if (searchParams) {
-      Object.entries(searchParams).forEach(([key, value]) => {
-        url.searchParams.set(key, value);
+      Object.entries(searchParams).forEach(([key2, value]) => {
+        url.searchParams.set(key2, value);
       });
     }
     return {
@@ -5662,7 +6502,8 @@ function getOrCreateApiClient(config) {
     token,
     api: providedApi,
     debug = false,
-    fetch: customFetch
+    fetch: customFetch,
+    callerPackage
   } = config;
   if (providedApi) {
     return providedApi;
@@ -5672,7 +6513,8 @@ function getOrCreateApiClient(config) {
     credentials,
     token,
     debug,
-    fetch: customFetch
+    fetch: customFetch,
+    callerPackage
   });
 }
 
@@ -5803,7 +6645,7 @@ var listAppsPlugin = definePlugin(
           locator
         ];
       }
-      const duplicatedLookupAppKeys = Object.keys(implementationNameToLocator).filter((key) => implementationNameToLocator[key].length > 1).map((key) => implementationNameToLocator[key]).flat().map((locator) => locator.lookupAppKey);
+      const duplicatedLookupAppKeys = Object.keys(implementationNameToLocator).filter((key2) => implementationNameToLocator[key2].length > 1).map((key2) => implementationNameToLocator[key2]).flat().map((locator) => locator.lookupAppKey);
       if (duplicatedLookupAppKeys.length > 0) {
         throw new Error(
           `Duplicate lookup app keys found: ${duplicatedLookupAppKeys.join(", ")}`
@@ -6296,7 +7138,7 @@ function formatRecordError(fieldId, err) {
 function formatResponseError(err) {
   const message = err.human_title || err.title || "Unknown error";
   if (err.meta && Object.keys(err.meta).length > 0) {
-    const metaParts = Object.entries(err.meta).map(([key, val]) => `${key}: ${JSON.stringify(val)}`).join(", ");
+    const metaParts = Object.entries(err.meta).map(([key2, val]) => `${key2}: ${JSON.stringify(val)}`).join(", ");
     return `${message} (${metaParts})`;
   }
   return message;
@@ -6331,8 +7173,8 @@ var TrashSchema = zod.z.enum(["exclude", "include", "only"]).optional().describe
   'Control soft-deleted item visibility. "exclude" (default) returns active items only, "include" returns both active and soft-deleted, "only" returns soft-deleted items only.'
 );
 var FIELD_ID_PATTERN = /^f\d+$/;
-function isFieldId(key) {
-  return FIELD_ID_PATTERN.test(key);
+function isFieldId(key2) {
+  return FIELD_ID_PATTERN.test(key2);
 }
 var NESTED_COMPONENTS = {
   labeled_string: /* @__PURE__ */ new Set(["value"]),
@@ -6370,7 +7212,7 @@ async function resolveFieldKeys({
   fieldKeys
 }) {
   const allAreIds = fieldKeys.every(
-    (key) => typeof key === "number" || /^(f?\d+)$/.test(key)
+    (key2) => typeof key2 === "number" || /^(f?\d+)$/.test(key2)
   );
   if (allAreIds) {
     return fieldKeys.map(toNumericFieldId);
@@ -6379,13 +7221,13 @@ async function resolveFieldKeys({
   if (!mapping) {
     return fieldKeys.map(toNumericFieldId);
   }
-  return fieldKeys.map((key) => {
-    if (typeof key === "number") return key;
-    if (FIELD_ID_PATTERN.test(key)) return toNumericFieldId(key);
-    const id = mapping.nameToId.get(key);
+  return fieldKeys.map((key2) => {
+    if (typeof key2 === "number") return key2;
+    if (FIELD_ID_PATTERN.test(key2)) return toNumericFieldId(key2);
+    const id = mapping.nameToId.get(key2);
     if (!id) {
       throw new ZapierValidationError(
-        `Unknown field name: "${key}". Use a valid field name or ID.`
+        `Unknown field name: "${key2}". Use a valid field name or ID.`
       );
     }
     return toNumericFieldId(id);
@@ -6401,13 +7243,13 @@ async function createFieldKeyTranslator({
     translateInput(data) {
       if (!mapping) return data;
       const result = {};
-      for (const [key, value] of Object.entries(data)) {
-        if (FIELD_ID_PATTERN.test(key) && mapping.idToName.has(key)) {
-          result[key] = value;
-        } else if (mapping.nameToId.has(key)) {
-          result[mapping.nameToId.get(key)] = value;
+      for (const [key2, value] of Object.entries(data)) {
+        if (FIELD_ID_PATTERN.test(key2) && mapping.idToName.has(key2)) {
+          result[key2] = value;
+        } else if (mapping.nameToId.has(key2)) {
+          result[mapping.nameToId.get(key2)] = value;
         } else {
-          result[key] = value;
+          result[key2] = value;
         }
       }
       return result;
@@ -6415,29 +7257,29 @@ async function createFieldKeyTranslator({
     translateOutput(data) {
       if (!mapping) return data;
       const result = {};
-      for (const [key, value] of Object.entries(data)) {
-        if (mapping.idToName.has(key)) {
-          result[mapping.idToName.get(key)] = value;
+      for (const [key2, value] of Object.entries(data)) {
+        if (mapping.idToName.has(key2)) {
+          result[mapping.idToName.get(key2)] = value;
         } else {
-          result[key] = value;
+          result[key2] = value;
         }
       }
       return result;
     },
-    translateFieldKey(key) {
-      if (!mapping) return key;
-      if (FIELD_ID_PATTERN.test(key) && mapping.idToName.has(key)) {
-        const fieldType = mapping.idToType.get(key);
+    translateFieldKey(key2) {
+      if (!mapping) return key2;
+      if (FIELD_ID_PATTERN.test(key2) && mapping.idToName.has(key2)) {
+        const fieldType = mapping.idToType.get(key2);
         if (fieldType) {
           const components = NESTED_COMPONENTS[fieldType];
           if (components?.size === 1) {
-            return `${key}__${[...components][0]}`;
+            return `${key2}__${[...components][0]}`;
           }
         }
-        return key;
+        return key2;
       }
-      if (mapping.nameToId.has(key)) {
-        const fieldId = mapping.nameToId.get(key);
+      if (mapping.nameToId.has(key2)) {
+        const fieldId = mapping.nameToId.get(key2);
         const fieldType = mapping.idToType.get(fieldId);
         if (fieldType) {
           const components = NESTED_COMPONENTS[fieldType];
@@ -6447,10 +7289,10 @@ async function createFieldKeyTranslator({
         }
         return fieldId;
       }
-      const sepIndex = key.lastIndexOf("__");
+      const sepIndex = key2.lastIndexOf("__");
       if (sepIndex > 0) {
-        const prefix = key.slice(0, sepIndex);
-        const component = key.slice(sepIndex + 2);
+        const prefix = key2.slice(0, sepIndex);
+        const component = key2.slice(sepIndex + 2);
         let fieldId;
         if (FIELD_ID_PATTERN.test(prefix) && mapping.idToName.has(prefix)) {
           fieldId = prefix;
@@ -6464,7 +7306,7 @@ async function createFieldKeyTranslator({
           }
         }
       }
-      return key;
+      return key2;
     }
   };
 }
@@ -7381,9 +8223,9 @@ var RunActionSchemaDeprecated = zod.z.object({
 var RunActionInputSchema = zod.z.union([RunActionSchema, RunActionSchemaDeprecated]).describe(RunActionDescription);
 
 // src/formatters/actionResult.ts
-function getStringProperty(obj, key) {
-  if (typeof obj === "object" && obj !== null && key in obj) {
-    const value = obj[key];
+function getStringProperty(obj, key2) {
+  if (typeof obj === "object" && obj !== null && key2 in obj) {
+    const value = obj[key2];
     return typeof value === "string" ? value : void 0;
   }
   return void 0;
@@ -7470,13 +8312,13 @@ var runActionPlugin = definePlugin(
       let oldestKey;
       let oldestExpiry = Infinity;
       let evictedAny = false;
-      for (const [key, entry] of runActionContextCache) {
+      for (const [key2, entry] of runActionContextCache) {
         if (now >= entry.expiresAt) {
-          runActionContextCache.delete(key);
+          runActionContextCache.delete(key2);
           evictedAny = true;
         } else if (entry.expiresAt < oldestExpiry) {
           oldestExpiry = entry.expiresAt;
-          oldestKey = key;
+          oldestKey = key2;
         }
       }
       if (!evictedAny && oldestKey) {
@@ -8104,36 +8946,36 @@ var createConnectionPlugin = definePlugin(
       sdk: inner,
       options
     }) => {
-      const { data: start } = await inner.getConnectionStartUrl({
+      const { data: start2 } = await inner.getConnectionStartUrl({
         app: options.app
       });
-      setMethodMetadata({ selectedApi: start.app });
+      setMethodMetadata({ selectedApi: start2.app });
       console.error(
         `
 Open this URL to complete the connection:
-  ${start.url}
+  ${start2.url}
 `
       );
       const shouldOpen = options.browser === "always" || options.browser === "auto" && shouldOpenBrowser();
       if (shouldOpen) {
         try {
-          await open_url_default(start.url);
+          await open_url_default(start2.url);
         } catch {
         }
       }
       const { data: fresh } = await inner.waitForNewConnection({
-        app: start.app,
+        app: start2.app,
         // Server-stamped mint time: measured on the same clock as a
         // connection's `date`, so the freshness check is immune to
         // client/server clock skew.
-        startedAt: start.startedAt,
+        startedAt: start2.startedAt,
         timeoutMs: options.timeoutMs,
         pollIntervalMs: options.pollIntervalMs
       });
       return {
         data: CreateConnectionItemSchema.parse({
           id: fresh.id,
-          app: start.app,
+          app: start2.app,
           title: fresh.title ?? null
         })
       };
@@ -10132,9 +10974,9 @@ function findManifestEntry({
       return [slug, manifest.apps[slug]];
     }
   }
-  for (const [key, entry] of Object.entries(manifest.apps)) {
+  for (const [key2, entry] of Object.entries(manifest.apps)) {
     if (entry.implementationName === appKeyWithoutVersion) {
-      return [key, entry];
+      return [key2, entry];
     }
   }
   return null;
@@ -10391,21 +11233,21 @@ var manifestPlugin = definePlugin(
 );
 
 // src/plugins/capabilities/index.ts
-function toDescription(key) {
-  const words = key.replace(/^can/, "").replace(/([A-Z])/g, " $1").trim().toLowerCase();
+function toDescription(key2) {
+  const words = key2.replace(/^can/, "").replace(/([A-Z])/g, " $1").trim().toLowerCase();
   return `To ${words}`;
 }
-function toEnvVar(key) {
-  return "ZAPIER_" + key.replace(/([A-Z])/g, "_$1").toUpperCase();
+function toEnvVar(key2) {
+  return "ZAPIER_" + key2.replace(/([A-Z])/g, "_$1").toUpperCase();
 }
-function toCliFlag(key) {
-  return "--" + key.replace(/([A-Z])/g, "-$1").toLowerCase();
+function toCliFlag(key2) {
+  return "--" + key2.replace(/([A-Z])/g, "-$1").toLowerCase();
 }
-function buildCapabilityMessage(key) {
+function buildCapabilityMessage(key2) {
   return [
-    `${toDescription(key)}, use ${toCliFlag(key)} in the CLI,`,
-    `set ${key}: true in SDK options or .zapierrc,`,
-    `or set ${toEnvVar(key)}=true.`
+    `${toDescription(key2)}, use ${toCliFlag(key2)} in the CLI,`,
+    `set ${key2}: true in SDK options or .zapierrc,`,
+    `or set ${toEnvVar(key2)}=true.`
   ].join(" ");
 }
 var GATED_FLAGS = [
@@ -10413,8 +11255,8 @@ var GATED_FLAGS = [
   "canIncludeSharedTables",
   "canDeleteTables"
 ];
-function isEnabledByEnv(key) {
-  const value = globalThis.process?.env?.[toEnvVar(key)];
+function isEnabledByEnv(key2) {
+  const value = globalThis.process?.env?.[toEnvVar(key2)];
   if (value === void 0) return void 0;
   if (value === "true" || value === "1") return true;
   if (value === "false" || value === "0") return false;
@@ -10437,17 +11279,17 @@ var capabilitiesPlugin = definePlugin(
     }
     return {
       context: {
-        checkCapability: async (key) => {
+        checkCapability: async (key2) => {
           const flags = await resolveFlags();
-          if (flags[key]) return;
+          if (flags[key2]) return;
           throw new ZapierConfigurationError(
-            buildCapabilityMessage(key) + " (If you are an AI agent, you MUST NOT retry. Ask the user if they want to enable this.)",
-            { configType: key }
+            buildCapabilityMessage(key2) + " (If you are an AI agent, you MUST NOT retry. Ask the user if they want to enable this.)",
+            { configType: key2 }
           );
         },
-        hasCapability: async (key) => {
+        hasCapability: async (key2) => {
           const flags = await resolveFlags();
-          return flags[key];
+          return flags[key2];
         }
       }
     };
@@ -10605,8 +11447,8 @@ function getOsInfo() {
 function getPlatformVersions() {
   const versions = {};
   if (typeof globalThis.process?.versions === "object") {
-    for (const [key, value] of Object.entries(globalThis.process.versions)) {
-      versions[key] = value || null;
+    for (const [key2, value] of Object.entries(globalThis.process.versions)) {
+      versions[key2] = value || null;
     }
   }
   return versions;
@@ -10848,9 +11690,9 @@ async function emitWithTimeout(transport, subject, event) {
 }
 function mergeUserContext(event, userContext) {
   const merged = { ...event };
-  for (const [key, value] of Object.entries(userContext)) {
-    if (merged[key] == null) {
-      merged[key] = value;
+  for (const [key2, value] of Object.entries(userContext)) {
+    if (merged[key2] == null) {
+      merged[key2] = value;
     }
   }
   return merged;
@@ -12123,9 +12965,9 @@ function createWaiter() {
     }
   };
 }
-function addToMap(m, key, value) {
-  const existing = m.get(key) ?? [];
-  m.set(key, [...existing, value]);
+function addToMap(m, key2, value) {
+  const existing = m.get(key2) ?? [];
+  m.set(key2, [...existing, value]);
 }
 async function runBatchedDrainPipeline(options) {
   const {
@@ -12928,14 +13770,14 @@ function toWireConnections(connections) {
 }
 function toWireAppVersions(appVersions) {
   const wire = {};
-  for (const [key, entry] of Object.entries(appVersions)) {
+  for (const [key2, entry] of Object.entries(appVersions)) {
     const implementationName = entry.implementationName ?? entry.implementation_name;
     if (implementationName === void 0) {
       throw new ZapierValidationError(
-        `appVersions["${key}"] is missing implementationName`
+        `appVersions["${key2}"] is missing implementationName`
       );
     }
-    wire[key] = {
+    wire[key2] = {
       implementation_name: implementationName,
       ...entry.version !== void 0 ? { version: entry.version } : {}
     };
@@ -14357,13 +15199,16 @@ exports.BaseSdkOptionsSchema = BaseSdkOptionsSchema;
 exports.CONTEXT_CACHE_MAX_SIZE = CONTEXT_CACHE_MAX_SIZE;
 exports.CONTEXT_CACHE_TTL_MS = CONTEXT_CACHE_TTL_MS;
 exports.CORE_ERROR_SYMBOL = CORE_ERROR_SYMBOL;
+exports.CORE_SIGNAL_SYMBOL = CORE_SIGNAL_SYMBOL;
 exports.ClientCredentialsObjectSchema = ClientCredentialsObjectSchema;
 exports.ConnectionEntrySchema = ConnectionEntrySchema;
 exports.ConnectionIdPropertySchema = ConnectionIdPropertySchema;
 exports.ConnectionPropertySchema = ConnectionPropertySchema;
 exports.ConnectionsMapSchema = ConnectionsMapSchema;
 exports.ConnectionsPropertySchema = ConnectionsPropertySchema;
+exports.CoreCancelledSignal = CoreCancelledSignal;
 exports.CoreErrorCode = CoreErrorCode;
+exports.CoreSignal = CoreSignal;
 exports.CredentialsFunctionSchema = CredentialsFunctionSchema;
 exports.CredentialsObjectSchema = CredentialsObjectSchema;
 exports.CredentialsSchema = CredentialsSchema;
@@ -14443,6 +15288,7 @@ exports.connectionIdResolver = connectionIdResolver;
 exports.connectionsPlugin = connectionsPlugin;
 exports.createBaseEvent = createBaseEvent;
 exports.createClientCredentialsPlugin = createClientCredentialsPlugin;
+exports.createController = createController;
 exports.createCorePlugin = createCorePlugin;
 exports.createFunction = createFunction;
 exports.createMemoryCache = createMemoryCache;
@@ -14466,6 +15312,7 @@ exports.defineLegacyMerge = defineLegacyMerge;
 exports.defineMethod = defineMethod;
 exports.definePlugin = definePlugin;
 exports.defineProperty = defineProperty;
+exports.defineResolver = defineResolver;
 exports.deleteClientCredentialsPlugin = deleteClientCredentialsPlugin;
 exports.deleteTableFieldsPlugin = deleteTableFieldsPlugin;
 exports.deleteTablePlugin = deleteTablePlugin;
@@ -14518,6 +15365,7 @@ exports.isCi = isCi;
 exports.isCliLoginAvailable = isCliLoginAvailable;
 exports.isClientCredentials = isClientCredentials;
 exports.isCoreError = isCoreError;
+exports.isCoreSignal = isCoreSignal;
 exports.isCredentialsFunction = isCredentialsFunction;
 exports.isCredentialsObject = isCredentialsObject;
 exports.isPermanentHttpError = isPermanentHttpError;