@zapier/zapier-sdk 0.81.1 → 0.82.0

package/dist/index.mjs

@@ -3138,14 +3138,14 @@ var TriggerInboxCommandBaseSchema = z.object({
     "Abort signal. Aborting cancels in-flight HTTP, releases unprocessed messages, and resolves cleanly. Errors during shutdown still reject."
   )
 });
-TriggerInboxCommandBaseSchema.extend({
+var DrainTriggerInboxSchema = TriggerInboxCommandBaseSchema.extend({
   maxMessages: z.number().int().min(1).optional().describe(
     "Cap total messages drained. Defaults to draining the inbox until empty."
   )
 }).describe(
   "Drain an existing trigger inbox: lease currently-available messages and process them via onMessage. Returns when the inbox is empty, maxMessages is reached, the abort signal fires, or a fatal error rejects."
 );
-TriggerInboxCommandBaseSchema.extend({
+var WatchTriggerInboxSchema = TriggerInboxCommandBaseSchema.extend({
   maxDrainIntervalSeconds: z.number().int().min(1).optional().describe(
     "Maximum seconds between safety drain attempts (default: 300). The watcher subscribes to SSE notifications for near-real-time wake-ups; this interval is the backstop that guarantees forward progress if SSE events are missed or the connection drops undetected."
   )
@@ -6783,11 +6783,11 @@ var runActionPlugin = definePlugin(
           timeoutMs
         });
         if (result.errors && result.errors.length > 0) {
-          const errorMessage = result.errors.map(
+          const errorMessage2 = result.errors.map(
             (error) => error.detail || error.title || "Unknown error"
           ).join("; ");
           throw new ZapierActionError(
-            `Action execution failed: ${errorMessage}`,
+            `Action execution failed: ${errorMessage2}`,
             { appKey, actionKey }
           );
         }
@@ -8750,7 +8750,7 @@ function parseDeprecationDate(value) {
 }
 
 // src/sdk-version.ts
-var SDK_VERSION = (typeof process !== "undefined" && process.env ? "0.81.1" : void 0) || "unknown";
+var SDK_VERSION = (typeof process !== "undefined" && process.env ? "0.82.0" : void 0) || "unknown";
 
 // src/utils/open-url.ts
 var nodePrefix = "node:";
@@ -9454,16 +9454,16 @@ var ZapierApiClient = class {
       if (typeof errorInfo.data === "string") {
         return { message: `${fallbackMessage}: ${errorInfo.data}` };
       }
-      const errorMessage = this.extractErrorMessage(errorInfo.data) || fallbackMessage;
+      const errorMessage2 = this.extractErrorMessage(errorInfo.data) || fallbackMessage;
       if (this.hasErrorArray(errorInfo.data)) {
         if (this.isApiErrorArray(errorInfo.data.errors)) {
           return {
-            message: errorMessage,
+            message: errorMessage2,
             errors: errorInfo.data.errors
           };
         } else {
           return {
-            message: errorMessage,
+            message: errorMessage2,
             errors: errorInfo.data.errors.map((e) => ({
               status: errorInfo.status,
               code: String(errorInfo.status),
@@ -9473,7 +9473,7 @@ var ZapierApiClient = class {
           };
         }
       }
-      return { message: errorMessage };
+      return { message: errorMessage2 };
     } catch {
       return { message: fallbackMessage };
     }
@@ -10496,6 +10496,1658 @@ var getInputFieldsSchemaDeprecatedPlugin = definePlugin(
     }
   })
 );
+var TriggerInboxStatusSchema = z.union([
+  z.enum([
+    "initializing",
+    "active",
+    "paused",
+    "deleting",
+    "initialization_failure"
+  ]),
+  z.string()
+]).describe("Inbox lifecycle status");
+var TriggerInboxPausedReasonSchema = z.union([
+  z.enum([
+    "user",
+    "authentication",
+    "authentication_access_revoked",
+    "partner_revoked",
+    "subscribe_failed",
+    "migrate_failed",
+    "abandoned",
+    "unknown",
+    "upstream_failures"
+  ]),
+  z.string()
+]).describe("Why the inbox was paused, if applicable");
+var TriggerSubscriptionApiSchema = z.object({
+  connection_id: z.union([z.string(), z.number(), z.null()]),
+  app_key: z.string(),
+  action_key: z.string(),
+  inputs: z.record(z.string(), z.unknown())
+});
+var TriggerInboxItemSchema = z.object({
+  id: z.string(),
+  created_at: z.string(),
+  // `key` is an API-layer alias over the same nullable `name` column, so it's
+  // always present but can be null — null means no natural key (inbox created
+  // without one, or key cleared on delete).
+  key: z.string().nullable(),
+  /** @deprecated Use `key` instead. */
+  name: z.string().nullable(),
+  status: TriggerInboxStatusSchema,
+  paused_reason: TriggerInboxPausedReasonSchema.nullable(),
+  notification_url: z.string().nullable(),
+  subscription: TriggerSubscriptionApiSchema
+});
+
+// src/plugins/triggers/createTriggerInbox/schemas.ts
+var CreateTriggerInboxDescription = "Create a new trigger inbox subscription. Always creates a new inbox; use ensureTriggerInbox for get-or-create on a stable key.";
+var CreateTriggerInboxSchema = z.object({
+  key: TriggerInboxKeyPropertySchema.optional().describe(
+    "Optional inbox key. Auto-generated when omitted. Throws a conflict error if the key is already in use by another subscription."
+  ),
+  /** @deprecated Use `key` instead. */
+  name: TriggerInboxNamePropertySchema.optional().describe(
+    "Optional inbox name. Auto-generated when omitted. Throws a conflict error if the name is already in use by another subscription."
+  ).meta({ deprecated: true }),
+  app: AppPropertySchema,
+  action: ActionPropertySchema,
+  connection: ConnectionPropertySchema.nullable().optional().describe(
+    "Connection alias or connection ID. Optional for triggers that don't require auth."
+  ),
+  inputs: InputsPropertySchema.optional().describe(
+    "Input parameters for the trigger subscription"
+  ),
+  notificationUrl: z.string().url().optional().describe("Webhook URL to POST to when new messages arrive")
+}).describe(CreateTriggerInboxDescription);
+
+// src/formatters/triggerInbox.ts
+var triggerInboxItemFormatter = {
+  format: (item) => {
+    const details = [
+      {
+        text: `Status: ${item.status}`,
+        style: item.status === "active" ? "accent" : "dim"
+      },
+      {
+        text: `Subscription: ${item.subscription.app_key} / ${item.subscription.action_key}`,
+        style: "dim"
+      }
+    ];
+    if (item.paused_reason) {
+      details.push({
+        text: `Paused reason: ${item.paused_reason}`,
+        style: "warning"
+      });
+    }
+    if (item.notification_url) {
+      details.push({
+        text: `Notify: ${item.notification_url}`,
+        style: "dim"
+      });
+    }
+    return {
+      title: item.key ?? item.name ?? `Trigger Inbox ${item.id}`,
+      id: item.id,
+      details
+    };
+  }
+};
+
+// src/plugins/triggers/shared.ts
+var triggersDefaults = {
+  categories: ["trigger"]
+};
+
+// src/plugins/triggers/utils.ts
+var UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+async function resolveTriggerInboxId({
+  api,
+  inbox
+}) {
+  if (UUID_REGEX.test(inbox)) {
+    return inbox;
+  }
+  const rawResponse = await api.get("/trigger-inbox/api/v1/inboxes", {
+    searchParams: { key: inbox, limit: "1" },
+    authRequired: true
+  });
+  const response = rawResponse;
+  const id = response.results?.[0]?.id;
+  if (!id) {
+    throw new ZapierResourceNotFoundError(
+      `No trigger inbox with key "${inbox}" found.`,
+      { resourceType: "trigger_inbox", resourceId: inbox }
+    );
+  }
+  return id;
+}
+function extractErrorDetail(data) {
+  if (typeof data !== "object" || data === null) return void 0;
+  const errors = data.errors;
+  if (!Array.isArray(errors) || errors.length === 0) return void 0;
+  const first = errors[0];
+  if (typeof first !== "object" || first === null) return void 0;
+  const detail = first.detail;
+  return typeof detail === "string" ? detail : void 0;
+}
+
+// src/plugins/triggers/createTriggerInbox/index.ts
+var createTriggerInboxPlugin = definePlugin(
+  (sdk) => createPluginMethod(sdk, {
+    ...triggersDefaults,
+    name: "createTriggerInbox",
+    type: "create",
+    itemType: "TriggerInbox",
+    inputSchema: CreateTriggerInboxSchema,
+    outputSchema: TriggerInboxItemSchema,
+    formatter: triggerInboxItemFormatter,
+    // actionKeyResolver and inputsResolver depend on actionType, which is
+    // always "read" for triggers. Pin it as a constant resolver so it's
+    // seeded into resolvedParams without polluting the user-facing schema
+    // (where it would leak into the SDK method signature and CLI flags).
+    resolvers: {
+      key: { type: "static", inputType: "text" },
+      app: appKeyResolver,
+      action: actionKeyResolver,
+      connection: connectionIdResolver,
+      inputs: inputsResolver,
+      actionType: { type: "constant", value: "read" }
+    },
+    handler: async ({ sdk: sdk2, options }) => {
+      const { api } = sdk2.context;
+      const {
+        app: appKey,
+        action: actionKey,
+        connection,
+        inputs = {},
+        notificationUrl
+      } = options;
+      const key2 = options.key ?? options.name;
+      const resolvedConnectionId = await resolveConnectionId({
+        connection,
+        resolveConnection: sdk2.context.resolveConnection
+      });
+      const selectedApi = await sdk2.context.getVersionedImplementationId(appKey);
+      if (!selectedApi) {
+        throw new ZapierConfigurationError(
+          `No current_implementation_id found for app "${appKey}"`,
+          { configType: "current_implementation_id" }
+        );
+      }
+      const requestBody = {
+        subscription: {
+          app_key: selectedApi,
+          action_key: actionKey,
+          inputs,
+          connection_id: resolvedConnectionId ?? null
+        }
+      };
+      if (key2 !== void 0) {
+        requestBody.key = key2;
+      }
+      if (notificationUrl !== void 0) {
+        requestBody.notification_url = notificationUrl;
+      }
+      const rawResponse = await api.post(
+        "/trigger-inbox/api/v1/inboxes",
+        requestBody,
+        {
+          authRequired: true,
+          customErrorHandler: ({ status, data }) => {
+            if (status === 409) {
+              const detail = extractErrorDetail(data);
+              return new ZapierConflictError(
+                detail ?? `An inbox with key "${key2}" already exists with a different subscription.`,
+                { statusCode: status, resourceType: "trigger_inbox" }
+              );
+            }
+            return void 0;
+          }
+        }
+      );
+      return { data: TriggerInboxItemSchema.parse(rawResponse) };
+    }
+  })
+);
+var EnsureTriggerInboxDescription = "Get-or-create a trigger inbox by key. Idempotent on (user, account, key): returns the existing inbox if a matching subscription is registered, creates a new one otherwise. Throws ZapierConflictError if the key exists with a different subscription.";
+var EnsureTriggerInboxBaseSchema = z.object({
+  app: AppPropertySchema,
+  action: ActionPropertySchema,
+  connection: ConnectionPropertySchema.nullable().optional().describe(
+    "Connection alias or connection ID. Optional for triggers that don't require auth."
+  ),
+  inputs: InputsPropertySchema.optional().describe(
+    "Input parameters for the trigger subscription"
+  ),
+  notificationUrl: z.string().url().optional().describe("Webhook URL to POST to when new messages arrive")
+});
+var EnsureTriggerInboxSchema = z.object({
+  key: TriggerInboxKeyPropertySchema.describe(
+    "Inbox key; serves as the idempotency key. Required for ensureTriggerInbox \u2014 without one, the API mints a fresh inbox each call (use createTriggerInbox for that path)."
+  )
+}).merge(EnsureTriggerInboxBaseSchema).describe(EnsureTriggerInboxDescription).meta({ aliases: { name: "key" } });
+var EnsureTriggerInboxSchemaDeprecated = z.object({
+  name: TriggerInboxNamePropertySchema.describe(
+    "Inbox name; serves as the idempotency key. Required for ensureTriggerInbox \u2014 without one, the API mints a fresh inbox each call (use createTriggerInbox for that path)."
+  )
+}).merge(EnsureTriggerInboxBaseSchema);
+var EnsureTriggerInboxInputSchema = z.union([EnsureTriggerInboxSchema, EnsureTriggerInboxSchemaDeprecated]).describe(EnsureTriggerInboxDescription);
+
+// src/plugins/triggers/ensureTriggerInbox/index.ts
+var ensureTriggerInboxPlugin = definePlugin(
+  (sdk) => createPluginMethod(sdk, {
+    ...triggersDefaults,
+    name: "ensureTriggerInbox",
+    type: "create",
+    itemType: "TriggerInbox",
+    inputSchema: EnsureTriggerInboxInputSchema,
+    outputSchema: TriggerInboxItemSchema,
+    formatter: triggerInboxItemFormatter,
+    // actionKeyResolver and inputsResolver depend on actionType, which is
+    // always "read" for triggers. Pin it as a constant resolver so it's
+    // seeded into resolvedParams without polluting the user-facing schema.
+    resolvers: {
+      key: { type: "static", inputType: "text" },
+      app: appKeyResolver,
+      action: actionKeyResolver,
+      connection: connectionIdResolver,
+      inputs: inputsResolver,
+      actionType: { type: "constant", value: "read" }
+    },
+    handler: async ({ sdk: sdk2, options }) => {
+      const { api } = sdk2.context;
+      const {
+        app: appKey,
+        action: actionKey,
+        connection,
+        inputs = {},
+        notificationUrl
+      } = options;
+      const key2 = "key" in options ? options.key : options.name;
+      const resolvedConnectionId = await resolveConnectionId({
+        connection,
+        resolveConnection: sdk2.context.resolveConnection
+      });
+      const selectedApi = await sdk2.context.getVersionedImplementationId(appKey);
+      if (!selectedApi) {
+        throw new ZapierConfigurationError(
+          `No current_implementation_id found for app "${appKey}"`,
+          { configType: "current_implementation_id" }
+        );
+      }
+      const requestBody = {
+        key: key2,
+        subscription: {
+          app_key: selectedApi,
+          action_key: actionKey,
+          inputs,
+          connection_id: resolvedConnectionId ?? null
+        }
+      };
+      if (notificationUrl !== void 0) {
+        requestBody.notification_url = notificationUrl;
+      }
+      const rawResponse = await api.put(
+        "/trigger-inbox/api/v1/inboxes",
+        requestBody,
+        {
+          authRequired: true,
+          customErrorHandler: ({ status, data }) => {
+            if (status === 409) {
+              const detail = extractErrorDetail(data);
+              return new ZapierConflictError(
+                detail ?? `An inbox with key "${key2}" already exists with a different subscription.`,
+                { statusCode: status, resourceType: "trigger_inbox" }
+              );
+            }
+            return void 0;
+          }
+        }
+      );
+      return { data: TriggerInboxItemSchema.parse(rawResponse) };
+    }
+  })
+);
+var ListTriggerInboxesSchema = z.object({
+  key: z.string().min(1).optional().describe(
+    "Filter by inbox key (exact match). Keys are unique per (user, account), so this returns at most one inbox."
+  ),
+  /** @deprecated Use `key` instead. */
+  name: z.string().min(1).optional().describe(
+    "Filter by inbox name (exact match). Names are unique per (user, account), so this returns at most one inbox."
+  ).meta({ deprecated: true }),
+  status: TriggerInboxStatusSchema.optional().describe(
+    "Filter by inbox status"
+  ),
+  pageSize: z.number().int().min(1).optional().describe("Number of inboxes per page"),
+  maxItems: z.number().int().min(1).optional().describe("Maximum total items to return across all pages"),
+  cursor: z.string().optional().describe("Cursor (offset) to start from for pagination")
+}).describe("List all trigger inboxes for the authenticated user");
+var ListTriggerInboxesApiResponseSchema = z.object({
+  count: z.number().int(),
+  next: z.string().nullable().optional(),
+  previous: z.string().nullable().optional(),
+  results: z.array(TriggerInboxItemSchema)
+});
+
+// src/plugins/triggers/listTriggerInboxes/index.ts
+var listTriggerInboxesPlugin = definePlugin(
+  (sdk) => createPaginatedPluginMethod(sdk, {
+    ...triggersDefaults,
+    ...zapierPagination,
+    name: "listTriggerInboxes",
+    type: "list",
+    itemType: "TriggerInbox",
+    inputSchema: ListTriggerInboxesSchema,
+    outputSchema: TriggerInboxItemSchema,
+    formatter: triggerInboxItemFormatter,
+    defaultPageSize: DEFAULT_PAGE_SIZE,
+    handler: async ({ sdk: sdk2, options }) => {
+      const { api } = sdk2.context;
+      const searchParams = {};
+      if (options.pageSize !== void 0) {
+        searchParams.limit = options.pageSize.toString();
+      }
+      if (options.cursor) {
+        searchParams.offset = options.cursor;
+      }
+      if (options.status) {
+        searchParams.status = options.status;
+      }
+      const keyFilter = options.key ?? options.name;
+      if (keyFilter) {
+        searchParams.key = keyFilter;
+      }
+      const rawResponse = await api.get("/trigger-inbox/api/v1/inboxes", {
+        searchParams,
+        authRequired: true
+      });
+      const response = ListTriggerInboxesApiResponseSchema.parse(rawResponse);
+      return {
+        data: response.results,
+        next: response.next ?? null
+      };
+    }
+  })
+);
+var GetTriggerInboxSchema = z.object({
+  inbox: TriggerInboxPropertySchema
+}).describe("Get details of a trigger inbox by ID");
+
+// src/plugins/triggers/getTriggerInbox/index.ts
+var getTriggerInboxPlugin = definePlugin(
+  (sdk) => createPluginMethod(sdk, {
+    ...triggersDefaults,
+    name: "getTriggerInbox",
+    type: "item",
+    itemType: "TriggerInbox",
+    inputSchema: GetTriggerInboxSchema,
+    outputSchema: TriggerInboxItemSchema,
+    formatter: triggerInboxItemFormatter,
+    resolvers: { inbox: triggerInboxResolver },
+    handler: async ({ sdk: sdk2, options }) => {
+      const { inbox } = options;
+      const inboxId = await resolveTriggerInboxId({
+        api: sdk2.context.api,
+        inbox
+      });
+      const rawResponse = await sdk2.context.api.get(
+        `/trigger-inbox/api/v1/inboxes/${encodeURIComponent(inboxId)}`,
+        {
+          authRequired: true,
+          resource: { type: "trigger_inbox", id: inboxId }
+        }
+      );
+      return { data: TriggerInboxItemSchema.parse(rawResponse) };
+    }
+  })
+);
+var UpdateTriggerInboxSchema = z.object({
+  inbox: TriggerInboxPropertySchema,
+  notificationUrl: z.string().url().nullable().optional().describe(
+    "Webhook URL to POST to when new messages arrive. Pass null to clear."
+  )
+}).describe("Update settings on an existing trigger inbox");
+
+// src/plugins/triggers/updateTriggerInbox/index.ts
+var updateTriggerInboxPlugin = definePlugin(
+  (sdk) => createPluginMethod(sdk, {
+    ...triggersDefaults,
+    name: "updateTriggerInbox",
+    type: "update",
+    itemType: "TriggerInbox",
+    inputSchema: UpdateTriggerInboxSchema,
+    outputSchema: TriggerInboxItemSchema,
+    formatter: triggerInboxItemFormatter,
+    resolvers: { inbox: triggerInboxResolver },
+    handler: async ({ sdk: sdk2, options }) => {
+      const { inbox, notificationUrl } = options;
+      const inboxId = await resolveTriggerInboxId({
+        api: sdk2.context.api,
+        inbox
+      });
+      const requestBody = {};
+      if (notificationUrl !== void 0) {
+        requestBody.notification_url = notificationUrl;
+      }
+      const rawResponse = await sdk2.context.api.patch(
+        `/trigger-inbox/api/v1/inboxes/${encodeURIComponent(inboxId)}`,
+        requestBody,
+        {
+          authRequired: true,
+          resource: { type: "trigger_inbox", id: inboxId }
+        }
+      );
+      return { data: TriggerInboxItemSchema.parse(rawResponse) };
+    }
+  })
+);
+var DeleteTriggerInboxSchema = z.object({
+  inbox: TriggerInboxPropertySchema
+}).describe("Mark a trigger inbox for deletion");
+
+// src/plugins/triggers/deleteTriggerInbox/index.ts
+var deleteTriggerInboxPlugin = definePlugin(
+  (sdk) => createPluginMethod(sdk, {
+    ...triggersDefaults,
+    name: "deleteTriggerInbox",
+    type: "delete",
+    itemType: "TriggerInbox",
+    inputSchema: DeleteTriggerInboxSchema,
+    outputSchema: TriggerInboxItemSchema,
+    formatter: triggerInboxItemFormatter,
+    resolvers: { inbox: triggerInboxResolver },
+    confirm: "delete",
+    handler: async ({ sdk: sdk2, options }) => {
+      const { inbox } = options;
+      const inboxId = await resolveTriggerInboxId({
+        api: sdk2.context.api,
+        inbox
+      });
+      const rawResponse = await sdk2.context.api.delete(
+        `/trigger-inbox/api/v1/inboxes/${encodeURIComponent(inboxId)}`,
+        void 0,
+        {
+          authRequired: true,
+          resource: { type: "trigger_inbox", id: inboxId }
+        }
+      );
+      return { data: TriggerInboxItemSchema.parse(rawResponse) };
+    }
+  })
+);
+var PauseTriggerInboxSchema = z.object({
+  inbox: TriggerInboxPropertySchema
+}).describe("Pause a trigger inbox; events stop being collected");
+
+// src/plugins/triggers/pauseTriggerInbox/index.ts
+var pauseTriggerInboxPlugin = definePlugin(
+  (sdk) => createPluginMethod(sdk, {
+    ...triggersDefaults,
+    name: "pauseTriggerInbox",
+    type: "update",
+    itemType: "TriggerInbox",
+    inputSchema: PauseTriggerInboxSchema,
+    outputSchema: TriggerInboxItemSchema,
+    formatter: triggerInboxItemFormatter,
+    resolvers: { inbox: triggerInboxResolver },
+    handler: async ({ sdk: sdk2, options }) => {
+      const { inbox } = options;
+      const inboxId = await resolveTriggerInboxId({
+        api: sdk2.context.api,
+        inbox
+      });
+      const rawResponse = await sdk2.context.api.post(
+        `/trigger-inbox/api/v1/inboxes/${encodeURIComponent(inboxId)}/pause`,
+        void 0,
+        {
+          authRequired: true,
+          resource: { type: "trigger_inbox", id: inboxId }
+        }
+      );
+      return { data: TriggerInboxItemSchema.parse(rawResponse) };
+    }
+  })
+);
+var ResumeTriggerInboxSchema = z.object({
+  inbox: TriggerInboxPropertySchema
+}).describe("Resume a paused trigger inbox; events resume being collected");
+
+// src/plugins/triggers/resumeTriggerInbox/index.ts
+var resumeTriggerInboxPlugin = definePlugin(
+  (sdk) => createPluginMethod(sdk, {
+    ...triggersDefaults,
+    name: "resumeTriggerInbox",
+    type: "update",
+    itemType: "TriggerInbox",
+    inputSchema: ResumeTriggerInboxSchema,
+    outputSchema: TriggerInboxItemSchema,
+    formatter: triggerInboxItemFormatter,
+    resolvers: { inbox: triggerInboxResolver },
+    handler: async ({ sdk: sdk2, options }) => {
+      const { inbox } = options;
+      const inboxId = await resolveTriggerInboxId({
+        api: sdk2.context.api,
+        inbox
+      });
+      const rawResponse = await sdk2.context.api.post(
+        `/trigger-inbox/api/v1/inboxes/${encodeURIComponent(inboxId)}/resume`,
+        void 0,
+        {
+          authRequired: true,
+          resource: { type: "trigger_inbox", id: inboxId }
+        }
+      );
+      return { data: TriggerInboxItemSchema.parse(rawResponse) };
+    }
+  })
+);
+var TriggerMessageStatusSchema = z.union([z.enum(["available", "leased", "acked", "quarantined"]), z.string()]).describe("Message lifecycle status");
+var TriggerMessageAttributesSchema = z.object({
+  lease_count: z.number().int(),
+  error_message: z.string().nullable(),
+  possible_duplicate_data: z.boolean()
+});
+var TriggerMessageItemSchema = z.object({
+  id: z.string(),
+  created_at: z.string(),
+  status: TriggerMessageStatusSchema,
+  message_attributes: TriggerMessageAttributesSchema
+});
+var LeasedTriggerMessageItemSchema = TriggerMessageItemSchema.extend({
+  payload: z.record(z.string(), z.unknown())
+});
+
+// src/plugins/triggers/listTriggerInboxMessages/schemas.ts
+var ListTriggerInboxMessagesSchema = z.object({
+  inbox: TriggerInboxPropertySchema,
+  pageSize: z.number().int().min(1).optional().describe("Number of messages per page"),
+  maxItems: z.number().int().min(1).optional().describe("Maximum total items to return across all pages"),
+  cursor: z.string().optional().describe("Pagination cursor")
+}).describe("List messages in a trigger inbox (no payload, status-only)");
+var ListTriggerInboxMessagesApiResponseSchema = z.object({
+  next: z.string().nullable().optional(),
+  previous: z.string().nullable().optional(),
+  results: z.array(TriggerMessageItemSchema)
+});
+
+// src/formatters/triggerMessage.ts
+function buildBaseDetails(item) {
+  const details = [
+    { text: `Status: ${item.status}`, style: "dim" },
+    {
+      text: `Lease count: ${item.message_attributes.lease_count}`,
+      style: "dim"
+    }
+  ];
+  if (item.message_attributes.error_message) {
+    details.push({
+      text: `Error: ${item.message_attributes.error_message}`,
+      style: "warning"
+    });
+  }
+  if (item.message_attributes.possible_duplicate_data) {
+    details.push({ text: "Possible duplicate data", style: "warning" });
+  }
+  return details;
+}
+var triggerMessageItemFormatter = {
+  format: (item) => ({
+    title: `Message ${item.id}`,
+    id: item.id,
+    details: buildBaseDetails(item)
+  })
+};
+
+// src/plugins/triggers/listTriggerInboxMessages/index.ts
+var listTriggerInboxMessagesPlugin = definePlugin(
+  (sdk) => createPaginatedPluginMethod(sdk, {
+    ...triggersDefaults,
+    ...zapierPagination,
+    name: "listTriggerInboxMessages",
+    type: "list",
+    itemType: "TriggerMessage",
+    inputSchema: ListTriggerInboxMessagesSchema,
+    outputSchema: TriggerMessageItemSchema,
+    formatter: triggerMessageItemFormatter,
+    defaultPageSize: DEFAULT_PAGE_SIZE,
+    resolvers: { inbox: triggerInboxResolver },
+    handler: async ({ sdk: sdk2, options }) => {
+      const { inbox, cursor, pageSize } = options;
+      const inboxId = await resolveTriggerInboxId({
+        api: sdk2.context.api,
+        inbox
+      });
+      const searchParams = {};
+      if (pageSize !== void 0) {
+        searchParams.limit = pageSize.toString();
+      }
+      if (cursor) {
+        searchParams.cursor = cursor;
+      }
+      const rawResponse = await sdk2.context.api.get(
+        `/trigger-inbox/api/v1/inboxes/${encodeURIComponent(inboxId)}/messages`,
+        { searchParams, authRequired: true }
+      );
+      const response = ListTriggerInboxMessagesApiResponseSchema.parse(rawResponse);
+      return {
+        data: response.results,
+        next: response.next ?? null
+      };
+    }
+  })
+);
+var LeaseTriggerInboxMessagesSchema = z.object({
+  inbox: TriggerInboxPropertySchema,
+  leaseLimit: LeaseLimitPropertySchema.optional(),
+  leaseSeconds: LeaseSecondsPropertySchema.optional(),
+  signal: z.custom((v) => v instanceof AbortSignal).optional().describe(
+    "Abort signal forwarded to the lease HTTP request. Aborting causes the in-flight request to reject with AbortError."
+  )
+}).describe(
+  "Lease up to N messages from a trigger inbox. Returns messages plus a lease ID; ack within the lease window to remove from the inbox."
+);
+var InboxAttributesSchema = z.object({
+  status: TriggerInboxStatusSchema,
+  paused_reason: TriggerInboxPausedReasonSchema.nullable()
+});
+var LeaseTriggerInboxMessagesItemSchema = z.object({
+  lease_id: z.string().nullable(),
+  leased_until: z.string().nullable(),
+  results: z.array(LeasedTriggerMessageItemSchema),
+  inbox_attributes: InboxAttributesSchema
+});
+
+// src/plugins/triggers/leaseTriggerInboxMessages/index.ts
+function parseLeaseConflict(data) {
+  if (typeof data !== "object" || data === null) return {};
+  const detail = data.detail;
+  const inboxAttributes = data.inbox_attributes;
+  let pausedReason;
+  if (typeof inboxAttributes === "object" && inboxAttributes !== null) {
+    const pr = inboxAttributes.paused_reason;
+    if (typeof pr === "string" && pr.length > 0) pausedReason = pr;
+  }
+  return {
+    detail: typeof detail === "string" ? detail : void 0,
+    pausedReason
+  };
+}
+var leaseTriggerInboxMessagesPlugin = definePlugin(
+  (sdk) => createPluginMethod(sdk, {
+    ...triggersDefaults,
+    name: "leaseTriggerInboxMessages",
+    type: "create",
+    itemType: "TriggerInboxLease",
+    inputSchema: LeaseTriggerInboxMessagesSchema,
+    outputSchema: LeaseTriggerInboxMessagesItemSchema,
+    resolvers: {
+      inbox: triggerInboxResolver,
+      leaseLimit: { type: "static", inputType: "text" },
+      leaseSeconds: { type: "static", inputType: "text" }
+    },
+    handler: async ({ sdk: sdk2, options }) => {
+      const { inbox, leaseLimit, leaseSeconds, signal } = options;
+      const inboxId = await resolveTriggerInboxId({
+        api: sdk2.context.api,
+        inbox
+      });
+      const requestBody = {};
+      if (leaseLimit !== void 0) {
+        requestBody.lease_limit = leaseLimit;
+      }
+      if (leaseSeconds !== void 0) {
+        requestBody.lease_seconds = leaseSeconds;
+      }
+      const rawResponse = await sdk2.context.api.post(
+        `/trigger-inbox/api/v1/inboxes/${encodeURIComponent(inboxId)}/messages/lease`,
+        requestBody,
+        {
+          authRequired: true,
+          signal,
+          customErrorHandler: ({ status, data }) => {
+            if (status !== 409) return void 0;
+            const { detail, pausedReason } = parseLeaseConflict(data);
+            const baseMessage = detail ?? "Inbox is paused and fully drained";
+            const message = pausedReason ? `${baseMessage} (paused_reason: ${pausedReason})` : baseMessage;
+            return new ZapierConflictError(message, {
+              statusCode: status,
+              resourceType: "trigger_inbox"
+            });
+          }
+        }
+      );
+      return { data: LeaseTriggerInboxMessagesItemSchema.parse(rawResponse) };
+    }
+  })
+);
+var AckTriggerInboxMessagesSchema = z.object({
+  inbox: TriggerInboxPropertySchema,
+  lease: LeasePropertySchema,
+  messages: z.array(z.string().min(1)).optional().describe(
+    "Specific message IDs to ack. Omit to ack every message in the lease."
+  )
+}).describe(
+  "Acknowledge messages from a lease. Acked messages are removed from the inbox; unacked ones return to the available pool when the lease expires."
+);
+var AckTriggerInboxMessagesItemSchema = z.object({
+  acked_id: z.string().nullable(),
+  results: z.array(TriggerMessageItemSchema)
+});
+
+// src/plugins/triggers/ackTriggerInboxMessages/index.ts
+var ackTriggerInboxMessagesPlugin = definePlugin(
+  (sdk) => createPluginMethod(sdk, {
+    ...triggersDefaults,
+    name: "ackTriggerInboxMessages",
+    type: "create",
+    itemType: "TriggerInboxAck",
+    inputSchema: AckTriggerInboxMessagesSchema,
+    outputSchema: AckTriggerInboxMessagesItemSchema,
+    resolvers: {
+      inbox: triggerInboxResolver,
+      // No way to look up a lease — leases are short-lived, only the
+      // most recent leaseTriggerInboxMessages caller knows the ID.
+      // Static resolver prompts for free-text input.
+      lease: { type: "static", inputType: "text" },
+      messages: triggerMessagesResolver
+    },
+    handler: async ({ sdk: sdk2, options }) => {
+      const { inbox, lease, messages } = options;
+      const inboxId = await resolveTriggerInboxId({
+        api: sdk2.context.api,
+        inbox
+      });
+      const requestBody = {
+        lease_id: lease
+      };
+      if (messages !== void 0) {
+        requestBody.message_ids = messages;
+      }
+      const rawResponse = await sdk2.context.api.post(
+        `/trigger-inbox/api/v1/inboxes/${encodeURIComponent(inboxId)}/messages/ack`,
+        requestBody,
+        { authRequired: true }
+      );
+      return { data: AckTriggerInboxMessagesItemSchema.parse(rawResponse) };
+    }
+  })
+);
+var ReleaseTriggerInboxMessagesSchema = z.object({
+  inbox: TriggerInboxPropertySchema,
+  lease: LeasePropertySchema,
+  messages: z.array(z.string().min(1)).optional().describe(
+    "Specific message IDs to release. Omit to release every message in the lease."
+  )
+}).describe(
+  "Release messages from a lease back to the inbox without acknowledging them. Released messages become immediately available for re-leasing. The lease attempt still counts against the per-message lease limit; releasing does not refund the attempt."
+);
+var ReleaseTriggerInboxMessagesItemSchema = z.object({
+  released_id: z.string().nullable(),
+  results: z.array(TriggerMessageItemSchema)
+});
+
+// src/plugins/triggers/releaseTriggerInboxMessages/index.ts
+var releaseTriggerInboxMessagesPlugin = definePlugin(
+  (sdk) => createPluginMethod(sdk, {
+    ...triggersDefaults,
+    name: "releaseTriggerInboxMessages",
+    type: "create",
+    itemType: "TriggerInboxRelease",
+    inputSchema: ReleaseTriggerInboxMessagesSchema,
+    outputSchema: ReleaseTriggerInboxMessagesItemSchema,
+    resolvers: {
+      inbox: triggerInboxResolver,
+      // No way to look up a lease — leases are short-lived, only the
+      // most recent leaseTriggerInboxMessages caller knows the ID.
+      // Static resolver prompts for free-text input.
+      lease: { type: "static", inputType: "text" },
+      messages: triggerMessagesResolver
+    },
+    handler: async ({ sdk: sdk2, options }) => {
+      const { inbox, lease, messages } = options;
+      const inboxId = await resolveTriggerInboxId({
+        api: sdk2.context.api,
+        inbox
+      });
+      const requestBody = {
+        lease_id: lease
+      };
+      if (messages !== void 0) {
+        requestBody.message_ids = messages;
+      }
+      const rawResponse = await sdk2.context.api.post(
+        `/trigger-inbox/api/v1/inboxes/${encodeURIComponent(inboxId)}/messages/release`,
+        requestBody,
+        { authRequired: true }
+      );
+      return {
+        data: ReleaseTriggerInboxMessagesItemSchema.parse(rawResponse)
+      };
+    }
+  })
+);
+
+// src/plugins/triggers/drainTriggerInbox/pipeline.ts
+function createBatchTracker() {
+  const batches = /* @__PURE__ */ new Map();
+  return {
+    addBatch(id, total) {
+      batches.set(id, { total, inFlight: 0, completed: 0 });
+    },
+    markInFlight(id) {
+      const e = batches.get(id);
+      if (e) e.inFlight++;
+    },
+    /** Decrement inFlight and increment completed. Paired with markInFlight. */
+    markCompleted(id) {
+      const e = batches.get(id);
+      if (!e) return;
+      e.inFlight--;
+      e.completed++;
+    },
+    /** Drop the batch once all items completed; tracker stays small over long drains. */
+    finalizeIfDone(id) {
+      const e = batches.get(id);
+      if (e && e.completed === e.total) batches.delete(id);
+    },
+    inFlightTotal() {
+      let n = 0;
+      for (const e of batches.values()) n += e.inFlight;
+      return n;
+    },
+    /** Items leased but not yet completed (queued + in-flight). */
+    pipelineSize() {
+      let n = 0;
+      for (const e of batches.values()) n += e.total - e.completed;
+      return n;
+    }
+  };
+}
+function createWaiter() {
+  const make = () => {
+    let signal;
+    const promise = new Promise((r) => {
+      signal = r;
+    });
+    return { promise, signal };
+  };
+  let current = make();
+  return {
+    wait: () => current.promise,
+    notifyAll: () => {
+      const prev = current;
+      current = make();
+      prev.signal();
+    }
+  };
+}
+function addToMap(m, key2, value) {
+  const existing = m.get(key2) ?? [];
+  m.set(key2, [...existing, value]);
+}
+async function runBatchedDrainPipeline(options) {
+  const {
+    concurrency,
+    maxItems,
+    leaseSize,
+    fetchBatch,
+    processItem,
+    ackItem,
+    releaseItems
+  } = options;
+  const tracker = createBatchTracker();
+  const waiter = createWaiter();
+  const accumulated = [];
+  const pendingReleases = /* @__PURE__ */ new Map();
+  const queue = [];
+  let totalProcessed = 0;
+  let aborted = false;
+  let exhausted = false;
+  let fetchInProgress = false;
+  let fetchError = void 0;
+  async function tryFetch() {
+    if (fetchInProgress || exhausted || aborted) return;
+    const remainingCap = maxItems !== void 0 ? maxItems - totalProcessed - tracker.pipelineSize() : Number.POSITIVE_INFINITY;
+    if (remainingCap <= 0) return;
+    const requestedSize = Math.min(remainingCap, leaseSize);
+    fetchInProgress = true;
+    try {
+      const result = await fetchBatch(requestedSize);
+      if (result === "exhausted") {
+        exhausted = true;
+        return;
+      }
+      tracker.addBatch(result.id, result.items.length);
+      for (const item of result.items) {
+        queue.push({ item, batchId: result.id });
+      }
+    } catch (err) {
+      fetchError = err;
+      exhausted = true;
+    } finally {
+      fetchInProgress = false;
+      waiter.notifyAll();
+    }
+  }
+  async function processQueueEntry(entry) {
+    tracker.markInFlight(entry.batchId);
+    try {
+      const result = await processItem(entry.item);
+      accumulated.push(result.value);
+      totalProcessed++;
+      if (result.action === "release") {
+        addToMap(pendingReleases, entry.batchId, entry.item.id);
+      }
+      if (result.abort) aborted = true;
+      if (result.action === "ack") {
+        await ackItem(entry.batchId, entry.item.id);
+      }
+    } finally {
+      tracker.markCompleted(entry.batchId);
+      tracker.finalizeIfDone(entry.batchId);
+      waiter.notifyAll();
+    }
+  }
+  async function worker() {
+    while (true) {
+      if (aborted) return;
+      if (maxItems !== void 0 && totalProcessed >= maxItems) return;
+      const entry = queue.shift();
+      if (entry !== void 0) {
+        if (tracker.pipelineSize() < concurrency && !fetchInProgress && !exhausted) {
+          void tryFetch();
+        }
+        await processQueueEntry(entry);
+        continue;
+      }
+      if (!exhausted && !fetchInProgress) void tryFetch();
+      if (queue.length === 0 && !fetchInProgress && (exhausted || aborted) && tracker.inFlightTotal() === 0) {
+        return;
+      }
+      await waiter.wait();
+    }
+  }
+  await tryFetch();
+  if (fetchError !== void 0) throw fetchError;
+  let cleanupError = void 0;
+  try {
+    if (!exhausted || queue.length > 0) {
+      let firstWorkerError = void 0;
+      const workers = Array.from(
+        { length: concurrency },
+        () => worker().catch((err) => {
+          if (firstWorkerError === void 0) firstWorkerError = err;
+        })
+      );
+      await Promise.all(workers);
+      if (firstWorkerError !== void 0) throw firstWorkerError;
+    }
+    if (fetchError !== void 0) throw fetchError;
+  } finally {
+    while (queue.length > 0) {
+      const entry = queue.shift();
+      addToMap(pendingReleases, entry.batchId, entry.item.id);
+    }
+    for (const [batchId, itemIds] of pendingReleases) {
+      try {
+        await releaseItems(batchId, itemIds);
+      } catch (err) {
+        cleanupError ?? (cleanupError = err);
+      }
+    }
+  }
+  if (cleanupError !== void 0) throw cleanupError;
+  return accumulated;
+}
+
+// src/plugins/triggers/drainTriggerInbox/index.ts
+var nonRetryableDrainErrors = /* @__PURE__ */ new WeakSet();
+function markNonRetryableDrainError(err) {
+  if (typeof err === "object" && err !== null) {
+    nonRetryableDrainErrors.add(err);
+  }
+  return err;
+}
+function isNonRetryableDrainError(err) {
+  return typeof err === "object" && err !== null && nonRetryableDrainErrors.has(err);
+}
+function isLeaseExpiredError(err) {
+  if (!(err instanceof ZapierValidationError)) return false;
+  return err.errors?.some((e) => e.code === "lease_expired") ?? false;
+}
+async function runDrainPass(options) {
+  const {
+    sdk,
+    inboxId,
+    onMessage,
+    concurrency,
+    leaseLimit,
+    leaseSeconds,
+    maxMessages,
+    releaseOnError,
+    continueOnError,
+    onError,
+    signal
+  } = options;
+  let firstFetch = options.firstFetch;
+  let abortedFromCallback = false;
+  let handlerErrorCaptured = false;
+  let firstHandlerError = void 0;
+  const outcomes = await runBatchedDrainPipeline({
+    concurrency,
+    maxItems: maxMessages,
+    leaseSize: leaseLimit,
+    fetchBatch: async (requestedSize) => {
+      if (signal?.aborted) return "exhausted";
+      let lease;
+      try {
+        ({ data: lease } = await sdk.leaseTriggerInboxMessages({
+          inbox: inboxId,
+          leaseLimit: requestedSize,
+          leaseSeconds,
+          signal
+        }));
+      } catch (err) {
+        if (signal?.aborted && isAbortError(err)) return "exhausted";
+        throw err;
+      }
+      if (lease.results.length === 0) {
+        if (firstFetch && lease.inbox_attributes.status === "initialization_failure") {
+          throw markNonRetryableDrainError(
+            new ZapierApiError(
+              `Trigger inbox ${inboxId} is in initialization_failure state \u2014 inspect via getTriggerInbox.`
+            )
+          );
+        }
+        firstFetch = false;
+        return "exhausted";
+      }
+      firstFetch = false;
+      if (!lease.lease_id) return "exhausted";
+      return { id: lease.lease_id, items: lease.results };
+    },
+    processItem: async (message) => {
+      if (signal?.aborted) {
+        return {
+          value: message,
+          action: "release",
+          abort: true
+        };
+      }
+      try {
+        await onMessage(message);
+        return { value: message, action: "ack" };
+      } catch (err) {
+        let action = "ignore";
+        let abort = false;
+        if (err instanceof ZapierAbortDrainSignal) {
+          abort = true;
+          abortedFromCallback = true;
+          if (releaseOnError) action = "release";
+        } else if (err instanceof ZapierReleaseTriggerMessageSignal) {
+          action = "release";
+        } else if (releaseOnError) {
+          action = "release";
+        }
+        if (onError && !(err instanceof ZapierSignal)) {
+          try {
+            await onError(err, message);
+          } catch {
+          }
+        }
+        if (!continueOnError && !(err instanceof ZapierSignal)) {
+          if (!handlerErrorCaptured) {
+            firstHandlerError = err;
+            handlerErrorCaptured = true;
+          }
+          abort = true;
+        }
+        return { value: message, action, abort };
+      }
+    },
+    ackItem: async (leaseId, messageId) => {
+      try {
+        await sdk.ackTriggerInboxMessages({
+          inbox: inboxId,
+          lease: leaseId,
+          messages: [messageId]
+        });
+      } catch (err) {
+        if (!isLeaseExpiredError(err)) throw err;
+      }
+    },
+    releaseItems: async (leaseId, messageIds) => {
+      try {
+        await sdk.releaseTriggerInboxMessages({
+          inbox: inboxId,
+          lease: leaseId,
+          messages: messageIds
+        });
+      } catch (err) {
+        if (!isLeaseExpiredError(err)) throw err;
+      }
+    }
+  });
+  if (handlerErrorCaptured) {
+    throw markNonRetryableDrainError(firstHandlerError);
+  }
+  return { abortedFromCallback, processed: outcomes.length };
+}
+function requireOnMessage(onMessage) {
+  if (typeof onMessage !== "function") {
+    throw new ZapierValidationError("onMessage is required.");
+  }
+  return onMessage;
+}
+function resolveConcurrencyAndLease(options) {
+  const concurrency = options.concurrency ?? options.leaseLimit ?? 1;
+  const leaseLimit = options.leaseLimit ?? concurrency;
+  return { concurrency, leaseLimit };
+}
+var drainTriggerInboxPlugin = definePlugin(
+  (sdk) => {
+    async function drainTriggerInbox(options) {
+      const onMessage = requireOnMessage(options.onMessage);
+      const { concurrency, leaseLimit } = resolveConcurrencyAndLease(options);
+      const inboxId = await resolveTriggerInboxId({
+        api: sdk.context.api,
+        inbox: options.inbox
+      });
+      await runDrainPass({
+        sdk,
+        inboxId,
+        onMessage,
+        concurrency,
+        leaseLimit,
+        leaseSeconds: options.leaseSeconds,
+        maxMessages: options.maxMessages,
+        releaseOnError: options.releaseOnError ?? false,
+        continueOnError: options.continueOnError ?? false,
+        onError: options.onError,
+        signal: options.signal,
+        firstFetch: true
+      });
+    }
+    return {
+      drainTriggerInbox,
+      context: {
+        meta: {
+          drainTriggerInbox: {
+            ...triggersDefaults,
+            type: "create",
+            description: "Drain an existing trigger inbox: lease currently-available messages, process each via onMessage, return when the inbox is empty, maxMessages is reached, or the abort signal fires.",
+            itemType: "void",
+            // The doc generator's default for type="create" + itemType
+            // appends "Item" (e.g. "RecordItem"), which would render
+            // "voidItem" here. drainTriggerInbox returns Promise<void>,
+            // so we override.
+            returnType: "void",
+            inputSchema: DrainTriggerInboxSchema,
+            resolvers: {
+              inbox: triggerInboxResolver
+            },
+            // Returns Promise<void>; the CLI ships a hand-written
+            // drain-trigger-inbox plugin that adds presentation flags
+            // (interactive, --json, etc.) around this command.
+            packages: ["sdk"]
+          }
+        }
+      }
+    };
+  }
+);
+
+// src/plugins/triggers/watchTriggerInbox/sse.ts
+async function* readInboxEvents({
+  api,
+  inboxId,
+  signal,
+  onOpen
+}) {
+  for await (const message of api.fetchJsonStream(
+    `/trigger-inbox/api/v1/inboxes/${encodeURIComponent(inboxId)}/events`,
+    { method: "GET", signal, authRequired: true, onOpen }
+  )) {
+    if (!message.parsed) continue;
+    const parsed = message.data;
+    if (typeof parsed === "object" && parsed !== null && typeof parsed.inbox_id === "string" && // Only wake on a frame for this inbox. Case-insensitive: the endpoint
+    // echoes the canonical lowercase UUID, but resolveTriggerInboxId passes
+    // a UUID-shaped `inbox` through unchanged, so its casing may differ.
+    parsed.inbox_id.toLowerCase() === inboxId.toLowerCase()) {
+      yield parsed;
+    }
+  }
+}
+
+// src/plugins/triggers/watchTriggerInbox/index.ts
+var SSE_RECONNECT_BACKOFF_MS = [500, 1e3, 2e3, 5e3];
+var DEFAULT_SAFETY_DRAIN_INTERVAL_MS = 3e5;
+var SSE_HEALTHY_CONNECTION_MS = 5e3;
+var ERROR_BACKOFF_CAP = 4;
+function createDrainLatch() {
+  let pending = false;
+  const make = () => {
+    let resolve2;
+    const promise = new Promise((r) => {
+      resolve2 = r;
+    });
+    return { promise, resolve: resolve2 };
+  };
+  let current = make();
+  return {
+    request() {
+      pending = true;
+      const prev = current;
+      current = make();
+      prev.resolve();
+    },
+    async waitForRequest() {
+      if (pending) {
+        pending = false;
+        return;
+      }
+      await current.promise;
+      pending = false;
+    }
+  };
+}
+async function drainRunner({
+  drainOptions,
+  drainRequest,
+  signal,
+  inboxId,
+  debug
+}) {
+  let firstFetch = true;
+  let consecutiveErrors = 0;
+  let errorAttempts = 0;
+  let drainDegraded = false;
+  while (!signal.aborted) {
+    await drainRequest.waitForRequest();
+    if (signal.aborted) return { kind: "aborted" };
+    let abortedFromCallback = false;
+    try {
+      ({ abortedFromCallback } = await runDrainPass({
+        ...drainOptions,
+        firstFetch
+      }));
+    } catch (error) {
+      if (signal.aborted) return { kind: "aborted" };
+      const isNonObjectThrow = typeof error !== "object" || error === null;
+      if (isNonObjectThrow || isNonRetryableDrainError(error) || isPermanentHttpError(error)) {
+        return { kind: "error", error };
+      }
+      consecutiveErrors = Math.min(consecutiveErrors + 1, ERROR_BACKOFF_CAP);
+      errorAttempts += 1;
+      const delay = calculateErrorBackoffMs(
+        BASE_ERROR_BACKOFF_MS,
+        consecutiveErrors
+      );
+      const statusCode = errorStatusCode(error);
+      const httpPart = statusCode !== void 0 ? ` (HTTP ${statusCode})` : "";
+      if (!drainDegraded && consecutiveErrors >= ERROR_BACKOFF_CAP) {
+        console.warn(
+          `[zapier-sdk] Draining inbox ${inboxId}${httpPart} is failing repeatedly: ${errorMessage(error)}. Continuing to retry with backoff.`
+        );
+        drainDegraded = true;
+      }
+      if (debug) {
+        console.error(
+          `[zapier-sdk] Retrying drain for inbox ${inboxId} (attempt ${errorAttempts}, retry in ${delay}ms)${httpPart}: ${errorMessage(error)}`
+        );
+      }
+      await sleep(delay, signal);
+      if (signal.aborted) return { kind: "aborted" };
+      drainRequest.request();
+      continue;
+    }
+    firstFetch = false;
+    consecutiveErrors = 0;
+    errorAttempts = 0;
+    drainDegraded = false;
+    if (abortedFromCallback) return { kind: "abortedFromCallback" };
+  }
+  return { kind: "aborted" };
+}
+function errorStatusCode(err) {
+  return err instanceof ZapierError ? err.statusCode : void 0;
+}
+function errorMessage(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+async function sseLoop({
+  api,
+  inboxId,
+  drainRequest,
+  safetyDrainMs,
+  signal,
+  debug
+}) {
+  let attempt = 0;
+  let degraded = false;
+  while (!signal.aborted) {
+    let connected = false;
+    let connectedAt = 0;
+    let transientError;
+    try {
+      for await (const _event of readInboxEvents({
+        api,
+        inboxId,
+        signal,
+        // SSE is edge-triggered with no replay, so draining on connect is the
+        // only way to pick up messages that arrived before this connection —
+        // including the window left by a prior disconnect.
+        onOpen: () => {
+          connected = true;
+          connectedAt = Date.now();
+          degraded = false;
+          drainRequest.request();
+        }
+      })) {
+        drainRequest.request();
+      }
+      if (connected && Date.now() - connectedAt >= SSE_HEALTHY_CONNECTION_MS) {
+        attempt = 0;
+      }
+    } catch (err) {
+      if (signal.aborted || isAbortError(err)) return;
+      if (isPermanentHttpError(err)) {
+        if (!degraded) {
+          const statusCode = errorStatusCode(err);
+          const errorMsg = errorMessage(err);
+          const httpPart = statusCode !== void 0 ? ` (HTTP ${statusCode})` : "";
+          console.warn(
+            `[zapier-sdk] Real-time wake-ups for inbox ${inboxId}${httpPart} paused: ${errorMsg}. Falling back to the periodic safety drain.`
+          );
+          degraded = true;
+        }
+        attempt = 0;
+        if (signal.aborted) return;
+        await sleep(safetyDrainMs, signal);
+        continue;
+      }
+      if (connected) attempt = 0;
+      transientError = err;
+    }
+    if (signal.aborted) return;
+    const delay = SSE_RECONNECT_BACKOFF_MS[Math.min(attempt, SSE_RECONNECT_BACKOFF_MS.length - 1)];
+    attempt = Math.min(attempt + 1, SSE_RECONNECT_BACKOFF_MS.length - 1);
+    if (transientError !== void 0 && debug) {
+      const statusCode = errorStatusCode(transientError);
+      const errorMsg = errorMessage(transientError);
+      const httpPart = statusCode !== void 0 ? ` (HTTP ${statusCode})` : "";
+      console.error(
+        `[zapier-sdk] Reconnecting real-time wake-ups for inbox ${inboxId} (attempt ${attempt}, retry in ${delay}ms)${httpPart}: ${errorMsg}`
+      );
+    }
+    await sleep(delay, signal);
+  }
+}
+async function safetyTimerLoop({
+  safetyDrainMs,
+  drainRequest,
+  signal
+}) {
+  while (!signal.aborted) {
+    await sleep(safetyDrainMs, signal);
+    if (signal.aborted) return;
+    drainRequest.request();
+  }
+}
+var watchTriggerInboxPlugin = definePlugin(
+  (sdk) => {
+    async function watchTriggerInbox(options) {
+      const onMessage = requireOnMessage(options.onMessage);
+      const { concurrency, leaseLimit } = resolveConcurrencyAndLease(options);
+      const inboxId = await resolveTriggerInboxId({
+        api: sdk.context.api,
+        inbox: options.inbox
+      });
+      if (options.signal?.aborted) return;
+      const safetyDrainMs = options.maxDrainIntervalSeconds !== void 0 ? options.maxDrainIntervalSeconds * 1e3 : DEFAULT_SAFETY_DRAIN_INTERVAL_MS;
+      const stop = new AbortController();
+      const combined = combineAbortSignals({
+        handles: [
+          ...options.signal ? [{ signal: options.signal, dispose: () => {
+          } }] : [],
+          { signal: stop.signal, dispose: () => {
+          } }
+        ]
+      });
+      const signal = combined?.signal ?? stop.signal;
+      const drainRequest = createDrainLatch();
+      signal.addEventListener("abort", () => drainRequest.request(), {
+        once: true
+      });
+      const debug = sdk.context.options.debug === true;
+      const drainOptions = {
+        sdk,
+        inboxId,
+        onMessage,
+        concurrency,
+        leaseLimit,
+        leaseSeconds: options.leaseSeconds,
+        maxMessages: void 0,
+        releaseOnError: options.releaseOnError ?? false,
+        continueOnError: options.continueOnError ?? false,
+        onError: options.onError,
+        signal
+      };
+      drainRequest.request();
+      const runnerDone = drainRunner({
+        drainOptions,
+        drainRequest,
+        signal,
+        inboxId,
+        debug
+      });
+      const sseDone = sseLoop({
+        api: sdk.context.api,
+        inboxId,
+        drainRequest,
+        safetyDrainMs,
+        signal,
+        debug
+      }).catch(() => {
+      });
+      const safetyDone = safetyTimerLoop({
+        safetyDrainMs,
+        drainRequest,
+        signal
+      }).catch(() => {
+      });
+      let end;
+      try {
+        end = await runnerDone;
+      } finally {
+        stop.abort();
+        await Promise.all([sseDone, safetyDone]);
+        combined?.dispose();
+      }
+      if (end.kind === "error") throw end.error;
+    }
+    return {
+      watchTriggerInbox,
+      context: {
+        meta: {
+          watchTriggerInbox: {
+            ...triggersDefaults,
+            type: "create",
+            description: "Continuously consume a trigger inbox: drain currently-available messages via onMessage, then subscribe to SSE notifications for new arrivals until aborted. A periodic safety drain runs every maxDrainIntervalSeconds (default: 300) to guarantee forward progress if SSE events are missed. Resolves cleanly on signal abort or ZapierAbortDrainSignal from a handler. Transient drain failures (5xx, 429, network blips) retry indefinitely with bounded backoff until they succeed or the watch is aborted; it rejects on a fail-fast handler error, an initialization_failure, or a permanent HTTP error. Real-time wake-up health is reported on stderr: a warning when wake-ups pause and the watch falls back to the safety drain, plus (with debug) transient reconnect notices. Persistent drain failures likewise warn once on stderr while bounded-backoff retries continue.",
+            itemType: "void",
+            // See drainTriggerInbox: override the doc generator's default
+            // suffix so the rendered return type is Promise<void>, not
+            // Promise<voidItem>.
+            returnType: "void",
+            inputSchema: WatchTriggerInboxSchema,
+            resolvers: {
+              inbox: triggerInboxResolver
+            },
+            packages: ["sdk"]
+          }
+        }
+      }
+    };
+  }
+);
+var ListTriggersSchema = z.object({
+  app: AppPropertySchema.describe(
+    "App key of triggers to list (e.g., 'SlackCLIAPI' or slug like 'github')"
+  ),
+  pageSize: z.number().min(1).optional().describe("Number of triggers per page"),
+  maxItems: z.number().min(1).optional().describe("Maximum total items to return across all pages"),
+  cursor: z.string().optional().describe("Cursor to start from")
+}).describe("List all triggers for a specific app");
+
+// src/plugins/triggers/listTriggers/index.ts
+var listTriggersPlugin = definePlugin(
+  (sdk) => createPaginatedPluginMethod(sdk, {
+    ...triggersDefaults,
+    name: "listTriggers",
+    type: "list",
+    itemType: "Action",
+    inputSchema: ListTriggersSchema,
+    outputSchema: ActionItemSchema,
+    formatter: actionItemFormatter,
+    defaultPageSize: DEFAULT_PAGE_SIZE,
+    resolvers: { app: appKeyResolver },
+    handler: async ({ sdk: sdk2, options }) => {
+      return await sdk2.listActions({
+        ...options,
+        actionType: "read"
+      });
+    }
+  })
+);
+var ListTriggerInputFieldsSchema = z.object({
+  app: AppPropertySchema,
+  action: ActionPropertySchema,
+  connection: ConnectionPropertySchema.optional().describe(
+    "Connection alias or connection ID. Required if the trigger needs a connection to determine available fields."
+  ),
+  inputs: InputsPropertySchema.optional().describe(
+    "Current input values that may affect available fields"
+  ),
+  pageSize: z.number().min(1).optional().describe("Number of input fields per page"),
+  maxItems: z.number().min(1).optional().describe("Maximum total items to return across all pages"),
+  cursor: z.string().optional().describe("Cursor to start from")
+}).describe("Get the input fields required for a specific trigger");
+
+// src/plugins/triggers/listTriggerInputFields/index.ts
+var listTriggerInputFieldsPlugin = definePlugin(
+  (sdk) => createPaginatedPluginMethod(sdk, {
+    ...triggersDefaults,
+    name: "listTriggerInputFields",
+    type: "list",
+    itemType: "RootField",
+    inputSchema: ListTriggerInputFieldsSchema,
+    outputSchema: RootFieldItemSchema,
+    formatter: rootFieldItemFormatter,
+    defaultPageSize: DEFAULT_PAGE_SIZE,
+    // actionKeyResolver and inputsAllOptionalResolver depend on actionType.
+    // Pin it to "read" so they resolve correctly without the user setting it.
+    resolvers: {
+      app: appKeyResolver,
+      action: actionKeyResolver,
+      connection: connectionIdResolver,
+      inputs: inputsAllOptionalResolver,
+      actionType: { type: "constant", value: "read" }
+    },
+    handler: async ({ sdk: sdk2, options }) => {
+      return await sdk2.listActionInputFields({
+        ...options,
+        actionType: "read"
+      });
+    }
+  })
+);
+var ListTriggerInputFieldChoicesSchema = z.object({
+  app: AppPropertySchema,
+  action: ActionPropertySchema,
+  inputField: InputFieldPropertySchema,
+  connection: ConnectionPropertySchema.optional().describe(
+    "Connection alias or connection ID. Required if the trigger needs a connection to populate dynamic dropdown options."
+  ),
+  inputs: InputsPropertySchema.optional().describe(
+    "Current input values that may affect available choices"
+  ),
+  page: z.number().int().min(0).optional().describe("Page number for paginated results"),
+  pageSize: z.number().min(1).optional().describe("Number of choices per page"),
+  maxItems: z.number().min(1).optional().describe("Maximum total items to return across all pages"),
+  cursor: z.string().optional().describe("Cursor to start from")
+}).describe(
+  "Get the available choices for a dynamic dropdown input field on a trigger"
+);
+
+// src/plugins/triggers/listTriggerInputFieldChoices/index.ts
+var listTriggerInputFieldChoicesPlugin = definePlugin(
+  (sdk) => createPaginatedPluginMethod(sdk, {
+    ...triggersDefaults,
+    name: "listTriggerInputFieldChoices",
+    type: "list",
+    itemType: "InputFieldChoice",
+    inputSchema: ListTriggerInputFieldChoicesSchema,
+    outputSchema: InputFieldChoiceItemSchema,
+    formatter: inputFieldChoiceItemFormatter,
+    defaultPageSize: DEFAULT_PAGE_SIZE,
+    resolvers: {
+      app: appKeyResolver,
+      action: actionKeyResolver,
+      connection: connectionIdResolver,
+      inputField: inputFieldKeyResolver,
+      inputs: inputsAllOptionalResolver,
+      actionType: { type: "constant", value: "read" }
+    },
+    handler: async ({ sdk: sdk2, options }) => {
+      return await sdk2.listActionInputFieldChoices({
+        ...options,
+        actionType: "read"
+      });
+    }
+  })
+);
+var GetTriggerInputFieldsSchemaSchema = z.object({
+  app: AppPropertySchema.describe(
+    "App key (e.g., 'SlackCLIAPI' or slug like 'github') to get the input schema for"
+  ),
+  action: ActionPropertySchema.describe(
+    "Trigger action key to get the input schema for"
+  ),
+  connection: ConnectionPropertySchema.optional().describe(
+    "Connection alias or connection ID. Required if the trigger needs a connection to determine available fields."
+  ),
+  inputs: InputsPropertySchema.optional().describe(
+    "Current input values that may affect the schema (e.g., when fields depend on other field values)"
+  )
+}).describe(
+  "Get the JSON Schema representation of input fields for a trigger. Returns a JSON Schema object describing the structure, types, and validation rules for the trigger's input parameters."
+);
+
+// src/plugins/triggers/getTriggerInputFieldsSchema/index.ts
+var getTriggerInputFieldsSchemaPlugin = definePlugin(
+  (sdk) => createPluginMethod(sdk, {
+    ...triggersDefaults,
+    name: "getTriggerInputFieldsSchema",
+    type: "function",
+    inputSchema: GetTriggerInputFieldsSchemaSchema,
+    resolvers: {
+      app: appKeyResolver,
+      action: actionKeyResolver,
+      connection: connectionIdResolver,
+      inputs: inputsAllOptionalResolver,
+      actionType: { type: "constant", value: "read" }
+    },
+    handler: async ({ sdk: sdk2, options }) => {
+      return sdk2.getActionInputFieldsSchema({
+        ...options,
+        actionType: "read"
+      });
+    }
+  })
+);
 var TableApiItemSchema = z.object({
   id: z.string(),
   name: z.string(),
@@ -11948,10 +13600,10 @@ var eventEmissionPlugin = definePlugin(
         registeredListeners.uncaughtException = uncaughtExceptionHandler;
         globalThis.process.on("uncaughtException", uncaughtExceptionHandler);
         const unhandledRejectionHandler = async (reason, promise) => {
-          const errorMessage = reason instanceof Error ? reason.message : typeof reason === "string" ? reason : "Unhandled promise rejection";
+          const errorMessage2 = reason instanceof Error ? reason.message : typeof reason === "string" ? reason : "Unhandled promise rejection";
           const errorStack = reason instanceof Error ? reason.stack : null;
           let errorEvent = buildErrorEventWithContext({
-            error_message: errorMessage,
+            error_message: errorMessage2,
             error_type: "UnhandledRejection",
             error_stack_trace: errorStack,
             error_severity: "critical",
@@ -12077,7 +13729,7 @@ function createZapierSdkWithoutRegistry(options = {}) {
   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(getConnectionStartUrlPlugin).use(waitForNewConnectionPlugin).use(createConnectionPlugin).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);
+  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(getConnectionStartUrlPlugin).use(waitForNewConnectionPlugin).use(createConnectionPlugin).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(listTriggerInboxesPlugin).use(createTriggerInboxPlugin).use(ensureTriggerInboxPlugin).use(getTriggerInboxPlugin).use(updateTriggerInboxPlugin).use(deleteTriggerInboxPlugin).use(pauseTriggerInboxPlugin).use(resumeTriggerInboxPlugin).use(listTriggerInboxMessagesPlugin).use(leaseTriggerInboxMessagesPlugin).use(ackTriggerInboxMessagesPlugin).use(releaseTriggerInboxMessagesPlugin).use(drainTriggerInboxPlugin).use(watchTriggerInboxPlugin).use(listTriggersPlugin).use(listTriggerInputFieldsPlugin).use(listTriggerInputFieldChoicesPlugin).use(getTriggerInputFieldsSchemaPlugin).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);
 }
 var zapierSdkPlugin = definePlugin({
   namespace: "zapier",