@zapier/zapier-sdk 0.64.0 → 0.67.0

package/dist/index.cjs

@@ -13,547 +13,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 zod.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 zod.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 zod.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(
-  zod.z.string().min(1).describe("App key (e.g., 'SlackCLIAPI' or slug like 'github')")
-);
-var AppPropertySchema = withPositional(
-  zod.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 = zod.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 = zod.z.string().min(1).describe("Action key to execute");
-var ActionPropertySchema = withPositional(
-  zod.z.string().min(1).describe("Action key (e.g., 'send_message' or 'find_row')")
-);
-var InputFieldPropertySchema = withPositional(
-  zod.z.string().min(1).describe("Input field key to get choices for")
-);
-var ConnectionIdPropertySchema = zod.z.union([zod.z.string(), zod.z.number().int().positive()]).describe("Connection ID to use for this action");
-var AuthenticationIdPropertySchema = ConnectionIdPropertySchema.meta({
-  deprecated: true
-});
-var ConnectionPropertySchema = zod.z.union([zod.z.string(), zod.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 = zod.z.record(zod.z.string(), zod.z.unknown()).describe("Input parameters for the action");
-var LimitPropertySchema = zod.z.number().int().min(1).max(MAX_PAGE_LIMIT).default(50).describe("Maximum number of items to return");
-var OffsetPropertySchema = zod.z.number().int().min(0).default(0).describe("Number of items to skip for pagination");
-var OutputPropertySchema = zod.z.string().describe("Output file path");
-var DebugPropertySchema = zod.z.boolean().default(false).describe("Enable debug logging");
-var ParamsPropertySchema = zod.z.record(zod.z.string(), zod.z.unknown()).describe("Additional parameters");
-var ActionTimeoutMsPropertySchema = zod.z.number().min(1e3).optional().describe(
-  `Maximum time to wait for action completion in milliseconds (default: ${DEFAULT_ACTION_TIMEOUT_MS})`
-);
-var TablePropertySchema = withPositional(
-  zod.z.string().regex(/^[A-Z0-9]{26}$/, "Table ID must be a valid ULID").describe("The unique identifier of the table")
-);
-var RecordPropertySchema = withPositional(
-  zod.z.string().regex(/^[A-Z0-9]{26}$/, "Record ID must be a valid ULID").describe("The unique identifier of the record")
-);
-var RecordsPropertySchema = zod.z.array(zod.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 = zod.z.array(zod.z.union([zod.z.string(), zod.z.number()])).describe(
-  'Fields to operate on. Accepts field names (e.g., "Email") or IDs (e.g., "f6", "6", or 6).'
-);
-var AppsPropertySchema = zod.z.array(zod.z.string()).describe("Filter by app keys (e.g., 'SlackCLIAPI' or slug like 'github')");
-var TablesPropertySchema = zod.z.array(zod.z.string()).describe("Filter by specific table IDs");
-var ConnectionsPropertySchema = zod.z.array(zod.z.string()).describe("List of connection IDs to filter by");
-var TriggerInboxPropertySchema = withPositional(
-  zod.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 = zod.z.string().min(1).max(100).describe(
-  "Inbox name; unique per (user, account). Enables get-or-create on createTriggerInbox."
-);
-var LeasePropertySchema = zod.z.string().min(1).describe("Lease ID returned from leaseTriggerInboxMessages");
-var LeaseSecondsPropertySchema = zod.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 = zod.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 = zod.z.object({
-  inbox: TriggerInboxPropertySchema,
-  onMessage: zod.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: zod.z.number().int().min(1).optional().describe(
-    "Per-message handler workers running in parallel. Defaults to `leaseLimit`, or 1 if neither is set."
-  ),
-  leaseLimit: zod.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: zod.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: zod.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: zod.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: zod.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: zod.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: zod.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 = zod.z.object({
-  inputs: zod.z.record(zod.z.string(), zod.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 = zod.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;
@@ -723,438 +447,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 async_hooks.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 zod.z.ZodOptional) {
+    return isPositional(schema._zod.def.innerType);
+  }
+  if (schema instanceof zod.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(
+  zod.z.string().min(1).describe("App key (e.g., 'SlackCLIAPI' or slug like 'github')")
+);
+var AppPropertySchema = withPositional(
+  zod.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 = zod.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 = zod.z.string().min(1).describe("Action key to execute");
+var ActionPropertySchema = withPositional(
+  zod.z.string().min(1).describe("Action key (e.g., 'send_message' or 'find_row')")
+);
+var InputFieldPropertySchema = withPositional(
+  zod.z.string().min(1).describe("Input field key to get choices for")
+);
+var ConnectionIdPropertySchema = zod.z.union([zod.z.string(), zod.z.number().int().positive()]).describe("Connection ID to use for this action");
+var AuthenticationIdPropertySchema = ConnectionIdPropertySchema.meta({
+  deprecated: true
+});
+var ConnectionPropertySchema = zod.z.union([zod.z.string(), zod.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 = zod.z.record(zod.z.string(), zod.z.unknown()).describe("Input parameters for the action");
+var LimitPropertySchema = zod.z.number().int().min(1).max(MAX_PAGE_LIMIT).default(50).describe("Maximum number of items to return");
+var OffsetPropertySchema = zod.z.number().int().min(0).default(0).describe("Number of items to skip for pagination");
+var OutputPropertySchema = zod.z.string().describe("Output file path");
+var DebugPropertySchema = zod.z.boolean().default(false).describe("Enable debug logging");
+var ParamsPropertySchema = zod.z.record(zod.z.string(), zod.z.unknown()).describe("Additional parameters");
+var ActionTimeoutMsPropertySchema = zod.z.number().min(1e3).optional().describe(
+  `Maximum time to wait for action completion in milliseconds (default: ${DEFAULT_ACTION_TIMEOUT_MS})`
+);
+var TablePropertySchema = withPositional(
+  zod.z.string().regex(/^[A-Z0-9]{26}$/, "Table ID must be a valid ULID").describe("The unique identifier of the table")
+);
+var RecordPropertySchema = withPositional(
+  zod.z.string().regex(/^[A-Z0-9]{26}$/, "Record ID must be a valid ULID").describe("The unique identifier of the record")
+);
+var RecordsPropertySchema = zod.z.array(zod.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 = zod.z.array(zod.z.union([zod.z.string(), zod.z.number()])).describe(
+  'Fields to operate on. Accepts field names (e.g., "Email") or IDs (e.g., "f6", "6", or 6).'
+);
+var AppsPropertySchema = zod.z.array(zod.z.string()).describe("Filter by app keys (e.g., 'SlackCLIAPI' or slug like 'github')");
+var TablesPropertySchema = zod.z.array(zod.z.string()).describe("Filter by specific table IDs");
+var ConnectionsPropertySchema = zod.z.array(zod.z.string()).describe("List of connection IDs to filter by");
+var TriggerInboxPropertySchema = withPositional(
+  zod.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 = zod.z.string().min(1).max(100).describe(
+  "Inbox name; unique per (user, account). Enables get-or-create on createTriggerInbox."
+);
+var LeasePropertySchema = zod.z.string().min(1).describe("Lease ID returned from leaseTriggerInboxMessages");
+var LeaseSecondsPropertySchema = zod.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 = zod.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 async_hooks.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(
-  zod.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 = zod.z.object({
+  inbox: TriggerInboxPropertySchema,
+  onMessage: zod.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: zod.z.number().int().min(1).optional().describe(
+    "Per-message handler workers running in parallel. Defaults to `leaseLimit`, or 1 if neither is set."
+  ),
+  leaseLimit: zod.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: zod.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: zod.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: zod.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: zod.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: zod.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: zod.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 = zod.z.object({
+  inputs: zod.z.record(zod.z.string(), zod.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 = zod.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 = zod.z.unknown().describe("Action execution result");
 
 // src/plugins/apps/index.ts
 function resolveProxyConnection({
@@ -1375,18 +1686,6 @@ var FetchInitSchema = zod.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);
@@ -1689,15 +1988,25 @@ function buildAbortHandle({
   return combineAbortSignals({ handles });
 }
 var FetchInitSdkValidationSchema = zod.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);
@@ -1769,17 +2078,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({
@@ -1791,17 +2096,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;
           }
         });
@@ -1811,7 +2113,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 },
@@ -1823,6 +2129,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 = apps.ListAppsQuerySchema.omit({
   offset: true,
   app_keys: true,
@@ -1844,27 +2173,30 @@ var ListAppsSchema = apps.ListAppsQuerySchema.omit({
   // SDK specific property for pagination/iterable helpers
   cursor: zod.z.string().optional().describe("Cursor to start from")
 }).describe("List all available apps with optional filtering");
-var AppItemSchema = withFormatter(apps.AppItemSchema, {
-  format: (item) => {
-    return {
-      title: item.title,
-      key: item.key,
-      keys: getAppKeyList(item),
-      description: item.description,
-      details: []
-    };
-  }
-});
+var AppItemSchema = apps.AppItemSchema;
+
+// 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;
@@ -1904,8 +2236,7 @@ var listAppsPlugin = definePlugin(
           ...options.cursor && { offset: options.cursor }
         }
       });
-    },
-    extractCursor: (response) => extractCursor(response.links)
+    }
   })
 );
 var ListActionsDescription = "List all actions for a specific app";
@@ -2230,48 +2561,42 @@ zod.z.object({
 });
 
 // src/schemas/Action.ts
-var ActionItemSchema = withFormatter(
-  ActionSchema.omit({ type: true, name: true, selected_api: true }).extend({
-    app_key: zod.z.string(),
-    // App key without version (extracted from selected_api)
-    app_version: zod.z.string().optional(),
-    // Version extracted from selected_api
-    action_type: ActionSchema.shape.type,
-    // Mapped from original 'type' field
-    title: zod.z.string(),
-    // Mapped from original 'name' field
-    type: zod.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: zod.z.string(),
+  // App key without version (extracted from selected_api)
+  app_version: zod.z.string().optional(),
+  // Version extracted from selected_api
+  action_type: ActionSchema.shape.type,
+  // Mapped from original 'type' field
+  title: zod.z.string(),
+  // Mapped from original 'name' field
+  type: zod.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 = {
@@ -2478,7 +2803,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,
@@ -2584,7 +2909,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
     }))
   })
@@ -2599,7 +2925,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
     }))
   })
@@ -2609,11 +2936,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",
@@ -2625,15 +2948,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",
@@ -3007,7 +3342,7 @@ var FieldApiItemSchema = zod.z.object({
 var ListTableFieldsApiResponseSchema = zod.z.object({
   data: zod.z.array(FieldApiItemSchema)
 });
-var FieldItemSchemaBase = zod.z.object({
+var FieldItemSchema = zod.z.object({
   id: zod.z.string(),
   type: FieldTypeSchema,
   name: zod.z.string(),
@@ -3017,13 +3352,6 @@ var FieldItemSchemaBase = zod.z.object({
   config: zod.z.record(zod.z.string(), zod.z.unknown()).optional(),
   deleted_at: zod.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 = zod.z.object({
   fields: FieldsPropertySchema.optional(),
@@ -3270,6 +3598,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, {
@@ -3279,12 +3619,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);
@@ -3371,99 +3709,36 @@ var BaseFieldItemSchema = zod.z.object({
   key: zod.z.string()
   // From need.key
 });
-var InputFieldItemSchema = withFormatter(
-  BaseFieldItemSchema.extend({
-    type: zod.z.literal("input_field"),
-    default_value: zod.z.string(),
-    // Mapped from 'default' with fallback to ""
-    depends_on: zod.z.array(zod.z.string()),
-    // Mapped from 'depends_on' with fallback to []
-    description: zod.z.string(),
-    // Mapped from 'help_text' with fallback to ""
-    invalidates_input_fields: zod.z.boolean(),
-    // Mapped from 'alters_custom_fields' with fallback to false
-    is_required: zod.z.boolean(),
-    // Mapped from 'required' with fallback to false
-    placeholder: zod.z.string(),
-    // Mapped from 'placeholder' with fallback to ""
-    title: zod.z.string(),
-    // Mapped from 'label' with fallback to ""
-    value_type: zod.z.string(),
-    // Computed from InputFieldType enum
-    format: zod.z.string().optional(),
-    // Computed from InputFieldFormat enum (optional)
-    items: zod.z.object({ type: zod.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: zod.z.literal("info_field"),
-    description: zod.z.string(),
-    // From need.help_text
-    title: zod.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: zod.z.literal("input_field"),
+  default_value: zod.z.string(),
+  // Mapped from 'default' with fallback to ""
+  depends_on: zod.z.array(zod.z.string()),
+  // Mapped from 'depends_on' with fallback to []
+  description: zod.z.string(),
+  // Mapped from 'help_text' with fallback to ""
+  invalidates_input_fields: zod.z.boolean(),
+  // Mapped from 'alters_custom_fields' with fallback to false
+  is_required: zod.z.boolean(),
+  // Mapped from 'required' with fallback to false
+  placeholder: zod.z.string(),
+  // Mapped from 'placeholder' with fallback to ""
+  title: zod.z.string(),
+  // Mapped from 'label' with fallback to ""
+  value_type: zod.z.string(),
+  // Computed from InputFieldType enum
+  format: zod.z.string().optional(),
+  // Computed from InputFieldFormat enum (optional)
+  items: zod.z.object({ type: zod.z.string() }).optional()
+  // Computed from ItemsType enum (optional, only for arrays)
+});
+var InfoFieldItemSchema = BaseFieldItemSchema.extend({
+  type: zod.z.literal("info_field"),
+  description: zod.z.string(),
+  // From need.help_text
+  title: zod.z.string().optional()
+  // Optional title
+});
 var FieldsetItemSchema = BaseFieldItemSchema.extend({
   type: zod.z.literal("fieldset"),
   title: zod.z.string(),
@@ -3483,6 +3758,53 @@ var RootFieldItemSchema = zod.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,
@@ -3648,6 +3970,7 @@ var listActionInputFieldsPlugin = definePlugin(
     itemType: "RootField",
     inputSchema: ListActionInputFieldsInputSchema,
     outputSchema: RootFieldItemSchema,
+    formatter: rootFieldItemFormatter,
     defaultPageSize: DEFAULT_PAGE_SIZE,
     resolvers: {
       app: appKeyResolver,
@@ -3656,10 +3979,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;
@@ -3707,26 +4027,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 = zod.z.object({
   connection: ConnectionPropertySchema.optional().describe(
@@ -3770,6 +4071,24 @@ var ListActionInputFieldChoicesInputSchema = zod.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 {
@@ -3787,6 +4106,7 @@ var listActionInputFieldChoicesPlugin = definePlugin(
     itemType: "InputFieldChoice",
     inputSchema: ListActionInputFieldChoicesInputSchema,
     outputSchema: InputFieldChoiceItemSchema,
+    formatter: inputFieldChoiceItemFormatter,
     defaultPageSize: DEFAULT_PAGE_SIZE,
     resolvers: {
       app: appKeyResolver,
@@ -3796,10 +4116,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;
@@ -4051,7 +4368,10 @@ var ListConnectionsQuerySchema = connections.ListConnectionsQuerySchema.omit({
   // SDK specific property for pagination/iterable helpers
   cursor: zod.z.string().optional().describe("Cursor to start from")
 }).describe("List available connections with optional filtering");
-var ConnectionItemSchema = withFormatter(connections.ConnectionItemSchema, {
+var ConnectionItemSchema = connections.ConnectionItemSchema;
+
+// src/formatters/connection.ts
+var connectionItemFormatter = {
   format: (item) => {
     const details = [];
     if (item.identifier) {
@@ -4076,17 +4396,19 @@ var ConnectionItemSchema = withFormatter(connections.ConnectionItemSchema, {
       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 }) => {
@@ -4159,8 +4481,7 @@ var listConnectionsPlugin = definePlugin(
         ...response,
         data: response.data.map(transformConnectionItem)
       };
-    },
-    extractCursor: (response) => extractCursor(response.links)
+    }
   })
 );
 var ListClientCredentialsQuerySchema = clientCredentials.ListClientCredentialsQuerySchema.omit({
@@ -4174,58 +4495,49 @@ var ListClientCredentialsQuerySchema = clientCredentials.ListClientCredentialsQu
   // SDK specific property for pagination/iterable helpers
   cursor: zod.z.string().optional().describe("Cursor to start from")
 }).describe("List client credentials for the authenticated user");
-var ClientCredentialsItemSchema = withFormatter(
-  clientCredentials.ClientCredentialsItemSchema,
-  {
-    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 = clientCredentials.ClientCredentialsItemSchema;
+var ClientCredentialsCreatedItemSchema = clientCredentials.ClientCredentialsCreatedItemSchema;
+
+// 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(
-  clientCredentials.ClientCredentialsCreatedItemSchema,
-  {
-    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,
@@ -4246,8 +4558,7 @@ var listClientCredentialsPlugin = definePlugin(
           requiredScopes: ["credentials"]
         }
       );
-    },
-    extractCursor: (response) => extractCursor(response.links)
+    }
   })
 );
 var CreateClientCredentialsSchema = clientCredentials.CreateClientCredentialsRequestSchema.omit({ allowed_scopes: true }).extend({
@@ -4265,6 +4576,7 @@ var createClientCredentialsPlugin = definePlugin(
     itemType: "ClientCredentials",
     inputSchema: CreateClientCredentialsSchema,
     outputSchema: ClientCredentialsCreatedItemSchema,
+    formatter: clientCredentialsCreatedItemFormatter,
     confirm: "create-secret",
     resolvers: { name: clientCredentialsNameResolver },
     handler: async ({ sdk: sdk2, options }) => {
@@ -4331,6 +4643,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;
@@ -4364,6 +4677,7 @@ var getActionPlugin = definePlugin(
     itemType: "Action",
     inputSchema: GetActionInputSchema,
     outputSchema: ActionItemSchema,
+    formatter: actionItemFormatter,
     resolvers: {
       app: appKeyResolver,
       actionType: actionTypeResolver,
@@ -4410,6 +4724,7 @@ var getConnectionPlugin = definePlugin(
     itemType: "Connection",
     inputSchema: GetConnectionParamSchema,
     outputSchema: ConnectionItemSchema,
+    formatter: connectionItemFormatter,
     resolvers: { connection: connectionIdGenericResolver },
     handler: async ({ sdk: sdk2, options }) => {
       const { api } = sdk2.context;
@@ -4450,6 +4765,7 @@ var findFirstConnectionPlugin = definePlugin(
     itemType: "Connection",
     inputSchema: FindFirstConnectionSchema,
     outputSchema: ConnectionItemSchema,
+    formatter: connectionItemFormatter,
     handler: async ({ sdk: sdk2, options = {} }) => {
       const connectionsResponse = await sdk2.listConnections({
         ...options,
@@ -4485,6 +4801,7 @@ var findUniqueConnectionPlugin = definePlugin(
     itemType: "Connection",
     inputSchema: FindUniqueConnectionSchema,
     outputSchema: ConnectionItemSchema,
+    formatter: connectionItemFormatter,
     handler: async ({ sdk: sdk2, options = {} }) => {
       const connectionsResponse = await sdk2.listConnections({
         ...options,
@@ -4542,6 +4859,29 @@ var RunActionSchemaDeprecated = zod.z.object({
   actionKey: ActionKeyPropertySchema
 }).merge(RunActionBaseSchema);
 var RunActionInputSchema = zod.z.union([RunActionSchema, RunActionSchemaDeprecated]).describe(RunActionDescription);
+
+// src/formatters/actionResult.ts
+function getStringProperty(obj, key) {
+  if (typeof obj === "object" && obj !== null && key in obj) {
+    const value = obj[key];
+    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,
@@ -4671,6 +5011,7 @@ var runActionPlugin = definePlugin(
       itemType: "ActionResult",
       inputSchema: RunActionInputSchema,
       outputSchema: ActionResultItemSchema,
+      formatter: actionResultItemFormatter,
       resolvers: {
         app: appKeyResolver,
         actionType: actionTypeResolver,
@@ -4678,10 +5019,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;
@@ -4734,7 +5072,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
         };
       }
     });
@@ -4764,26 +5104,19 @@ var RelayRequestSchema = zod.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,
@@ -5003,7 +5336,7 @@ async function listAppsForSlugsPage({
     data: implementationsEnvelope.results.map(
       normalizeImplementationMetaToAppItem
     ),
-    nextCursor: extractCursor(implementationsEnvelope)
+    nextCursor: implementationsEnvelope.next ? extractCursorFromUrl(implementationsEnvelope.next) : void 0
   };
 }
 function findManifestEntry({
@@ -5281,36 +5614,36 @@ var manifestPlugin = definePlugin(
   }
 );
 var GetProfileSchema = zod.z.object({}).optional().describe("Get current user's profile information");
-var UserProfileItemSchema = withFormatter(
-  zod.z.object({
-    id: zod.z.string(),
-    first_name: zod.z.string(),
-    last_name: zod.z.string(),
-    full_name: zod.z.string(),
-    email: zod.z.string(),
-    email_confirmed: zod.z.boolean(),
-    timezone: zod.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 = zod.z.object({
+  id: zod.z.string(),
+  first_name: zod.z.string(),
+  last_name: zod.z.string(),
+  full_name: zod.z.string(),
+  email: zod.z.string(),
+  email_confirmed: zod.z.boolean(),
+  timezone: zod.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(
@@ -5321,6 +5654,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/",
@@ -5417,7 +5751,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) {
@@ -5426,9 +5760,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);
     }
   };
 }
@@ -5627,7 +5961,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", {
@@ -5639,6 +5974,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;
@@ -5661,7 +6004,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++;
@@ -5944,17 +6288,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."
       );
     }
@@ -5988,7 +6332,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;
@@ -6230,7 +6574,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");
@@ -6249,7 +6593,7 @@ async function tryStoredClientCredentialToken(options) {
     );
   }
   if (options.debug)
-    console.log(
+    console.error(
       `[auth] Using stored client credential (clientId: ${storedCredential.clientId})`
     );
   const token = await resolveAuthTokenFromCredentials(
@@ -6271,7 +6615,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,
@@ -6301,7 +6645,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;
     }
@@ -6311,7 +6655,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)`
           );
         }
@@ -6374,7 +6718,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:";
@@ -6459,6 +6803,7 @@ var PollApprovalResponseSchema = zod.z.object({
   status: ApprovalStatusSchema,
   approval_id: zod.z.string()
 });
+var APPROVAL_MAX_POLLING_INTERVAL_MS = 5e3;
 function parseRateLimitHeaders(response) {
   const info = {};
   const retryAfter = response.headers.get("retry-after");
@@ -7167,6 +7512,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";
@@ -7534,6 +7880,7 @@ var tablesDefaults = {
 var listTablesPlugin = definePlugin(
   (sdk) => createPaginatedPluginMethod(sdk, {
     ...tablesDefaults,
+    ...zapierPagination,
     name: "listTables",
     type: "list",
     itemType: "Table",
@@ -7589,8 +7936,7 @@ var listTablesPlugin = definePlugin(
         data: response.data.map(transformTableItem),
         links: response.links
       };
-    },
-    extractCursor: (response) => extractCursor(response.links)
+    }
   })
 );
 var GetTableApiResponseSchema = zod.z.object({
@@ -7693,6 +8039,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, {
@@ -7702,6 +8057,7 @@ var listTableFieldsPlugin = definePlugin(
     itemType: "Field",
     inputSchema: ListTableFieldsOptionsInputSchema,
     outputSchema: FieldItemSchema,
+    formatter: tableFieldItemFormatter,
     resolvers: { table: tableIdResolver },
     handler: async ({ sdk: sdk2, options }) => {
       const { api } = sdk2.context;
@@ -7774,6 +8130,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;
@@ -7852,21 +8209,13 @@ var RecordApiItemSchema = zod.z.object({
   is_source_record: zod.z.boolean().nullable().optional(),
   deleted_at: zod.z.string().nullable().optional()
 });
-var RecordItemSchemaBase = zod.z.object({
+var RecordItemSchema = zod.z.object({
   id: zod.z.string(),
   data: zod.z.record(zod.z.string(), zod.z.unknown()),
   created_at: zod.z.string(),
   edited_at: zod.z.string(),
   deleted_at: zod.z.string().nullable().optional()
 });
-var RecordItemSchema = withFormatter(RecordItemSchemaBase, {
-  format: (item) => ({
-    title: `Record ${item.id}`,
-    id: item.id,
-    data: item.data,
-    details: []
-  })
-});
 var GetTableRecordApiResponseSchema = zod.z.object({
   data: RecordApiItemSchema
 });
@@ -7890,9 +8239,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) => ({
@@ -8017,10 +8366,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({
@@ -8270,85 +8616,13 @@ var updateTableRecordsPlugin = definePlugin(
     }
   })
 );
-function canonicalInputSchema(schema) {
-  if (schema instanceof zod.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
@@ -8359,11 +8633,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
         }
       }
     }
@@ -8376,11 +8652,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
         }
       }
     }
@@ -8393,11 +8671,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
         }
       }
     }
@@ -8410,11 +8690,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
         }
       }
     }
@@ -8428,11 +8710,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
         }
       }
@@ -8445,11 +8729,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
         }
       }
@@ -8462,7 +8750,8 @@ var getInputFieldsSchemaDeprecatedPlugin = definePlugin(
     context: {
       meta: {
         getInputFieldsSchema: {
-          categories: ["action", "deprecated"],
+          categories: ["action"],
+          deprecation: { message: "Use getActionInputFieldsSchema instead." },
           type: "function",
           inputSchema: GetActionInputFieldsSchemaInputSchema
         }
@@ -8526,7 +8815,7 @@ function createConsoleTransport() {
   return {
     async emit(subject, event) {
       try {
-        console.log(
+        console.error(
           "[SDK Telemetry]",
           JSON.stringify({ subject, properties: event }, null, 2)
         );
@@ -8735,6 +9024,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 = {};
@@ -8865,6 +9183,8 @@ var eventEmissionPlugin = definePlugin(
       }
     }
     if (!config.enabled) {
+      const noopEmitMethodCalled = () => {
+      };
       return {
         context: {
           eventEmission: {
@@ -8882,12 +9202,13 @@ var eventEmissionPlugin = definePlugin(
               visitor_id: null,
               correlation_id: null
             }),
-            emitMethodCalled: () => {
-            },
             flush: async () => {
             },
             close: async () => {
             }
+          },
+          hooks: {
+            onMethodEnd: makeMethodEndHook(noopEmitMethodCalled)
           }
         }
       };
@@ -9058,6 +9379,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: {
@@ -9069,22 +9404,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)
         }
       }
     };
@@ -9096,78 +9420,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 = zod.z.object({
   credentials: CredentialsSchema.optional().describe(
@@ -9230,7 +9498,7 @@ var BaseSdkOptionsSchema = zod.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 {};
@@ -9247,12 +9515,14 @@ exports.AuthenticationIdPropertySchema = AuthenticationIdPropertySchema;
 exports.BaseSdkOptionsSchema = BaseSdkOptionsSchema;
 exports.CONTEXT_CACHE_MAX_SIZE = CONTEXT_CACHE_MAX_SIZE;
 exports.CONTEXT_CACHE_TTL_MS = CONTEXT_CACHE_TTL_MS;
+exports.CORE_ERROR_SYMBOL = CORE_ERROR_SYMBOL;
 exports.ClientCredentialsObjectSchema = ClientCredentialsObjectSchema;
 exports.ConnectionEntrySchema = ConnectionEntrySchema;
 exports.ConnectionIdPropertySchema = ConnectionIdPropertySchema;
 exports.ConnectionPropertySchema = ConnectionPropertySchema;
 exports.ConnectionsMapSchema = ConnectionsMapSchema;
 exports.ConnectionsPropertySchema = ConnectionsPropertySchema;
+exports.CoreErrorCode = CoreErrorCode;
 exports.CredentialsFunctionSchema = CredentialsFunctionSchema;
 exports.CredentialsObjectSchema = CredentialsObjectSchema;
 exports.CredentialsSchema = CredentialsSchema;
@@ -9309,6 +9579,7 @@ exports.ZapierUnknownError = ZapierUnknownError;
 exports.ZapierValidationError = ZapierValidationError;
 exports.actionKeyResolver = actionKeyResolver;
 exports.actionTypeResolver = actionTypeResolver;
+exports.addPlugin = addPlugin;
 exports.apiPlugin = apiPlugin;
 exports.appKeyResolver = appKeyResolver;
 exports.appsPlugin = appsPlugin;
@@ -9330,17 +9601,21 @@ exports.connectionIdResolver = connectionIdResolver;
 exports.connectionsPlugin = connectionsPlugin;
 exports.createBaseEvent = createBaseEvent;
 exports.createClientCredentialsPlugin = createClientCredentialsPlugin;
+exports.createCorePlugin = createCorePlugin;
 exports.createFunction = createFunction;
 exports.createMemoryCache = createMemoryCache;
 exports.createOptionsPlugin = createOptionsPlugin;
 exports.createPaginatedPluginMethod = createPaginatedPluginMethod;
 exports.createPluginMethod = createPluginMethod;
+exports.createPluginStack = createPluginStack;
 exports.createSdk = createSdk;
 exports.createTableFieldsPlugin = createTableFieldsPlugin;
 exports.createTablePlugin = createTablePlugin;
 exports.createTableRecordsPlugin = createTableRecordsPlugin;
 exports.createZapierApi = createZapierApi;
+exports.createZapierCoreStack = createZapierCoreStack;
 exports.createZapierSdk = createZapierSdk;
+exports.createZapierSdkStack = createZapierSdkStack;
 exports.createZapierSdkWithoutRegistry = createZapierSdkWithoutRegistry;
 exports.definePlugin = definePlugin;
 exports.deleteClientCredentialsPlugin = deleteClientCredentialsPlugin;
@@ -9362,6 +9637,8 @@ exports.getBaseUrlFromCredentials = getBaseUrlFromCredentials;
 exports.getCiPlatform = getCiPlatform;
 exports.getClientIdFromCredentials = getClientIdFromCredentials;
 exports.getConnectionPlugin = getConnectionPlugin;
+exports.getCoreErrorCause = getCoreErrorCause;
+exports.getCoreErrorCode = getCoreErrorCode;
 exports.getCpuTime = getCpuTime;
 exports.getCurrentTimestamp = getCurrentTimestamp;
 exports.getMemoryUsage = getMemoryUsage;
@@ -9386,6 +9663,7 @@ exports.invalidateCredentialsToken = invalidateCredentialsToken;
 exports.isCi = isCi;
 exports.isCliLoginAvailable = isCliLoginAvailable;
 exports.isClientCredentials = isClientCredentials;
+exports.isCoreError = isCoreError;
 exports.isCredentialsFunction = isCredentialsFunction;
 exports.isCredentialsObject = isCredentialsObject;
 exports.isPkceCredentials = isPkceCredentials;
@@ -9399,17 +9677,18 @@ exports.listConnectionsPlugin = listConnectionsPlugin;
 exports.listTableFieldsPlugin = listTableFieldsPlugin;
 exports.listTableRecordsPlugin = listTableRecordsPlugin;
 exports.listTablesPlugin = listTablesPlugin;
-exports.logDeprecation = logDeprecation;
+exports.logDeprecation = logDeprecation2;
 exports.manifestPlugin = manifestPlugin;
 exports.parseConcurrencyEnvVar = parseConcurrencyEnvVar;
 exports.readManifestFromFile = readManifestFromFile;
 exports.registryPlugin = registryPlugin;
 exports.requestPlugin = requestPlugin;
-exports.resetDeprecationWarnings = resetDeprecationWarnings;
+exports.resetDeprecationWarnings = resetDeprecationWarnings2;
 exports.resolveAuthToken = resolveAuthToken;
 exports.resolveCredentials = resolveCredentials;
 exports.resolveCredentialsFromEnv = resolveCredentialsFromEnv;
 exports.runActionPlugin = runActionPlugin;
+exports.runInMethodScope = runInMethodScope;
 exports.runWithTelemetryContext = runWithTelemetryContext;
 exports.tableFieldIdsResolver = tableFieldIdsResolver;
 exports.tableFieldsResolver = tableFieldsResolver;
@@ -9427,4 +9706,6 @@ exports.triggerInboxResolver = triggerInboxResolver;
 exports.triggerMessagesResolver = triggerMessagesResolver;
 exports.updateTableRecordsPlugin = updateTableRecordsPlugin;
 exports.workflowIdResolver = workflowIdResolver;
+exports.workflowRunIdResolver = workflowRunIdResolver;
 exports.workflowVersionIdResolver = workflowVersionIdResolver;
+exports.zapierAdaptError = zapierAdaptError;