@zapier/zapier-sdk 0.64.0 → 0.67.0

package/dist/index.mjs

@@ -11,547 +11,271 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
   if (typeof require !== "undefined") return require.apply(this, arguments);
   throw Error('Dynamic require of "' + x + '" is not supported');
 });
-function withFormatter(schema, formatMeta) {
-  Object.assign(schema._zod.def, {
-    formatMeta
-  });
-  return schema;
-}
-function withPositional(schema) {
-  Object.assign(schema._zod.def, {
-    positionalMeta: { positional: true }
-  });
-  return schema;
-}
-function schemaHasPositionalMeta(schema) {
-  return "positionalMeta" in schema._zod.def;
+function toTitleCase(input) {
+  return input.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/[_\-]+/g, " ").replace(/\s+/g, " ").trim().split(" ").map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join(" ");
 }
-function isPositional(schema) {
-  if (schemaHasPositionalMeta(schema) && schema._zod.def.positionalMeta?.positional) {
-    return true;
-  }
-  if (schema instanceof z.ZodOptional) {
-    return isPositional(schema._zod.def.innerType);
+function toSnakeCase(input) {
+  let result = input.replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/[\s\-]+/g, "_").replace(/_+/g, "_").replace(/^_|_$/g, "").toLowerCase();
+  if (/^[0-9]/.test(result)) {
+    result = "_" + result;
   }
-  if (schema instanceof z.ZodDefault) {
-    return isPositional(schema._zod.def.innerType);
+  return result;
+}
+function pluralize(word) {
+  if (/s$/i.test(word)) return word;
+  if (/[bcdfghjklmnpqrstvwxz]y$/i.test(word)) {
+    return word.slice(0, -1) + "ies";
   }
-  return false;
+  return word + "s";
 }
-
-// src/constants.ts
-var ZAPIER_BASE_URL = globalThis.process?.env?.ZAPIER_BASE_URL || "https://zapier.com";
-function getZapierSdkService() {
-  return globalThis.process?.env?.ZAPIER_SDK_SERVICE;
+function pluralizeLastWord(title) {
+  const words = title.split(" ");
+  return [...words.slice(0, -1), pluralize(words[words.length - 1])].join(" ");
 }
-var MAX_PAGE_LIMIT = 1e4;
-var DEFAULT_PAGE_SIZE = 100;
-var DEFAULT_ACTION_TIMEOUT_MS = 18e4;
-function parseIntEnvVar(name) {
-  const value = globalThis.process?.env?.[name];
-  if (value === void 0) return void 0;
-  const parsed = parseInt(value, 10);
-  if (isNaN(parsed)) {
-    console.warn(
-      `[zapier-sdk] Invalid value for ${name}: "${value}" (expected integer)`
-    );
-    return void 0;
+function resolveCategoryDefinition(ref) {
+  const def = typeof ref === "string" ? { key: ref } : ref;
+  const title = def.title ?? toTitleCase(def.key);
+  return {
+    key: def.key,
+    title,
+    titlePlural: def.titlePlural ?? pluralizeLastWord(title)
+  };
+}
+function canonicalInputSchema(schema) {
+  if (schema instanceof z.ZodUnion) {
+    return schema.options[0];
   }
-  return parsed;
+  return schema;
 }
-var ZAPIER_MAX_NETWORK_RETRIES = parseIntEnvVar("ZAPIER_MAX_NETWORK_RETRIES") ?? 3;
-var ZAPIER_MAX_NETWORK_RETRY_DELAY_MS = parseIntEnvVar("ZAPIER_MAX_NETWORK_RETRY_DELAY_MS") ?? 6e4;
-var MAX_CONCURRENCY_LIMIT = 1e4;
-function parseConcurrencyEnvVar(name) {
-  const value = globalThis.process?.env?.[name];
-  if (!value) return void 0;
-  if (value === "Infinity") return Infinity;
-  if (/^[1-9]\d*$/.test(value)) {
-    const parsed = parseInt(value, 10);
-    if (parsed <= MAX_CONCURRENCY_LIMIT) return parsed;
+function buildRegistry({
+  sdk,
+  meta,
+  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;
+      if (typeof ref === "object") {
+        objectDeclaredKeys.add(key);
+        definitionsByKey.set(key, resolveCategoryDefinition(ref));
+      } else if (!objectDeclaredKeys.has(key)) {
+        definitionsByKey.set(key, resolveCategoryDefinition(ref));
+      }
+    }
   }
-  console.warn(
-    `[zapier-sdk] Invalid value for ${name}: "${value}" (expected positive integer 1-${MAX_CONCURRENCY_LIMIT} or "Infinity")`
-  );
-  return void 0;
+  if (!definitionsByKey.has("other")) {
+    definitionsByKey.set("other", resolveCategoryDefinition("other"));
+  }
+  const knownCategories = Array.from(definitionsByKey.keys());
+  const functions = Object.keys(meta).filter((key) => {
+    const property = sdk[key];
+    if (typeof property === "function") return true;
+    const [rootKey] = key.split(".");
+    const rootProperty = sdk[rootKey];
+    return typeof rootProperty === "object" && rootProperty !== null;
+  }).map((key) => {
+    const m = meta[key];
+    return {
+      name: key,
+      description: m.description,
+      type: m.type,
+      itemType: m.itemType,
+      returnType: m.returnType,
+      inputSchema: canonicalInputSchema(m.inputSchema),
+      inputParameters: m.inputParameters,
+      outputSchema: m.outputSchema,
+      categories: (m.categories ?? []).map(
+        (c) => typeof c === "string" ? c : c.key
+      ),
+      resolvers: m.resolvers,
+      formatter: m.formatter,
+      experimental: m.experimental,
+      packages: m.packages,
+      confirm: m.confirm ?? (m.type === "delete" ? "delete" : void 0),
+      deprecation: m.deprecation,
+      aliases: m.aliases,
+      supportsJsonOutput: m.supportsJsonOutput ?? true
+    };
+  }).sort((a, b) => a.name.localeCompare(b.name));
+  const filteredFunctions = packageFilter ? functions.filter((f) => !f.packages || f.packages.includes(packageFilter)) : functions;
+  const filteredCategories = knownCategories.slice().sort((a, b) => {
+    if (a === "other") return 1;
+    if (b === "other") return -1;
+    return definitionsByKey.get(a).title.localeCompare(definitionsByKey.get(b).title);
+  }).map((categoryKey) => {
+    const categoryFunctions = filteredFunctions.filter(
+      (f) => f.categories.includes(categoryKey) || categoryKey === "other" && !f.categories.some((c) => knownCategories.includes(c))
+    ).map((f) => f.name).sort();
+    const def = definitionsByKey.get(categoryKey);
+    return {
+      key: categoryKey,
+      title: def.title,
+      titlePlural: def.titlePlural,
+      functions: categoryFunctions
+    };
+  }).filter((category) => category.functions.length > 0);
+  return { functions: filteredFunctions, categories: filteredCategories };
 }
-var ZAPIER_MAX_CONCURRENT_REQUESTS = parseConcurrencyEnvVar("ZAPIER_MAX_CONCURRENT_REQUESTS") ?? 200;
-function getZapierApprovalMode() {
-  const value = globalThis.process?.env?.ZAPIER_APPROVAL_MODE;
-  if (value === "disabled" || value === "poll" || value === "throw")
-    return value;
-  return void 0;
+function composeVoid(existing, added) {
+  if (!existing) return added;
+  if (!added) return existing;
+  return (ctx) => {
+    existing(ctx);
+    added(ctx);
+  };
 }
-function getZapierDefaultApprovalMode() {
-  const isInteractive = !!globalThis.process?.stdin?.isTTY && !!globalThis.process?.stdout?.isTTY;
-  return isInteractive ? "poll" : "throw";
+function buildHooks(existing, added) {
+  const result = {};
+  const start = composeVoid(existing.onMethodStart, added.onMethodStart);
+  if (start) result.onMethodStart = start;
+  const end = composeVoid(existing.onMethodEnd, added.onMethodEnd);
+  if (end) result.onMethodEnd = end;
+  return result;
 }
-var DEFAULT_APPROVAL_TIMEOUT_MS = 10 * 60 * 1e3;
-var DEFAULT_MAX_APPROVAL_RETRIES = 2;
-
-// src/types/properties.ts
-var AppKeyPropertySchema = withPositional(
-  z.string().min(1).describe("App key (e.g., 'SlackCLIAPI' or slug like 'github')")
-);
-var AppPropertySchema = withPositional(
-  z.string().min(1).describe(
-    "App slug (e.g., 'github'), implementation name (e.g., 'SlackCLIAPI'), or versioned ID (e.g., 'github@1.2.3')"
-  )
-);
-var ActionTypePropertySchema = z.enum([
-  "read",
-  "read_bulk",
-  "write",
-  "run",
-  "search",
-  "search_or_write",
-  "search_and_write",
-  "filter"
-]).describe("Action type that matches the action's defined type");
-var ActionKeyPropertySchema = z.string().min(1).describe("Action key to execute");
-var ActionPropertySchema = withPositional(
-  z.string().min(1).describe("Action key (e.g., 'send_message' or 'find_row')")
-);
-var InputFieldPropertySchema = withPositional(
-  z.string().min(1).describe("Input field key to get choices for")
-);
-var ConnectionIdPropertySchema = z.union([z.string(), z.number().int().positive()]).describe("Connection ID to use for this action");
-var AuthenticationIdPropertySchema = ConnectionIdPropertySchema.meta({
-  deprecated: true
-});
-var ConnectionPropertySchema = z.union([z.string(), z.number().int().positive()]).describe(
-  "Connection alias or connection ID (UUID or positive integer). Strings that match a key in the connections map are resolved against it; otherwise the value is used as a connection ID directly."
-);
-var InputsPropertySchema = z.record(z.string(), z.unknown()).describe("Input parameters for the action");
-var LimitPropertySchema = z.number().int().min(1).max(MAX_PAGE_LIMIT).default(50).describe("Maximum number of items to return");
-var OffsetPropertySchema = z.number().int().min(0).default(0).describe("Number of items to skip for pagination");
-var OutputPropertySchema = z.string().describe("Output file path");
-var DebugPropertySchema = z.boolean().default(false).describe("Enable debug logging");
-var ParamsPropertySchema = z.record(z.string(), z.unknown()).describe("Additional parameters");
-var ActionTimeoutMsPropertySchema = z.number().min(1e3).optional().describe(
-  `Maximum time to wait for action completion in milliseconds (default: ${DEFAULT_ACTION_TIMEOUT_MS})`
-);
-var TablePropertySchema = withPositional(
-  z.string().regex(/^[A-Z0-9]{26}$/, "Table ID must be a valid ULID").describe("The unique identifier of the table")
-);
-var RecordPropertySchema = withPositional(
-  z.string().regex(/^[A-Z0-9]{26}$/, "Record ID must be a valid ULID").describe("The unique identifier of the record")
-);
-var RecordsPropertySchema = z.array(z.string().regex(/^[A-Z0-9]{26}$/, "Record ID must be a valid ULID")).min(1).max(100).describe("Record IDs to operate on");
-var FieldsPropertySchema = z.array(z.union([z.string(), z.number()])).describe(
-  'Fields to operate on. Accepts field names (e.g., "Email") or IDs (e.g., "f6", "6", or 6).'
-);
-var AppsPropertySchema = z.array(z.string()).describe("Filter by app keys (e.g., 'SlackCLIAPI' or slug like 'github')");
-var TablesPropertySchema = z.array(z.string()).describe("Filter by specific table IDs");
-var ConnectionsPropertySchema = z.array(z.string()).describe("List of connection IDs to filter by");
-var TriggerInboxPropertySchema = withPositional(
-  z.string().min(1).describe(
-    "Trigger inbox identifier \u2014 UUID or name. Non-UUID values are resolved by name via the inbox list endpoint."
-  )
-);
-var TriggerInboxNamePropertySchema = z.string().min(1).max(100).describe(
-  "Inbox name; unique per (user, account). Enables get-or-create on createTriggerInbox."
-);
-var LeasePropertySchema = z.string().min(1).describe("Lease ID returned from leaseTriggerInboxMessages");
-var LeaseSecondsPropertySchema = z.number().int().min(1).max(3600).describe(
-  "Seconds until the lease expires; messages return to available if not acked. API default is 300 (5 minutes)."
-);
-var LeaseLimitPropertySchema = z.number().int().min(1).max(100).describe("Maximum messages to lease in a single batch (1-100)");
-
-// src/types/errors.ts
-var ZapierError = class extends Error {
+function createDeprecationLogger(tag) {
+  const loggedDeprecations = /* @__PURE__ */ new Set();
+  return {
+    logDeprecation(message) {
+      if (loggedDeprecations.has(message)) return;
+      loggedDeprecations.add(message);
+      console.warn(`[${tag}] Deprecation: ${message}`);
+    },
+    resetDeprecationWarnings() {
+      loggedDeprecations.clear();
+    }
+  };
+}
+var { logDeprecation} = createDeprecationLogger("core");
+var CORE_ERROR_SYMBOL = Symbol.for("kitcore.error");
+var CoreErrorCode = {
+  Validation: "VALIDATION_ERROR",
+  Unknown: "UNKNOWN_ERROR"
+};
+var CoreError = class extends Error {
   constructor(message, options = {}) {
     super(message);
-    this.statusCode = options.statusCode;
-    this.errors = options.errors;
-    this.cause = options.cause;
-    this.response = options.response;
+    this.name = "CoreError";
+    if (options.statusCode !== void 0) this.statusCode = options.statusCode;
+    if (options.errors !== void 0) this.errors = options.errors;
+    if (options.cause !== void 0) this.cause = options.cause;
+    if (options.response !== void 0) this.response = options.response;
     Object.setPrototypeOf(this, new.target.prototype);
   }
 };
-var ZapierApiError = class extends ZapierError {
-  constructor(message, options = {}) {
-    super(message, options);
-    this.name = "ZapierApiError";
-    this.code = "ZAPIER_API_ERROR";
-  }
-};
-var ZapierAppNotFoundError = class extends ZapierError {
-  constructor(message, options = {}) {
-    super(message, options);
-    this.name = "ZapierAppNotFoundError";
-    this.code = "ZAPIER_APP_NOT_FOUND_ERROR";
-    this.appKey = options.appKey;
-  }
-};
-var ZapierValidationError = class extends ZapierError {
-  constructor(message, options = {}) {
-    super(message, options);
-    this.name = "ZapierValidationError";
-    this.code = "ZAPIER_VALIDATION_ERROR";
-    this.details = options.details;
-  }
-};
-var ZapierUnknownError = class extends ZapierError {
-  constructor(message, options = {}) {
-    super(message, options);
-    this.name = "ZapierUnknownError";
-    this.code = "ZAPIER_UNKNOWN_ERROR";
-  }
+function createCoreError(options, adaptError) {
+  const error = adaptError?.(options) ?? new CoreError(options.message, { cause: options.cause });
+  Object.defineProperty(error, CORE_ERROR_SYMBOL, {
+    value: true,
+    enumerable: false,
+    configurable: true,
+    writable: false
+  });
+  Object.defineProperty(error, "coreCode", {
+    value: options.code,
+    enumerable: false,
+    configurable: true,
+    writable: false
+  });
+  return error;
+}
+function isCoreError(value) {
+  return Boolean(
+    value && typeof value === "object" && value[CORE_ERROR_SYMBOL] === true
+  );
+}
+function getCoreErrorCode(value) {
+  if (!isCoreError(value)) return void 0;
+  return value.coreCode;
+}
+function getCoreErrorCause(value) {
+  if (!isCoreError(value)) return void 0;
+  return value.cause;
+}
+var CURSOR_VERSION = 1;
+var CURSOR_SOURCE = {
+  API: "api",
+  SDK: "sdk"
 };
-var ZapierAuthenticationError = class extends ZapierError {
-  constructor(message, options = {}) {
-    super(message, options);
-    this.name = "ZapierAuthenticationError";
-    this.code = "ZAPIER_AUTHENTICATION_ERROR";
-  }
-};
-var ZapierNotFoundError = class extends ZapierError {
-  constructor(message, options = {}) {
-    super(message, options);
-    this.name = "ZapierNotFoundError";
-    this.code = "ZAPIER_NOT_FOUND_ERROR";
-  }
-};
-var ZapierResourceNotFoundError = class extends ZapierNotFoundError {
-  constructor(message, options = {}) {
-    super(message, options);
-    this.name = "ZapierResourceNotFoundError";
-    this.code = "ZAPIER_RESOURCE_NOT_FOUND_ERROR";
-    this.resourceType = options.resourceType;
-    this.resourceId = options.resourceId;
-  }
-};
-var ZapierConfigurationError = class extends ZapierError {
-  constructor(message, options = {}) {
-    super(message, options);
-    this.name = "ZapierConfigurationError";
-    this.code = "ZAPIER_CONFIGURATION_ERROR";
-    this.configType = options.configType;
-  }
-};
-var ZapierBundleError = class extends ZapierError {
-  constructor(message, options = {}) {
-    super(message, options);
-    this.name = "ZapierBundleError";
-    this.code = "ZAPIER_BUNDLE_ERROR";
-    this.buildErrors = options.buildErrors;
-  }
-};
-var ZapierTimeoutError = class extends ZapierError {
-  constructor(message, options = {}) {
-    super(message, options);
-    this.name = "ZapierTimeoutError";
-    this.code = "ZAPIER_TIMEOUT_ERROR";
-    this.attempts = options.attempts;
-    this.maxAttempts = options.maxAttempts;
-  }
-};
-var ZapierActionError = class extends ZapierError {
-  constructor(message, options = {}) {
-    super(message, options);
-    this.name = "ZapierActionError";
-    this.code = "ZAPIER_ACTION_ERROR";
-    this.appKey = options.appKey;
-    this.actionKey = options.actionKey;
-  }
-  // Legacy accessor for backward compatibility
-  get actionErrors() {
-    return this.errors;
-  }
-};
-var ZapierConflictError = class extends ZapierError {
-  constructor(message, options = {}) {
-    super(message, options);
-    this.name = "ZapierConflictError";
-    this.code = "ZAPIER_CONFLICT_ERROR";
-    this.resourceType = options.resourceType;
-  }
-};
-var ZapierRateLimitError = class extends ZapierError {
-  constructor(message, options = {}) {
-    super(message, options);
-    this.name = "ZapierRateLimitError";
-    this.code = "ZAPIER_RATE_LIMIT_ERROR";
-    this.rateLimit = options.rateLimit ?? {};
-    this.retries = options.retries ?? 0;
-  }
-};
-var ZapierApprovalError = class extends ZapierError {
-  constructor(message, options = {}) {
-    super(message, options);
-    this.name = "ZapierApprovalError";
-    this.code = "ZAPIER_APPROVAL_ERROR";
-    this.approvalId = options.approvalId;
-    this.approvalStatus = options.status;
-    this.approvalUrl = options.approvalUrl;
-    this.pollUrl = options.pollUrl;
-  }
-};
-var ZapierRelayError = class extends ZapierError {
-  constructor(message, options = {}) {
-    super(message, options);
-    this.name = "ZapierRelayError";
-    this.code = "ZAPIER_RELAY_ERROR";
-  }
-};
-function formatErrorMessage(error) {
-  let message = error.message;
-  if (error.errors && error.errors.length > 0) {
-    const additionalErrors = error.errors.slice(1);
-    if (additionalErrors.length > 0) {
-      const errorDetails = additionalErrors.map((err) => `  \u2022 ${err.detail || err.title || err.code}`).join("\n");
-      message += "\n\nAdditional errors:\n" + errorDetails;
-    }
-  }
-  if (error instanceof ZapierAppNotFoundError && error.appKey) {
-    message += `
-App key: ${error.appKey}`;
-  }
-  if (error instanceof ZapierActionError && (error.appKey || error.actionKey)) {
-    const context = [];
-    if (error.appKey) context.push(`App: ${error.appKey}`);
-    if (error.actionKey) context.push(`Action: ${error.actionKey}`);
-    message += `
-${context.join(", ")}`;
-  }
-  if (error instanceof ZapierResourceNotFoundError && (error.resourceType || error.resourceId)) {
-    const context = [];
-    if (error.resourceType) context.push(`Type: ${error.resourceType}`);
-    if (error.resourceId) context.push(`ID: ${error.resourceId}`);
-    message += `
-${context.join(", ")}`;
-  }
-  if (error instanceof ZapierConflictError && error.resourceType) {
-    message += `
-Type: ${error.resourceType}`;
-  }
-  if (error instanceof ZapierTimeoutError && (error.attempts || error.maxAttempts)) {
-    const context = [];
-    if (error.attempts) context.push(`Attempts: ${error.attempts}`);
-    if (error.maxAttempts) context.push(`Max attempts: ${error.maxAttempts}`);
-    message += `
-${context.join(", ")}`;
-  }
-  if (error instanceof ZapierBundleError && error.buildErrors && error.buildErrors.length > 0) {
-    message += "\n\nBuild errors:\n" + error.buildErrors.map((err) => `  \u2022 ${err}`).join("\n");
-  }
-  if (error instanceof ZapierApprovalError && error.approvalUrl) {
-    message += `
-Approval URL: ${error.approvalUrl}`;
+function encodeBase64(str) {
+  return btoa(
+    Array.from(
+      new TextEncoder().encode(str),
+      (b) => String.fromCharCode(b)
+    ).join("")
+  );
+}
+function decodeBase64(str) {
+  return new TextDecoder().decode(
+    Uint8Array.from(atob(str), (c) => c.charCodeAt(0))
+  );
+}
+function encodeApiCursor(cursor) {
+  const envelope = {
+    v: CURSOR_VERSION,
+    source: CURSOR_SOURCE.API,
+    cursor
+  };
+  return encodeBase64(JSON.stringify(envelope));
+}
+function encodeSdkCursor(offset, cursor) {
+  const envelope = {
+    v: CURSOR_VERSION,
+    source: CURSOR_SOURCE.SDK,
+    cursor,
+    offset
+  };
+  return encodeBase64(JSON.stringify(envelope));
+}
+function decodeIncomingCursor(incoming) {
+  if (!incoming) {
+    return { offset: 0, cursor: void 0 };
   }
-  if (error instanceof ZapierRateLimitError) {
-    const { limit, remaining, retryAfterMs } = error.rateLimit;
-    const parts = [];
-    if (limit !== void 0) {
-      const used = remaining !== void 0 ? limit - remaining : limit;
-      parts.push(`${used}/${limit} used`);
-    }
-    if (retryAfterMs !== void 0 && retryAfterMs > 0) {
-      parts.push(`retry in ${formatDuration(retryAfterMs)}`);
+  try {
+    const decoded = decodeBase64(incoming);
+    const envelope = JSON.parse(decoded);
+    if (envelope.v !== CURSOR_VERSION) {
+      return { offset: 0, cursor: incoming };
     }
-    if (error.retries > 0) {
-      parts.push(
-        `after ${error.retries} retr${error.retries === 1 ? "y" : "ies"}`
-      );
+    if (envelope.source === CURSOR_SOURCE.SDK) {
+      return { offset: envelope.offset ?? 0, cursor: envelope.cursor };
     }
-    if (parts.length > 0) {
-      message += `
-${parts.join(", ")}`;
+    if (envelope.source === CURSOR_SOURCE.API) {
+      return { offset: 0, cursor: envelope.cursor };
     }
+    return { offset: 0, cursor: incoming };
+  } catch {
+    return { offset: 0, cursor: incoming };
   }
-  if (error.statusCode && !message.includes(`${error.statusCode}`)) {
-    message += `
-HTTP Status: ${error.statusCode}`;
-  }
-  return message;
 }
-function formatDuration(ms) {
-  const seconds = Math.round(ms / 1e3);
-  if (seconds < 60) return `${seconds}s`;
-  const minutes = Math.round(seconds / 60);
-  if (minutes < 60) return `${minutes}m`;
-  const hours = Math.round(minutes / 60);
-  if (hours < 24) return `${hours}h`;
-  const days = Math.round(hours / 24);
-  return `${days}d`;
-}
-
-// src/types/signals.ts
-var ZapierSignal = class extends Error {
-  constructor(message) {
-    super(message);
-    Object.setPrototypeOf(this, new.target.prototype);
-  }
-};
-var ZapierReleaseTriggerMessageSignal = class extends ZapierSignal {
-  constructor() {
-    super(...arguments);
-    this.name = "ZapierReleaseTriggerMessageSignal";
-    this.code = "ZAPIER_RELEASE_TRIGGER_MESSAGE_SIGNAL";
-  }
-};
-var ZapierAbortDrainSignal = class extends ZapierSignal {
-  constructor() {
-    super(...arguments);
-    this.name = "ZapierAbortDrainSignal";
-    this.code = "ZAPIER_ABORT_DRAIN_SIGNAL";
-  }
-};
-var TriggerInboxCommandBaseSchema = z.object({
-  inbox: TriggerInboxPropertySchema,
-  onMessage: z.function().optional().meta({ exampleRequired: true }).describe(
-    "Per-message handler. Resolves to ack; rejects to release-or-leave per `releaseOnError`. Throw `ZapierReleaseTriggerMessageSignal` to release explicitly, or `ZapierAbortDrainSignal` to stop after the current batch."
-  ),
-  concurrency: z.number().int().min(1).optional().describe(
-    "Per-message handler workers running in parallel. Defaults to `leaseLimit`, or 1 if neither is set."
-  ),
-  leaseLimit: z.number().int().min(1).max(100).optional().describe(
-    "Per-lease HTTP batch size. Defaults to `concurrency`, or 1 if neither is set."
-  ),
-  leaseSeconds: LeaseSecondsPropertySchema.optional(),
-  releaseOnError: z.boolean().optional().describe(
-    "If true, errors release the message when the drain finishes. If false (default), errors leave it leased until the lease timeout. `ZapierReleaseTriggerMessageSignal` always releases regardless."
-  ),
-  continueOnError: z.boolean().optional().describe(
-    "If false (default, fail-fast), the first handler error rejects and stops the drain. If true, handler errors are observed via `onError` and the drain continues. SDK-level errors (lease / ack / release) reject regardless."
-  ),
-  onError: z.function().optional().describe(
-    "Per-message error observer for `continueOnError: true`. Called with the failure and the message; control-flow signals are filtered out. Throws from `onError` are swallowed."
-  ),
-  signal: z.custom((v) => v instanceof AbortSignal).optional().describe(
-    "Abort signal. Aborting cancels in-flight HTTP, releases unprocessed messages, and resolves cleanly. Errors during shutdown still reject."
-  )
-});
-TriggerInboxCommandBaseSchema.extend({
-  maxMessages: z.number().int().min(1).optional().describe(
-    "Cap total messages drained. Defaults to draining the inbox until empty."
-  )
-}).describe(
-  "Drain an existing trigger inbox: lease currently-available messages and process them via onMessage. Returns when the inbox is empty, maxMessages is reached, the abort signal fires, or a fatal error rejects."
-);
-TriggerInboxCommandBaseSchema.extend({
-  maxDrainIntervalSeconds: z.number().int().min(1).optional().describe(
-    "Maximum seconds between empty-inbox poll attempts (default: 60). Caps the back-off cadence."
-  )
-}).describe(
-  "Continuously consume a trigger inbox: drain currently-available messages, then poll with backoff for new arrivals, until aborted. Stop via the `signal` AbortSignal or by throwing `ZapierAbortDrainSignal` from a handler. Resolves cleanly on abort; rejects on a fatal error or a fail-fast handler error."
-);
-var ActionExecutionInputSchema = z.object({
-  inputs: z.record(z.string(), z.unknown()).optional(),
-  /** @deprecated Use `connection` instead. */
-  connectionId: ConnectionIdPropertySchema.optional().meta({
-    deprecated: true
-  }),
-  connection: ConnectionPropertySchema.optional(),
-  /** @deprecated Use connection instead */
-  authenticationId: AuthenticationIdPropertySchema.optional().meta({
-    deprecated: true
-  }),
-  timeoutMs: ActionTimeoutMsPropertySchema
-}).describe(
-  "Execute an action with the given inputs for the bound app, as an alternative to runAction"
-).meta({
-  aliases: { connectionId: "connection", authenticationId: "connection" }
-});
-var AppFactoryInputSchema = z.object({
-  /** @deprecated Use `connection` instead. */
-  connectionId: ConnectionIdPropertySchema.optional().meta({
-    deprecated: true
-  }),
-  connection: ConnectionPropertySchema.optional(),
-  /** @deprecated Use connection instead */
-  authenticationId: AuthenticationIdPropertySchema.optional().meta({
-    deprecated: true
-  })
-}).describe("Bind a connection alias or numeric connectionId to an app").meta({
-  aliases: { connectionId: "connection", authenticationId: "connection" }
-});
-
-// src/utils/pagination-utils.ts
-var CURSOR_VERSION = 1;
-var CURSOR_SOURCE = {
-  API: "api",
-  SDK: "sdk"
-};
-function encodeBase64(str) {
-  return btoa(
-    Array.from(
-      new TextEncoder().encode(str),
-      (b) => String.fromCharCode(b)
-    ).join("")
-  );
-}
-function decodeBase64(str) {
-  return new TextDecoder().decode(
-    Uint8Array.from(atob(str), (c) => c.charCodeAt(0))
-  );
-}
-function encodeApiCursor(cursor) {
-  const envelope = {
-    v: CURSOR_VERSION,
-    source: CURSOR_SOURCE.API,
-    cursor
-  };
-  return encodeBase64(JSON.stringify(envelope));
-}
-function encodeSdkCursor(offset, cursor) {
-  const envelope = {
-    v: CURSOR_VERSION,
-    source: CURSOR_SOURCE.SDK,
-    cursor,
-    offset
-  };
-  return encodeBase64(JSON.stringify(envelope));
-}
-function decodeIncomingCursor(incoming) {
-  if (!incoming) {
-    return { offset: 0, cursor: void 0 };
-  }
-  try {
-    const decoded = decodeBase64(incoming);
-    const envelope = JSON.parse(decoded);
-    if (envelope.v !== CURSOR_VERSION) {
-      return { offset: 0, cursor: incoming };
-    }
-    if (envelope.source === CURSOR_SOURCE.SDK) {
-      return { offset: envelope.offset ?? 0, cursor: envelope.cursor };
-    }
-    if (envelope.source === CURSOR_SOURCE.API) {
-      return { offset: 0, cursor: envelope.cursor };
-    }
-    return { offset: 0, cursor: incoming };
-  } catch {
-    return { offset: 0, cursor: incoming };
-  }
-}
-async function* paginateMaxItemsWithUnencodedCursor(pageFunction, pageOptions) {
-  let cursor = pageOptions?.cursor;
-  let totalItemsYielded = 0;
-  const maxItems = pageOptions?.maxItems;
-  const pageSize = pageOptions?.pageSize;
-  do {
-    const options = {
-      ...pageOptions || {},
-      cursor,
-      pageSize: maxItems !== void 0 && pageSize !== void 0 ? Math.min(pageSize, maxItems) : pageSize
-    };
-    const page = await pageFunction(options);
-    if (maxItems !== void 0) {
-      const remainingItems = maxItems - totalItemsYielded;
-      if (page.data.length >= remainingItems) {
-        yield {
-          ...page,
-          data: page.data.slice(0, remainingItems),
-          nextCursor: void 0
-        };
-        break;
-      }
-    }
-    yield page;
-    totalItemsYielded += page.data.length;
-    cursor = page.nextCursor;
-  } while (cursor);
+async function* paginateMaxItemsWithUnencodedCursor(pageFunction, pageOptions) {
+  let cursor = pageOptions?.cursor;
+  let totalItemsYielded = 0;
+  const maxItems = pageOptions?.maxItems;
+  const pageSize = pageOptions?.pageSize;
+  do {
+    const options = {
+      ...pageOptions || {},
+      cursor,
+      pageSize: maxItems !== void 0 && pageSize !== void 0 ? Math.min(pageSize, maxItems) : pageSize
+    };
+    const page = await pageFunction(options);
+    if (maxItems !== void 0) {
+      const remainingItems = maxItems - totalItemsYielded;
+      if (page.data.length >= remainingItems) {
+        yield {
+          ...page,
+          data: page.data.slice(0, remainingItems),
+          nextCursor: void 0
+        };
+        break;
+      }
+    }
+    yield page;
+    totalItemsYielded += page.data.length;
+    cursor = page.nextCursor;
+  } while (cursor);
 }
 async function* paginateBuffered(pageFunction, pageOptions) {
   const pageSize = pageOptions?.pageSize;
@@ -721,438 +445,1025 @@ function concatPaginated({
 function toIterable(source) {
   return { [Symbol.asyncIterator]: () => source[Symbol.asyncIterator]() };
 }
-
-// src/utils/validation.ts
-var validate = (schema, input) => {
+var parseOrThrow = (schema, input, { adaptError } = {}) => {
   const result = schema.safeParse(input);
   if (!result.success) {
-    const errorMessages = result.error.issues.map((error) => {
-      const path = error.path.length > 0 ? error.path.join(".") : "input";
-      return `${path}: ${error.message}`;
+    const errorMessages = result.error.issues.map((issue) => {
+      const path = issue.path.length > 0 ? issue.path.join(".") : "input";
+      return `${path}: ${issue.message}`;
     });
-    const message = `Validation failed:
-  ${errorMessages.join("\n  ")}`;
-    throw new ZapierValidationError(message, {
-      details: {
-        zodErrors: result.error.issues,
-        input
+    throw createCoreError(
+      {
+        code: CoreErrorCode.Validation,
+        message: `Validation failed:
+  ${errorMessages.join("\n  ")}`,
+        details: {
+          zodErrors: result.error.issues,
+          input
+        }
+      },
+      adaptError
+    );
+  }
+  return result.data;
+};
+function createValidator(schema, { adaptError } = {}) {
+  return function validateFn(input) {
+    return parseOrThrow(schema, input, { adaptError });
+  };
+}
+var validateOptions = (schema, options, { adaptError } = {}) => parseOrThrow(schema, options, { adaptError });
+var scopeStore = null;
+try {
+  scopeStore = new AsyncLocalStorage();
+} catch {
+}
+function getCurrentScope() {
+  if (!scopeStore) return void 0;
+  return scopeStore.getStore();
+}
+function getCurrentDepth() {
+  return getCurrentScope()?.depth ?? 0;
+}
+function runInMethodScope(fn) {
+  if (!scopeStore) return fn();
+  const currentDepth = scopeStore.getStore()?.depth ?? -1;
+  return scopeStore.run({ depth: currentDepth + 1 }, fn);
+}
+var runWithTelemetryContext = runInMethodScope;
+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);
+  return createCoreError(
+    {
+      code: CoreErrorCode.Unknown,
+      message,
+      cause: error
+    },
+    adaptError
+  );
+}
+function createFunction(coreFn, options) {
+  const { sdk, schema } = options;
+  const functionName = coreFn.name;
+  const namedFunctions = {
+    [functionName]: async function(callOptions) {
+      return runInMethodScope(async () => {
+        const startTime = Date.now();
+        const normalizedOptions = callOptions ?? {};
+        const args = [normalizedOptions];
+        const depth = getCurrentDepth();
+        const hooks = sdk.context.hooks;
+        const adaptError = sdk.context.core?.adaptError;
+        hooks?.onMethodStart?.({
+          methodName: functionName,
+          args,
+          isPaginated: false,
+          depth
+        });
+        try {
+          let result;
+          if (schema) {
+            const validatedOptions = validateOptions(
+              schema,
+              normalizedOptions,
+              {
+                adaptError
+              }
+            );
+            result = await coreFn({
+              ...normalizedOptions,
+              ...validatedOptions
+            });
+          } else {
+            result = await coreFn(normalizedOptions);
+          }
+          hooks?.onMethodEnd?.({
+            methodName: functionName,
+            args,
+            isPaginated: false,
+            depth,
+            durationMs: Date.now() - startTime
+          });
+          return result;
+        } catch (error) {
+          const normalizedError = normalizeError(error, adaptError);
+          hooks?.onMethodEnd?.({
+            methodName: functionName,
+            args,
+            isPaginated: false,
+            depth,
+            durationMs: Date.now() - startTime,
+            error: normalizedError
+          });
+          throw normalizedError;
+        }
+      });
+    }
+  };
+  return namedFunctions[functionName];
+}
+function isSdkPage(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const page = value;
+  if (!Array.isArray(page.data)) return false;
+  if (page.nextCursor !== void 0 && typeof page.nextCursor !== "string") {
+    return false;
+  }
+  return Object.keys(page).every((k) => k === "data" || k === "nextCursor");
+}
+function createPageFunction(coreFn, {
+  sdk,
+  adaptPage
+}) {
+  const functionName = coreFn.name + "Page";
+  const namedFunctions = {
+    [functionName]: async function(options) {
+      try {
+        const response = await coreFn(options);
+        const page = adaptPage ? adaptPage(response) : response;
+        if (!isSdkPage(page)) {
+          throw new Error(
+            `${functionName}: paginated result must be exactly { data: TItem[], nextCursor? } (produced by the handler or its \`adaptPage\`); got keys [${page && typeof page === "object" ? Object.keys(page).join(", ") : typeof page}]. If the handler returns a raw shape, set \`adaptPage\` to translate it; if \`adaptPage\` already runs, it must return only \`data\`/\`nextCursor\`.`
+          );
+        }
+        return page;
+      } catch (error) {
+        throw normalizeError(
+          error,
+          sdk.context.core?.adaptError
+        );
       }
-    });
+    }
+  };
+  return namedFunctions[functionName];
+}
+function createPaginatedFunction(coreFn, options) {
+  const { sdk, schema, name, defaultPageSize, adaptPage } = options;
+  const pageFunction = createPageFunction(coreFn, { sdk, adaptPage });
+  const functionName = name || coreFn.name;
+  const namedFunctions = {
+    [functionName]: function(callOptions) {
+      return runInMethodScope(() => {
+        const startTime = Date.now();
+        const normalizedOptions = callOptions ?? {};
+        const args = [normalizedOptions];
+        const depth = getCurrentDepth();
+        const hooks = sdk.context.hooks;
+        const adaptError = sdk.context.core?.adaptError;
+        hooks?.onMethodStart?.({
+          methodName: functionName,
+          args,
+          isPaginated: true,
+          depth
+        });
+        const validatedOptions = {
+          ...normalizedOptions,
+          ...schema ? createValidator(schema, { adaptError })(normalizedOptions) : normalizedOptions
+        };
+        const pageSize = validatedOptions.pageSize ?? defaultPageSize;
+        const optimizedOptions = {
+          ...validatedOptions,
+          pageSize
+        };
+        const iterator = paginate(pageFunction, optimizedOptions);
+        const firstPagePromise = iterator.next().then((result) => {
+          if (result.done) {
+            throw new Error("Paginate should always iterate at least once");
+          }
+          return result.value;
+        });
+        if (hooks?.onMethodEnd) {
+          firstPagePromise.then(() => {
+            hooks.onMethodEnd({
+              methodName: functionName,
+              args,
+              isPaginated: true,
+              depth,
+              durationMs: Date.now() - startTime
+            });
+          }).catch((error) => {
+            hooks.onMethodEnd({
+              methodName: functionName,
+              args,
+              isPaginated: true,
+              depth,
+              durationMs: Date.now() - startTime,
+              error: error instanceof Error ? error : new Error(String(error))
+            });
+          });
+        }
+        return Object.assign(firstPagePromise, {
+          [Symbol.asyncIterator]: async function* () {
+            yield await firstPagePromise;
+            for await (const page of iterator) {
+              yield page;
+            }
+          },
+          items: function() {
+            return {
+              [Symbol.asyncIterator]: async function* () {
+                const firstPage = await firstPagePromise;
+                for (const item of firstPage.data) {
+                  yield item;
+                }
+                for await (const page of iterator) {
+                  for (const item of page.data) {
+                    yield item;
+                  }
+                }
+              }
+            };
+          }
+        });
+      });
+    }
+  };
+  return namedFunctions[functionName];
+}
+function definePlugin(fn) {
+  return fn;
+}
+function createPluginMethod(sdk, config) {
+  const { name, inputSchema, handler, ...metaFields } = config;
+  const namedHandlers = {
+    [name]: async function(options) {
+      return handler({ sdk, options });
+    }
+  };
+  const wrappedFn = createFunction(namedHandlers[name], {
+    sdk,
+    schema: inputSchema
+  });
+  return {
+    [name]: wrappedFn,
+    context: {
+      meta: {
+        [name]: {
+          ...metaFields,
+          ...inputSchema ? { inputSchema } : {}
+        }
+      }
+    }
+  };
+}
+function createPaginatedPluginMethod(sdk, config) {
+  const {
+    name,
+    inputSchema,
+    handler,
+    adaptPage,
+    defaultPageSize,
+    ...metaFields
+  } = config;
+  const namedHandlers = {
+    [name]: function(options) {
+      return handler({ sdk, options });
+    }
+  };
+  const wrappedFn = createPaginatedFunction(namedHandlers[name], {
+    sdk,
+    schema: inputSchema,
+    name,
+    defaultPageSize,
+    adaptPage
+  });
+  return {
+    [name]: wrappedFn,
+    context: {
+      meta: {
+        [name]: {
+          ...metaFields,
+          ...inputSchema ? { inputSchema } : {}
+        }
+      }
+    }
+  };
+}
+function splitPluginContribution(result) {
+  const { context, ...rootKeys } = result;
+  const { meta, hooks, ...contextRest } = context ?? {};
+  return {
+    rootKeys,
+    meta: meta ?? {},
+    hooks: hooks ?? {},
+    contextRest
+  };
+}
+var RESERVED_ROOT_KEYS = /* @__PURE__ */ new Set([
+  "context",
+  "getRegistry",
+  "addPlugin"
+]);
+function hasOwn(obj, key) {
+  return Object.prototype.hasOwnProperty.call(obj, key);
+}
+function setOwn(target, key, value) {
+  Object.defineProperty(target, key, {
+    value,
+    enumerable: true,
+    configurable: true,
+    writable: true
+  });
+}
+function checkCollisions(target, source, kind, callerLabel, override) {
+  for (const key of Object.keys(source)) {
+    if (kind === "root key" && RESERVED_ROOT_KEYS.has(key)) {
+      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.`
+      );
+    }
+    if (!override && hasOwn(target, key)) {
+      throw new Error(
+        `${callerLabel}: duplicate ${kind} "${key}". 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]);
+  }
+}
+function createPluginAccumulator(initialProperties = {}, initialContext = {}) {
+  const initialMeta = initialContext.meta ?? {};
+  const initialHooks = initialContext.hooks ?? {};
+  const context = {
+    ...initialContext,
+    meta: { ...initialMeta },
+    hooks: { ...initialHooks }
+  };
+  const view = { ...initialProperties, context };
+  return { view, context };
+}
+function mergeContribution(propertiesTarget, contextTarget, contribution, options) {
+  checkCollisions(
+    propertiesTarget,
+    contribution.rootKeys,
+    "root key",
+    options.callerLabel,
+    options.override
+  );
+  checkCollisions(
+    contextTarget.meta,
+    contribution.meta,
+    "context.meta key",
+    options.callerLabel,
+    options.override
+  );
+  checkCollisions(
+    contextTarget,
+    contribution.contextRest,
+    "context key",
+    options.callerLabel,
+    options.override
+  );
+  applyOwnProperties(propertiesTarget, contribution.rootKeys);
+  applyOwnProperties(contextTarget.meta, contribution.meta);
+  applyOwnProperties(contextTarget, contribution.contextRest);
+  contextTarget.hooks = buildHooks(contextTarget.hooks, contribution.hooks);
+}
+function applyPluginContribution(acc, contribution, options) {
+  mergeContribution(acc.view, acc.context, contribution, options);
+}
+function wrapAsSdk(properties, context, opts) {
+  const sdk = {
+    ...properties,
+    context,
+    getRegistry(qopts) {
+      return buildRegistry({
+        sdk,
+        meta: context.meta,
+        packageFilter: qopts?.package
+      });
+    }
+  };
+  if (opts?.addPlugin !== void 0) {
+    sdk.addPlugin = opts.addPlugin;
+  }
+  return sdk;
+}
+function wrapAccumulatorAsSdk(acc) {
+  const { context: _ctx, ...rootKeys } = acc.view;
+  return wrapAsSdk(
+    rootKeys,
+    acc.context
+  );
+}
+function applyPluginToSdk(sdk, plugin, options) {
+  const context = sdk.context;
+  const contribution = splitPluginContribution(
+    plugin(sdk)
+  );
+  mergeContribution(sdk, context, contribution, {
+    callerLabel: "addPlugin",
+    override: options.override === true
+  });
+}
+function buildStackAccumulator(head, callerLabel) {
+  const ordered = [];
+  let node = head;
+  while (node) {
+    ordered.unshift(node);
+    node = node.prev;
+  }
+  const acc = createPluginAccumulator();
+  for (const { plugin, override } of ordered) {
+    const contribution = splitPluginContribution(
+      plugin(acc.view)
+    );
+    applyPluginContribution(acc, contribution, { callerLabel, override });
+  }
+  return acc;
+}
+function addPlugin(sdk, plugin, options) {
+  applyPluginToSdk(
+    sdk,
+    plugin,
+    options ?? {}
+  );
+}
+function buildSdk(properties, context) {
+  const addPlugin2 = (plugin, options) => {
+    logDeprecation(
+      "sdk.addPlugin(plugin) (the chain-style extension) is deprecated. Build the SDK in one pass with createPluginStack().use(...).toSdk() instead \u2014 each .toSdk() produces fresh plugin closures and avoids the closure-sharing semantics that caused this to be deprecated."
+    );
+    const contribution = splitPluginContribution(
+      plugin({ ...properties, context })
+    );
+    const mergedProperties = { ...properties };
+    const mergedContext = {
+      ...context,
+      meta: { ...context.meta },
+      hooks: { ...context.hooks }
+    };
+    mergeContribution(mergedProperties, mergedContext, contribution, {
+      callerLabel: "addPlugin",
+      override: options?.override === true
+    });
+    return buildSdk(
+      mergedProperties,
+      mergedContext
+    );
+  };
+  return wrapAsSdk(properties, context, { addPlugin: addPlugin2 });
+}
+function withDeprecatedAddPlugin(sdk) {
+  const initialProperties = {};
+  for (const key of Object.keys(sdk)) {
+    if (key === "context" || key === "getRegistry" || key === "addPlugin") {
+      continue;
+    }
+    initialProperties[key] = sdk[key];
+  }
+  const initialContext = sdk.context;
+  return buildSdk(
+    initialProperties,
+    initialContext
+  );
+}
+function composePlugins(...plugins) {
+  logDeprecation(
+    "composePlugins(...) is deprecated. Use createPluginStack().use(a).use(b).use(c).toPlugin() instead. The stack carries the same collision-detection and hook-composition behavior, supports per-step { override: true } for intentional duplicates, and progressively narrows types so dependency mistakes surface at the specific .use call."
+  );
+  let stack = buildPluginStack(
+    null,
+    "composePlugins"
+  );
+  for (const plugin of plugins) {
+    stack = stack.use(plugin);
+  }
+  return stack.toPlugin();
+}
+function createPluginStack() {
+  return buildPluginStack(null, "createPluginStack");
+}
+function buildPluginStack(head, callerLabel) {
+  return {
+    use(plugin, options) {
+      const next = {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        plugin,
+        override: options?.override === true,
+        prev: head
+      };
+      return buildPluginStack(next, callerLabel);
+    },
+    toPlugin() {
+      const ordered = [];
+      let node = head;
+      while (node) {
+        ordered.unshift(node);
+        node = node.prev;
+      }
+      return (outerSdk) => {
+        const { context: outerContext, ...outerProperties } = outerSdk ?? {};
+        const viewAcc = createPluginAccumulator(outerProperties, outerContext);
+        const contribsAcc = createPluginAccumulator();
+        for (const { plugin: subPlugin, override } of ordered) {
+          const contribution = splitPluginContribution(
+            subPlugin(viewAcc.view)
+          );
+          applyPluginContribution(viewAcc, contribution, {
+            callerLabel,
+            override
+          });
+          applyPluginContribution(contribsAcc, contribution, {
+            callerLabel,
+            override
+          });
+        }
+        const { context: _ignored, ...contributedRoot } = contribsAcc.view;
+        return {
+          ...contributedRoot,
+          context: contribsAcc.context
+        };
+      };
+    },
+    toSdk() {
+      return wrapAccumulatorAsSdk(
+        buildStackAccumulator(head, callerLabel)
+      );
+    }
+  };
+}
+function createCorePlugin(options) {
+  return () => ({
+    context: {
+      core: options
+    }
+  });
+}
+function withPositional(schema) {
+  Object.assign(schema._zod.def, {
+    positionalMeta: { positional: true }
+  });
+  return schema;
+}
+function schemaHasPositionalMeta(schema) {
+  return "positionalMeta" in schema._zod.def;
+}
+function isPositional(schema) {
+  if (schemaHasPositionalMeta(schema) && schema._zod.def.positionalMeta?.positional) {
+    return true;
+  }
+  if (schema instanceof z.ZodOptional) {
+    return isPositional(schema._zod.def.innerType);
+  }
+  if (schema instanceof z.ZodDefault) {
+    return isPositional(schema._zod.def.innerType);
+  }
+  return false;
+}
+
+// src/constants.ts
+var ZAPIER_BASE_URL = globalThis.process?.env?.ZAPIER_BASE_URL || "https://zapier.com";
+function getZapierSdkService() {
+  return globalThis.process?.env?.ZAPIER_SDK_SERVICE;
+}
+var MAX_PAGE_LIMIT = 1e4;
+var DEFAULT_PAGE_SIZE = 100;
+var DEFAULT_ACTION_TIMEOUT_MS = 18e4;
+function parseIntEnvVar(name) {
+  const value = globalThis.process?.env?.[name];
+  if (value === void 0) return void 0;
+  const parsed = parseInt(value, 10);
+  if (isNaN(parsed)) {
+    console.warn(
+      `[zapier-sdk] Invalid value for ${name}: "${value}" (expected integer)`
+    );
+    return void 0;
+  }
+  return parsed;
+}
+var ZAPIER_MAX_NETWORK_RETRIES = parseIntEnvVar("ZAPIER_MAX_NETWORK_RETRIES") ?? 3;
+var ZAPIER_MAX_NETWORK_RETRY_DELAY_MS = parseIntEnvVar("ZAPIER_MAX_NETWORK_RETRY_DELAY_MS") ?? 6e4;
+var MAX_CONCURRENCY_LIMIT = 1e4;
+function parseConcurrencyEnvVar(name) {
+  const value = globalThis.process?.env?.[name];
+  if (!value) return void 0;
+  if (value === "Infinity") return Infinity;
+  if (/^[1-9]\d*$/.test(value)) {
+    const parsed = parseInt(value, 10);
+    if (parsed <= MAX_CONCURRENCY_LIMIT) return parsed;
+  }
+  console.warn(
+    `[zapier-sdk] Invalid value for ${name}: "${value}" (expected positive integer 1-${MAX_CONCURRENCY_LIMIT} or "Infinity")`
+  );
+  return void 0;
+}
+var ZAPIER_MAX_CONCURRENT_REQUESTS = parseConcurrencyEnvVar("ZAPIER_MAX_CONCURRENT_REQUESTS") ?? 200;
+function getZapierApprovalMode() {
+  const value = globalThis.process?.env?.ZAPIER_APPROVAL_MODE;
+  if (value === "disabled" || value === "poll" || value === "throw")
+    return value;
+  return void 0;
+}
+function getZapierDefaultApprovalMode() {
+  const isInteractive = !!globalThis.process?.stdin?.isTTY && !!globalThis.process?.stdout?.isTTY;
+  return isInteractive ? "poll" : "throw";
+}
+var DEFAULT_APPROVAL_TIMEOUT_MS = 10 * 60 * 1e3;
+var DEFAULT_MAX_APPROVAL_RETRIES = 2;
+
+// src/types/properties.ts
+var AppKeyPropertySchema = withPositional(
+  z.string().min(1).describe("App key (e.g., 'SlackCLIAPI' or slug like 'github')")
+);
+var AppPropertySchema = withPositional(
+  z.string().min(1).describe(
+    "App slug (e.g., 'github'), implementation name (e.g., 'SlackCLIAPI'), or versioned ID (e.g., 'github@1.2.3')"
+  )
+);
+var ActionTypePropertySchema = z.enum([
+  "read",
+  "read_bulk",
+  "write",
+  "run",
+  "search",
+  "search_or_write",
+  "search_and_write",
+  "filter"
+]).describe("Action type that matches the action's defined type");
+var ActionKeyPropertySchema = z.string().min(1).describe("Action key to execute");
+var ActionPropertySchema = withPositional(
+  z.string().min(1).describe("Action key (e.g., 'send_message' or 'find_row')")
+);
+var InputFieldPropertySchema = withPositional(
+  z.string().min(1).describe("Input field key to get choices for")
+);
+var ConnectionIdPropertySchema = z.union([z.string(), z.number().int().positive()]).describe("Connection ID to use for this action");
+var AuthenticationIdPropertySchema = ConnectionIdPropertySchema.meta({
+  deprecated: true
+});
+var ConnectionPropertySchema = z.union([z.string(), z.number().int().positive()]).describe(
+  "Connection alias or connection ID (UUID or positive integer). Strings that match a key in the connections map are resolved against it; otherwise the value is used as a connection ID directly."
+);
+var InputsPropertySchema = z.record(z.string(), z.unknown()).describe("Input parameters for the action");
+var LimitPropertySchema = z.number().int().min(1).max(MAX_PAGE_LIMIT).default(50).describe("Maximum number of items to return");
+var OffsetPropertySchema = z.number().int().min(0).default(0).describe("Number of items to skip for pagination");
+var OutputPropertySchema = z.string().describe("Output file path");
+var DebugPropertySchema = z.boolean().default(false).describe("Enable debug logging");
+var ParamsPropertySchema = z.record(z.string(), z.unknown()).describe("Additional parameters");
+var ActionTimeoutMsPropertySchema = z.number().min(1e3).optional().describe(
+  `Maximum time to wait for action completion in milliseconds (default: ${DEFAULT_ACTION_TIMEOUT_MS})`
+);
+var TablePropertySchema = withPositional(
+  z.string().regex(/^[A-Z0-9]{26}$/, "Table ID must be a valid ULID").describe("The unique identifier of the table")
+);
+var RecordPropertySchema = withPositional(
+  z.string().regex(/^[A-Z0-9]{26}$/, "Record ID must be a valid ULID").describe("The unique identifier of the record")
+);
+var RecordsPropertySchema = z.array(z.string().regex(/^[A-Z0-9]{26}$/, "Record ID must be a valid ULID")).min(1).max(100).describe("Record IDs to operate on");
+var FieldsPropertySchema = z.array(z.union([z.string(), z.number()])).describe(
+  'Fields to operate on. Accepts field names (e.g., "Email") or IDs (e.g., "f6", "6", or 6).'
+);
+var AppsPropertySchema = z.array(z.string()).describe("Filter by app keys (e.g., 'SlackCLIAPI' or slug like 'github')");
+var TablesPropertySchema = z.array(z.string()).describe("Filter by specific table IDs");
+var ConnectionsPropertySchema = z.array(z.string()).describe("List of connection IDs to filter by");
+var TriggerInboxPropertySchema = withPositional(
+  z.string().min(1).describe(
+    "Trigger inbox identifier \u2014 UUID or name. Non-UUID values are resolved by name via the inbox list endpoint."
+  )
+);
+var TriggerInboxNamePropertySchema = z.string().min(1).max(100).describe(
+  "Inbox name; unique per (user, account). Enables get-or-create on createTriggerInbox."
+);
+var LeasePropertySchema = z.string().min(1).describe("Lease ID returned from leaseTriggerInboxMessages");
+var LeaseSecondsPropertySchema = z.number().int().min(1).max(3600).describe(
+  "Seconds until the lease expires; messages return to available if not acked. API default is 300 (5 minutes)."
+);
+var LeaseLimitPropertySchema = z.number().int().min(1).max(100).describe("Maximum messages to lease in a single batch (1-100)");
+
+// src/types/errors.ts
+var _a, _b;
+var ZapierError = class extends (_b = Error, _a = CORE_ERROR_SYMBOL, _b) {
+  constructor(message, options = {}) {
+    super(message);
+    this[_a] = true;
+    this.name = "ZapierError";
+    this.code = "ZAPIER_ERROR";
+    if (options.statusCode !== void 0) this.statusCode = options.statusCode;
+    if (options.errors !== void 0) this.errors = options.errors;
+    if (options.cause !== void 0) this.cause = options.cause;
+    if (options.response !== void 0) this.response = options.response;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var ZapierValidationError = class extends ZapierError {
+  constructor(message, options = {}) {
+    super(message, options);
+    this.name = "ZapierValidationError";
+    this.code = "ZAPIER_VALIDATION_ERROR";
+    this.details = options.details;
+  }
+};
+var ZapierUnknownError = class extends ZapierError {
+  constructor() {
+    super(...arguments);
+    this.name = "ZapierUnknownError";
+    this.code = "ZAPIER_UNKNOWN_ERROR";
+  }
+};
+var ZapierAuthenticationError = class extends ZapierError {
+  constructor() {
+    super(...arguments);
+    this.name = "ZapierAuthenticationError";
+    this.code = "ZAPIER_AUTHENTICATION_ERROR";
+  }
+};
+var zapierAdaptError = (options) => {
+  switch (options.code) {
+    case CoreErrorCode.Validation:
+      return new ZapierValidationError(options.message, {
+        cause: options.cause,
+        details: options.details
+      });
+    case CoreErrorCode.Unknown:
+      return new ZapierUnknownError(options.message, {
+        cause: options.cause
+      });
+    default:
+      return new ZapierError(options.message, { cause: options.cause });
+  }
+};
+var ZapierApiError = class extends ZapierError {
+  constructor(message, options = {}) {
+    super(message, options);
+    this.name = "ZapierApiError";
+    this.code = "ZAPIER_API_ERROR";
+  }
+};
+var ZapierAppNotFoundError = class extends ZapierError {
+  constructor(message, options = {}) {
+    super(message, options);
+    this.name = "ZapierAppNotFoundError";
+    this.code = "ZAPIER_APP_NOT_FOUND_ERROR";
+    this.appKey = options.appKey;
+  }
+};
+var ZapierNotFoundError = class extends ZapierError {
+  constructor(message, options = {}) {
+    super(message, options);
+    this.name = "ZapierNotFoundError";
+    this.code = "ZAPIER_NOT_FOUND_ERROR";
+  }
+};
+var ZapierResourceNotFoundError = class extends ZapierNotFoundError {
+  constructor(message, options = {}) {
+    super(message, options);
+    this.name = "ZapierResourceNotFoundError";
+    this.code = "ZAPIER_RESOURCE_NOT_FOUND_ERROR";
+    this.resourceType = options.resourceType;
+    this.resourceId = options.resourceId;
+  }
+};
+var ZapierConfigurationError = class extends ZapierError {
+  constructor(message, options = {}) {
+    super(message, options);
+    this.name = "ZapierConfigurationError";
+    this.code = "ZAPIER_CONFIGURATION_ERROR";
+    this.configType = options.configType;
+  }
+};
+var ZapierBundleError = class extends ZapierError {
+  constructor(message, options = {}) {
+    super(message, options);
+    this.name = "ZapierBundleError";
+    this.code = "ZAPIER_BUNDLE_ERROR";
+    this.buildErrors = options.buildErrors;
+  }
+};
+var ZapierTimeoutError = class extends ZapierError {
+  constructor(message, options = {}) {
+    super(message, options);
+    this.name = "ZapierTimeoutError";
+    this.code = "ZAPIER_TIMEOUT_ERROR";
+    this.attempts = options.attempts;
+    this.maxAttempts = options.maxAttempts;
+  }
+};
+var ZapierActionError = class extends ZapierError {
+  constructor(message, options = {}) {
+    super(message, options);
+    this.name = "ZapierActionError";
+    this.code = "ZAPIER_ACTION_ERROR";
+    this.appKey = options.appKey;
+    this.actionKey = options.actionKey;
+  }
+  // Legacy accessor for backward compatibility
+  get actionErrors() {
+    return this.errors;
+  }
+};
+var ZapierConflictError = class extends ZapierError {
+  constructor(message, options = {}) {
+    super(message, options);
+    this.name = "ZapierConflictError";
+    this.code = "ZAPIER_CONFLICT_ERROR";
+    this.resourceType = options.resourceType;
+  }
+};
+var ZapierRateLimitError = class extends ZapierError {
+  constructor(message, options = {}) {
+    super(message, options);
+    this.name = "ZapierRateLimitError";
+    this.code = "ZAPIER_RATE_LIMIT_ERROR";
+    this.rateLimit = options.rateLimit ?? {};
+    this.retries = options.retries ?? 0;
+  }
+};
+var ZapierApprovalError = class extends ZapierError {
+  constructor(message, options = {}) {
+    super(message, options);
+    this.name = "ZapierApprovalError";
+    this.code = "ZAPIER_APPROVAL_ERROR";
+    this.approvalId = options.approvalId;
+    this.approvalStatus = options.status;
+    this.approvalUrl = options.approvalUrl;
+    this.pollUrl = options.pollUrl;
   }
-  return result.data;
 };
-function createValidator(schema) {
-  return function validateFn(input) {
-    return validate(schema, input);
-  };
-}
-var validateOptions = (schema, options) => {
-  return validate(schema, options);
+var ZapierRelayError = class extends ZapierError {
+  constructor(message, options = {}) {
+    super(message, options);
+    this.name = "ZapierRelayError";
+    this.code = "ZAPIER_RELAY_ERROR";
+  }
 };
-var telemetryStore = null;
-try {
-  telemetryStore = new AsyncLocalStorage();
-} catch {
-}
-function isTelemetryNested() {
-  if (!telemetryStore) return true;
-  const store = telemetryStore.getStore();
-  return store !== void 0 && store.depth > 0;
-}
-function runWithTelemetryContext(fn) {
-  if (!telemetryStore) return fn();
-  const currentDepth = telemetryStore.getStore()?.depth ?? -1;
-  return telemetryStore.run({ depth: currentDepth + 1 }, fn);
-}
-function setMethodMetadata(metadata) {
-  if (!telemetryStore) return;
-  const store = telemetryStore.getStore();
-  if (!store) return;
-  store.methodMetadata = { ...store.methodMetadata, ...metadata };
-}
-function getMethodMetadata() {
-  if (!telemetryStore) return void 0;
-  return telemetryStore.getStore()?.methodMetadata;
-}
-
-// src/utils/function-utils.ts
-function extractCursor(data) {
-  if (!data?.next) {
-    return void 0;
+function formatErrorMessage(error) {
+  let message = error.message;
+  if (error.errors && error.errors.length > 0) {
+    const additionalErrors = error.errors.slice(1);
+    if (additionalErrors.length > 0) {
+      const errorDetails = additionalErrors.map((err) => `  \u2022 ${err.detail || err.title || err.code}`).join("\n");
+      message += "\n\nAdditional errors:\n" + errorDetails;
+    }
   }
-  try {
-    const urlObj = new URL(data.next);
-    const offset = urlObj.searchParams.get("offset");
-    return offset || void 0;
-  } catch {
-    return void 0;
+  if (error instanceof ZapierAppNotFoundError && error.appKey) {
+    message += `
+App key: ${error.appKey}`;
   }
-}
-function normalizeError(error) {
-  if (error instanceof ZapierError) {
-    return error;
+  if (error instanceof ZapierActionError && (error.appKey || error.actionKey)) {
+    const context = [];
+    if (error.appKey) context.push(`App: ${error.appKey}`);
+    if (error.actionKey) context.push(`Action: ${error.actionKey}`);
+    message += `
+${context.join(", ")}`;
   }
-  const message = error instanceof Error ? error.message : String(error);
-  const cause = error instanceof Error ? error : void 0;
-  if (error instanceof Error) {
-    if (error.name === "ZapierAuthenticationError") {
-      return new ZapierAuthenticationError(message, { cause });
-    }
+  if (error instanceof ZapierResourceNotFoundError && (error.resourceType || error.resourceId)) {
+    const context = [];
+    if (error.resourceType) context.push(`Type: ${error.resourceType}`);
+    if (error.resourceId) context.push(`ID: ${error.resourceId}`);
+    message += `
+${context.join(", ")}`;
   }
-  return new ZapierUnknownError(message, { cause });
-}
-function createFunction(coreFn, schema, telemetry) {
-  const functionName = coreFn.name;
-  const namedFunctions = {
-    [functionName]: async function(options) {
-      return runWithTelemetryContext(async () => {
-        const startTime = Date.now();
-        const normalizedOptions = options ?? {};
-        const isNested = isTelemetryNested();
-        try {
-          if (schema) {
-            const validatedOptions = validateOptions(schema, normalizedOptions);
-            const result2 = await coreFn({
-              ...normalizedOptions,
-              ...validatedOptions
-            });
-            if (!isNested && telemetry?.onMethodCalled) {
-              const argumentCount = Object.keys(
-                normalizedOptions
-              ).length;
-              telemetry.onMethodCalled({
-                methodName: functionName,
-                durationMs: Date.now() - startTime,
-                success: true,
-                argumentCount,
-                isPaginated: false
-              });
-            }
-            return result2;
-          }
-          const result = await coreFn(normalizedOptions);
-          if (!isNested && telemetry?.onMethodCalled) {
-            const argumentCount = Object.keys(
-              normalizedOptions
-            ).length;
-            telemetry.onMethodCalled({
-              methodName: functionName,
-              durationMs: Date.now() - startTime,
-              success: true,
-              argumentCount,
-              isPaginated: false
-            });
-          }
-          return result;
-        } catch (error) {
-          const normalizedError = normalizeError(error);
-          if (!isNested && telemetry?.onMethodCalled) {
-            const argumentCount = Object.keys(
-              normalizedOptions
-            ).length;
-            telemetry.onMethodCalled({
-              methodName: functionName,
-              durationMs: Date.now() - startTime,
-              success: false,
-              error: normalizedError,
-              argumentCount,
-              isPaginated: false
-            });
-          }
-          throw normalizedError;
-        }
-      });
-    }
-  };
-  return namedFunctions[functionName];
-}
-function createPageFunction(coreFn) {
-  const functionName = coreFn.name + "Page";
-  const namedFunctions = {
-    [functionName]: async function(options) {
-      try {
-        const result = await coreFn(options);
-        if (result && typeof result === "object" && "data" in result) {
-          const paginatedResult = result;
-          let nextCursor;
-          if (paginatedResult.nextCursor) {
-            nextCursor = paginatedResult.nextCursor;
-          } else if (paginatedResult.links?.next) {
-            nextCursor = extractCursor({ next: paginatedResult.links.next });
-          }
-          return {
-            data: Array.isArray(paginatedResult.data) ? paginatedResult.data : [paginatedResult.data],
-            nextCursor
-          };
-        }
-        if (Array.isArray(result)) {
-          return { data: result };
-        }
-        return { data: [result] };
-      } catch (error) {
-        throw normalizeError(error);
-      }
-    }
-  };
-  return namedFunctions[functionName];
-}
-function createPaginatedFunction(coreFn, schema, telemetry, explicitFunctionName, defaultPageSize) {
-  const pageFunction = createPageFunction(coreFn);
-  const functionName = explicitFunctionName || coreFn.name;
-  const validator = schema ? createValidator(schema) : null;
-  const namedFunctions = {
-    [functionName]: function(options) {
-      return runWithTelemetryContext(() => {
-        const startTime = Date.now();
-        const normalizedOptions = options ?? {};
-        const isNested = isTelemetryNested();
-        const validatedOptions = {
-          ...normalizedOptions,
-          ...validator ? validator(normalizedOptions) : normalizedOptions
-        };
-        const pageSize = validatedOptions.pageSize ?? defaultPageSize;
-        const optimizedOptions = {
-          ...validatedOptions,
-          pageSize
-        };
-        const iterator = paginate(pageFunction, optimizedOptions);
-        const firstPagePromise = iterator.next().then((result) => {
-          if (result.done) {
-            throw new Error("Paginate should always iterate at least once");
-          }
-          return result.value;
-        });
-        if (!isNested && telemetry?.onMethodCalled) {
-          firstPagePromise.then(() => {
-            const argumentCount = Object.keys(
-              normalizedOptions
-            ).length;
-            telemetry.onMethodCalled({
-              methodName: functionName,
-              durationMs: Date.now() - startTime,
-              success: true,
-              argumentCount,
-              isPaginated: true
-            });
-          }).catch((error) => {
-            const argumentCount = Object.keys(
-              normalizedOptions
-            ).length;
-            telemetry.onMethodCalled({
-              methodName: functionName,
-              durationMs: Date.now() - startTime,
-              success: false,
-              error: error instanceof Error ? error : new Error(String(error)),
-              argumentCount,
-              isPaginated: true
-            });
-          });
-        }
-        return Object.assign(firstPagePromise, {
-          [Symbol.asyncIterator]: async function* () {
-            yield await firstPagePromise;
-            for await (const page of iterator) {
-              yield page;
-            }
-          },
-          items: function() {
-            return {
-              [Symbol.asyncIterator]: async function* () {
-                const firstPage = await firstPagePromise;
-                for (const item of firstPage.data) {
-                  yield item;
-                }
-                for await (const page of iterator) {
-                  for (const item of page.data) {
-                    yield item;
-                  }
-                }
-              }
-            };
-          }
-        });
-      });
-    }
-  };
-  return namedFunctions[functionName];
-}
-
-// src/utils/telemetry-utils.ts
-function createTelemetryCallback(emitMethodCalled, methodName) {
-  return {
-    onMethodCalled: (data) => {
-      const metadata = getMethodMetadata();
-      emitMethodCalled({
-        method_name: methodName,
-        execution_duration_ms: data.durationMs,
-        success_flag: data.success,
-        error_message: data.error?.message ?? null,
-        error_type: data.error?.constructor.name ?? null,
-        argument_count: data.argumentCount,
-        is_paginated: data.isPaginated,
-        selected_api: metadata?.selectedApi ?? null,
-        operation_type: metadata?.operationType ?? null,
-        operation_key: metadata?.operationKey ?? null
-      });
-    }
-  };
-}
-
-// src/utils/plugin-utils.ts
-function definePlugin(fn) {
-  return fn;
-}
-function maybeTelemetry(sdk, name) {
-  const ctx = sdk.context;
-  if (!ctx.eventEmission) return void 0;
-  return createTelemetryCallback(ctx.eventEmission.emitMethodCalled, name);
-}
-function createPluginMethod(sdk, config) {
-  const { name, inputSchema, handler, ...metaFields } = config;
-  const namedHandlers = {
-    [name]: async function(options) {
-      return handler({ sdk, options });
-    }
-  };
-  const wrappedFn = createFunction(
-    namedHandlers[name],
-    inputSchema,
-    maybeTelemetry(sdk, name)
-  );
-  return {
-    [name]: wrappedFn,
-    context: {
-      meta: {
-        [name]: {
-          ...metaFields,
-          ...inputSchema ? { inputSchema } : {}
-        }
-      }
-    }
-  };
-}
-function createPaginatedPluginMethod(sdk, config) {
-  const {
-    name,
-    inputSchema,
-    handler,
-    extractCursor: extractCursorFn,
-    defaultPageSize,
-    ...metaFields
-  } = config;
-  const namedPageHandlers = {
-    [name]: async function(options) {
-      const response = await handler({ sdk, options });
-      if (extractCursorFn) {
-        const extracted = extractCursorFn(response);
-        if (extracted !== void 0) {
-          return { data: response.data, nextCursor: extracted };
-        }
-      }
-      return response;
-    }
-  };
-  const wrappedFn = createPaginatedFunction(
-    namedPageHandlers[name],
-    inputSchema,
-    maybeTelemetry(sdk, name),
-    name,
-    defaultPageSize
-  );
-  return {
-    [name]: wrappedFn,
-    context: {
-      meta: {
-        [name]: {
-          ...metaFields,
-          ...inputSchema ? { inputSchema } : {}
-        }
-      }
+  if (error instanceof ZapierConflictError && error.resourceType) {
+    message += `
+Type: ${error.resourceType}`;
+  }
+  if (error instanceof ZapierTimeoutError && (error.attempts || error.maxAttempts)) {
+    const context = [];
+    if (error.attempts) context.push(`Attempts: ${error.attempts}`);
+    if (error.maxAttempts) context.push(`Max attempts: ${error.maxAttempts}`);
+    message += `
+${context.join(", ")}`;
+  }
+  if (error instanceof ZapierBundleError && error.buildErrors && error.buildErrors.length > 0) {
+    message += "\n\nBuild errors:\n" + error.buildErrors.map((err) => `  \u2022 ${err}`).join("\n");
+  }
+  if (error instanceof ZapierApprovalError && error.approvalUrl) {
+    message += `
+Approval URL: ${error.approvalUrl}`;
+  }
+  if (error instanceof ZapierRateLimitError) {
+    const { limit, remaining, retryAfterMs } = error.rateLimit;
+    const parts = [];
+    if (limit !== void 0) {
+      const used = remaining !== void 0 ? limit - remaining : limit;
+      parts.push(`${used}/${limit} used`);
     }
-  };
-}
-function mergeRootKeysWithCollisionCheck(target, source, seen) {
-  for (const key of Object.keys(source)) {
-    if (seen.has(key)) {
-      throw new Error(
-        `composePlugins: duplicate root key "${key}". Plugins composed in the same call must register distinct method names.`
-      );
+    if (retryAfterMs !== void 0 && retryAfterMs > 0) {
+      parts.push(`retry in ${formatDuration(retryAfterMs)}`);
     }
-    seen.add(key);
-    target[key] = source[key];
-  }
-}
-function mergeMetaKeysWithCollisionCheck(target, source, seen) {
-  for (const key of Object.keys(source)) {
-    if (seen.has(key)) {
-      throw new Error(
-        `composePlugins: duplicate context.meta key "${key}". Two sub-plugins registered metadata for the same name.`
+    if (error.retries > 0) {
+      parts.push(
+        `after ${error.retries} retr${error.retries === 1 ? "y" : "ies"}`
       );
     }
-    seen.add(key);
-    target[key] = source[key];
-  }
-}
-function mergeContextKeysWithCollisionCheck(target, source, seen) {
-  for (const key of Object.keys(source)) {
-    if (seen.has(key)) {
-      throw new Error(
-        `composePlugins: duplicate context key "${key}". Two sub-plugins contributed the same context.${key} field.`
-      );
+    if (parts.length > 0) {
+      message += `
+${parts.join(", ")}`;
     }
-    seen.add(key);
-    target[key] = source[key];
   }
-}
-function composePlugins(...plugins) {
-  return (sdk) => {
-    const merged = { context: { meta: {} } };
-    const seenRoot = /* @__PURE__ */ new Set();
-    const seenMeta = /* @__PURE__ */ new Set();
-    const seenContext = /* @__PURE__ */ new Set();
-    for (const plugin of plugins) {
-      const { context, ...rootKeys } = plugin(sdk);
-      mergeRootKeysWithCollisionCheck(merged, rootKeys, seenRoot);
-      if (context) {
-        const { meta, ...nonMetaContext } = context;
-        if (meta) {
-          mergeMetaKeysWithCollisionCheck(merged.context.meta, meta, seenMeta);
-        }
-        mergeContextKeysWithCollisionCheck(
-          merged.context,
-          nonMetaContext,
-          seenContext
-        );
-      }
-    }
-    return merged;
-  };
-}
-function getStringProperty(obj, key) {
-  if (typeof obj === "object" && obj !== null && key in obj) {
-    const value = obj[key];
-    return typeof value === "string" ? value : void 0;
+  if (error.statusCode && !message.includes(`${error.statusCode}`)) {
+    message += `
+HTTP Status: ${error.statusCode}`;
   }
-  return void 0;
+  return message;
 }
-function formatActionResult(item) {
-  const obj = typeof item === "object" && item !== null ? item : {};
-  const title = getStringProperty(obj, "title") || getStringProperty(obj, "name") || getStringProperty(obj, "label") || getStringProperty(obj, "subject") || "Action Result";
-  return {
-    title,
-    id: getStringProperty(obj, "id"),
-    key: getStringProperty(obj, "key"),
-    description: getStringProperty(obj, "description"),
-    data: item,
-    // Let formatJsonOutput handle the JSON rendering
-    details: []
-    // Not used when data is provided
-  };
+function formatDuration(ms) {
+  const seconds = Math.round(ms / 1e3);
+  if (seconds < 60) return `${seconds}s`;
+  const minutes = Math.round(seconds / 60);
+  if (minutes < 60) return `${minutes}m`;
+  const hours = Math.round(minutes / 60);
+  if (hours < 24) return `${hours}h`;
+  const days = Math.round(hours / 24);
+  return `${days}d`;
 }
-var ActionResultItemSchema = withFormatter(
-  z.unknown().describe("Action execution result"),
-  { format: formatActionResult }
+
+// src/types/signals.ts
+var ZapierSignal = class extends Error {
+  constructor(message) {
+    super(message);
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var ZapierReleaseTriggerMessageSignal = class extends ZapierSignal {
+  constructor() {
+    super(...arguments);
+    this.name = "ZapierReleaseTriggerMessageSignal";
+    this.code = "ZAPIER_RELEASE_TRIGGER_MESSAGE_SIGNAL";
+  }
+};
+var ZapierAbortDrainSignal = class extends ZapierSignal {
+  constructor() {
+    super(...arguments);
+    this.name = "ZapierAbortDrainSignal";
+    this.code = "ZAPIER_ABORT_DRAIN_SIGNAL";
+  }
+};
+var TriggerInboxCommandBaseSchema = z.object({
+  inbox: TriggerInboxPropertySchema,
+  onMessage: z.function().optional().meta({ exampleRequired: true }).describe(
+    "Per-message handler. Resolves to ack; rejects to release-or-leave per `releaseOnError`. Throw `ZapierReleaseTriggerMessageSignal` to release explicitly, or `ZapierAbortDrainSignal` to stop after the current batch."
+  ),
+  concurrency: z.number().int().min(1).optional().describe(
+    "Per-message handler workers running in parallel. Defaults to `leaseLimit`, or 1 if neither is set."
+  ),
+  leaseLimit: z.number().int().min(1).max(100).optional().describe(
+    "Per-lease HTTP batch size. Defaults to `concurrency`, or 1 if neither is set."
+  ),
+  leaseSeconds: LeaseSecondsPropertySchema.optional(),
+  releaseOnError: z.boolean().optional().describe(
+    "If true, errors release the message when the drain finishes. If false (default), errors leave it leased until the lease timeout. `ZapierReleaseTriggerMessageSignal` always releases regardless."
+  ),
+  continueOnError: z.boolean().optional().describe(
+    "If false (default, fail-fast), the first handler error rejects and stops the drain. If true, handler errors are observed via `onError` and the drain continues. SDK-level errors (lease / ack / release) reject regardless."
+  ),
+  onError: z.function().optional().describe(
+    "Per-message error observer for `continueOnError: true`. Called with the failure and the message; control-flow signals are filtered out. Throws from `onError` are swallowed."
+  ),
+  signal: z.custom((v) => v instanceof AbortSignal).optional().describe(
+    "Abort signal. Aborting cancels in-flight HTTP, releases unprocessed messages, and resolves cleanly. Errors during shutdown still reject."
+  )
+});
+TriggerInboxCommandBaseSchema.extend({
+  maxMessages: z.number().int().min(1).optional().describe(
+    "Cap total messages drained. Defaults to draining the inbox until empty."
+  )
+}).describe(
+  "Drain an existing trigger inbox: lease currently-available messages and process them via onMessage. Returns when the inbox is empty, maxMessages is reached, the abort signal fires, or a fatal error rejects."
+);
+TriggerInboxCommandBaseSchema.extend({
+  maxDrainIntervalSeconds: z.number().int().min(1).optional().describe(
+    "Maximum seconds between empty-inbox poll attempts (default: 60). Caps the back-off cadence."
+  )
+}).describe(
+  "Continuously consume a trigger inbox: drain currently-available messages, then poll with backoff for new arrivals, until aborted. Stop via the `signal` AbortSignal or by throwing `ZapierAbortDrainSignal` from a handler. Resolves cleanly on abort; rejects on a fatal error or a fail-fast handler error."
 );
+var ActionExecutionInputSchema = z.object({
+  inputs: z.record(z.string(), z.unknown()).optional(),
+  /** @deprecated Use `connection` instead. */
+  connectionId: ConnectionIdPropertySchema.optional().meta({
+    deprecated: true
+  }),
+  connection: ConnectionPropertySchema.optional(),
+  /** @deprecated Use connection instead */
+  authenticationId: AuthenticationIdPropertySchema.optional().meta({
+    deprecated: true
+  }),
+  timeoutMs: ActionTimeoutMsPropertySchema
+}).describe(
+  "Execute an action with the given inputs for the bound app, as an alternative to runAction"
+).meta({
+  aliases: { connectionId: "connection", authenticationId: "connection" }
+});
+var AppFactoryInputSchema = z.object({
+  /** @deprecated Use `connection` instead. */
+  connectionId: ConnectionIdPropertySchema.optional().meta({
+    deprecated: true
+  }),
+  connection: ConnectionPropertySchema.optional(),
+  /** @deprecated Use connection instead */
+  authenticationId: AuthenticationIdPropertySchema.optional().meta({
+    deprecated: true
+  })
+}).describe("Bind a connection alias or numeric connectionId to an app").meta({
+  aliases: { connectionId: "connection", authenticationId: "connection" }
+});
+var ActionResultItemSchema = z.unknown().describe("Action execution result");
 
 // src/plugins/apps/index.ts
 function resolveProxyConnection({
@@ -1373,18 +1684,6 @@ var FetchInitSchema = z.object({
   aliases: { connectionId: "connection", authenticationId: "connection" }
 });
 
-// src/utils/string-utils.ts
-function toTitleCase(input) {
-  return input.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/[_\-]+/g, " ").replace(/\s+/g, " ").trim().split(" ").map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join(" ");
-}
-function toSnakeCase(input) {
-  let result = input.replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/[\s\-]+/g, "_").replace(/_+/g, "_").replace(/^_|_$/g, "").toLowerCase();
-  if (/^[0-9]/.test(result)) {
-    result = "_" + result;
-  }
-  return result;
-}
-
 // src/utils/domain-utils.ts
 function isConnectionId(value) {
   return /^\d+$/.test(value) || isUuid(value);
@@ -1687,15 +1986,25 @@ function buildAbortHandle({
   return combineAbortSignals({ handles });
 }
 var FetchInitSdkValidationSchema = z.looseObject(FetchInitZapierFieldsSchema.shape).optional();
-var validateFetchInit = createValidator(FetchInitSdkValidationSchema);
 var fetchPlugin = definePlugin(
   (sdk) => {
+    const validateFetchInit = createValidator(FetchInitSdkValidationSchema, {
+      adaptError: sdk.context.core?.adaptError
+    });
     return {
       fetch: async function fetch2(url, init) {
-        return runWithTelemetryContext(async () => {
+        return runInMethodScope(async () => {
           const { api } = sdk.context;
+          const { onMethodStart, onMethodEnd } = sdk.context.hooks;
           const startTime = Date.now();
-          const isNested = isTelemetryNested();
+          const depth = getCurrentDepth();
+          const args = init === void 0 ? [url] : [url, init];
+          onMethodStart?.({
+            methodName: "fetch",
+            args,
+            isPaginated: false,
+            depth
+          });
           try {
             if (init) {
               validateFetchInit(init);
@@ -1767,17 +2076,13 @@ var fetchPlugin = definePlugin(
                   statusCode: result.status
                 });
               }
-              if (!isNested) {
-                sdk.context.eventEmission.emitMethodCalled({
-                  method_name: "fetch",
-                  execution_duration_ms: Date.now() - startTime,
-                  success_flag: true,
-                  error_message: null,
-                  error_type: null,
-                  argument_count: init ? 2 : 1,
-                  is_paginated: false
-                });
-              }
+              onMethodEnd?.({
+                methodName: "fetch",
+                args,
+                isPaginated: false,
+                depth,
+                durationMs: Date.now() - startTime
+              });
               return result;
             } catch (error) {
               throw rewrapIfMaxTimeTimeout({
@@ -1789,17 +2094,14 @@ var fetchPlugin = definePlugin(
               abortHandle?.dispose();
             }
           } catch (error) {
-            if (!isNested) {
-              sdk.context.eventEmission.emitMethodCalled({
-                method_name: "fetch",
-                execution_duration_ms: Date.now() - startTime,
-                success_flag: false,
-                error_message: error instanceof Error ? error.message : String(error),
-                error_type: error instanceof Error ? error.constructor.name : "Unknown",
-                argument_count: init ? 2 : 1,
-                is_paginated: false
-              });
-            }
+            onMethodEnd?.({
+              methodName: "fetch",
+              args,
+              isPaginated: false,
+              depth,
+              durationMs: Date.now() - startTime,
+              error: error instanceof Error ? error : new Error(String(error))
+            });
             throw error;
           }
         });
@@ -1809,7 +2111,11 @@ var fetchPlugin = definePlugin(
           fetch: {
             description: "Make authenticated HTTP requests to any API through Zapier. Pass a connectionId to automatically inject the user's stored credentials (OAuth tokens, API keys, etc.) into the outgoing request. Mirrors the native fetch(url, init?) signature with additional Zapier-specific options.",
             packages: ["sdk", "cli", "mcp"],
-            categories: ["http"],
+            // Auto-derive would produce "Http"/"Https" from the key alone;
+            // declare the title explicitly here so the registry renders
+            // "HTTP Request". Other plugins in this category use the bare
+            // string "http"; the object form wins regardless of order.
+            categories: [{ key: "http", title: "HTTP Request" }],
             returnType: "Response",
             inputParameters: [
               { name: "url", schema: FetchUrlSchema },
@@ -1821,6 +2127,29 @@ var fetchPlugin = definePlugin(
     };
   }
 );
+
+// src/utils/pagination.ts
+function extractCursorFromUrl(url) {
+  try {
+    const params = new URL(url).searchParams;
+    return params.get("offset") ?? params.get("cursor") ?? void 0;
+  } catch {
+    return void 0;
+  }
+}
+function adaptZapierPage(response) {
+  const r = response ?? {};
+  const data = r.data;
+  const linksNext = r.links?.next;
+  if (typeof linksNext === "string") {
+    return { data, nextCursor: extractCursorFromUrl(linksNext) };
+  }
+  if (typeof r.next === "string") {
+    return { data, nextCursor: extractCursorFromUrl(r.next) };
+  }
+  return { data };
+}
+var zapierPagination = { adaptPage: adaptZapierPage };
 var ListAppsSchema = ListAppsQuerySchema.omit({
   offset: true,
   app_keys: true,
@@ -1842,27 +2171,30 @@ var ListAppsSchema = ListAppsQuerySchema.omit({
   // SDK specific property for pagination/iterable helpers
   cursor: z.string().optional().describe("Cursor to start from")
 }).describe("List all available apps with optional filtering");
-var AppItemSchema = withFormatter(AppItemSchema$1, {
-  format: (item) => {
-    return {
-      title: item.title,
-      key: item.key,
-      keys: getAppKeyList(item),
-      description: item.description,
-      details: []
-    };
-  }
-});
+var AppItemSchema = AppItemSchema$1;
+
+// src/formatters/app.ts
+var appItemFormatter = {
+  format: (item) => ({
+    title: item.title,
+    key: item.key,
+    keys: getAppKeyList(item),
+    description: item.description,
+    details: []
+  })
+};
 
 // src/plugins/listApps/index.ts
 var listAppsPlugin = definePlugin(
   (sdk) => createPaginatedPluginMethod(sdk, {
+    ...zapierPagination,
     name: "listApps",
     categories: ["app"],
     type: "list",
     itemType: "App",
     inputSchema: ListAppsSchema,
     outputSchema: AppItemSchema,
+    formatter: appItemFormatter,
     defaultPageSize: DEFAULT_PAGE_SIZE,
     handler: async ({ sdk: sdk2, options }) => {
       const { api, resolveAppKeys: resolveAppKeys2 } = sdk2.context;
@@ -1902,8 +2234,7 @@ var listAppsPlugin = definePlugin(
           ...options.cursor && { offset: options.cursor }
         }
       });
-    },
-    extractCursor: (response) => extractCursor(response.links)
+    }
   })
 );
 var ListActionsDescription = "List all actions for a specific app";
@@ -2228,48 +2559,42 @@ z.object({
 });
 
 // src/schemas/Action.ts
-var ActionItemSchema = withFormatter(
-  ActionSchema.omit({ type: true, name: true, selected_api: true }).extend({
-    app_key: z.string(),
-    // App key without version (extracted from selected_api)
-    app_version: z.string().optional(),
-    // Version extracted from selected_api
-    action_type: ActionSchema.shape.type,
-    // Mapped from original 'type' field
-    title: z.string(),
-    // Mapped from original 'name' field
-    type: z.literal("action")
-    // Fixed type identifier
-  }),
-  {
-    format: (item) => {
-      const details = [];
-      details.push({
-        text: `Type: ${item.action_type}`,
-        style: "accent"
-      });
-      if (item.app_key) {
-        details.push({
-          text: `App: ${item.app_key}`,
-          style: "normal"
-        });
-      }
-      if (item.description) {
-        details.push({
-          text: item.description,
-          style: "dim"
-        });
-      }
-      return {
-        title: item.title || item.key,
-        id: item.id,
-        key: item.key,
-        description: item.description,
-        details
-      };
+var ActionItemSchema = ActionSchema.omit({
+  type: true,
+  name: true,
+  selected_api: true
+}).extend({
+  app_key: z.string(),
+  // App key without version (extracted from selected_api)
+  app_version: z.string().optional(),
+  // Version extracted from selected_api
+  action_type: ActionSchema.shape.type,
+  // Mapped from original 'type' field
+  title: z.string(),
+  // Mapped from original 'name' field
+  type: z.literal("action")
+  // Fixed type identifier
+});
+
+// src/formatters/action.ts
+var actionItemFormatter = {
+  format: (item) => {
+    const details = [{ text: `Type: ${item.action_type}`, style: "accent" }];
+    if (item.app_key) {
+      details.push({ text: `App: ${item.app_key}`, style: "normal" });
+    }
+    if (item.description) {
+      details.push({ text: item.description, style: "dim" });
     }
+    return {
+      title: item.title || item.key,
+      id: item.id,
+      key: item.key,
+      description: item.description,
+      details
+    };
   }
-);
+};
 
 // src/resolvers/appKey.ts
 var appKeyResolver = {
@@ -2476,7 +2801,7 @@ var inputFieldKeyResolver = {
   type: "dynamic",
   depends: ["app", "action", "actionType", "connection"],
   fetch: async (sdk, resolvedParams) => {
-    const fieldsResponse = await sdk.listInputFields({
+    const fieldsResponse = await sdk.listActionInputFields({
       app: resolvedParams.app,
       action: resolvedParams.action,
       actionType: resolvedParams.actionType,
@@ -2582,7 +2907,8 @@ var workflowIdResolver = {
     name: "workflow",
     message: "Select a workflow:",
     choices: workflows.map((workflow) => ({
-      name: workflow.enabled ? workflow.name : `${workflow.name} (disabled)`,
+      name: workflow.name,
+      hint: workflow.enabled ? void 0 : [workflow.id, "disabled"],
       value: workflow.id
     }))
   })
@@ -2597,7 +2923,8 @@ var durableRunIdResolver = {
     name: "run",
     message: "Select a run:",
     choices: runs.map((run) => ({
-      name: `${run.id} \u2014 ${run.status}`,
+      name: run.id,
+      hint: run.status,
       value: run.id
     }))
   })
@@ -2607,11 +2934,7 @@ var durableRunIdResolver = {
 var workflowVersionIdResolver = {
   type: "dynamic",
   depends: ["workflow"],
-  fetch: async (sdk, params) => toIterable(
-    sdk.listWorkflowVersions({
-      workflow: params.workflow
-    })
-  ),
+  fetch: async (sdk, params) => toIterable(sdk.listWorkflowVersions({ workflow: params.workflow })),
   prompt: (versions) => ({
     type: "list",
     name: "version",
@@ -2623,15 +2946,27 @@ var workflowVersionIdResolver = {
   })
 };
 
+// src/resolvers/workflowRunId.ts
+var workflowRunIdResolver = {
+  type: "dynamic",
+  depends: ["workflow"],
+  fetch: async (sdk, params) => toIterable(sdk.listWorkflowRuns({ workflow: params.workflow })),
+  prompt: (runs) => ({
+    type: "list",
+    name: "run",
+    message: "Select a workflow run:",
+    choices: runs.map((r) => ({
+      name: `${r.id} \u2014 ${r.status}`,
+      value: r.id
+    }))
+  })
+};
+
 // src/resolvers/triggerMessages.ts
 var triggerMessagesResolver = {
   type: "dynamic",
   depends: ["inbox"],
-  fetch: async (sdk, params) => toIterable(
-    sdk.listTriggerInboxMessages({
-      inbox: params.inbox
-    })
-  ),
+  fetch: async (sdk, params) => toIterable(sdk.listTriggerInboxMessages({ inbox: params.inbox })),
   prompt: (messages) => ({
     type: "checkbox",
     name: "messages",
@@ -3005,7 +3340,7 @@ var FieldApiItemSchema = z.object({
 var ListTableFieldsApiResponseSchema = z.object({
   data: z.array(FieldApiItemSchema)
 });
-var FieldItemSchemaBase = z.object({
+var FieldItemSchema = z.object({
   id: z.string(),
   type: FieldTypeSchema,
   name: z.string(),
@@ -3015,13 +3350,6 @@ var FieldItemSchemaBase = z.object({
   config: z.record(z.string(), z.unknown()).optional(),
   deleted_at: z.string().nullable().optional()
 });
-var FieldItemSchema = withFormatter(FieldItemSchemaBase, {
-  format: (item) => ({
-    title: item.name,
-    id: item.id,
-    details: [{ text: `Type: ${item.type}`, style: "dim" }]
-  })
-});
 var ListTableFieldsDescription = "List fields for a table";
 var ListTableFieldsOptionsBaseSchema = z.object({
   fields: FieldsPropertySchema.optional(),
@@ -3268,6 +3596,18 @@ var tableSortResolver = {
   }
 };
 
+// src/plugins/eventEmission/method-metadata.ts
+var SCOPE_KEY = "methodMetadata";
+function setMethodMetadata(metadata) {
+  const scope = getCurrentScope();
+  if (!scope) return;
+  const existing = scope[SCOPE_KEY];
+  scope[SCOPE_KEY] = { ...existing, ...metadata };
+}
+function getMethodMetadata() {
+  return getCurrentScope()?.[SCOPE_KEY];
+}
+
 // src/plugins/listActions/index.ts
 var listActionsPlugin = definePlugin(
   (sdk) => createPaginatedPluginMethod(sdk, {
@@ -3277,12 +3617,10 @@ var listActionsPlugin = definePlugin(
     itemType: "Action",
     inputSchema: ListActionsInputSchema,
     outputSchema: ActionItemSchema,
+    formatter: actionItemFormatter,
     defaultPageSize: DEFAULT_PAGE_SIZE,
     resolvers: { app: appKeyResolver, actionType: actionTypeResolver },
-    handler: async ({
-      sdk: sdk2,
-      options
-    }) => {
+    handler: async ({ sdk: sdk2, options }) => {
       const { api, getVersionedImplementationId } = sdk2.context;
       const appKey = "app" in options ? options.app : options.appKey;
       const selectedApi = await getVersionedImplementationId(appKey);
@@ -3369,99 +3707,36 @@ var BaseFieldItemSchema = z.object({
   key: z.string()
   // From need.key
 });
-var InputFieldItemSchema = withFormatter(
-  BaseFieldItemSchema.extend({
-    type: z.literal("input_field"),
-    default_value: z.string(),
-    // Mapped from 'default' with fallback to ""
-    depends_on: z.array(z.string()),
-    // Mapped from 'depends_on' with fallback to []
-    description: z.string(),
-    // Mapped from 'help_text' with fallback to ""
-    invalidates_input_fields: z.boolean(),
-    // Mapped from 'alters_custom_fields' with fallback to false
-    is_required: z.boolean(),
-    // Mapped from 'required' with fallback to false
-    placeholder: z.string(),
-    // Mapped from 'placeholder' with fallback to ""
-    title: z.string(),
-    // Mapped from 'label' with fallback to ""
-    value_type: z.string(),
-    // Computed from InputFieldType enum
-    format: z.string().optional(),
-    // Computed from InputFieldFormat enum (optional)
-    items: z.object({ type: z.string() }).optional()
-    // Computed from ItemsType enum (optional, only for arrays)
-  }),
-  {
-    format: (item) => {
-      const details = [];
-      const typeInfo = [
-        item.value_type && `Type: ${item.value_type}`,
-        `Required: ${item.is_required ? "Yes" : "No"}`
-      ].filter(Boolean).join(" | ");
-      if (typeInfo) {
-        details.push({ text: typeInfo, style: "dim" });
-      }
-      if (item.description) {
-        details.push({
-          text: item.description,
-          style: "normal"
-        });
-      }
-      if (item.default_value) {
-        details.push({
-          text: `Default: ${item.default_value}`,
-          style: "accent"
-        });
-      }
-      if (item.placeholder) {
-        details.push({
-          text: `Placeholder: ${item.placeholder}`,
-          style: "dim"
-        });
-      }
-      if (item.depends_on && item.depends_on.length > 0) {
-        details.push({
-          text: `Depends on: ${item.depends_on.join(", ")}`,
-          style: "warning"
-        });
-      }
-      if (item.format) {
-        details.push({ text: `Format: ${item.format}`, style: "dim" });
-      }
-      if (item.items) {
-        details.push({
-          text: `Items type: ${item.items.type}`,
-          style: "dim"
-        });
-      }
-      return {
-        title: item.title || item.key,
-        key: item.key,
-        description: item.description,
-        details
-      };
-    }
-  }
-);
-var InfoFieldItemSchema = withFormatter(
-  BaseFieldItemSchema.extend({
-    type: z.literal("info_field"),
-    description: z.string(),
-    // From need.help_text
-    title: z.string().optional()
-    // Optional title
-  }),
-  {
-    format: (item) => ({
-      title: item.title || "Info",
-      key: item.key,
-      description: item.description,
-      details: [{ text: item.description, style: "normal" }]
-    })
-  }
-);
+var InputFieldItemSchema = BaseFieldItemSchema.extend({
+  type: z.literal("input_field"),
+  default_value: z.string(),
+  // Mapped from 'default' with fallback to ""
+  depends_on: z.array(z.string()),
+  // Mapped from 'depends_on' with fallback to []
+  description: z.string(),
+  // Mapped from 'help_text' with fallback to ""
+  invalidates_input_fields: z.boolean(),
+  // Mapped from 'alters_custom_fields' with fallback to false
+  is_required: z.boolean(),
+  // Mapped from 'required' with fallback to false
+  placeholder: z.string(),
+  // Mapped from 'placeholder' with fallback to ""
+  title: z.string(),
+  // Mapped from 'label' with fallback to ""
+  value_type: z.string(),
+  // Computed from InputFieldType enum
+  format: z.string().optional(),
+  // Computed from InputFieldFormat enum (optional)
+  items: z.object({ type: z.string() }).optional()
+  // Computed from ItemsType enum (optional, only for arrays)
+});
+var InfoFieldItemSchema = BaseFieldItemSchema.extend({
+  type: z.literal("info_field"),
+  description: z.string(),
+  // From need.help_text
+  title: z.string().optional()
+  // Optional title
+});
 var FieldsetItemSchema = BaseFieldItemSchema.extend({
   type: z.literal("fieldset"),
   title: z.string(),
@@ -3481,6 +3756,53 @@ var RootFieldItemSchema = z.union([
   FieldsetItemSchema
 ]);
 
+// src/formatters/field.ts
+function formatInputField(item) {
+  const details = [];
+  const typeInfo = [
+    item.value_type && `Type: ${item.value_type}`,
+    `Required: ${item.is_required ? "Yes" : "No"}`
+  ].filter(Boolean).join(" | ");
+  if (typeInfo) details.push({ text: typeInfo, style: "dim" });
+  if (item.description)
+    details.push({ text: item.description, style: "normal" });
+  if (item.default_value)
+    details.push({ text: `Default: ${item.default_value}`, style: "accent" });
+  if (item.placeholder)
+    details.push({ text: `Placeholder: ${item.placeholder}`, style: "dim" });
+  if (item.depends_on && item.depends_on.length > 0) {
+    details.push({
+      text: `Depends on: ${item.depends_on.join(", ")}`,
+      style: "warning"
+    });
+  }
+  if (item.format)
+    details.push({ text: `Format: ${item.format}`, style: "dim" });
+  if (item.items)
+    details.push({ text: `Items type: ${item.items.type}`, style: "dim" });
+  return {
+    title: item.title || item.key,
+    key: item.key,
+    description: item.description,
+    details
+  };
+}
+function formatInfoField(item) {
+  return {
+    title: item.title || "Info",
+    key: item.key,
+    description: item.description,
+    details: [{ text: item.description, style: "normal" }]
+  };
+}
+var rootFieldItemFormatter = {
+  format: (item) => {
+    if (item.type === "input_field") return formatInputField(item);
+    if (item.type === "info_field") return formatInfoField(item);
+    return { title: item.title || item.key, key: item.key, details: [] };
+  }
+};
+
 // src/services/implementations.ts
 async function fetchImplementationNeeds({
   api,
@@ -3646,6 +3968,7 @@ var listActionInputFieldsPlugin = definePlugin(
     itemType: "RootField",
     inputSchema: ListActionInputFieldsInputSchema,
     outputSchema: RootFieldItemSchema,
+    formatter: rootFieldItemFormatter,
     defaultPageSize: DEFAULT_PAGE_SIZE,
     resolvers: {
       app: appKeyResolver,
@@ -3654,10 +3977,7 @@ var listActionInputFieldsPlugin = definePlugin(
       connection: connectionIdResolver,
       inputs: inputsAllOptionalResolver
     },
-    handler: async ({
-      sdk: sdk2,
-      options
-    }) => {
+    handler: async ({ sdk: sdk2, options }) => {
       const { api, getVersionedImplementationId } = sdk2.context;
       const appKey = "app" in options ? options.app : options.appKey;
       const actionKey = "action" in options ? options.action : options.actionKey;
@@ -3705,26 +4025,7 @@ var listActionInputFieldsPlugin = definePlugin(
     }
   })
 );
-var InputFieldChoiceItemSchema = withFormatter(NeedChoicesSchema, {
-  format: (item) => {
-    const title = item.label || item.key || "Choice";
-    const details = [];
-    if (item.label && item.key && item.label !== item.key) {
-      details.push({ text: `Key: ${item.key}`, style: "dim" });
-    }
-    if (item.sample && item.sample !== item.key) {
-      details.push({ text: `Sample: ${item.sample}`, style: "dim" });
-    }
-    if (item.value && item.value !== item.key) {
-      details.push({ text: `Value: ${item.value}`, style: "normal" });
-    }
-    return {
-      title,
-      key: item.key,
-      details
-    };
-  }
-});
+var InputFieldChoiceItemSchema = NeedChoicesSchema;
 var ListActionInputFieldChoicesDescription = "Get the available choices for a dynamic dropdown input field";
 var ListActionInputFieldChoicesBaseSchema = z.object({
   connection: ConnectionPropertySchema.optional().describe(
@@ -3768,6 +4069,24 @@ var ListActionInputFieldChoicesInputSchema = z.union([
   ListActionInputFieldChoicesSchemaDeprecated
 ]).describe(ListActionInputFieldChoicesDescription);
 
+// src/formatters/inputFieldChoice.ts
+var inputFieldChoiceItemFormatter = {
+  format: (item) => {
+    const title = item.label || item.key || "Choice";
+    const details = [];
+    if (item.label && item.key && item.label !== item.key) {
+      details.push({ text: `Key: ${item.key}`, style: "dim" });
+    }
+    if (item.sample && item.sample !== item.key) {
+      details.push({ text: `Sample: ${item.sample}`, style: "dim" });
+    }
+    if (item.value && item.value !== item.key) {
+      details.push({ text: `Value: ${item.value}`, style: "normal" });
+    }
+    return { title, key: item.key, details };
+  }
+};
+
 // src/plugins/listActionInputFieldChoices/index.ts
 function transformNeedChoicesToInputFieldChoiceItem(choice) {
   return {
@@ -3785,6 +4104,7 @@ var listActionInputFieldChoicesPlugin = definePlugin(
     itemType: "InputFieldChoice",
     inputSchema: ListActionInputFieldChoicesInputSchema,
     outputSchema: InputFieldChoiceItemSchema,
+    formatter: inputFieldChoiceItemFormatter,
     defaultPageSize: DEFAULT_PAGE_SIZE,
     resolvers: {
       app: appKeyResolver,
@@ -3794,10 +4114,7 @@ var listActionInputFieldChoicesPlugin = definePlugin(
       inputField: inputFieldKeyResolver,
       inputs: inputsAllOptionalResolver
     },
-    handler: async ({
-      sdk: sdk2,
-      options
-    }) => {
+    handler: async ({ sdk: sdk2, options }) => {
       const { api, getVersionedImplementationId } = sdk2.context;
       const appKey = "app" in options ? options.app : options.appKey;
       const actionKey = "action" in options ? options.action : options.actionKey;
@@ -4049,7 +4366,10 @@ var ListConnectionsQuerySchema = ListConnectionsQuerySchema$1.omit({
   // SDK specific property for pagination/iterable helpers
   cursor: z.string().optional().describe("Cursor to start from")
 }).describe("List available connections with optional filtering");
-var ConnectionItemSchema = withFormatter(ConnectionItemSchema$1, {
+var ConnectionItemSchema = ConnectionItemSchema$1;
+
+// src/formatters/connection.ts
+var connectionItemFormatter = {
   format: (item) => {
     const details = [];
     if (item.identifier) {
@@ -4074,17 +4394,19 @@ var ConnectionItemSchema = withFormatter(ConnectionItemSchema$1, {
       details
     };
   }
-});
+};
 
 // src/plugins/listConnections/index.ts
 var listConnectionsPlugin = definePlugin(
   (sdk) => createPaginatedPluginMethod(sdk, {
+    ...zapierPagination,
     name: "listConnections",
     categories: ["connection"],
     type: "list",
     itemType: "Connection",
     inputSchema: ListConnectionsQuerySchema,
     outputSchema: ConnectionItemSchema,
+    formatter: connectionItemFormatter,
     defaultPageSize: DEFAULT_PAGE_SIZE,
     resolvers: { app: appKeyResolver },
     handler: async ({ sdk: sdk2, options }) => {
@@ -4157,8 +4479,7 @@ var listConnectionsPlugin = definePlugin(
         ...response,
         data: response.data.map(transformConnectionItem)
       };
-    },
-    extractCursor: (response) => extractCursor(response.links)
+    }
   })
 );
 var ListClientCredentialsQuerySchema = ListClientCredentialsQuerySchema$1.omit({
@@ -4172,58 +4493,49 @@ var ListClientCredentialsQuerySchema = ListClientCredentialsQuerySchema$1.omit({
   // SDK specific property for pagination/iterable helpers
   cursor: z.string().optional().describe("Cursor to start from")
 }).describe("List client credentials for the authenticated user");
-var ClientCredentialsItemSchema = withFormatter(
-  ClientCredentialsItemSchema$1,
-  {
-    format: (item) => {
-      const details = [];
-      if (item.allowed_scopes && item.allowed_scopes.length > 0) {
-        details.push({
-          text: `Scopes: ${item.allowed_scopes.join(", ")}`,
-          style: "accent"
-        });
-      }
-      if (item.created_at) {
-        details.push({
-          text: `Created: ${new Date(item.created_at).toLocaleDateString()}`,
-          style: "dim"
-        });
-      }
-      return {
-        title: item.name,
-        id: item.client_id,
-        details
-      };
+var ClientCredentialsItemSchema = ClientCredentialsItemSchema$1;
+var ClientCredentialsCreatedItemSchema = ClientCredentialsCreatedItemSchema$1;
+
+// src/formatters/clientCredentials.ts
+var clientCredentialsItemFormatter = {
+  format: (item) => {
+    const details = [];
+    if (item.allowed_scopes && item.allowed_scopes.length > 0) {
+      details.push({
+        text: `Scopes: ${item.allowed_scopes.join(", ")}`,
+        style: "accent"
+      });
     }
-  }
-);
-var ClientCredentialsCreatedItemSchema = withFormatter(
-  ClientCredentialsCreatedItemSchema$1,
-  {
-    format: (item) => {
-      return {
-        title: item.name,
-        id: item.client_id,
-        details: [
-          {
-            text: `Client Secret: ${item.client_secret}`,
-            style: "accent"
-          }
-        ]
-      };
+    if (item.created_at) {
+      details.push({
+        text: `Created: ${new Date(item.created_at).toLocaleDateString()}`,
+        style: "dim"
+      });
     }
+    return { title: item.name, id: item.client_id, details };
   }
-);
+};
+var clientCredentialsCreatedItemFormatter = {
+  format: (item) => ({
+    title: item.name,
+    id: item.client_id,
+    details: [
+      { text: `Client Secret: ${item.client_secret}`, style: "accent" }
+    ]
+  })
+};
 
 // src/plugins/listClientCredentials/index.ts
 var listClientCredentialsPlugin = definePlugin(
   (sdk) => createPaginatedPluginMethod(sdk, {
+    ...zapierPagination,
     name: "listClientCredentials",
     categories: ["client-credentials"],
     type: "list",
     itemType: "ClientCredentials",
     inputSchema: ListClientCredentialsQuerySchema,
     outputSchema: ClientCredentialsItemSchema,
+    formatter: clientCredentialsItemFormatter,
     defaultPageSize: DEFAULT_PAGE_SIZE,
     handler: async ({
       sdk: sdk2,
@@ -4244,8 +4556,7 @@ var listClientCredentialsPlugin = definePlugin(
           requiredScopes: ["credentials"]
         }
       );
-    },
-    extractCursor: (response) => extractCursor(response.links)
+    }
   })
 );
 var CreateClientCredentialsSchema = CreateClientCredentialsRequestSchema.omit({ allowed_scopes: true }).extend({
@@ -4263,6 +4574,7 @@ var createClientCredentialsPlugin = definePlugin(
     itemType: "ClientCredentials",
     inputSchema: CreateClientCredentialsSchema,
     outputSchema: ClientCredentialsCreatedItemSchema,
+    formatter: clientCredentialsCreatedItemFormatter,
     confirm: "create-secret",
     resolvers: { name: clientCredentialsNameResolver },
     handler: async ({ sdk: sdk2, options }) => {
@@ -4329,6 +4641,7 @@ var getAppPlugin = definePlugin(
     itemType: "App",
     inputSchema: GetAppInputSchema,
     outputSchema: AppItemSchema,
+    formatter: appItemFormatter,
     resolvers: { app: appKeyResolver },
     handler: async ({ sdk: sdk2, options }) => {
       const appKey = "app" in options ? options.app : options.appKey;
@@ -4362,6 +4675,7 @@ var getActionPlugin = definePlugin(
     itemType: "Action",
     inputSchema: GetActionInputSchema,
     outputSchema: ActionItemSchema,
+    formatter: actionItemFormatter,
     resolvers: {
       app: appKeyResolver,
       actionType: actionTypeResolver,
@@ -4408,6 +4722,7 @@ var getConnectionPlugin = definePlugin(
     itemType: "Connection",
     inputSchema: GetConnectionParamSchema,
     outputSchema: ConnectionItemSchema,
+    formatter: connectionItemFormatter,
     resolvers: { connection: connectionIdGenericResolver },
     handler: async ({ sdk: sdk2, options }) => {
       const { api } = sdk2.context;
@@ -4448,6 +4763,7 @@ var findFirstConnectionPlugin = definePlugin(
     itemType: "Connection",
     inputSchema: FindFirstConnectionSchema,
     outputSchema: ConnectionItemSchema,
+    formatter: connectionItemFormatter,
     handler: async ({ sdk: sdk2, options = {} }) => {
       const connectionsResponse = await sdk2.listConnections({
         ...options,
@@ -4483,6 +4799,7 @@ var findUniqueConnectionPlugin = definePlugin(
     itemType: "Connection",
     inputSchema: FindUniqueConnectionSchema,
     outputSchema: ConnectionItemSchema,
+    formatter: connectionItemFormatter,
     handler: async ({ sdk: sdk2, options = {} }) => {
       const connectionsResponse = await sdk2.listConnections({
         ...options,
@@ -4540,6 +4857,29 @@ var RunActionSchemaDeprecated = z.object({
   actionKey: ActionKeyPropertySchema
 }).merge(RunActionBaseSchema);
 var RunActionInputSchema = 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];
+    return typeof value === "string" ? value : void 0;
+  }
+  return void 0;
+}
+var actionResultItemFormatter = {
+  format: (item) => {
+    const obj = typeof item === "object" && item !== null ? item : {};
+    const title = getStringProperty(obj, "title") || getStringProperty(obj, "name") || getStringProperty(obj, "label") || getStringProperty(obj, "subject") || "Action Result";
+    return {
+      title,
+      id: getStringProperty(obj, "id"),
+      key: getStringProperty(obj, "key"),
+      description: getStringProperty(obj, "description"),
+      data: item,
+      details: []
+    };
+  }
+};
 async function executeAction(actionOptions) {
   const {
     api,
@@ -4669,6 +5009,7 @@ var runActionPlugin = definePlugin(
       itemType: "ActionResult",
       inputSchema: RunActionInputSchema,
       outputSchema: ActionResultItemSchema,
+      formatter: actionResultItemFormatter,
       resolvers: {
         app: appKeyResolver,
         actionType: actionTypeResolver,
@@ -4676,10 +5017,7 @@ var runActionPlugin = definePlugin(
         connection: connectionIdResolver,
         inputs: inputsResolver
       },
-      handler: async ({
-        sdk: sdk2,
-        options
-      }) => {
+      handler: async ({ sdk: sdk2, options }) => {
         const { api } = sdk2.context;
         const appKey = "app" in options ? options.app : options.appKey;
         const actionKey = "action" in options ? options.action : options.actionKey;
@@ -4732,7 +5070,9 @@ var runActionPlugin = definePlugin(
         }
         return {
           data: result.results || [],
-          nextCursor: result.next_page
+          // Coerce to a string: the API returns a numeric page index, but
+          // `SdkPage.nextCursor` is a string (and the page guard enforces it).
+          nextCursor: result.next_page != null ? String(result.next_page) : void 0
         };
       }
     });
@@ -4762,26 +5102,19 @@ var RelayRequestSchema = z.object({
 var RelayFetchSchema = RelayRequestSchema;
 
 // src/utils/logging.ts
-var loggedDeprecations = /* @__PURE__ */ new Set();
-function logDeprecation(message) {
-  if (loggedDeprecations.has(message)) return;
-  loggedDeprecations.add(message);
-  console.warn(`[zapier-sdk] Deprecation: ${message}`);
-}
-function resetDeprecationWarnings() {
-  loggedDeprecations.clear();
-}
+var { logDeprecation: logDeprecation2, resetDeprecationWarnings: resetDeprecationWarnings2 } = createDeprecationLogger("zapier-sdk");
 
 // src/plugins/request/index.ts
 var requestPlugin = definePlugin(
   (sdk) => createPluginMethod(sdk, {
     name: "request",
     packages: ["cli", "mcp"],
-    categories: ["http", "deprecated"],
+    categories: ["http"],
+    deprecation: { message: "Use fetch() instead." },
     returnType: "Response",
     inputSchema: RelayRequestSchema,
     handler: async ({ sdk: sdk2, options }) => {
-      logDeprecation("request() is deprecated. Use fetch() instead.");
+      logDeprecation2("request() is deprecated. Use fetch() instead.");
       const {
         url,
         method,
@@ -5001,7 +5334,7 @@ async function listAppsForSlugsPage({
     data: implementationsEnvelope.results.map(
       normalizeImplementationMetaToAppItem
     ),
-    nextCursor: extractCursor(implementationsEnvelope)
+    nextCursor: implementationsEnvelope.next ? extractCursorFromUrl(implementationsEnvelope.next) : void 0
   };
 }
 function findManifestEntry({
@@ -5279,36 +5612,36 @@ var manifestPlugin = definePlugin(
   }
 );
 var GetProfileSchema = z.object({}).optional().describe("Get current user's profile information");
-var UserProfileItemSchema = withFormatter(
-  z.object({
-    id: z.string(),
-    first_name: z.string(),
-    last_name: z.string(),
-    full_name: z.string(),
-    email: z.string(),
-    email_confirmed: z.boolean(),
-    timezone: z.string()
-  }),
-  {
-    format: (item) => {
-      const details = [];
-      if ("email" in item) {
-        details.push({ text: item.email, style: "dim" });
-      }
-      if ("timezone" in item && item.timezone) {
-        details.push({
-          text: `Timezone: ${item.timezone}`,
-          style: "accent"
-        });
-      }
-      return {
-        title: item.full_name,
-        id: item.id,
-        details
-      };
+var UserProfileItemSchema = z.object({
+  id: z.string(),
+  first_name: z.string(),
+  last_name: z.string(),
+  full_name: z.string(),
+  email: z.string(),
+  email_confirmed: z.boolean(),
+  timezone: z.string()
+});
+
+// src/formatters/userProfile.ts
+var userProfileItemFormatter = {
+  format: (item) => {
+    const details = [];
+    if (item.email) {
+      details.push({ text: item.email, style: "dim" });
+    }
+    if (item.timezone) {
+      details.push({
+        text: `Timezone: ${item.timezone}`,
+        style: "accent"
+      });
     }
+    return {
+      title: item.full_name,
+      id: item.id,
+      details
+    };
   }
-);
+};
 
 // src/plugins/getProfile/index.ts
 var getProfilePlugin = definePlugin(
@@ -5319,6 +5652,7 @@ var getProfilePlugin = definePlugin(
     itemType: "Profile",
     inputSchema: GetProfileSchema,
     outputSchema: UserProfileItemSchema,
+    formatter: userProfileItemFormatter,
     handler: async ({ sdk: sdk2 }) => {
       const profile = await sdk2.context.api.get(
         "/zapier/api/v4/profile/",
@@ -5415,7 +5749,7 @@ function createDebugLogger(enabled) {
   }
   return (message, data) => {
     if (data === void 0 || data === "") {
-      console.log(`[Zapier SDK] ${message}`);
+      console.error(`[Zapier SDK] ${message}`);
       return;
     }
     if (utilModule) {
@@ -5424,9 +5758,9 @@ function createDebugLogger(enabled) {
         depth: null,
         breakLength: 80
       });
-      console.log(`[Zapier SDK] ${message}`, formatted);
+      console.error(`[Zapier SDK] ${message}`, formatted);
     } else {
-      console.log(`[Zapier SDK] ${message}`, data);
+      console.error(`[Zapier SDK] ${message}`, data);
     }
   };
 }
@@ -5625,7 +5959,8 @@ async function pollUntilComplete(options) {
     pendingStatus = DEFAULT_PENDING_STATUS,
     isPending,
     resultExtractor = (response) => response,
-    signal
+    signal,
+    maxPollingIntervalMs
   } = options;
   if (timeoutMs <= 0) {
     throw new ZapierValidationError("Timeout must be greater than 0", {
@@ -5637,6 +5972,14 @@ async function pollUntilComplete(options) {
       details: { initialDelay }
     });
   }
+  if (maxPollingIntervalMs !== void 0 && maxPollingIntervalMs <= 0) {
+    throw new ZapierValidationError(
+      "Max polling interval must be greater than 0",
+      {
+        details: { maxPollingIntervalMs }
+      }
+    );
+  }
   if (signal?.aborted) throw makeAbortError();
   const startTime = Date.now();
   let attempts = 0;
@@ -5659,7 +6002,8 @@ async function pollUntilComplete(options) {
     if (attempts > 0) {
       const interval = getPollingInterval(elapsedTime);
       const waitTime = calculateErrorBackoffMs(interval, errorCount);
-      await sleep(waitTime, signal);
+      const cappedWaitTime = maxPollingIntervalMs === void 0 ? waitTime : Math.min(waitTime, maxPollingIntervalMs);
+      await sleep(cappedWaitTime, signal);
       if (signal?.aborted) throw makeAbortError();
     }
     attempts++;
@@ -5942,17 +6286,17 @@ function resolveCredentialsFromEnv(sdkBaseUrl) {
     }
   }
   if (globalThis.process?.env?.ZAPIER_TOKEN) {
-    logDeprecation(
+    logDeprecation2(
       "ZAPIER_TOKEN is deprecated. Use ZAPIER_CREDENTIALS instead."
     );
     return globalThis.process?.env?.ZAPIER_TOKEN;
   }
   if (globalThis.process?.env?.ZAPIER_AUTH_CLIENT_ID) {
-    logDeprecation(
+    logDeprecation2(
       "ZAPIER_AUTH_CLIENT_ID is deprecated. Use ZAPIER_CREDENTIALS_CLIENT_ID instead."
     );
     if (globalThis.process?.env?.ZAPIER_AUTH_BASE_URL) {
-      logDeprecation(
+      logDeprecation2(
         "ZAPIER_AUTH_BASE_URL is deprecated. Use ZAPIER_CREDENTIALS_BASE_URL instead."
       );
     }
@@ -5986,7 +6330,7 @@ async function resolveCredentials(options = {}) {
     return options.credentials;
   }
   if (options.token !== void 0) {
-    logDeprecation(
+    logDeprecation2(
       "The `token` option is deprecated. Use `credentials` instead."
     );
     return options.token;
@@ -6228,7 +6572,7 @@ async function tryStoredClientCredentialToken(options) {
   const cached = await readCachedToken(cacheKey, cache);
   if (cached !== void 0) {
     if (options.debug)
-      console.log(
+      console.error(
         `[auth] Using cached token (clientId: ${activeCredential.clientId})`
       );
     emitAuthResolved(options.onEvent, "client_credentials");
@@ -6247,7 +6591,7 @@ async function tryStoredClientCredentialToken(options) {
     );
   }
   if (options.debug)
-    console.log(
+    console.error(
       `[auth] Using stored client credential (clientId: ${storedCredential.clientId})`
     );
   const token = await resolveAuthTokenFromCredentials(
@@ -6269,7 +6613,7 @@ async function resolveAuthToken(options = {}) {
   const storedToken = await tryStoredClientCredentialToken(options);
   if (storedToken !== void 0) return storedToken;
   if (options.debug) {
-    console.log("[auth] Using JWT (no stored client credential found)");
+    console.error("[auth] Using JWT (no stored client credential found)");
   }
   const jwtToken = await getTokenFromCliLogin({
     onEvent: options.onEvent,
@@ -6299,7 +6643,7 @@ async function resolveAuthTokenFromCredentials(credentials, options) {
     const cached = await readCachedToken(cacheKey, cache);
     if (cached !== void 0) {
       if (options.debug) {
-        console.log(`[auth] Using cached token (clientId: ${clientId})`);
+        console.error(`[auth] Using cached token (clientId: ${clientId})`);
       }
       return cached;
     }
@@ -6309,7 +6653,7 @@ async function resolveAuthTokenFromCredentials(credentials, options) {
       const recheck = await readCachedToken(cacheKey, cache);
       if (recheck !== void 0) {
         if (options.debug) {
-          console.log(
+          console.error(
             `[auth] Using cached token (clientId: ${clientId}, locked recheck)`
           );
         }
@@ -6372,7 +6716,7 @@ async function invalidateCredentialsToken(options) {
 }
 
 // src/sdk-version.ts
-var SDK_VERSION = (typeof process !== "undefined" && process.env ? "0.64.0" : void 0) || "unknown";
+var SDK_VERSION = (typeof process !== "undefined" && process.env ? "0.67.0" : void 0) || "unknown";
 
 // src/utils/open-url.ts
 var nodePrefix = "node:";
@@ -6457,6 +6801,7 @@ var PollApprovalResponseSchema = z.object({
   status: ApprovalStatusSchema,
   approval_id: z.string()
 });
+var APPROVAL_MAX_POLLING_INTERVAL_MS = 5e3;
 function parseRateLimitHeaders(response) {
   const info = {};
   const retryAfter = response.headers.get("retry-after");
@@ -7165,6 +7510,7 @@ var ZapierApiClient = class {
           })
         ),
         timeoutMs,
+        maxPollingIntervalMs: APPROVAL_MAX_POLLING_INTERVAL_MS,
         isPending: (body2) => {
           const parsed = PollApprovalResponseSchema.safeParse(body2);
           return parsed.success && parsed.data.status === "pending_approval";
@@ -7532,6 +7878,7 @@ var tablesDefaults = {
 var listTablesPlugin = definePlugin(
   (sdk) => createPaginatedPluginMethod(sdk, {
     ...tablesDefaults,
+    ...zapierPagination,
     name: "listTables",
     type: "list",
     itemType: "Table",
@@ -7587,8 +7934,7 @@ var listTablesPlugin = definePlugin(
         data: response.data.map(transformTableItem),
         links: response.links
       };
-    },
-    extractCursor: (response) => extractCursor(response.links)
+    }
   })
 );
 var GetTableApiResponseSchema = z.object({
@@ -7691,6 +8037,15 @@ var deleteTablePlugin = definePlugin(
   })
 );
 
+// src/formatters/tableField.ts
+var tableFieldItemFormatter = {
+  format: (item) => ({
+    title: item.name,
+    id: item.id,
+    details: [{ text: `Type: ${item.type}`, style: "dim" }]
+  })
+};
+
 // src/plugins/tables/listTableFields/index.ts
 var listTableFieldsPlugin = definePlugin(
   (sdk) => createPluginMethod(sdk, {
@@ -7700,6 +8055,7 @@ var listTableFieldsPlugin = definePlugin(
     itemType: "Field",
     inputSchema: ListTableFieldsOptionsInputSchema,
     outputSchema: FieldItemSchema,
+    formatter: tableFieldItemFormatter,
     resolvers: { table: tableIdResolver },
     handler: async ({ sdk: sdk2, options }) => {
       const { api } = sdk2.context;
@@ -7772,6 +8128,7 @@ var createTableFieldsPlugin = definePlugin(
     returnType: "FieldItem[]",
     inputSchema: CreateTableFieldsOptionsInputSchema,
     outputSchema: FieldItemSchema,
+    formatter: tableFieldItemFormatter,
     resolvers: { table: tableIdResolver, fields: tableFieldsResolver },
     handler: async ({ sdk: sdk2, options }) => {
       const tableId = "table" in options ? options.table : options.tableId;
@@ -7850,21 +8207,13 @@ var RecordApiItemSchema = z.object({
   is_source_record: z.boolean().nullable().optional(),
   deleted_at: z.string().nullable().optional()
 });
-var RecordItemSchemaBase = z.object({
+var RecordItemSchema = z.object({
   id: z.string(),
   data: z.record(z.string(), z.unknown()),
   created_at: z.string(),
   edited_at: z.string(),
   deleted_at: z.string().nullable().optional()
 });
-var RecordItemSchema = withFormatter(RecordItemSchemaBase, {
-  format: (item) => ({
-    title: `Record ${item.id}`,
-    id: item.id,
-    data: item.data,
-    details: []
-  })
-});
 var GetTableRecordApiResponseSchema = z.object({
   data: RecordApiItemSchema
 });
@@ -7888,9 +8237,9 @@ var tableRecordFormatter = {
     if (context) return context;
     const hasFieldIds = Object.keys(item.data).some(isFieldId);
     if (!hasFieldIds) return {};
-    const { data: fields } = await sdk.listTableFields({
-      table: params.tableId
-    });
+    const table = params.table ?? params.tableId;
+    if (!table) return {};
+    const { data: fields } = await sdk.listTableFields({ table });
     return Object.fromEntries(fields.map((f) => [f.id, f.name]));
   },
   format: (item, fieldLabels) => ({
@@ -8015,10 +8364,7 @@ var listTableRecordsPlugin = definePlugin(
       sort: tableSortResolver
     },
     formatter: tableRecordFormatter,
-    handler: async ({
-      sdk: sdk2,
-      options
-    }) => {
+    handler: async ({ sdk: sdk2, options }) => {
       const { api } = sdk2.context;
       const tableId = "table" in options ? options.table : options.tableId;
       const translator = await createFieldKeyTranslator({
@@ -8268,85 +8614,13 @@ var updateTableRecordsPlugin = definePlugin(
     }
   })
 );
-function canonicalInputSchema(schema) {
-  if (schema instanceof z.ZodUnion) {
-    return schema.options[0];
-  }
-  return schema;
-}
-var categoryDefinitions = {
-  account: { title: "Account" },
-  app: { title: "App", titlePlural: "Apps" },
-  connection: { title: "Connection" },
-  action: { title: "Action" },
-  "client-credentials": {
-    title: "Client Credentials",
-    titlePlural: "Client Credentials"
-  },
-  table: { title: "Table" },
-  trigger: { title: "Trigger" },
-  "code-workflow": {
-    title: "Code Workflow",
-    titlePlural: "Code Workflows"
-  },
-  http: { title: "HTTP Request" },
-  utility: { title: "Utility", titlePlural: "Utilities" },
-  other: { title: "Other" }
-};
-var knownCategories = Object.keys(categoryDefinitions);
-function buildRegistry({
-  sdk,
-  meta,
-  packageFilter
-}) {
-  const functions = Object.keys(meta).filter((key) => {
-    const property = sdk[key];
-    if (typeof property === "function") return true;
-    const [rootKey] = key.split(".");
-    const rootProperty = sdk[rootKey];
-    return typeof rootProperty === "object" && rootProperty !== null;
-  }).map((key) => {
-    const m = meta[key];
-    return {
-      name: key,
-      description: m.description,
-      type: m.type,
-      itemType: m.itemType,
-      returnType: m.returnType,
-      inputSchema: canonicalInputSchema(m.inputSchema),
-      inputParameters: m.inputParameters,
-      outputSchema: m.outputSchema,
-      categories: m.categories || [],
-      resolvers: m.resolvers,
-      formatter: m.formatter,
-      experimental: m.experimental,
-      packages: m.packages,
-      confirm: m.confirm ?? (m.type === "delete" ? "delete" : void 0),
-      deprecation: m.deprecation,
-      aliases: m.aliases,
-      supportsJsonOutput: m.supportsJsonOutput ?? true
-    };
-  }).sort((a, b) => a.name.localeCompare(b.name));
-  const filteredFunctions = packageFilter ? functions.filter((f) => !f.packages || f.packages.includes(packageFilter)) : functions;
-  const filteredCategories = knownCategories.slice().sort((a, b) => {
-    if (a === "other") return 1;
-    if (b === "other") return -1;
-    return categoryDefinitions[a].title.localeCompare(
-      categoryDefinitions[b].title
-    );
-  }).map((categoryKey) => {
-    const categoryFunctions = filteredFunctions.filter(
-      (f) => f.categories.includes(categoryKey) || categoryKey === "other" && !f.categories.some((c) => knownCategories.includes(c))
-    ).map((f) => f.name).sort();
-    const definition = categoryDefinitions[categoryKey];
-    return {
-      key: categoryKey,
-      title: definition.title,
-      titlePlural: definition.titlePlural ?? `${definition.title}s`,
-      functions: categoryFunctions
-    };
-  }).filter((category) => category.functions.length > 0);
-  return { functions: filteredFunctions, categories: filteredCategories };
+
+// src/core-stack.ts
+var zapierCorePlugin = createCorePlugin({
+  adaptError: zapierAdaptError
+});
+function createZapierCoreStack() {
+  return createPluginStack().use(zapierCorePlugin);
 }
 
 // src/plugins/deprecated/authentications.ts
@@ -8357,11 +8631,13 @@ var listAuthenticationsPlugin = definePlugin(
       meta: {
         listAuthentications: {
           packages: ["cli", "mcp"],
-          categories: ["connection", "deprecated"],
+          categories: ["connection"],
+          deprecation: { message: "Use listConnections instead." },
           type: "list",
           itemType: "Connection",
           inputSchema: ListConnectionsQuerySchema,
-          outputSchema: ConnectionItemSchema
+          outputSchema: ConnectionItemSchema,
+          formatter: connectionItemFormatter
         }
       }
     }
@@ -8374,11 +8650,13 @@ var getAuthenticationPlugin = definePlugin(
       meta: {
         getAuthentication: {
           packages: ["cli", "mcp"],
-          categories: ["connection", "deprecated"],
+          categories: ["connection"],
+          deprecation: { message: "Use getConnection instead." },
           type: "item",
           itemType: "Connection",
           inputSchema: GetConnectionParamSchema,
-          outputSchema: ConnectionItemSchema
+          outputSchema: ConnectionItemSchema,
+          formatter: connectionItemFormatter
         }
       }
     }
@@ -8391,11 +8669,13 @@ var findFirstAuthenticationPlugin = definePlugin(
       meta: {
         findFirstAuthentication: {
           packages: ["cli", "mcp"],
-          categories: ["connection", "deprecated"],
+          categories: ["connection"],
+          deprecation: { message: "Use findFirstConnection instead." },
           type: "item",
           itemType: "Connection",
           inputSchema: FindFirstConnectionSchema,
-          outputSchema: ConnectionItemSchema
+          outputSchema: ConnectionItemSchema,
+          formatter: connectionItemFormatter
         }
       }
     }
@@ -8408,11 +8688,13 @@ var findUniqueAuthenticationPlugin = definePlugin(
       meta: {
         findUniqueAuthentication: {
           packages: ["cli", "mcp"],
-          categories: ["connection", "deprecated"],
+          categories: ["connection"],
+          deprecation: { message: "Use findUniqueConnection instead." },
           type: "item",
           itemType: "Connection",
           inputSchema: FindUniqueConnectionSchema,
-          outputSchema: ConnectionItemSchema
+          outputSchema: ConnectionItemSchema,
+          formatter: connectionItemFormatter
         }
       }
     }
@@ -8426,11 +8708,13 @@ var listInputFieldsDeprecatedPlugin = definePlugin(
     context: {
       meta: {
         listInputFields: {
-          categories: ["action", "deprecated"],
+          categories: ["action"],
+          deprecation: { message: "Use listActionInputFields instead." },
           type: "list",
           itemType: "RootField",
           inputSchema: ListActionInputFieldsInputSchema,
           outputSchema: RootFieldItemSchema,
+          formatter: rootFieldItemFormatter,
           defaultPageSize: DEFAULT_PAGE_SIZE
         }
       }
@@ -8443,11 +8727,15 @@ var listInputFieldChoicesDeprecatedPlugin = definePlugin(
     context: {
       meta: {
         listInputFieldChoices: {
-          categories: ["action", "deprecated"],
+          categories: ["action"],
+          deprecation: {
+            message: "Use listActionInputFieldChoices instead."
+          },
           type: "list",
           itemType: "InputFieldChoiceItem",
           inputSchema: ListActionInputFieldChoicesInputSchema,
           outputSchema: InputFieldChoiceItemSchema,
+          formatter: inputFieldChoiceItemFormatter,
           defaultPageSize: DEFAULT_PAGE_SIZE
         }
       }
@@ -8460,7 +8748,8 @@ var getInputFieldsSchemaDeprecatedPlugin = definePlugin(
     context: {
       meta: {
         getInputFieldsSchema: {
-          categories: ["action", "deprecated"],
+          categories: ["action"],
+          deprecation: { message: "Use getActionInputFieldsSchema instead." },
           type: "function",
           inputSchema: GetActionInputFieldsSchemaInputSchema
         }
@@ -8524,7 +8813,7 @@ function createConsoleTransport() {
   return {
     async emit(subject, event) {
       try {
-        console.log(
+        console.error(
           "[SDK Telemetry]",
           JSON.stringify({ subject, properties: event }, null, 2)
         );
@@ -8733,6 +9022,35 @@ function buildMethodCalledEvent(data, context = {}) {
   };
 }
 
+// src/plugins/eventEmission/event-emission-hook.ts
+function computeArgumentCount(args) {
+  if (args.length === 1) {
+    const arg0 = args[0];
+    if (arg0 !== null && typeof arg0 === "object" && !Array.isArray(arg0) && Object.getPrototypeOf(arg0) === Object.prototype) {
+      return Object.keys(arg0).length;
+    }
+  }
+  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();
+    emitMethodCalled({
+      method_name: methodName,
+      execution_duration_ms: durationMs,
+      success_flag: !error,
+      error_message: error?.message ?? null,
+      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
+    });
+  };
+}
+
 // src/plugins/eventEmission/index.ts
 var TELEMETRY_EMIT_TIMEOUT_MS = 300;
 var registeredListeners = {};
@@ -8863,6 +9181,8 @@ var eventEmissionPlugin = definePlugin(
       }
     }
     if (!config.enabled) {
+      const noopEmitMethodCalled = () => {
+      };
       return {
         context: {
           eventEmission: {
@@ -8880,12 +9200,13 @@ var eventEmissionPlugin = definePlugin(
               visitor_id: null,
               correlation_id: null
             }),
-            emitMethodCalled: () => {
-            },
             flush: async () => {
             },
             close: async () => {
             }
+          },
+          hooks: {
+            onMethodEnd: makeMethodEndHook(noopEmitMethodCalled)
           }
         }
       };
@@ -9056,6 +9377,20 @@ var eventEmissionPlugin = definePlugin(
       );
       removeExistingListeners();
     };
+    const emitMethodCalled = (data) => {
+      const event = {
+        ...buildMethodCalledEvent(data),
+        call_context: config.callContext ?? "sdk"
+      };
+      trackEmission(
+        silentEmit(
+          transport,
+          METHOD_CALLED_EVENT_SUBJECT,
+          event,
+          getUserContext
+        )
+      );
+    };
     return {
       context: {
         eventEmission: {
@@ -9067,22 +9402,11 @@ var eventEmissionPlugin = definePlugin(
             );
           },
           createBaseEvent: createBaseEventHelper,
-          emitMethodCalled: (data) => {
-            const event = {
-              ...buildMethodCalledEvent(data),
-              call_context: config.callContext ?? "sdk"
-            };
-            trackEmission(
-              silentEmit(
-                transport,
-                METHOD_CALLED_EVENT_SUBJECT,
-                event,
-                getUserContext
-              )
-            );
-          },
           flush,
           close
+        },
+        hooks: {
+          onMethodEnd: makeMethodEndHook(emitMethodCalled)
         }
       }
     };
@@ -9094,78 +9418,22 @@ function createOptionsPlugin(options) {
   return () => ({ context: { options } });
 }
 function createSdk() {
-  return buildSdk({}, { meta: {} });
-}
-function buildSdk(properties, context) {
-  const frozenContext = Object.freeze(context);
-  const registryCache = /* @__PURE__ */ new Map();
-  const sdk = {
-    ...properties,
-    get context() {
-      return frozenContext;
-    },
-    getContext: () => frozenContext,
-    // runtime compat shim, not in types
-    getRegistry(options) {
-      const cacheKey = options?.package ?? "__all__";
-      if (!registryCache.has(cacheKey)) {
-        registryCache.set(
-          cacheKey,
-          buildRegistry({
-            sdk,
-            meta: frozenContext.meta,
-            packageFilter: options?.package
-          })
-        );
-      }
-      return registryCache.get(cacheKey);
-    },
-    addPlugin(plugin, options) {
-      const pluginResult = plugin({
-        ...properties,
-        context: frozenContext
-      });
-      const { context: pluginContext, ...pluginProperties } = pluginResult;
-      const { meta: pluginMeta, ...pluginContextRest } = pluginContext ?? {};
-      const existingProperties = properties;
-      const existingContext = context;
-      const existingMeta = context.meta ?? {};
-      const collisions = [];
-      for (const key of Object.keys(pluginProperties)) {
-        if (key in existingProperties) collisions.push(`method "${key}"`);
-      }
-      for (const key of Object.keys(pluginContextRest)) {
-        if (key in existingContext) collisions.push(`context.${key}`);
-      }
-      if (collisions.length > 0 && !options?.override) {
-        const name = plugin.name || "anonymous plugin";
-        console.warn(
-          `[zapier-sdk] Skipping "${name}" \u2014 duplicate registration of: ${collisions.join(", ")}. If the duplicate is intentional, pass { override: true } to addPlugin or wrap with composePlugins(...). Otherwise rename the method or remove the duplicate.`
-        );
-        return buildSdk(properties, context);
-      }
-      const mergedProperties = { ...properties, ...pluginProperties };
-      const mergedContext = {
-        ...context,
-        ...pluginContextRest,
-        meta: { ...existingMeta, ...pluginMeta ?? {} }
-      };
-      return buildSdk(
-        mergedProperties,
-        mergedContext
-      );
-    }
-  };
-  return sdk;
+  logDeprecation2(
+    "createSdk() is deprecated. Build SDKs with createPluginStack().use(...).toSdk() instead. The chain pattern shares plugin closures (and their state) across derived SDKs in ways that are rarely what callers expect; stacks produce fresh closures per .toSdk() call."
+  );
+  return withDeprecatedAddPlugin(createZapierCoreStack().toSdk());
 }
 function createZapierSdkWithoutRegistry(options = {}) {
-  logDeprecation(
+  logDeprecation2(
     "createZapierSdkWithoutRegistry is deprecated; use createZapierSdk instead. getRegistry is now available on every sdk."
   );
   return createZapierSdk(options);
 }
+function createZapierSdkStack(options = {}) {
+  return createZapierCoreStack().use(createOptionsPlugin(options)).use(eventEmissionPlugin).use(apiPlugin).use(manifestPlugin).use(capabilitiesPlugin).use(connectionsPlugin).use(listAppsPlugin).use(getAppPlugin).use(listConnectionsPlugin).use(getConnectionPlugin).use(findFirstConnectionPlugin).use(findUniqueConnectionPlugin).use(listActionsPlugin).use(getActionPlugin).use(listActionInputFieldsPlugin).use(getActionInputFieldsSchemaPlugin).use(listActionInputFieldChoicesPlugin).use(listInputFieldsDeprecatedPlugin).use(getInputFieldsSchemaDeprecatedPlugin).use(listInputFieldChoicesDeprecatedPlugin).use(runActionPlugin).use(listAuthenticationsPlugin).use(getAuthenticationPlugin).use(findFirstAuthenticationPlugin).use(findUniqueAuthenticationPlugin).use(listClientCredentialsPlugin).use(createClientCredentialsPlugin).use(deleteClientCredentialsPlugin).use(fetchPlugin).use(requestPlugin).use(listTablesPlugin).use(getTablePlugin).use(deleteTablePlugin).use(createTablePlugin).use(listTableFieldsPlugin).use(createTableFieldsPlugin).use(deleteTableFieldsPlugin).use(listTableRecordsPlugin).use(getTableRecordPlugin).use(createTableRecordsPlugin).use(deleteTableRecordsPlugin).use(updateTableRecordsPlugin).use(appsPlugin).use(getProfilePlugin);
+}
 function createZapierSdk(options = {}) {
-  return createSdk().addPlugin(createOptionsPlugin(options)).addPlugin(eventEmissionPlugin).addPlugin(apiPlugin).addPlugin(manifestPlugin).addPlugin(capabilitiesPlugin).addPlugin(connectionsPlugin).addPlugin(listAppsPlugin).addPlugin(getAppPlugin).addPlugin(listActionsPlugin).addPlugin(getActionPlugin).addPlugin(listActionInputFieldsPlugin).addPlugin(getActionInputFieldsSchemaPlugin).addPlugin(listActionInputFieldChoicesPlugin).addPlugin(listInputFieldsDeprecatedPlugin).addPlugin(getInputFieldsSchemaDeprecatedPlugin).addPlugin(listInputFieldChoicesDeprecatedPlugin).addPlugin(runActionPlugin).addPlugin(listConnectionsPlugin).addPlugin(getConnectionPlugin).addPlugin(findFirstConnectionPlugin).addPlugin(findUniqueConnectionPlugin).addPlugin(listAuthenticationsPlugin).addPlugin(getAuthenticationPlugin).addPlugin(findFirstAuthenticationPlugin).addPlugin(findUniqueAuthenticationPlugin).addPlugin(listClientCredentialsPlugin).addPlugin(createClientCredentialsPlugin).addPlugin(deleteClientCredentialsPlugin).addPlugin(fetchPlugin).addPlugin(requestPlugin).addPlugin(listTablesPlugin).addPlugin(getTablePlugin).addPlugin(deleteTablePlugin).addPlugin(createTablePlugin).addPlugin(listTableFieldsPlugin).addPlugin(createTableFieldsPlugin).addPlugin(deleteTableFieldsPlugin).addPlugin(getTableRecordPlugin).addPlugin(listTableRecordsPlugin).addPlugin(createTableRecordsPlugin).addPlugin(deleteTableRecordsPlugin).addPlugin(updateTableRecordsPlugin).addPlugin(appsPlugin).addPlugin(getProfilePlugin);
+  return withDeprecatedAddPlugin(createZapierSdkStack(options).toSdk());
 }
 var BaseSdkOptionsSchema = z.object({
   credentials: CredentialsSchema.optional().describe(
@@ -9228,10 +9496,10 @@ var BaseSdkOptionsSchema = z.object({
 
 // src/plugins/registry/index.ts
 var registryPlugin = definePlugin((_sdk) => {
-  logDeprecation(
+  logDeprecation2(
     "registryPlugin is deprecated and a no-op; getRegistry is now built into every sdk. Remove .addPlugin(registryPlugin)."
   );
   return {};
 });
 
-export { ActionKeyPropertySchema, ActionPropertySchema, ActionTimeoutMsPropertySchema, ActionTypePropertySchema, AppKeyPropertySchema, AppPropertySchema, AppsPropertySchema, AuthenticationIdPropertySchema, BaseSdkOptionsSchema, CONTEXT_CACHE_MAX_SIZE, CONTEXT_CACHE_TTL_MS, ClientCredentialsObjectSchema, ConnectionEntrySchema, ConnectionIdPropertySchema, ConnectionPropertySchema, ConnectionsMapSchema, ConnectionsPropertySchema, CredentialsFunctionSchema, CredentialsObjectSchema, CredentialsSchema, DEFAULT_ACTION_TIMEOUT_MS, DEFAULT_APPROVAL_TIMEOUT_MS, DEFAULT_CONFIG_PATH, DEFAULT_MAX_APPROVAL_RETRIES, DEFAULT_PAGE_SIZE, DebugPropertySchema, FieldsPropertySchema, InputFieldPropertySchema, InputsPropertySchema, LeaseLimitPropertySchema, LeasePropertySchema, LeaseSecondsPropertySchema, LimitPropertySchema, MAX_CONCURRENCY_LIMIT, MAX_PAGE_LIMIT, OffsetPropertySchema, OutputPropertySchema, ParamsPropertySchema, PkceCredentialsObjectSchema, RecordPropertySchema, RecordsPropertySchema, RelayFetchSchema, RelayRequestSchema, ResolvedCredentialsSchema, TablePropertySchema, TablesPropertySchema, TriggerInboxNamePropertySchema, TriggerInboxPropertySchema, ZAPIER_BASE_URL, ZAPIER_MAX_CONCURRENT_REQUESTS, ZAPIER_MAX_NETWORK_RETRIES, ZAPIER_MAX_NETWORK_RETRY_DELAY_MS, ZapierAbortDrainSignal, ZapierActionError, ZapierApiError, ZapierAppNotFoundError, ZapierApprovalError, ZapierAuthenticationError, ZapierBundleError, ZapierConfigurationError, ZapierConflictError, ZapierError, ZapierNotFoundError, ZapierRateLimitError, ZapierRelayError, ZapierReleaseTriggerMessageSignal, ZapierResourceNotFoundError, ZapierSignal, ZapierTimeoutError, ZapierUnknownError, ZapierValidationError, actionKeyResolver, actionTypeResolver, apiPlugin, appKeyResolver, appsPlugin, connectionIdGenericResolver as authenticationIdGenericResolver, connectionIdResolver as authenticationIdResolver, batch, buildApplicationLifecycleEvent, buildCapabilityMessage, buildErrorEvent, buildErrorEventWithContext, buildMethodCalledEvent, cleanupEventListeners, clearTokenCache, clientCredentialsNameResolver, clientIdResolver, composePlugins, connectionIdGenericResolver, connectionIdResolver, connectionsPlugin, createBaseEvent, createClientCredentialsPlugin, createFunction, createMemoryCache, createOptionsPlugin, createPaginatedPluginMethod, createPluginMethod, createSdk, createTableFieldsPlugin, createTablePlugin, createTableRecordsPlugin, createZapierApi, createZapierSdk, createZapierSdkWithoutRegistry, definePlugin, deleteClientCredentialsPlugin, deleteTableFieldsPlugin, deleteTablePlugin, deleteTableRecordsPlugin, durableRunIdResolver, eventEmissionPlugin, fetchPlugin, findFirstConnectionPlugin, findManifestEntry, findUniqueConnectionPlugin, formatErrorMessage, generateEventId, getActionInputFieldsSchemaPlugin, getActionPlugin, getAppPlugin, getBaseUrlFromCredentials, getCiPlatform, getClientIdFromCredentials, getConnectionPlugin, getCpuTime, getCurrentTimestamp, getMemoryUsage, getOrCreateApiClient, getOsInfo, getPlatformVersions, getPreferredManifestEntryKey, getProfilePlugin, getReleaseId, getTablePlugin, getTableRecordPlugin, getTokenFromCliLogin, getZapierApprovalMode, getZapierDefaultApprovalMode, getZapierSdkService, injectCliLogin, inputFieldKeyResolver, inputsAllOptionalResolver, inputsResolver, invalidateCachedToken, invalidateCredentialsToken, isCi, isCliLoginAvailable, isClientCredentials, isCredentialsFunction, isCredentialsObject, isPkceCredentials, isPositional, listActionInputFieldChoicesPlugin, listActionInputFieldsPlugin, listActionsPlugin, listAppsPlugin, listClientCredentialsPlugin, listConnectionsPlugin, listTableFieldsPlugin, listTableRecordsPlugin, listTablesPlugin, logDeprecation, manifestPlugin, parseConcurrencyEnvVar, readManifestFromFile, registryPlugin, requestPlugin, resetDeprecationWarnings, resolveAuthToken, resolveCredentials, resolveCredentialsFromEnv, runActionPlugin, runWithTelemetryContext, tableFieldIdsResolver, tableFieldsResolver, tableFiltersResolver, tableIdResolver, tableNameResolver, tableRecordIdResolver, tableRecordIdsResolver, tableRecordsResolver, tableSortResolver, tableUpdateRecordsResolver, toSnakeCase, toTitleCase, triggerInboxResolver, triggerMessagesResolver, updateTableRecordsPlugin, workflowIdResolver, workflowVersionIdResolver };
+export { ActionKeyPropertySchema, ActionPropertySchema, ActionTimeoutMsPropertySchema, ActionTypePropertySchema, AppKeyPropertySchema, AppPropertySchema, AppsPropertySchema, AuthenticationIdPropertySchema, BaseSdkOptionsSchema, CONTEXT_CACHE_MAX_SIZE, CONTEXT_CACHE_TTL_MS, CORE_ERROR_SYMBOL, ClientCredentialsObjectSchema, ConnectionEntrySchema, ConnectionIdPropertySchema, ConnectionPropertySchema, ConnectionsMapSchema, ConnectionsPropertySchema, CoreErrorCode, CredentialsFunctionSchema, CredentialsObjectSchema, CredentialsSchema, DEFAULT_ACTION_TIMEOUT_MS, DEFAULT_APPROVAL_TIMEOUT_MS, DEFAULT_CONFIG_PATH, DEFAULT_MAX_APPROVAL_RETRIES, DEFAULT_PAGE_SIZE, DebugPropertySchema, FieldsPropertySchema, InputFieldPropertySchema, InputsPropertySchema, LeaseLimitPropertySchema, LeasePropertySchema, LeaseSecondsPropertySchema, LimitPropertySchema, MAX_CONCURRENCY_LIMIT, MAX_PAGE_LIMIT, OffsetPropertySchema, OutputPropertySchema, ParamsPropertySchema, PkceCredentialsObjectSchema, RecordPropertySchema, RecordsPropertySchema, RelayFetchSchema, RelayRequestSchema, ResolvedCredentialsSchema, TablePropertySchema, TablesPropertySchema, TriggerInboxNamePropertySchema, TriggerInboxPropertySchema, ZAPIER_BASE_URL, ZAPIER_MAX_CONCURRENT_REQUESTS, ZAPIER_MAX_NETWORK_RETRIES, ZAPIER_MAX_NETWORK_RETRY_DELAY_MS, ZapierAbortDrainSignal, ZapierActionError, ZapierApiError, ZapierAppNotFoundError, ZapierApprovalError, ZapierAuthenticationError, ZapierBundleError, ZapierConfigurationError, ZapierConflictError, ZapierError, ZapierNotFoundError, ZapierRateLimitError, ZapierRelayError, ZapierReleaseTriggerMessageSignal, ZapierResourceNotFoundError, ZapierSignal, ZapierTimeoutError, ZapierUnknownError, ZapierValidationError, actionKeyResolver, actionTypeResolver, addPlugin, apiPlugin, appKeyResolver, appsPlugin, connectionIdGenericResolver as authenticationIdGenericResolver, connectionIdResolver as authenticationIdResolver, batch, buildApplicationLifecycleEvent, buildCapabilityMessage, buildErrorEvent, buildErrorEventWithContext, buildMethodCalledEvent, cleanupEventListeners, clearTokenCache, clientCredentialsNameResolver, clientIdResolver, composePlugins, connectionIdGenericResolver, connectionIdResolver, connectionsPlugin, createBaseEvent, createClientCredentialsPlugin, createCorePlugin, createFunction, createMemoryCache, createOptionsPlugin, createPaginatedPluginMethod, createPluginMethod, createPluginStack, createSdk, createTableFieldsPlugin, createTablePlugin, createTableRecordsPlugin, createZapierApi, createZapierCoreStack, createZapierSdk, createZapierSdkStack, createZapierSdkWithoutRegistry, definePlugin, deleteClientCredentialsPlugin, deleteTableFieldsPlugin, deleteTablePlugin, deleteTableRecordsPlugin, durableRunIdResolver, eventEmissionPlugin, fetchPlugin, findFirstConnectionPlugin, findManifestEntry, findUniqueConnectionPlugin, formatErrorMessage, generateEventId, getActionInputFieldsSchemaPlugin, getActionPlugin, getAppPlugin, getBaseUrlFromCredentials, getCiPlatform, getClientIdFromCredentials, getConnectionPlugin, getCoreErrorCause, getCoreErrorCode, getCpuTime, getCurrentTimestamp, getMemoryUsage, getOrCreateApiClient, getOsInfo, getPlatformVersions, getPreferredManifestEntryKey, getProfilePlugin, getReleaseId, getTablePlugin, getTableRecordPlugin, getTokenFromCliLogin, getZapierApprovalMode, getZapierDefaultApprovalMode, getZapierSdkService, injectCliLogin, inputFieldKeyResolver, inputsAllOptionalResolver, inputsResolver, invalidateCachedToken, invalidateCredentialsToken, isCi, isCliLoginAvailable, isClientCredentials, isCoreError, isCredentialsFunction, isCredentialsObject, isPkceCredentials, isPositional, listActionInputFieldChoicesPlugin, listActionInputFieldsPlugin, listActionsPlugin, listAppsPlugin, listClientCredentialsPlugin, listConnectionsPlugin, listTableFieldsPlugin, listTableRecordsPlugin, listTablesPlugin, logDeprecation2 as logDeprecation, manifestPlugin, parseConcurrencyEnvVar, readManifestFromFile, registryPlugin, requestPlugin, resetDeprecationWarnings2 as resetDeprecationWarnings, resolveAuthToken, resolveCredentials, resolveCredentialsFromEnv, runActionPlugin, runInMethodScope, runWithTelemetryContext, tableFieldIdsResolver, tableFieldsResolver, tableFiltersResolver, tableIdResolver, tableNameResolver, tableRecordIdResolver, tableRecordIdsResolver, tableRecordsResolver, tableSortResolver, tableUpdateRecordsResolver, toSnakeCase, toTitleCase, triggerInboxResolver, triggerMessagesResolver, updateTableRecordsPlugin, workflowIdResolver, workflowRunIdResolver, workflowVersionIdResolver, zapierAdaptError };