@zapier/zapier-sdk 0.93.0 → 0.94.1

package/dist/{chunk-S2WSKNCP.cjs → chunk-7NCOFRA6.cjs}

@@ -4219,6 +4219,7 @@ function getZapierSdkService() {
 var MAX_PAGE_LIMIT = 1e4;
 var DEFAULT_PAGE_SIZE = 100;
 var DEFAULT_ACTION_TIMEOUT_MILLISECONDS = 18e4;
+var ACTION_RUNS_PATH = "/zapier/api/actions/v1/runs";
 function parseIntEnvVar(name) {
   const value = globalThis.process?.env?.[name];
   if (value === void 0) return void 0;
@@ -4512,6 +4513,7 @@ var ZapierRelayError = class extends ZapierError {
     super(message, options);
     this.name = "ZapierRelayError";
     this.code = "ZAPIER_RELAY_ERROR";
+    if (options.retryable !== void 0) this.retryable = options.retryable;
   }
 };
 function hasZapierErrorCode(value, code) {
@@ -6192,7 +6194,7 @@ function parseDeprecationDate(value) {
 }
 
 // src/sdk-version.ts
-var SDK_VERSION = (typeof process !== "undefined" && process.env ? "0.93.0" : void 0) || "unknown";
+var SDK_VERSION = (typeof process !== "undefined" && process.env ? "0.94.1" : void 0) || "unknown";
 
 // src/utils/open-url.ts
 var nodePrefix = "node:";
@@ -7064,7 +7066,7 @@ var ZapierApiClient = class {
       requiredScopes: options.requiredScopes
     });
     if (typeof result === "string") {
-      if (result === "" && (method === "DELETE" || response.status === 204)) {
+      if (result === "" && (method === "DELETE" || response.status === 204 || response.status === 202)) {
         return void 0;
       }
       throw new ZapierValidationError(
@@ -8460,8 +8462,20 @@ var fetchPlugin = defineMethod({
       });
       const relayError = result.headers.get("x-relay-error");
       if (relayError) {
+        const relayErrorCode = result.headers.get("x-relay-error-code");
+        const retryableHeader = result.headers.get("x-relay-error-retryable");
+        const retryable = retryableHeader === "true" ? true : retryableHeader === "false" ? false : void 0;
         throw new ZapierRelayError(relayError, {
-          statusCode: result.status
+          statusCode: result.status,
+          retryable,
+          errors: relayErrorCode ? [
+            {
+              status: result.status,
+              code: relayErrorCode,
+              title: "API Proxy Error",
+              detail: relayError
+            }
+          ] : void 0
         });
       }
       return result;
@@ -8538,538 +8552,166 @@ var actionResultItemFormatter = defineFormatter({
     };
   }
 });
-var GetActionDescription = "Get detailed information about a specific action";
-var GetActionSchema = zod.z.object({
-  app: AppPropertySchema,
-  actionType: ActionTypePropertySchema,
-  action: ActionPropertySchema
-}).describe(GetActionDescription).meta({ aliases: { appKey: "app", actionKey: "action" } });
-var GetActionSchemaDeprecated = zod.z.object({
-  appKey: AppKeyPropertySchema,
-  actionType: ActionTypePropertySchema,
-  actionKey: ActionKeyPropertySchema
-});
-var GetActionInputSchema = zod.z.union([GetActionSchema, GetActionSchemaDeprecated]).describe(GetActionDescription);
-var ListActionsDescription = "List all actions for a specific app";
-var ListActionsBaseSchema = zod.z.object({
-  pageSize: zod.z.number().min(1).optional().describe("Number of actions per page"),
-  maxItems: zod.z.number().min(1).optional().describe("Maximum total items to return across all pages"),
-  cursor: zod.z.string().optional().describe("Cursor to start from")
-});
-var ListActionsSchema = zod.z.object({
-  app: AppPropertySchema.describe(
-    "App key of actions to list (e.g., 'SlackCLIAPI' or slug like 'github')"
-  ),
-  actionType: ActionTypePropertySchema.optional().describe(
-    "Filter actions by type"
-  )
-}).merge(ListActionsBaseSchema).describe(ListActionsDescription).meta({ aliases: { appKey: "app" } });
-var ListActionsSchemaDeprecated = zod.z.object({
-  appKey: AppKeyPropertySchema.describe(
-    "App key of actions to list (e.g., 'SlackCLIAPI' or slug like 'github')"
-  ),
-  actionType: ActionTypePropertySchema.optional().describe(
-    "Filter actions by type"
-  )
-}).merge(ListActionsBaseSchema);
-var ListActionsInputSchema = zod.z.union([ListActionsSchema, ListActionsSchemaDeprecated]).describe(ListActionsDescription);
-var NeedChoicesSchema = zod.z.object({
-  key: zod.z.string().optional(),
-  label: zod.z.string().optional(),
-  sample: zod.z.string().optional(),
-  value: zod.z.string().optional()
+
+// src/resolvers/appKey.ts
+var getAppRef = declareMethod({ id: "getApp" });
+var listAppsRef = declareMethod({ id: "listApps" });
+var appKeyResolver = defineResolver({
+  imports: [getAppRef, listAppsRef],
+  inputType: "search",
+  placeholder: "e.g., 'slack' or 'SlackCLIAPI' or 'mail'",
+  // Try the typed string as an exact app locator (getApp accepts slug, key, or
+  // implementation id). On a hit, resolve with the input as-is and skip the
+  // picker — every variant the user could type is already a valid value
+  // wherever `app` is required, so no canonicalization is needed. A 404 falls
+  // through to the search list; any other error (auth, network, rate-limit)
+  // propagates. ZapierAppNotFoundError and ZapierNotFoundError are independent
+  // siblings, so both are checked.
+  tryResolveFromSearch: async ({ imports, search }) => {
+    if (!search) return null;
+    try {
+      await imports.getApp({ app: search });
+      return { resolvedValue: search };
+    } catch (err) {
+      if (!isZapierAppNotFoundError(err) && !isZapierNotFoundError(err)) {
+        throw err;
+      }
+      return null;
+    }
+  },
+  listItems: ({
+    imports,
+    search,
+    cursor
+  }) => imports.listApps({ search, cursor }),
+  prompt: ({ items }) => ({
+    type: "list",
+    message: "Select app:",
+    choices: items.map((app) => ({
+      label: app.title || app.key,
+      hint: app.title ? getAppKeyList(app) : void 0,
+      value: app.key
+    }))
+  })
 });
-var NeedSchema = zod.z.object({
-  key: zod.z.string(),
-  alters_custom_fields: zod.z.boolean().nullable().optional(),
-  capabilities: zod.z.array(zod.z.string()).optional(),
-  choices: zod.z.array(NeedChoicesSchema).optional(),
-  computed: zod.z.boolean().nullable().optional(),
-  custom_field: zod.z.boolean().optional(),
-  default: zod.z.string().optional(),
-  depends_on: zod.z.array(zod.z.string()).optional(),
-  format: zod.z.literal("SELECT").optional(),
-  from_search: zod.z.boolean().optional(),
-  from_write: zod.z.boolean().optional(),
-  help_text: zod.z.string().optional(),
-  help_text_html: zod.z.string().optional(),
-  input_format: zod.z.array(zod.z.string()).optional(),
-  label: zod.z.string().optional(),
-  language: zod.z.string().optional(),
-  parent_key: zod.z.string().optional(),
-  placeholder: zod.z.string().optional(),
-  prefill: zod.z.string().optional(),
-  required: zod.z.boolean().optional(),
-  searchfill: zod.z.string().optional(),
-  send_in_json: zod.z.boolean().optional(),
-  regex: zod.z.string().optional(),
-  type: zod.z.enum([
-    "integer",
-    "string",
-    "text",
-    "datetime",
-    "boolean",
-    "file",
-    "decimal",
-    "copy",
-    "password",
-    "dict",
-    "code",
-    "filter",
-    "json"
-  ]).optional(),
-  list: zod.z.boolean().optional()
+
+// src/resolvers/actionType.ts
+var listActionsRef = declareMethod({ id: "listActions" });
+var actionTypeResolver = defineResolver({
+  imports: [listActionsRef],
+  requireParameters: ["app"],
+  listItems: async ({
+    imports,
+    input
+  }) => {
+    const types = /* @__PURE__ */ new Set();
+    for await (const action of imports.listActions({ app: input.app }).items()) {
+      types.add(action.action_type);
+    }
+    return { data: [...types].map((type) => ({ key: type, name: type })) };
+  },
+  prompt: ({ items }) => ({
+    type: "list",
+    message: "Select action type:",
+    choices: items.map((type) => ({ label: type.name, value: type.key }))
+  })
 });
-zod.z.object({
-  action_url: zod.z.string().optional()
+
+// src/resolvers/actionKey.ts
+var listActionsRef2 = declareMethod({ id: "listActions" });
+var actionKeyResolver = defineResolver({
+  imports: [listActionsRef2],
+  requireParameters: ["app", "actionType"],
+  listItems: async ({
+    imports,
+    input,
+    cursor
+  }) => {
+    const page = await imports.listActions({ app: input.app, cursor });
+    return {
+      data: page.data.filter(
+        (action) => action.action_type === input.actionType && !action.is_hidden
+      ),
+      nextCursor: page.nextCursor
+    };
+  },
+  prompt: ({ items }) => ({
+    type: "list",
+    message: "Select action:",
+    choices: items.map((action) => ({
+      label: action.title || action.name || action.key,
+      hint: action.description || void 0,
+      value: action.key
+    }))
+  })
 });
-zod.z.object({
-  can_use: zod.z.boolean().optional()
-});
-var ActionSchema = zod.z.object({
-  id: zod.z.string().optional(),
-  type: zod.z.enum([
-    "filter",
-    "read",
-    "read_bulk",
-    "run",
-    "search",
-    "search_and_write",
-    "search_or_write",
-    "write"
-  ]),
-  key: zod.z.string(),
-  name: zod.z.string(),
-  description: zod.z.string(),
-  is_important: zod.z.boolean().optional(),
-  is_hidden: zod.z.boolean().optional(),
-  selected_api: zod.z.string().optional()
-});
-var ChoiceSchema = zod.z.object({
-  value: zod.z.union([zod.z.string(), zod.z.number()]),
-  label: zod.z.string()
-});
-zod.z.object({
-  key: zod.z.string(),
-  label: zod.z.string(),
-  type: zod.z.enum([
-    "string",
-    "number",
-    "boolean",
-    "datetime",
-    "file",
-    "object",
-    "array"
-  ]),
-  required: zod.z.boolean(),
-  description: zod.z.string().optional(),
-  choices: zod.z.array(ChoiceSchema).optional()
-});
-zod.z.object({
-  data: zod.z.array(zod.z.unknown())
-});
-var ActionFieldChoiceSchema = zod.z.object({
-  value: zod.z.union([zod.z.string(), zod.z.number()]),
-  label: zod.z.string()
-});
-zod.z.object({
-  key: zod.z.string(),
-  label: zod.z.string().optional(),
-  required: zod.z.boolean(),
-  type: zod.z.string().optional(),
-  helpText: zod.z.string().optional(),
-  helpTextHtml: zod.z.string().optional(),
-  choices: zod.z.array(ActionFieldChoiceSchema).optional(),
-  default: zod.z.string().optional(),
-  placeholder: zod.z.string().optional(),
-  computed: zod.z.boolean().optional(),
-  customField: zod.z.boolean().optional(),
-  dependsOn: zod.z.array(zod.z.string()).optional(),
-  format: zod.z.string().optional(),
-  inputFormat: zod.z.array(zod.z.string()).optional()
-});
-zod.z.object({
-  id: zod.z.number(),
-  public_id: zod.z.string().optional(),
-  code: zod.z.string(),
-  user_id: zod.z.number(),
-  auto_provisioned: zod.z.boolean(),
-  first_name: zod.z.string(),
-  last_name: zod.z.string(),
-  username: zod.z.string(),
-  personas: zod.z.string(),
-  user_generated_personas: zod.z.string(),
-  last_login: zod.z.string(),
-  email: zod.z.string(),
-  email_hash: zod.z.string(),
-  email_confirmed: zod.z.boolean(),
-  timezone: zod.z.string(),
-  photo_url: zod.z.string(),
-  has_seen_notifications: zod.z.record(zod.z.string(), zod.z.boolean().nullable()),
-  signup: zod.z.string(),
-  since_signup: zod.z.string(),
-  has_activated: zod.z.boolean(),
-  enable_gz_creator: zod.z.boolean(),
-  should_see_nps_survey: zod.z.boolean(),
-  is_developer: zod.z.boolean(),
-  is_expert: zod.z.boolean(),
-  tos_agreement: zod.z.boolean(),
-  should_renew_tos: zod.z.boolean(),
-  is_gdpr_consented: zod.z.boolean(),
-  disable_ssl_check: zod.z.boolean(),
-  identity: zod.z.number(),
-  summary_schedule: zod.z.string(),
-  alert_triggers: zod.z.string(),
-  alert_actions: zod.z.string(),
-  is_staff: zod.z.boolean(),
-  is_zt_reviewer: zod.z.boolean(),
-  is_high_value: zod.z.boolean(),
-  is_temporary: zod.z.boolean(),
-  banner_message: zod.z.string(),
-  enable_totp_2fa: zod.z.boolean(),
-  viewed_help: zod.z.record(zod.z.string(), zod.z.boolean()),
-  show_editor_migration_mesaging: zod.z.boolean(),
-  switches: zod.z.record(zod.z.string(), zod.z.unknown()),
-  organizations: zod.z.array(zod.z.record(zod.z.string(), zod.z.unknown()).nullable()),
-  primary_organization: zod.z.record(zod.z.string(), zod.z.unknown()).nullable(),
-  has_active_zaps: zod.z.boolean(),
-  has_google_sso: zod.z.boolean(),
-  auth_realm: zod.z.string(),
-  roles: zod.z.array(
-    zod.z.object({
-      account_id: zod.z.number(),
-      role: zod.z.string()
-    })
-  )
-});
-zod.z.object({
-  age_in_days: zod.z.string().optional(),
-  api_docs_url: zod.z.string().nullable().optional(),
-  app_profile_url: zod.z.string(),
-  banner: zod.z.string().optional(),
-  categories: zod.z.array(zod.z.string()).optional(),
-  // Service category names
-  canonical_id: zod.z.string().optional(),
-  current_implementation_id: zod.z.string(),
-  days_since_last_update: zod.z.string().optional(),
-  description: zod.z.string(),
-  external_url: zod.z.string(),
-  hashtag: zod.z.string().optional(),
-  id: zod.z.number().optional(),
-  image: zod.z.string().optional(),
-  images: zod.z.string().optional(),
-  integration_overview_html: zod.z.string().nullable().optional(),
-  internal_id: zod.z.string(),
-  invite_url: zod.z.string().nullable().optional(),
-  is_beta: zod.z.string().optional(),
-  is_built_in: zod.z.string().optional(),
-  is_featured: zod.z.string().optional(),
-  is_premium: zod.z.boolean().optional(),
-  is_public: zod.z.string().optional(),
-  is_upcoming: zod.z.string().optional(),
-  learn_more_url: zod.z.string(),
-  name: zod.z.string(),
-  popularity: zod.z.number(),
-  primary_color: zod.z.string(),
-  request_count: zod.z.string().optional(),
-  slug: zod.z.string(),
-  zap_usage_count: zod.z.number().nullable().optional()
-});
-var ServiceSchema = zod.z.object({
-  id: zod.z.number().optional(),
-  canonical_id: zod.z.string().optional(),
-  current_implementation_id: zod.z.string(),
-  name: zod.z.string(),
-  slug: zod.z.string(),
-  app_url: zod.z.string().optional(),
-  learn_more_url: zod.z.string().optional(),
-  description: zod.z.string(),
-  primary_color: zod.z.string(),
-  popularity: zod.z.number(),
-  image: zod.z.string().optional(),
-  images: zod.z.string().optional()
-});
-zod.z.object({
-  results: zod.z.array(ServiceSchema),
-  next: zod.z.string().nullable().optional(),
-  previous: zod.z.string().nullable().optional()
-});
-zod.z.object({
-  selected_api: zod.z.string(),
-  action: zod.z.string(),
-  type_of: zod.z.string(),
-  authentication_id: zod.z.union([zod.z.string(), zod.z.number()]).optional(),
-  params: zod.z.record(zod.z.string(), zod.z.unknown()).optional()
-});
-zod.z.object({
-  success: zod.z.boolean(),
-  needs: zod.z.array(NeedSchema).optional(),
-  errors: zod.z.array(zod.z.string()).optional(),
-  last_fetched_at: zod.z.string().optional(),
-  schema: zod.z.record(zod.z.string(), zod.z.unknown()).optional()
-});
-var ImplementationSchema = zod.z.object({
-  selected_api: zod.z.string(),
-  app_id: zod.z.number().optional(),
-  auth_type: zod.z.string().optional(),
-  auth_fields: zod.z.string().optional(),
-  actions: zod.z.array(ActionSchema).optional(),
-  is_deprecated: zod.z.boolean().optional(),
-  is_private_only: zod.z.boolean().optional(),
-  is_invite_only: zod.z.boolean().optional(),
-  is_beta: zod.z.boolean().optional().default(false),
-  is_premium: zod.z.boolean().optional().default(false),
-  is_hidden: zod.z.string().optional(),
-  name: zod.z.string().optional(),
-  slug: zod.z.string().optional(),
-  images: zod.z.record(zod.z.string(), zod.z.string().nullable()).optional(),
-  primary_color: zod.z.string().optional(),
-  secondary_color: zod.z.string().optional(),
-  current_implementation: zod.z.string().optional(),
-  other_implementations: zod.z.string().optional()
-});
-zod.z.object({
-  count: zod.z.number(),
-  next: zod.z.string().nullable().optional(),
-  previous: zod.z.string().nullable().optional(),
-  results: zod.z.array(ImplementationSchema)
-});
-var NeedChoicesResponseMetaSchema = zod.z.object({
-  page: zod.z.string().nullable().optional()
-});
-var NeedChoicesResponseLinksSchema = zod.z.object({
-  next: zod.z.string().nullable().optional(),
-  prev: zod.z.string().nullable().optional()
-});
-zod.z.object({
-  selected_api: zod.z.string().optional().describe(
-    "Something like `SlackAPI` (for Python apps) or `SplitwiseCLIAPI@1.0.0` (for CLI apps). Non-public apps are fine as long as the authed user can access them."
-  ),
-  authentication_id: zod.z.union([zod.z.string(), zod.z.number()]).optional().describe(
-    "If the app needs auth, provide an `authentication_id` that has the `selected_api` of the app you want to run. Can be any auth visible to the user (including shared)."
-  ),
-  params: zod.z.record(zod.z.string(), zod.z.unknown()).optional().describe(
-    "Object that matches the input the node would normally get. Has all the same keys/types as the `needs` of the action."
-  ),
-  page: zod.z.number().optional().default(0),
-  prefill: zod.z.string().optional().describe(
-    "The prefill string to indicate what we're fetching choices for. Likely something like `spreadsheet.id.title`. Must be provided alongside `selected_api` if both `action_id` and `input_field_id` are not."
-  ),
-  action_id: zod.z.string().optional().describe(
-    "The id that will be used to lookup the Action for prefill lookup. If provided, `input_field_id` is required, else `prefill` must be provided."
-  ),
-  input_field_id: zod.z.string().optional().describe(
-    "The id (key) of the input field (Need) that dynamic choices are being retrieved for. If provided, `action_id` is required, else `prefill` must be provided."
-  )
-});
-zod.z.object({
-  success: zod.z.boolean(),
-  choices: zod.z.array(NeedChoicesSchema).optional(),
-  next_page: zod.z.number().optional(),
-  errors: zod.z.array(zod.z.string()).optional(),
-  meta: NeedChoicesResponseMetaSchema.optional(),
-  links: NeedChoicesResponseLinksSchema.optional()
-});
-
-// src/schemas/Action.ts
-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
-function formatActionItem(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,
-    // `hint` is the dumb secondary string shown after the title (the action key
-    // and, when present, its id). Replaces the deprecated `key`/`id` fields.
-    hint: [item.key, item.id].filter((v) => Boolean(v)),
-    description: item.description,
-    details
-  };
-}
-var actionItemFormatter = defineFormatter({
-  format: ({ item }) => formatActionItem(item)
-});
-
-// src/resolvers/appKey.ts
-var getAppRef = declareMethod({ id: "getApp" });
-var listAppsRef = declareMethod({ id: "listApps" });
-var appKeyResolver = defineResolver({
-  imports: [getAppRef, listAppsRef],
-  inputType: "search",
-  placeholder: "e.g., 'slack' or 'SlackCLIAPI' or 'mail'",
-  // Try the typed string as an exact app locator (getApp accepts slug, key, or
-  // implementation id). On a hit, resolve with the input as-is and skip the
-  // picker — every variant the user could type is already a valid value
-  // wherever `app` is required, so no canonicalization is needed. A 404 falls
-  // through to the search list; any other error (auth, network, rate-limit)
-  // propagates. ZapierAppNotFoundError and ZapierNotFoundError are independent
-  // siblings, so both are checked.
-  tryResolveFromSearch: async ({ imports, search }) => {
-    if (!search) return null;
-    try {
-      await imports.getApp({ app: search });
-      return { resolvedValue: search };
-    } catch (err) {
-      if (!isZapierAppNotFoundError(err) && !isZapierNotFoundError(err)) {
-        throw err;
-      }
-      return null;
-    }
-  },
-  listItems: ({
-    imports,
-    search,
-    cursor
-  }) => imports.listApps({ search, cursor }),
-  prompt: ({ items }) => ({
-    type: "list",
-    message: "Select app:",
-    choices: items.map((app) => ({
-      label: app.title || app.key,
-      hint: app.title ? getAppKeyList(app) : void 0,
-      value: app.key
-    }))
-  })
-});
-
-// src/resolvers/actionType.ts
-var listActionsRef = declareMethod({ id: "listActions" });
-var actionTypeResolver = defineResolver({
-  imports: [listActionsRef],
-  requireParameters: ["app"],
-  listItems: async ({
-    imports,
-    input
-  }) => {
-    const types = /* @__PURE__ */ new Set();
-    for await (const action of imports.listActions({ app: input.app }).items()) {
-      types.add(action.action_type);
-    }
-    return { data: [...types].map((type) => ({ key: type, name: type })) };
-  },
-  prompt: ({ items }) => ({
-    type: "list",
-    message: "Select action type:",
-    choices: items.map((type) => ({ label: type.name, value: type.key }))
-  })
-});
-
-// src/resolvers/actionKey.ts
-var listActionsRef2 = declareMethod({ id: "listActions" });
-var actionKeyResolver = defineResolver({
-  imports: [listActionsRef2],
-  requireParameters: ["app", "actionType"],
-  listItems: async ({
-    imports,
-    input,
-    cursor
-  }) => {
-    const page = await imports.listActions({ app: input.app, cursor });
-    return {
-      data: page.data.filter(
-        (action) => action.action_type === input.actionType && !action.is_hidden
-      ),
-      nextCursor: page.nextCursor
-    };
-  },
-  prompt: ({ items }) => ({
-    type: "list",
-    message: "Select action:",
-    choices: items.map((action) => ({
-      label: action.title || action.name || action.key,
-      hint: action.description || void 0,
-      value: action.key
-    }))
-  })
-});
-
-// src/plugins/capabilities/index.ts
-function toDescription(key) {
-  const words = key.replace(/^can/, "").replace(/([A-Z])/g, " $1").trim().toLowerCase();
-  return `To ${words}`;
-}
-function toEnvVar(key) {
-  return "ZAPIER_" + key.replace(/([A-Z])/g, "_$1").toUpperCase();
-}
-function toCliFlag(key) {
-  return "--" + key.replace(/([A-Z])/g, "-$1").toLowerCase();
-}
-function buildCapabilityMessage(key) {
-  return [
-    `${toDescription(key)}, use ${toCliFlag(key)} in the CLI,`,
-    `set ${key}: true in SDK options or .zapierrc,`,
-    `or set ${toEnvVar(key)}=true.`
-  ].join(" ");
-}
-var GATED_FLAGS = [
-  "canIncludeSharedConnections",
-  "canIncludeSharedTables",
-  "canDeleteTables"
-];
-function isEnabledByEnv(key) {
-  const value = globalThis.process?.env?.[toEnvVar(key)];
-  if (value === void 0) return void 0;
-  if (value === "true" || value === "1") return true;
-  if (value === "false" || value === "0") return false;
-  return void 0;
-}
-var CAPABILITIES_ID = "zapier/capabilities";
-var capabilitiesPluginRef = declareProperty({ id: CAPABILITIES_ID });
-var capabilitiesPlugin = defineProperty({
-  namespace: "zapier",
-  name: "capabilities",
-  imports: [sdkOptionsPluginRef, manifestPluginRef],
-  setup: ({ imports }) => {
-    const options = imports.sdkOptions ?? {};
-    let cached;
-    async function resolveFlags() {
-      if (cached) return cached;
-      const manifest = await imports.manifest.getResolvedManifest();
-      cached = {};
-      for (const flag of GATED_FLAGS) {
-        cached[flag] = Boolean(
-          options[flag] ?? isEnabledByEnv(flag) ?? manifest?.[flag]
-        );
-      }
-      return cached;
-    }
-    return {
-      checkCapability: async (key) => {
-        const flags = await resolveFlags();
-        if (flags[key]) return;
-        throw new ZapierConfigurationError(
-          buildCapabilityMessage(key) + " (If you are an AI agent, you MUST NOT retry. Ask the user if they want to enable this.)",
-          { configType: key }
-        );
-      },
-      hasCapability: async (key) => {
-        const flags = await resolveFlags();
-        return flags[key];
-      }
-    };
-  },
-  get: ({ state }) => state
+
+// src/plugins/capabilities/index.ts
+function toDescription(key) {
+  const words = key.replace(/^can/, "").replace(/([A-Z])/g, " $1").trim().toLowerCase();
+  return `To ${words}`;
+}
+function toEnvVar(key) {
+  return "ZAPIER_" + key.replace(/([A-Z])/g, "_$1").toUpperCase();
+}
+function toCliFlag(key) {
+  return "--" + key.replace(/([A-Z])/g, "-$1").toLowerCase();
+}
+function buildCapabilityMessage(key) {
+  return [
+    `${toDescription(key)}, use ${toCliFlag(key)} in the CLI,`,
+    `set ${key}: true in SDK options or .zapierrc,`,
+    `or set ${toEnvVar(key)}=true.`
+  ].join(" ");
+}
+var GATED_FLAGS = [
+  "canIncludeSharedConnections",
+  "canIncludeSharedTables",
+  "canDeleteTables"
+];
+function isEnabledByEnv(key) {
+  const value = globalThis.process?.env?.[toEnvVar(key)];
+  if (value === void 0) return void 0;
+  if (value === "true" || value === "1") return true;
+  if (value === "false" || value === "0") return false;
+  return void 0;
+}
+var CAPABILITIES_ID = "zapier/capabilities";
+var capabilitiesPluginRef = declareProperty({ id: CAPABILITIES_ID });
+var capabilitiesPlugin = defineProperty({
+  namespace: "zapier",
+  name: "capabilities",
+  imports: [sdkOptionsPluginRef, manifestPluginRef],
+  setup: ({ imports }) => {
+    const options = imports.sdkOptions ?? {};
+    let cached;
+    async function resolveFlags() {
+      if (cached) return cached;
+      const manifest = await imports.manifest.getResolvedManifest();
+      cached = {};
+      for (const flag of GATED_FLAGS) {
+        cached[flag] = Boolean(
+          options[flag] ?? isEnabledByEnv(flag) ?? manifest?.[flag]
+        );
+      }
+      return cached;
+    }
+    return {
+      checkCapability: async (key) => {
+        const flags = await resolveFlags();
+        if (flags[key]) return;
+        throw new ZapierConfigurationError(
+          buildCapabilityMessage(key) + " (If you are an AI agent, you MUST NOT retry. Ask the user if they want to enable this.)",
+          { configType: key }
+        );
+      },
+      hasCapability: async (key) => {
+        const flags = await resolveFlags();
+        return flags[key];
+      }
+    };
+  },
+  get: ({ state }) => state
 });
 
 // src/resolvers/connectionId.ts
@@ -9753,396 +9395,768 @@ async function createFieldKeyTranslator({
           }
         }
       }
-      return key;
+      return key;
+    }
+  };
+}
+
+// src/resolvers/tableRecordId.ts
+var listTableRecordsRef = declareMethod({ id: "listTableRecords" });
+function summarizeRecord(record) {
+  const values = Object.values(record.data);
+  const preview = values.slice(0, 3).map((v) => formatFieldValue(v).replace(/\s+/g, " ").trim()).filter((s) => s.length > 0).join(", ");
+  if (!preview) return void 0;
+  return preview.length > 60 ? preview.slice(0, 57) + "..." : preview;
+}
+function recordChoices(records) {
+  return records.map((record) => ({
+    label: summarizeRecord(record) || record.id,
+    value: record.id
+  }));
+}
+var tableRecordIdResolver = defineResolver({
+  imports: [listTableRecordsRef],
+  requireParameters: ["table"],
+  listItems: ({ imports, input, cursor }) => imports.listTableRecords({
+    table: input.table,
+    keyMode: "names",
+    cursor
+  }),
+  prompt: ({ items }) => ({
+    type: "list",
+    message: "Select a record:",
+    choices: recordChoices(items)
+  })
+});
+var tableRecordIdsResolver = defineResolver({
+  imports: [listTableRecordsRef],
+  requireParameters: ["table"],
+  listItems: ({ imports, input, cursor }) => imports.listTableRecords({
+    table: input.table,
+    keyMode: "names",
+    cursor
+  }),
+  prompt: ({ items }) => ({
+    type: "checkbox",
+    message: "Select records to delete:",
+    choices: recordChoices(items)
+  }),
+  validate: ({ value }) => Array.isArray(value) && value.length > 0 ? true : "Select at least one record"
+});
+
+// src/resolvers/tableFieldIds.ts
+var listTableFieldsRef = declareMethod({ id: "listTableFields" });
+var tableFieldIdsResolver = defineResolver({
+  imports: [listTableFieldsRef],
+  requireParameters: ["table"],
+  // No cursor forwarding: the fields API is unpaginated (no cursor on the
+  // response), so the listing is always exhausted after one page.
+  listItems: ({ imports, input }) => imports.listTableFields({ table: input.table }),
+  prompt: ({ items }) => ({
+    type: "checkbox",
+    message: "Select fields:",
+    choices: items.map((field) => ({
+      label: field.name,
+      hint: [field.id, field.type],
+      value: field.id
+    }))
+  }),
+  validate: ({ value }) => Array.isArray(value) && value.length > 0 ? true : "Select at least one field"
+});
+
+// src/resolvers/tableName.ts
+var tableNameResolver = defineResolver({
+  type: "static",
+  inputType: "text",
+  placeholder: "Enter a name for the table"
+});
+var FieldTypeSchema = zod.z.enum([
+  "string",
+  "multiple_string",
+  "labeled_string",
+  "multiple_labeled_string",
+  "text",
+  "multiple_text",
+  "boolean",
+  "multiple_boolean",
+  "number",
+  "multiple_number",
+  "decimal",
+  "multiple_decimal",
+  "datetime",
+  "multiple_datetime",
+  "uuid",
+  "multiple_uuid",
+  "json",
+  "multiple_json",
+  "formula",
+  "button_trigger_zap",
+  "button_continue_zap",
+  "email",
+  "multiple_email",
+  "link",
+  "multiple_link",
+  "currency",
+  "phone_number",
+  "ai_formula",
+  "linked_record",
+  "multiple_linked_record"
+]);
+var FieldApiItemSchema = zod.z.object({
+  id: zod.z.number(),
+  type: FieldTypeSchema,
+  name: zod.z.string(),
+  created_at: zod.z.string().optional(),
+  edited_at: zod.z.string().optional(),
+  options: zod.z.record(zod.z.string(), zod.z.unknown()).optional(),
+  config: zod.z.record(zod.z.string(), zod.z.unknown()).optional(),
+  is_order_field: zod.z.boolean().optional(),
+  is_filter_field: zod.z.boolean().optional(),
+  is_selected_field: zod.z.boolean().optional(),
+  deleted_at: zod.z.string().nullable().optional()
+});
+var ListTableFieldsApiResponseSchema = zod.z.object({
+  data: zod.z.array(FieldApiItemSchema)
+});
+var FieldItemSchema = zod.z.object({
+  id: zod.z.string(),
+  type: FieldTypeSchema,
+  name: zod.z.string(),
+  created_at: zod.z.string().optional(),
+  edited_at: zod.z.string().optional(),
+  options: zod.z.record(zod.z.string(), zod.z.unknown()).optional(),
+  config: zod.z.record(zod.z.string(), zod.z.unknown()).optional(),
+  deleted_at: zod.z.string().nullable().optional()
+});
+var ListTableFieldsDescription = "List fields for a table";
+var ListTableFieldsOptionsBaseSchema = zod.z.object({
+  fields: FieldsPropertySchema.optional(),
+  fieldKeys: zod.z.array(zod.z.union([zod.z.string(), zod.z.number()])).optional().describe(
+    'Filter by specific fields. Accepts field names (e.g., "Email") or IDs (e.g., "f6", "6", or 6).'
+  ).meta({ deprecated: true }),
+  trash: TrashSchema
+});
+var ListTableFieldsOptionsSchema = zod.z.object({
+  table: TablePropertySchema
+}).merge(ListTableFieldsOptionsBaseSchema).describe(ListTableFieldsDescription).meta({ aliases: { tableId: "table", fieldKeys: "fields" } });
+var ListTableFieldsOptionsSchemaDeprecated = zod.z.object({
+  tableId: zod.z.string().regex(/^[A-Z0-9]{26}$/, "Table ID must be a valid ULID").describe("The unique identifier of the table")
+}).merge(ListTableFieldsOptionsBaseSchema);
+var ListTableFieldsOptionsInputSchema = zod.z.union([ListTableFieldsOptionsSchema, ListTableFieldsOptionsSchemaDeprecated]).describe(ListTableFieldsDescription);
+
+// src/resolvers/tableFields.ts
+var fieldTypeChoices = FieldTypeSchema.options.map((type) => ({
+  label: type,
+  value: type
+}));
+var singleFieldResolver = defineResolver({
+  type: "object",
+  properties: {
+    type: {
+      label: "Field type",
+      required: true,
+      resolver: defineResolver({
+        listItems: () => ({ data: fieldTypeChoices }),
+        prompt: ({ items }) => ({
+          type: "list",
+          message: "Select field type:",
+          choices: items
+        })
+      })
+    },
+    name: {
+      label: "Field name",
+      required: true,
+      resolver: defineResolver({ type: "static", inputType: "text" })
+    }
+  }
+});
+var tableFieldsResolver = defineResolver({
+  type: "array",
+  items: singleFieldResolver,
+  minItems: 1
+});
+
+// src/resolvers/tableRecords.ts
+var listTableFieldsRef2 = declareMethod({ id: "listTableFields" });
+function tableFieldValueType(fieldType) {
+  if (fieldType.startsWith("multiple_")) return "array";
+  switch (fieldType) {
+    case "number":
+    case "decimal":
+    case "currency":
+      return "number";
+    case "boolean":
+      return "boolean";
+    default:
+      return void 0;
+  }
+}
+function buildDataFields(fields) {
+  const props = {};
+  for (const field of fields) {
+    const valueType = tableFieldValueType(field.type);
+    props[field.id] = {
+      label: field.name,
+      required: false,
+      ...valueType ? { valueType } : {},
+      resolver: { type: "static", inputType: "text" }
+    };
+  }
+  return props;
+}
+function makeRecordsResolver(includeRecordId) {
+  const singleRecordResolver = defineResolver({
+    type: "object",
+    imports: [listTableFieldsRef2],
+    requireParameters: ["table"],
+    // The record-id resolver is import-bearing, so it lives in `definitions` and
+    // is reached by `{ ref }` from the built `id` field (updates only).
+    definitions: includeRecordId ? { recordId: tableRecordIdResolver } : {},
+    getProperties: async ({ imports, input }) => {
+      const { data: fields } = await imports.listTableFields({
+        table: input.table
+      });
+      const props = {
+        data: {
+          label: "Field values",
+          resolver: { type: "object", properties: buildDataFields(fields) }
+        }
+      };
+      if (includeRecordId) {
+        props.id = {
+          label: "Record",
+          required: true,
+          resolver: { ref: "recordId" }
+        };
+      }
+      return props;
     }
-  };
+  });
+  return defineResolver({
+    type: "array",
+    requireParameters: ["table"],
+    minItems: 1,
+    items: singleRecordResolver
+  });
 }
+var tableRecordsResolver = makeRecordsResolver(false);
+var tableUpdateRecordsResolver = makeRecordsResolver(true);
 
-// src/resolvers/tableRecordId.ts
-var listTableRecordsRef = declareMethod({ id: "listTableRecords" });
-function summarizeRecord(record) {
-  const values = Object.values(record.data);
-  const preview = values.slice(0, 3).map((v) => formatFieldValue(v).replace(/\s+/g, " ").trim()).filter((s) => s.length > 0).join(", ");
-  if (!preview) return void 0;
-  return preview.length > 60 ? preview.slice(0, 57) + "..." : preview;
+// src/resolvers/tableFilters.ts
+var listTableFieldsRef3 = declareMethod({ id: "listTableFields" });
+var FILTER_OPERATORS = [
+  { label: "equals", value: "exact" },
+  { label: "not equals", value: "different" },
+  { label: "contains", value: "contains" },
+  { label: "contains (case-insensitive)", value: "icontains" },
+  { label: "starts with", value: "startswith" },
+  { label: "search", value: "search" },
+  { label: "greater than", value: "gt" },
+  { label: "greater than or equal", value: "gte" },
+  { label: "less than", value: "lt" },
+  { label: "less than or equal", value: "lte" },
+  { label: "in range", value: "range" },
+  { label: "in list", value: "in" },
+  { label: "is empty", value: "isnull" },
+  { label: "is within (date)", value: "is_within" }
+];
+function fieldKeyChoices(fields) {
+  return fields.flatMap((field) => {
+    const components = NESTED_COMPONENTS[field.type];
+    if (components && components.size > 1) {
+      return [...components].map((component) => ({
+        label: `${field.name}__${component} (${field.id}, ${field.type})`,
+        value: `${field.name}__${component}`
+      }));
+    }
+    return {
+      label: `${field.name} (${field.id}${components ? `, ${field.type}` : ""})`,
+      value: components ? `${field.name}__${[...components][0]}` : field.name
+    };
+  });
 }
-function recordChoices(records) {
-  return records.map((record) => ({
-    label: summarizeRecord(record) || record.id,
-    value: record.id
-  }));
+var singleFilterResolver = defineResolver({
+  type: "object",
+  imports: [listTableFieldsRef3],
+  requireParameters: ["table"],
+  getProperties: async ({ imports, input }) => {
+    const { data: fields } = await imports.listTableFields({
+      table: input.table
+    });
+    const choices = fieldKeyChoices(fields);
+    const props = {
+      fieldKey: {
+        label: "Field",
+        required: true,
+        resolver: {
+          type: "dynamic",
+          listItems: () => ({ data: choices }),
+          prompt: () => ({
+            type: "list",
+            message: "Select field:",
+            choices
+          })
+        }
+      },
+      operator: {
+        label: "Operator",
+        required: true,
+        resolver: {
+          type: "dynamic",
+          listItems: () => ({ data: FILTER_OPERATORS }),
+          prompt: () => ({
+            type: "list",
+            message: "Select operator:",
+            choices: FILTER_OPERATORS
+          })
+        }
+      },
+      value: {
+        label: "Value",
+        required: false,
+        resolver: { type: "static", inputType: "text" }
+      }
+    };
+    return props;
+  }
+});
+var tableFiltersResolver = defineResolver({
+  type: "array",
+  requireParameters: ["table"],
+  minItems: 0,
+  items: singleFilterResolver
+});
+
+// src/resolvers/tableSort.ts
+var listTableFieldsRef4 = declareMethod({ id: "listTableFields" });
+function fieldKeyChoices2(fields) {
+  return fields.flatMap((field) => {
+    const components = NESTED_COMPONENTS[field.type];
+    if (components) {
+      return [...components].map((component) => ({
+        label: `${field.name}__${component} (${field.id}, ${field.type})`,
+        value: `${field.name}__${component}`
+      }));
+    }
+    return { label: `${field.name} (${field.id})`, value: field.name };
+  });
 }
-var tableRecordIdResolver = defineResolver({
-  imports: [listTableRecordsRef],
+var DIRECTION_CHOICES = [
+  { label: "Ascending", value: "asc" },
+  { label: "Descending", value: "desc" }
+];
+var tableSortResolver = defineResolver({
+  type: "object",
+  imports: [listTableFieldsRef4],
   requireParameters: ["table"],
-  listItems: ({ imports, input, cursor }) => imports.listTableRecords({
-    table: input.table,
-    keyMode: "names",
-    cursor
-  }),
-  prompt: ({ items }) => ({
-    type: "list",
-    message: "Select a record:",
-    choices: recordChoices(items)
-  })
+  getProperties: async ({ imports, input }) => {
+    const { data: fields } = await imports.listTableFields({
+      table: input.table
+    });
+    const choices = fieldKeyChoices2(fields);
+    const props = {
+      fieldKey: {
+        label: "Field",
+        required: true,
+        resolver: {
+          type: "dynamic",
+          listItems: () => ({ data: choices }),
+          prompt: () => ({
+            type: "list",
+            message: "Select field:",
+            choices
+          })
+        }
+      },
+      direction: {
+        label: "Direction",
+        required: true,
+        resolver: {
+          type: "dynamic",
+          listItems: () => ({ data: DIRECTION_CHOICES }),
+          prompt: () => ({
+            type: "list",
+            message: "Select direction:",
+            choices: DIRECTION_CHOICES
+          })
+        }
+      }
+    };
+    return props;
+  }
+});
+var GetActionDescription = "Get detailed information about a specific action";
+var GetActionSchema = zod.z.object({
+  app: AppPropertySchema,
+  actionType: ActionTypePropertySchema,
+  action: ActionPropertySchema
+}).describe(GetActionDescription).meta({ aliases: { appKey: "app", actionKey: "action" } });
+var GetActionSchemaDeprecated = zod.z.object({
+  appKey: AppKeyPropertySchema,
+  actionType: ActionTypePropertySchema,
+  actionKey: ActionKeyPropertySchema
+});
+var GetActionInputSchema = zod.z.union([GetActionSchema, GetActionSchemaDeprecated]).describe(GetActionDescription);
+var ListActionsDescription = "List all actions for a specific app";
+var ListActionsBaseSchema = zod.z.object({
+  pageSize: zod.z.number().min(1).optional().describe("Number of actions per page"),
+  maxItems: zod.z.number().min(1).optional().describe("Maximum total items to return across all pages"),
+  cursor: zod.z.string().optional().describe("Cursor to start from")
+});
+var ListActionsSchema = zod.z.object({
+  app: AppPropertySchema.describe(
+    "App key of actions to list (e.g., 'SlackCLIAPI' or slug like 'github')"
+  ),
+  actionType: ActionTypePropertySchema.optional().describe(
+    "Filter actions by type"
+  )
+}).merge(ListActionsBaseSchema).describe(ListActionsDescription).meta({ aliases: { appKey: "app" } });
+var ListActionsSchemaDeprecated = zod.z.object({
+  appKey: AppKeyPropertySchema.describe(
+    "App key of actions to list (e.g., 'SlackCLIAPI' or slug like 'github')"
+  ),
+  actionType: ActionTypePropertySchema.optional().describe(
+    "Filter actions by type"
+  )
+}).merge(ListActionsBaseSchema);
+var ListActionsInputSchema = zod.z.union([ListActionsSchema, ListActionsSchemaDeprecated]).describe(ListActionsDescription);
+var NeedChoicesSchema = zod.z.object({
+  key: zod.z.string().optional(),
+  label: zod.z.string().optional(),
+  sample: zod.z.string().optional(),
+  value: zod.z.string().optional()
+});
+var NeedSchema = zod.z.object({
+  key: zod.z.string(),
+  alters_custom_fields: zod.z.boolean().nullable().optional(),
+  capabilities: zod.z.array(zod.z.string()).optional(),
+  choices: zod.z.array(NeedChoicesSchema).optional(),
+  computed: zod.z.boolean().nullable().optional(),
+  custom_field: zod.z.boolean().optional(),
+  default: zod.z.string().optional(),
+  depends_on: zod.z.array(zod.z.string()).optional(),
+  format: zod.z.literal("SELECT").optional(),
+  from_search: zod.z.boolean().optional(),
+  from_write: zod.z.boolean().optional(),
+  help_text: zod.z.string().optional(),
+  help_text_html: zod.z.string().optional(),
+  input_format: zod.z.array(zod.z.string()).optional(),
+  label: zod.z.string().optional(),
+  language: zod.z.string().optional(),
+  parent_key: zod.z.string().optional(),
+  placeholder: zod.z.string().optional(),
+  prefill: zod.z.string().optional(),
+  required: zod.z.boolean().optional(),
+  searchfill: zod.z.string().optional(),
+  send_in_json: zod.z.boolean().optional(),
+  regex: zod.z.string().optional(),
+  type: zod.z.enum([
+    "integer",
+    "string",
+    "text",
+    "datetime",
+    "boolean",
+    "file",
+    "decimal",
+    "copy",
+    "password",
+    "dict",
+    "code",
+    "filter",
+    "json"
+  ]).optional(),
+  list: zod.z.boolean().optional()
 });
-var tableRecordIdsResolver = defineResolver({
-  imports: [listTableRecordsRef],
-  requireParameters: ["table"],
-  listItems: ({ imports, input, cursor }) => imports.listTableRecords({
-    table: input.table,
-    keyMode: "names",
-    cursor
-  }),
-  prompt: ({ items }) => ({
-    type: "checkbox",
-    message: "Select records to delete:",
-    choices: recordChoices(items)
-  }),
-  validate: ({ value }) => Array.isArray(value) && value.length > 0 ? true : "Select at least one record"
+zod.z.object({
+  action_url: zod.z.string().optional()
 });
-
-// src/resolvers/tableFieldIds.ts
-var listTableFieldsRef = declareMethod({ id: "listTableFields" });
-var tableFieldIdsResolver = defineResolver({
-  imports: [listTableFieldsRef],
-  requireParameters: ["table"],
-  // No cursor forwarding: the fields API is unpaginated (no cursor on the
-  // response), so the listing is always exhausted after one page.
-  listItems: ({ imports, input }) => imports.listTableFields({ table: input.table }),
-  prompt: ({ items }) => ({
-    type: "checkbox",
-    message: "Select fields:",
-    choices: items.map((field) => ({
-      label: field.name,
-      hint: [field.id, field.type],
-      value: field.id
-    }))
-  }),
-  validate: ({ value }) => Array.isArray(value) && value.length > 0 ? true : "Select at least one field"
+zod.z.object({
+  can_use: zod.z.boolean().optional()
 });
-
-// src/resolvers/tableName.ts
-var tableNameResolver = defineResolver({
-  type: "static",
-  inputType: "text",
-  placeholder: "Enter a name for the table"
+var ActionSchema = zod.z.object({
+  id: zod.z.string().optional(),
+  type: zod.z.enum([
+    "filter",
+    "read",
+    "read_bulk",
+    "run",
+    "search",
+    "search_and_write",
+    "search_or_write",
+    "write"
+  ]),
+  key: zod.z.string(),
+  name: zod.z.string(),
+  description: zod.z.string(),
+  is_important: zod.z.boolean().optional(),
+  is_hidden: zod.z.boolean().optional(),
+  selected_api: zod.z.string().optional()
 });
-var FieldTypeSchema = zod.z.enum([
-  "string",
-  "multiple_string",
-  "labeled_string",
-  "multiple_labeled_string",
-  "text",
-  "multiple_text",
-  "boolean",
-  "multiple_boolean",
-  "number",
-  "multiple_number",
-  "decimal",
-  "multiple_decimal",
-  "datetime",
-  "multiple_datetime",
-  "uuid",
-  "multiple_uuid",
-  "json",
-  "multiple_json",
-  "formula",
-  "button_trigger_zap",
-  "button_continue_zap",
-  "email",
-  "multiple_email",
-  "link",
-  "multiple_link",
-  "currency",
-  "phone_number",
-  "ai_formula",
-  "linked_record",
-  "multiple_linked_record"
-]);
-var FieldApiItemSchema = zod.z.object({
+var ChoiceSchema = zod.z.object({
+  value: zod.z.union([zod.z.string(), zod.z.number()]),
+  label: zod.z.string()
+});
+zod.z.object({
+  key: zod.z.string(),
+  label: zod.z.string(),
+  type: zod.z.enum([
+    "string",
+    "number",
+    "boolean",
+    "datetime",
+    "file",
+    "object",
+    "array"
+  ]),
+  required: zod.z.boolean(),
+  description: zod.z.string().optional(),
+  choices: zod.z.array(ChoiceSchema).optional()
+});
+zod.z.object({
+  data: zod.z.array(zod.z.unknown())
+});
+var ActionFieldChoiceSchema = zod.z.object({
+  value: zod.z.union([zod.z.string(), zod.z.number()]),
+  label: zod.z.string()
+});
+zod.z.object({
+  key: zod.z.string(),
+  label: zod.z.string().optional(),
+  required: zod.z.boolean(),
+  type: zod.z.string().optional(),
+  helpText: zod.z.string().optional(),
+  helpTextHtml: zod.z.string().optional(),
+  choices: zod.z.array(ActionFieldChoiceSchema).optional(),
+  default: zod.z.string().optional(),
+  placeholder: zod.z.string().optional(),
+  computed: zod.z.boolean().optional(),
+  customField: zod.z.boolean().optional(),
+  dependsOn: zod.z.array(zod.z.string()).optional(),
+  format: zod.z.string().optional(),
+  inputFormat: zod.z.array(zod.z.string()).optional()
+});
+zod.z.object({
   id: zod.z.number(),
-  type: FieldTypeSchema,
+  public_id: zod.z.string().optional(),
+  code: zod.z.string(),
+  user_id: zod.z.number(),
+  auto_provisioned: zod.z.boolean(),
+  first_name: zod.z.string(),
+  last_name: zod.z.string(),
+  username: zod.z.string(),
+  personas: zod.z.string(),
+  user_generated_personas: zod.z.string(),
+  last_login: zod.z.string(),
+  email: zod.z.string(),
+  email_hash: zod.z.string(),
+  email_confirmed: zod.z.boolean(),
+  timezone: zod.z.string(),
+  photo_url: zod.z.string(),
+  has_seen_notifications: zod.z.record(zod.z.string(), zod.z.boolean().nullable()),
+  signup: zod.z.string(),
+  since_signup: zod.z.string(),
+  has_activated: zod.z.boolean(),
+  enable_gz_creator: zod.z.boolean(),
+  should_see_nps_survey: zod.z.boolean(),
+  is_developer: zod.z.boolean(),
+  is_expert: zod.z.boolean(),
+  tos_agreement: zod.z.boolean(),
+  should_renew_tos: zod.z.boolean(),
+  is_gdpr_consented: zod.z.boolean(),
+  disable_ssl_check: zod.z.boolean(),
+  identity: zod.z.number(),
+  summary_schedule: zod.z.string(),
+  alert_triggers: zod.z.string(),
+  alert_actions: zod.z.string(),
+  is_staff: zod.z.boolean(),
+  is_zt_reviewer: zod.z.boolean(),
+  is_high_value: zod.z.boolean(),
+  is_temporary: zod.z.boolean(),
+  banner_message: zod.z.string(),
+  enable_totp_2fa: zod.z.boolean(),
+  viewed_help: zod.z.record(zod.z.string(), zod.z.boolean()),
+  show_editor_migration_mesaging: zod.z.boolean(),
+  switches: zod.z.record(zod.z.string(), zod.z.unknown()),
+  organizations: zod.z.array(zod.z.record(zod.z.string(), zod.z.unknown()).nullable()),
+  primary_organization: zod.z.record(zod.z.string(), zod.z.unknown()).nullable(),
+  has_active_zaps: zod.z.boolean(),
+  has_google_sso: zod.z.boolean(),
+  auth_realm: zod.z.string(),
+  roles: zod.z.array(
+    zod.z.object({
+      account_id: zod.z.number(),
+      role: zod.z.string()
+    })
+  )
+});
+zod.z.object({
+  age_in_days: zod.z.string().optional(),
+  api_docs_url: zod.z.string().nullable().optional(),
+  app_profile_url: zod.z.string(),
+  banner: zod.z.string().optional(),
+  categories: zod.z.array(zod.z.string()).optional(),
+  // Service category names
+  canonical_id: zod.z.string().optional(),
+  current_implementation_id: zod.z.string(),
+  days_since_last_update: zod.z.string().optional(),
+  description: zod.z.string(),
+  external_url: zod.z.string(),
+  hashtag: zod.z.string().optional(),
+  id: zod.z.number().optional(),
+  image: zod.z.string().optional(),
+  images: zod.z.string().optional(),
+  integration_overview_html: zod.z.string().nullable().optional(),
+  internal_id: zod.z.string(),
+  invite_url: zod.z.string().nullable().optional(),
+  is_beta: zod.z.string().optional(),
+  is_built_in: zod.z.string().optional(),
+  is_featured: zod.z.string().optional(),
+  is_premium: zod.z.boolean().optional(),
+  is_public: zod.z.string().optional(),
+  is_upcoming: zod.z.string().optional(),
+  learn_more_url: zod.z.string(),
   name: zod.z.string(),
-  created_at: zod.z.string().optional(),
-  edited_at: zod.z.string().optional(),
-  options: zod.z.record(zod.z.string(), zod.z.unknown()).optional(),
-  config: zod.z.record(zod.z.string(), zod.z.unknown()).optional(),
-  is_order_field: zod.z.boolean().optional(),
-  is_filter_field: zod.z.boolean().optional(),
-  is_selected_field: zod.z.boolean().optional(),
-  deleted_at: zod.z.string().nullable().optional()
+  popularity: zod.z.number(),
+  primary_color: zod.z.string(),
+  request_count: zod.z.string().optional(),
+  slug: zod.z.string(),
+  zap_usage_count: zod.z.number().nullable().optional()
+});
+var ServiceSchema = zod.z.object({
+  id: zod.z.number().optional(),
+  canonical_id: zod.z.string().optional(),
+  current_implementation_id: zod.z.string(),
+  name: zod.z.string(),
+  slug: zod.z.string(),
+  app_url: zod.z.string().optional(),
+  learn_more_url: zod.z.string().optional(),
+  description: zod.z.string(),
+  primary_color: zod.z.string(),
+  popularity: zod.z.number(),
+  image: zod.z.string().optional(),
+  images: zod.z.string().optional()
 });
-var ListTableFieldsApiResponseSchema = zod.z.object({
-  data: zod.z.array(FieldApiItemSchema)
+zod.z.object({
+  results: zod.z.array(ServiceSchema),
+  next: zod.z.string().nullable().optional(),
+  previous: zod.z.string().nullable().optional()
 });
-var FieldItemSchema = zod.z.object({
-  id: zod.z.string(),
-  type: FieldTypeSchema,
-  name: zod.z.string(),
-  created_at: zod.z.string().optional(),
-  edited_at: zod.z.string().optional(),
-  options: zod.z.record(zod.z.string(), zod.z.unknown()).optional(),
-  config: zod.z.record(zod.z.string(), zod.z.unknown()).optional(),
-  deleted_at: zod.z.string().nullable().optional()
+zod.z.object({
+  selected_api: zod.z.string(),
+  action: zod.z.string(),
+  type_of: zod.z.string(),
+  authentication_id: zod.z.union([zod.z.string(), zod.z.number()]).optional(),
+  params: zod.z.record(zod.z.string(), zod.z.unknown()).optional()
 });
-var ListTableFieldsDescription = "List fields for a table";
-var ListTableFieldsOptionsBaseSchema = zod.z.object({
-  fields: FieldsPropertySchema.optional(),
-  fieldKeys: zod.z.array(zod.z.union([zod.z.string(), zod.z.number()])).optional().describe(
-    'Filter by specific fields. Accepts field names (e.g., "Email") or IDs (e.g., "f6", "6", or 6).'
-  ).meta({ deprecated: true }),
-  trash: TrashSchema
+zod.z.object({
+  success: zod.z.boolean(),
+  needs: zod.z.array(NeedSchema).optional(),
+  errors: zod.z.array(zod.z.string()).optional(),
+  last_fetched_at: zod.z.string().optional(),
+  schema: zod.z.record(zod.z.string(), zod.z.unknown()).optional()
 });
-var ListTableFieldsOptionsSchema = zod.z.object({
-  table: TablePropertySchema
-}).merge(ListTableFieldsOptionsBaseSchema).describe(ListTableFieldsDescription).meta({ aliases: { tableId: "table", fieldKeys: "fields" } });
-var ListTableFieldsOptionsSchemaDeprecated = zod.z.object({
-  tableId: zod.z.string().regex(/^[A-Z0-9]{26}$/, "Table ID must be a valid ULID").describe("The unique identifier of the table")
-}).merge(ListTableFieldsOptionsBaseSchema);
-var ListTableFieldsOptionsInputSchema = zod.z.union([ListTableFieldsOptionsSchema, ListTableFieldsOptionsSchemaDeprecated]).describe(ListTableFieldsDescription);
-
-// src/resolvers/tableFields.ts
-var fieldTypeChoices = FieldTypeSchema.options.map((type) => ({
-  label: type,
-  value: type
-}));
-var singleFieldResolver = defineResolver({
-  type: "object",
-  properties: {
-    type: {
-      label: "Field type",
-      required: true,
-      resolver: defineResolver({
-        listItems: () => ({ data: fieldTypeChoices }),
-        prompt: ({ items }) => ({
-          type: "list",
-          message: "Select field type:",
-          choices: items
-        })
-      })
-    },
-    name: {
-      label: "Field name",
-      required: true,
-      resolver: defineResolver({ type: "static", inputType: "text" })
-    }
-  }
+var ImplementationSchema = zod.z.object({
+  selected_api: zod.z.string(),
+  app_id: zod.z.number().optional(),
+  auth_type: zod.z.string().optional(),
+  auth_fields: zod.z.string().optional(),
+  actions: zod.z.array(ActionSchema).optional(),
+  is_deprecated: zod.z.boolean().optional(),
+  is_private_only: zod.z.boolean().optional(),
+  is_invite_only: zod.z.boolean().optional(),
+  is_beta: zod.z.boolean().optional().default(false),
+  is_premium: zod.z.boolean().optional().default(false),
+  is_hidden: zod.z.string().optional(),
+  name: zod.z.string().optional(),
+  slug: zod.z.string().optional(),
+  images: zod.z.record(zod.z.string(), zod.z.string().nullable()).optional(),
+  primary_color: zod.z.string().optional(),
+  secondary_color: zod.z.string().optional(),
+  current_implementation: zod.z.string().optional(),
+  other_implementations: zod.z.string().optional()
 });
-var tableFieldsResolver = defineResolver({
-  type: "array",
-  items: singleFieldResolver,
-  minItems: 1
+zod.z.object({
+  count: zod.z.number(),
+  next: zod.z.string().nullable().optional(),
+  previous: zod.z.string().nullable().optional(),
+  results: zod.z.array(ImplementationSchema)
 });
-
-// src/resolvers/tableRecords.ts
-var listTableFieldsRef2 = declareMethod({ id: "listTableFields" });
-function tableFieldValueType(fieldType) {
-  if (fieldType.startsWith("multiple_")) return "array";
-  switch (fieldType) {
-    case "number":
-    case "decimal":
-    case "currency":
-      return "number";
-    case "boolean":
-      return "boolean";
-    default:
-      return void 0;
-  }
-}
-function buildDataFields(fields) {
-  const props = {};
-  for (const field of fields) {
-    const valueType = tableFieldValueType(field.type);
-    props[field.id] = {
-      label: field.name,
-      required: false,
-      ...valueType ? { valueType } : {},
-      resolver: { type: "static", inputType: "text" }
-    };
-  }
-  return props;
-}
-function makeRecordsResolver(includeRecordId) {
-  const singleRecordResolver = defineResolver({
-    type: "object",
-    imports: [listTableFieldsRef2],
-    requireParameters: ["table"],
-    // The record-id resolver is import-bearing, so it lives in `definitions` and
-    // is reached by `{ ref }` from the built `id` field (updates only).
-    definitions: includeRecordId ? { recordId: tableRecordIdResolver } : {},
-    getProperties: async ({ imports, input }) => {
-      const { data: fields } = await imports.listTableFields({
-        table: input.table
-      });
-      const props = {
-        data: {
-          label: "Field values",
-          resolver: { type: "object", properties: buildDataFields(fields) }
-        }
-      };
-      if (includeRecordId) {
-        props.id = {
-          label: "Record",
-          required: true,
-          resolver: { ref: "recordId" }
-        };
-      }
-      return props;
-    }
-  });
-  return defineResolver({
-    type: "array",
-    requireParameters: ["table"],
-    minItems: 1,
-    items: singleRecordResolver
-  });
-}
-var tableRecordsResolver = makeRecordsResolver(false);
-var tableUpdateRecordsResolver = makeRecordsResolver(true);
-
-// src/resolvers/tableFilters.ts
-var listTableFieldsRef3 = declareMethod({ id: "listTableFields" });
-var FILTER_OPERATORS = [
-  { label: "equals", value: "exact" },
-  { label: "not equals", value: "different" },
-  { label: "contains", value: "contains" },
-  { label: "contains (case-insensitive)", value: "icontains" },
-  { label: "starts with", value: "startswith" },
-  { label: "search", value: "search" },
-  { label: "greater than", value: "gt" },
-  { label: "greater than or equal", value: "gte" },
-  { label: "less than", value: "lt" },
-  { label: "less than or equal", value: "lte" },
-  { label: "in range", value: "range" },
-  { label: "in list", value: "in" },
-  { label: "is empty", value: "isnull" },
-  { label: "is within (date)", value: "is_within" }
-];
-function fieldKeyChoices(fields) {
-  return fields.flatMap((field) => {
-    const components = NESTED_COMPONENTS[field.type];
-    if (components && components.size > 1) {
-      return [...components].map((component) => ({
-        label: `${field.name}__${component} (${field.id}, ${field.type})`,
-        value: `${field.name}__${component}`
-      }));
-    }
-    return {
-      label: `${field.name} (${field.id}${components ? `, ${field.type}` : ""})`,
-      value: components ? `${field.name}__${[...components][0]}` : field.name
-    };
-  });
-}
-var singleFilterResolver = defineResolver({
-  type: "object",
-  imports: [listTableFieldsRef3],
-  requireParameters: ["table"],
-  getProperties: async ({ imports, input }) => {
-    const { data: fields } = await imports.listTableFields({
-      table: input.table
-    });
-    const choices = fieldKeyChoices(fields);
-    const props = {
-      fieldKey: {
-        label: "Field",
-        required: true,
-        resolver: {
-          type: "dynamic",
-          listItems: () => ({ data: choices }),
-          prompt: () => ({
-            type: "list",
-            message: "Select field:",
-            choices
-          })
-        }
-      },
-      operator: {
-        label: "Operator",
-        required: true,
-        resolver: {
-          type: "dynamic",
-          listItems: () => ({ data: FILTER_OPERATORS }),
-          prompt: () => ({
-            type: "list",
-            message: "Select operator:",
-            choices: FILTER_OPERATORS
-          })
-        }
-      },
-      value: {
-        label: "Value",
-        required: false,
-        resolver: { type: "static", inputType: "text" }
-      }
-    };
-    return props;
-  }
+var NeedChoicesResponseMetaSchema = zod.z.object({
+  page: zod.z.string().nullable().optional()
+});
+var NeedChoicesResponseLinksSchema = zod.z.object({
+  next: zod.z.string().nullable().optional(),
+  prev: zod.z.string().nullable().optional()
+});
+zod.z.object({
+  selected_api: zod.z.string().optional().describe(
+    "Something like `SlackAPI` (for Python apps) or `SplitwiseCLIAPI@1.0.0` (for CLI apps). Non-public apps are fine as long as the authed user can access them."
+  ),
+  authentication_id: zod.z.union([zod.z.string(), zod.z.number()]).optional().describe(
+    "If the app needs auth, provide an `authentication_id` that has the `selected_api` of the app you want to run. Can be any auth visible to the user (including shared)."
+  ),
+  params: zod.z.record(zod.z.string(), zod.z.unknown()).optional().describe(
+    "Object that matches the input the node would normally get. Has all the same keys/types as the `needs` of the action."
+  ),
+  page: zod.z.number().optional().default(0),
+  prefill: zod.z.string().optional().describe(
+    "The prefill string to indicate what we're fetching choices for. Likely something like `spreadsheet.id.title`. Must be provided alongside `selected_api` if both `action_id` and `input_field_id` are not."
+  ),
+  action_id: zod.z.string().optional().describe(
+    "The id that will be used to lookup the Action for prefill lookup. If provided, `input_field_id` is required, else `prefill` must be provided."
+  ),
+  input_field_id: zod.z.string().optional().describe(
+    "The id (key) of the input field (Need) that dynamic choices are being retrieved for. If provided, `action_id` is required, else `prefill` must be provided."
+  )
 });
-var tableFiltersResolver = defineResolver({
-  type: "array",
-  requireParameters: ["table"],
-  minItems: 0,
-  items: singleFilterResolver
+zod.z.object({
+  success: zod.z.boolean(),
+  choices: zod.z.array(NeedChoicesSchema).optional(),
+  next_page: zod.z.number().optional(),
+  errors: zod.z.array(zod.z.string()).optional(),
+  meta: NeedChoicesResponseMetaSchema.optional(),
+  links: NeedChoicesResponseLinksSchema.optional()
 });
 
-// src/resolvers/tableSort.ts
-var listTableFieldsRef4 = declareMethod({ id: "listTableFields" });
-function fieldKeyChoices2(fields) {
-  return fields.flatMap((field) => {
-    const components = NESTED_COMPONENTS[field.type];
-    if (components) {
-      return [...components].map((component) => ({
-        label: `${field.name}__${component} (${field.id}, ${field.type})`,
-        value: `${field.name}__${component}`
-      }));
-    }
-    return { label: `${field.name} (${field.id})`, value: field.name };
-  });
-}
-var DIRECTION_CHOICES = [
-  { label: "Ascending", value: "asc" },
-  { label: "Descending", value: "desc" }
-];
-var tableSortResolver = defineResolver({
-  type: "object",
-  imports: [listTableFieldsRef4],
-  requireParameters: ["table"],
-  getProperties: async ({ imports, input }) => {
-    const { data: fields } = await imports.listTableFields({
-      table: input.table
-    });
-    const choices = fieldKeyChoices2(fields);
-    const props = {
-      fieldKey: {
-        label: "Field",
-        required: true,
-        resolver: {
-          type: "dynamic",
-          listItems: () => ({ data: choices }),
-          prompt: () => ({
-            type: "list",
-            message: "Select field:",
-            choices
-          })
-        }
-      },
-      direction: {
-        label: "Direction",
-        required: true,
-        resolver: {
-          type: "dynamic",
-          listItems: () => ({ data: DIRECTION_CHOICES }),
-          prompt: () => ({
-            type: "list",
-            message: "Select direction:",
-            choices: DIRECTION_CHOICES
-          })
-        }
-      }
-    };
-    return props;
+// src/schemas/Action.ts
+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
+function formatActionItem(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,
+    // `hint` is the dumb secondary string shown after the title (the action key
+    // and, when present, its id). Replaces the deprecated `key`/`id` fields.
+    hint: [item.key, item.id].filter((v) => Boolean(v)),
+    description: item.description,
+    details
+  };
+}
+var actionItemFormatter = defineFormatter({
+  format: ({ item }) => formatActionItem(item)
 });
 
 // src/plugins/listActions/index.ts
@@ -10241,65 +10255,37 @@ var getActionPlugin = defineMethod({
     );
   }
 });
-async function executeAction(actionOptions) {
-  const {
-    api,
-    selectedApi,
-    actionId,
-    actionKey,
-    actionType,
-    executionOptions,
-    cursor,
-    connectionId,
-    timeoutMilliseconds
-  } = actionOptions;
-  const runRequestData = {
-    selected_api: selectedApi,
-    action_id: actionId,
-    action_key: actionKey,
-    action_type: actionType,
-    inputs: executionOptions.inputs || {}
-  };
-  if (connectionId !== null && connectionId !== void 0) {
-    runRequestData.authentication_id = connectionId;
-  }
-  if (cursor) {
-    runRequestData.page = cursor;
-  }
-  const runRequest = { data: runRequestData };
-  const runData = await api.post(
-    "/zapier/api/actions/v1/runs",
-    runRequest,
-    {
-      approvalContext: () => policyContext.buildActionRunContext({
-        selected_api: selectedApi,
-        action_type: actionType,
-        action_key: actionKey,
-        connection_id: connectionId != null ? String(connectionId) : void 0,
-        // Cast: inputs is Record<string, unknown> at the SDK surface;
-        // buildActionRunContext validates it as JSON at runtime via zod
-        // (non-JSON values like Date/undefined are rejected there).
-        inputs: executionOptions.inputs ?? {}
-      })
-    }
-  );
-  const runId = runData.data.id;
-  return await api.poll(`/zapier/api/actions/v1/runs/${runId}`, {
-    successStatus: 200,
-    pendingStatus: 202,
-    timeoutMilliseconds: timeoutMilliseconds ?? DEFAULT_ACTION_TIMEOUT_MILLISECONDS,
-    resource: { type: "run", id: runId },
-    isPending: (result) => {
-      const data = result?.data;
-      return data?.status === "waiting";
-    },
-    resultExtractor: (result) => result.data
-  });
-}
+var CreateActionRunSchema = zod.z.object({
+  app: AppPropertySchema,
+  actionType: ActionTypePropertySchema,
+  action: ActionPropertySchema,
+  connection: ConnectionPropertySchema.optional().describe(
+    "Connection alias or connection ID (UUID or positive integer). Required if the action needs a connection to authenticate and interact with the service. Strings that match a key in the connections map are resolved against it; otherwise the value is used as a connection ID directly."
+  ),
+  inputs: InputsPropertySchema.optional().describe(
+    "Input parameters for the action"
+  ),
+  page: zod.z.string().optional().describe(
+    "Page to fetch for bulk read actions. Pass the `next_page` a previous run returned to fetch the following page."
+  ),
+  callbackUrl: zod.z.string().url().optional().describe(
+    "URL Zapier posts the finished run to, so you do not have to poll for it. Must use HTTPS and resolve to a public host, so a local receiver needs a tunnel. The body matches what `getActionRun` returns. Verify the `Zapier-Callback-Signature` header, and expect the same run to arrive more than once."
+  ).meta({ valueHint: "url" })
+}).describe(
+  "Start an action run and return its ID without waiting for the result. Running an action is asynchronous: this hands back a run ID immediately, and `getActionRun` fetches the outcome. Reach for this pair when you want to start work and collect it later (fan out many runs, hand the ID to another process, survive a restart). `runAction` is the one-call form that starts a run and waits for its result."
+);
+var ActionRunStartedItemSchema = zod.z.object({
+  id: zod.z.string().describe(
+    "Action run ID. Pass it as the `run` for `getActionRun` to fetch the run's result."
+  ),
+  implementation_id: zod.z.string().describe(
+    "Versioned implementation ID the run was started against (e.g. 'SlackCLIAPI@1.21.1'). The versionless app key is the part before the `@`."
+  )
+});
 var CONTEXT_CACHE_TTL_MILLISECONDS = 6e4;
 var CONTEXT_CACHE_MAX_SIZE = 500;
-var runActionPlugin = defineMethod({
-  name: "runAction",
+var createActionRunPlugin = defineMethod({
+  name: "createActionRun",
   imports: [
     connectionsPluginRef,
     manifestPluginRef,
@@ -10307,14 +10293,11 @@ var runActionPlugin = defineMethod({
     getActionPlugin
   ],
   categories: ["action"],
-  itemType: "ActionResult",
-  inputSchema: RunActionInputSchema,
-  outputSchema: ActionResultItemSchema,
-  skipOutputValidation: true,
-  formatter: actionResultItemFormatter,
-  // No defaultPageSize — leave the default to the Actions API rather than
-  // eagerly running more actions than the user intends (avoids app rate limits).
-  output: "list",
+  type: "create",
+  itemType: "StartedActionRun",
+  inputSchema: CreateActionRunSchema,
+  outputSchema: ActionRunStartedItemSchema,
+  output: "item",
   resolvers: {
     app: appKeyResolver,
     actionType: actionTypeResolver,
@@ -10322,14 +10305,12 @@ var runActionPlugin = defineMethod({
     connection: connectionIdResolver,
     inputs: inputsResolver
   },
-  // A per-SDK-instance TTL cache of resolved (selectedApi, actionId), built once
-  // in setup so it persists across calls. The imports it resolves through
-  // (`manifest.getVersionedImplementationId`, `getAction`) are threaded in per
-  // call from `run`, not captured here.
   setup: () => {
     const cache = /* @__PURE__ */ new Map();
     function evictIfNeeded() {
-      if (cache.size < CONTEXT_CACHE_MAX_SIZE) return;
+      if (cache.size < CONTEXT_CACHE_MAX_SIZE) {
+        return;
+      }
       const now = Date.now();
       let oldestKey;
       let oldestExpiry = Infinity;
@@ -10343,13 +10324,15 @@ var runActionPlugin = defineMethod({
           oldestKey = key;
         }
       }
-      if (!evictedAny && oldestKey) cache.delete(oldestKey);
+      if (!evictedAny && oldestKey) {
+        cache.delete(oldestKey);
+      }
     }
-    async function resolveRunActionContext(options) {
+    async function resolveActionRunContext(options) {
       const { imports, appKey, actionKey, actionType } = options;
       const getVersionedImplementationId = imports.manifest.getVersionedImplementationId;
-      const selectedApi = await getVersionedImplementationId(appKey);
-      if (!selectedApi) {
+      const implementationId = await getVersionedImplementationId(appKey);
+      if (!implementationId) {
         throw new ZapierConfigurationError(
           "No current_implementation_id found for app",
           { configType: "current_implementation_id" }
@@ -10365,15 +10348,19 @@ var runActionPlugin = defineMethod({
           `Action type mismatch: expected ${actionType}, got ${actionData.data.action_type}`
         );
       }
-      return { selectedApi, actionId: actionData.data.id };
+      return { implementationId, actionId: actionData.data.id };
     }
-    function getRunActionContext(options) {
+    function getActionRunContext(options) {
       const contextKey = `${options.appKey}:${options.actionKey}:${options.actionType}`;
       const cached = cache.get(contextKey);
-      if (cached && Date.now() < cached.expiresAt) return cached.promise;
-      const pending = resolveRunActionContext(options).catch((error) => {
+      if (cached && Date.now() < cached.expiresAt) {
+        return cached.promise;
+      }
+      const pending = resolveActionRunContext(options).catch((error) => {
         const current = cache.get(contextKey);
-        if (current?.promise === pending) cache.delete(contextKey);
+        if (current?.promise === pending) {
+          cache.delete(contextKey);
+        }
         throw error;
       });
       evictIfNeeded();
@@ -10383,11 +10370,105 @@ var runActionPlugin = defineMethod({
       });
       return pending;
     }
-    return { getRunActionContext };
+    return { getActionRunContext };
   },
   run: async ({ imports, input, state, annotate }) => {
     const api = imports.api;
-    const resolveConnection = imports.connections.resolveConnection;
+    const {
+      app: appKey,
+      action: actionKey,
+      actionType,
+      connection,
+      inputs = {},
+      page,
+      callbackUrl
+    } = input;
+    const connectionId = await resolveConnectionId({
+      connection,
+      resolveConnection: imports.connections.resolveConnection
+    });
+    const { implementationId, actionId } = await state.getActionRunContext({
+      imports,
+      appKey,
+      actionKey,
+      actionType
+    });
+    annotate({ selectedApi: implementationId });
+    const runRequestData = {
+      selected_api: implementationId,
+      // Some actions require the action ID, but it's not guaranteed available
+      // at retrieval time (legacy), so pass everything through.
+      action_id: actionId,
+      action_key: actionKey,
+      action_type: actionType,
+      inputs
+    };
+    if (connectionId != null) {
+      runRequestData.authentication_id = connectionId;
+    }
+    if (page) {
+      runRequestData.page = page;
+    }
+    if (callbackUrl) {
+      runRequestData.callback_url = callbackUrl;
+    }
+    const runData = await api.post(
+      ACTION_RUNS_PATH,
+      { data: runRequestData },
+      {
+        approvalContext: () => policyContext.buildActionRunContext({
+          selected_api: implementationId,
+          action_type: actionType,
+          action_key: actionKey,
+          connection_id: connectionId != null ? String(connectionId) : void 0,
+          // `inputs` is `Record<string, unknown>` at the SDK surface;
+          // buildActionRunContext validates it as JSON at runtime via zod
+          // (non-JSON values like Date/undefined are rejected there).
+          inputs
+        })
+      }
+    );
+    return {
+      data: {
+        id: runData.data.id,
+        implementation_id: implementationId
+      }
+    };
+  }
+});
+
+// src/utils/action-run-wire.ts
+function actionRunPath(run) {
+  return `${ACTION_RUNS_PATH}/${encodeURIComponent(run)}`;
+}
+function actionRunPayload(body) {
+  return body?.data;
+}
+function isActionRunPending(body) {
+  return actionRunPayload(body)?.status === "waiting";
+}
+
+// src/plugins/runAction/index.ts
+var runActionPlugin = defineMethod({
+  name: "runAction",
+  imports: [apiPluginRef, connectionsPluginRef, createActionRunPlugin],
+  categories: ["action"],
+  itemType: "ActionResult",
+  inputSchema: RunActionInputSchema,
+  outputSchema: ActionResultItemSchema,
+  skipOutputValidation: true,
+  formatter: actionResultItemFormatter,
+  // No defaultPageSize — leave the default to the Actions API rather than
+  // eagerly running more actions than the user intends (avoids app rate limits).
+  output: "list",
+  resolvers: {
+    app: appKeyResolver,
+    actionType: actionTypeResolver,
+    action: actionKeyResolver,
+    connection: connectionIdResolver,
+    inputs: inputsResolver
+  },
+  run: async ({ imports, input, annotate }) => {
     const appKey = "app" in input ? input.app : input.appKey;
     const actionKey = "action" in input ? input.action : input.actionKey;
     const {
@@ -10398,39 +10479,40 @@ var runActionPlugin = defineMethod({
       inputs = {},
       cursor
     } = input;
-    const timeoutMilliseconds = input.timeoutSeconds != null ? input.timeoutSeconds * 1e3 : input.timeoutMs;
+    const timeoutMilliseconds = (input.timeoutSeconds != null ? input.timeoutSeconds * 1e3 : input.timeoutMs) ?? DEFAULT_ACTION_TIMEOUT_MILLISECONDS;
     const resolvedConnectionId = await resolveConnectionId({
       connectionId,
       connection,
       authenticationId,
-      resolveConnection
-    });
-    const { selectedApi, actionId } = await state.getRunActionContext({
-      imports,
-      appKey,
-      actionKey,
-      actionType
+      resolveConnection: imports.connections.resolveConnection
     });
-    annotate({ selectedApi });
-    const result = await executeAction({
-      api,
-      selectedApi,
-      // Some actions require the action ID, but it's not guaranteed available at
-      // retrieval time (legacy), so pass everything through.
-      actionId,
-      actionKey,
+    const { data: started } = await imports.createActionRun({
+      app: appKey,
       actionType,
-      executionOptions: { inputs },
-      cursor,
-      connectionId: resolvedConnectionId,
-      timeoutMilliseconds
+      action: actionKey,
+      connection: resolvedConnectionId,
+      inputs,
+      page: cursor
     });
-    if (result.errors && result.errors.length > 0) {
-      const errorMessage2 = result.errors.map((error) => error.detail || error.title || "Unknown error").join("; ");
+    annotate({ selectedApi: started.implementation_id });
+    const run = await imports.api.poll(
+      actionRunPath(started.id),
+      {
+        resource: { type: "run", id: started.id },
+        successStatus: 200,
+        pendingStatus: 202,
+        timeoutMilliseconds,
+        isPending: isActionRunPending,
+        resultExtractor: (body) => actionRunPayload(body) ?? {}
+      }
+    );
+    const errors = run.errors ?? [];
+    if (errors.length > 0) {
+      const errorMessage2 = errors.map((error) => error.detail || error.title || "Unknown error").join("; ");
       throw new ZapierActionError(`Action execution failed: ${errorMessage2}`, {
         appKey,
         actionKey,
-        errors: result.errors.map(
+        errors: errors.map(
           (error) => ({
             status: 200,
             code: error.code ?? "unknown",
@@ -10441,10 +10523,10 @@ var runActionPlugin = defineMethod({
       });
     }
     return {
-      data: result.results || [],
+      data: run.results ?? [],
       // 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
+      nextCursor: run.next_page != null ? String(run.next_page) : void 0
     };
   }
 });
@@ -11875,6 +11957,65 @@ var findUniqueConnectionPlugin = defineMethod({
     return { data: connectionsResponse.data[0] };
   }
 });
+var GetActionRunSchema = zod.z.object({
+  run: zod.z.string().min(1).describe("Action run ID returned by `createActionRun`")
+}).describe(
+  "Fetch the current state of an action run started by `createActionRun`. This is a point-in-time read that returns immediately: a run Zapier has not finished executing comes back with status `waiting`, so call again to check for a result. `runAction` starts a run and waits for its result in one call. Results are stored for seven days after the run was created."
+);
+var ActionRunStatusSchema = openEnum(
+  ["waiting", "success", "error", "unknown"],
+  "Where the run is in its lifecycle. `waiting` means Zapier is still executing it; `error` means the app returned a failure (details in `errors`). `unknown` means the response carried no status, so the outcome could not be determined \u2014 treat it as inconclusive rather than as success."
+);
+var ActionRunErrorSchema = zod.z.object({
+  code: zod.z.string().optional().describe("Machine-readable error category"),
+  title: zod.z.string().nullable().optional().describe("Short error label"),
+  detail: zod.z.string().optional().describe("Human-readable error detail")
+});
+var ActionRunItemSchema = zod.z.object({
+  id: zod.z.string().describe("Action run ID"),
+  status: ActionRunStatusSchema,
+  results: zod.z.array(zod.z.unknown()).describe(
+    "Records the action produced. Can be empty even on a successful run."
+  ),
+  next_page: zod.z.string().optional().describe(
+    "For bulk read actions, the following page. Pass it back as the `page` for `createActionRun` to fetch that page."
+  ),
+  errors: zod.z.array(ActionRunErrorSchema).describe("Errors the app returned while running the action")
+});
+
+// src/plugins/getActionRun/index.ts
+function toActionRun(runId, payload) {
+  if (!payload) {
+    return { id: runId, status: "waiting", results: [], errors: [] };
+  }
+  return {
+    id: payload.id ?? runId,
+    // Never infer success from an absent status.
+    status: payload.status ?? "unknown",
+    results: payload.results ?? [],
+    // The API answers with either a page token or a numeric page index, but
+    // `createActionRun` takes `page` as a string, so normalize to one type the
+    // caller can hand straight back.
+    ...payload.next_page != null ? { next_page: String(payload.next_page) } : {},
+    errors: payload.errors ?? []
+  };
+}
+var getActionRunPlugin = defineMethod({
+  name: "getActionRun",
+  imports: [apiPluginRef],
+  categories: ["action"],
+  itemType: "ActionRun",
+  inputSchema: GetActionRunSchema,
+  outputSchema: ActionRunItemSchema,
+  output: "item",
+  run: async ({ imports, input }) => {
+    const body = await imports.api.get(
+      actionRunPath(input.run),
+      { resource: { type: "run", id: input.run } }
+    );
+    return { data: toActionRun(input.run, actionRunPayload(body)) };
+  }
+});
 var RelayRequestSchema = zod.z.object({
   url: zod.z.string().url().describe("The URL to request (will be proxied through Relay)"),
   method: zod.z.enum(["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"]).optional().describe("HTTP method"),
@@ -15701,6 +15842,8 @@ var zapierSdkPlugin = definePlugin({
     listInputFieldsDeprecatedPlugin,
     getInputFieldsSchemaDeprecatedPlugin,
     listInputFieldChoicesDeprecatedPlugin,
+    createActionRunPlugin,
+    getActionRunPlugin,
     runActionPlugin,
     fetchPlugin,
     requestPlugin,
@@ -15915,6 +16058,7 @@ var registryPlugin = (_sdk) => {
   return {};
 };
 
+exports.ACTION_RUNS_PATH = ACTION_RUNS_PATH;
 exports.API_ID = API_ID;
 exports.ActionKeyPropertySchema = ActionKeyPropertySchema;
 exports.ActionPropertySchema = ActionPropertySchema;
@@ -16028,6 +16172,7 @@ exports.connectionIdGenericResolver = connectionIdGenericResolver;
 exports.connectionIdResolver = connectionIdResolver;
 exports.connectionsPlugin = connectionsPlugin;
 exports.connectionsPluginRef = connectionsPluginRef;
+exports.createActionRunPlugin = createActionRunPlugin;
 exports.createBaseEvent = createBaseEvent;
 exports.createClientCredentialsPlugin = createClientCredentialsPlugin;
 exports.createController = createController;
@@ -16075,6 +16220,7 @@ exports.fromFunctionPlugin = fromFunctionPlugin;
 exports.generateEventId = generateEventId;
 exports.getActionInputFieldsSchemaPlugin = getActionInputFieldsSchemaPlugin;
 exports.getActionPlugin = getActionPlugin;
+exports.getActionRunPlugin = getActionRunPlugin;
 exports.getAgent = getAgent;
 exports.getAppPlugin = getAppPlugin;
 exports.getBaseUrlFromCredentials = getBaseUrlFromCredentials;