@zapier/zapier-sdk 0.8.3 → 0.10.0

package/dist/index.cjs

@@ -1,25 +1,26 @@
 'use strict';
 
 var zod = require('zod');
-var fs = require('fs');
-var path = require('path');
 var promises = require('timers/promises');
 
 // src/types/properties.ts
 function withFormatter(schema, formatMeta) {
-  schema._def.formatMeta = formatMeta;
+  Object.assign(schema._def, {
+    formatMeta
+  });
   return schema;
 }
-function withOutputSchema(inputSchema, outputSchema) {
-  inputSchema._def.outputSchema = outputSchema;
-  return inputSchema;
-}
 function withPositional(schema) {
-  schema._def.positionalMeta = { positional: true };
+  Object.assign(schema._def, {
+    positionalMeta: { positional: true }
+  });
   return schema;
 }
+function schemaHasPositionalMeta(schema) {
+  return "positionalMeta" in schema._def;
+}
 function isPositional(schema) {
-  if (schema._def.positionalMeta?.positional) {
+  if (schemaHasPositionalMeta(schema) && schema._def.positionalMeta?.positional) {
     return true;
   }
   if (schema instanceof zod.z.ZodOptional) {
@@ -606,256 +607,14 @@ function createPaginatedFunction(coreFn, schema) {
   };
   return namedFunctions[functionName];
 }
-var AppItemSchema = withFormatter(
-  zod.z.object({
-    // Essential properties only
-    title: zod.z.string(),
-    // Mapped from name
-    key: zod.z.string(),
-    // Mapped from selected_api
-    current_implementation_id: zod.z.string(),
-    // From id, keeps the full version
-    version: zod.z.string().optional(),
-    // Extracted from implementation ID
-    description: zod.z.string().optional(),
-    slug: zod.z.string().optional()
-  }),
-  {
-    format: (item) => {
-      return {
-        title: item.title,
-        subtitle: `(${item.key})`,
-        details: []
-      };
-    }
-  }
-);
-
-// src/plugins/listApps/schemas.ts
-var ListAppsSchema = withOutputSchema(
-  zod.z.object({
-    appKeys: zod.z.array(zod.z.string()).optional().describe(
-      "Filter apps by app keys (e.g., 'SlackCLIAPI' or slug like 'github')"
-    ),
-    search: zod.z.string().optional().describe("Search for apps by name"),
-    pageSize: zod.z.number().min(1).optional().describe("Number of apps per page"),
-    maxItems: zod.z.number().min(1).optional().describe("Maximum total items to return across all pages")
-  }).describe("List all available apps with optional filtering"),
-  AppItemSchema
-);
-
-// src/utils/domain-utils.ts
-function splitVersionedKey(versionedKey) {
-  const parts = versionedKey.split("@");
-  if (parts.length >= 2) {
-    const baseKey = parts[0];
-    const version = parts.slice(1).join("@");
-    return [baseKey, version];
-  }
-  return [versionedKey, void 0];
-}
-function normalizeImplementationToAppItem(implementation) {
-  const [selectedApi, appVersion] = implementation.selected_api ? splitVersionedKey(implementation.selected_api) : [implementation.selected_api || "", void 0];
-  return {
-    title: implementation.name || selectedApi,
-    key: selectedApi,
-    current_implementation_id: implementation.selected_api || "",
-    version: appVersion
-    // Extract version separately
-  };
-}
-function normalizeImplementationMetaToAppItem(implementationMeta) {
-  const [selectedApi, appVersion] = splitVersionedKey(implementationMeta.id);
-  return {
-    title: implementationMeta.name,
-    key: selectedApi,
-    current_implementation_id: implementationMeta.id,
-    // Keep the full versioned ID
-    version: appVersion,
-    // Extract version separately
-    slug: implementationMeta.slug
-  };
-}
-function normalizeAuthenticationItem(auth, options = {}) {
-  let appKey = options.app_key;
-  let version = options.version;
-  if (auth.selected_api) {
-    const [extractedAppKey, extractedVersion] = splitVersionedKey(
-      auth.selected_api
-    );
-    if (!appKey) {
-      appKey = extractedAppKey;
-    }
-    if (!version) {
-      version = extractedVersion;
-    }
-  }
-  const {
-    selected_api: selectedApi,
-    customuser_id: userId,
-    ...restOfAuth
-  } = auth;
-  return {
-    ...restOfAuth,
-    // Pass through all other API response fields except selected_api
-    implementation_id: selectedApi,
-    // Rename selected_api to implementation_id
-    title: auth.title || auth.label || void 0,
-    // Coerce title from label if missing
-    is_expired: auth.is_stale,
-    // Map is_stale to is_expired
-    expired_at: auth.marked_stale_at,
-    // Map marked_stale_at to expired_at
-    app_key: appKey,
-    // App key from implementations endpoint or parsed from selected_api
-    version,
-    // Version from selected_api or provided
-    user_id: userId
-    // Map customuser_id to user_id
-  };
-}
-function normalizeActionItem(action) {
-  const { name, type, selected_api: appKey, ...restOfAction } = action;
-  return {
-    ...restOfAction,
-    app_key: appKey || "",
-    action_type: type,
-    title: name,
-    // Map name to title
-    type: "action"
-  };
-}
-function groupVersionedAppKeysByType(appKeys) {
-  const result = {
-    selectedApi: [],
-    slug: []
-  };
-  const seenSelectedApi = /* @__PURE__ */ new Set();
-  const seenSlugs = /* @__PURE__ */ new Set();
-  for (const key of appKeys) {
-    const [keyWithoutVersion, version] = splitVersionedKey(key);
-    const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-    if (uuidRegex.test(keyWithoutVersion)) {
-      throw new Error(
-        `UUID app keys are not supported. Use app slug or implementation ID instead of: ${key}`
-      );
-    }
-    if (isSnakeCasedSlug(keyWithoutVersion)) {
-      const dashified = dashifySnakeCasedSlug(keyWithoutVersion);
-      const slugWithVersion = version ? `${dashified}@${version}` : dashified;
-      if (!seenSlugs.has(slugWithVersion)) {
-        seenSlugs.add(slugWithVersion);
-        result.slug.push(slugWithVersion);
-      }
-      continue;
-    }
-    if (keyWithoutVersion.match(/^[a-z0-9]+(?:-[a-z0-9]+)*$/)) {
-      seenSlugs.add(key);
-      result.slug.push(key);
-      continue;
-    }
-    if (!seenSelectedApi.has(key)) {
-      seenSelectedApi.add(key);
-      result.selectedApi.push(key);
-    }
-  }
-  return result;
-}
-function groupAppKeysByType(appKeys) {
-  const grouped = groupVersionedAppKeysByType(appKeys);
-  return {
-    selectedApi: [
-      ...new Set(grouped.selectedApi.map((key) => key.split("@")[0]))
-    ],
-    slug: [...new Set(grouped.slug.map((key) => key.split("@")[0]))]
-  };
-}
-function isSnakeCasedSlug(slug) {
-  if (slug.match(/^_[0-9]/)) {
-    slug = slug.slice(1);
-  }
-  return !!slug.match(/^[a-z0-9]+(?:_[a-z0-9]+)*$/);
-}
-function dashifySnakeCasedSlug(slug) {
-  if (!isSnakeCasedSlug(slug)) {
-    return slug;
-  }
-  if (slug.startsWith("_")) {
-    slug = slug.slice(1);
-  }
-  return slug.replace(/_/g, "-");
-}
-
-// src/plugins/listApps/index.ts
-var listAppsPlugin = ({ context }) => {
-  const listApps = createPaginatedFunction(async function listAppsPage(options) {
-    const api = context.api;
-    const opts = options;
-    const appKeys = [...opts.appKeys ?? []].map(
-      (key) => splitVersionedKey(key)[0]
-    );
-    if (opts.search) {
-      const searchParams2 = {};
-      searchParams2.term = opts.search;
-      const searchEnvelope = await api.get(
-        "/api/v4/implementations-meta/search/",
-        {
-          searchParams: searchParams2
-        }
-      );
-      const implementations = searchEnvelope.results.map(
-        normalizeImplementationMetaToAppItem
-      );
-      const appKeysSet = new Set(appKeys);
-      for (const implementation of implementations) {
-        if (!appKeysSet.has(implementation.key)) {
-          appKeysSet.add(implementation.key);
-          appKeys.push(implementation.key);
-        }
-      }
-    }
-    const searchParams = {};
-    if (opts.pageSize) {
-      searchParams.limit = opts.pageSize.toString();
-    }
-    searchParams.latest_only = "true";
-    if (opts.cursor) {
-      searchParams.offset = opts.cursor;
-    }
-    if (appKeys.length > 0) {
-      const groupedAppKeys = groupAppKeysByType(appKeys);
-      if (groupedAppKeys.selectedApi.length > 0) {
-        searchParams.selected_apis = groupedAppKeys.selectedApi.join(",");
-      }
-      if (groupedAppKeys.slug.length > 0) {
-        searchParams.slugs = groupedAppKeys.slug.join(",");
-      }
-    }
-    const implementationsEnvelope = await api.get(
-      "/api/v4/implementations-meta/lookup/",
-      {
-        searchParams
-      }
-    );
-    return {
-      data: implementationsEnvelope.results.map(
-        normalizeImplementationMetaToAppItem
-      ),
-      nextCursor: extractCursor(implementationsEnvelope)
-    };
-  }, ListAppsSchema);
-  return {
-    listApps,
-    context: {
-      meta: {
-        listApps: {
-          categories: ["app"],
-          inputSchema: ListAppsSchema
-        }
-      }
-    }
-  };
-};
+var ListAppsSchema = zod.z.object({
+  appKeys: zod.z.array(zod.z.string()).optional().describe(
+    "Filter apps by app keys (e.g., 'SlackCLIAPI' or slug like 'github')"
+  ),
+  search: zod.z.string().optional().describe("Search for apps by name"),
+  pageSize: zod.z.number().min(1).optional().describe("Number of apps per page"),
+  maxItems: zod.z.number().min(1).optional().describe("Maximum total items to return across all pages")
+}).describe("List all available apps with optional filtering");
 var NeedChoicesSchema = zod.z.object({
   key: zod.z.string().optional(),
   label: zod.z.string().optional(),
@@ -955,7 +714,7 @@ zod.z.object({
   choices: zod.z.array(ChoiceSchema).optional()
 });
 zod.z.object({
-  data: zod.z.array(zod.z.any())
+  data: zod.z.array(zod.z.unknown())
 });
 var ActionFieldChoiceSchema = zod.z.object({
   value: zod.z.union([zod.z.string(), zod.z.number()]),
@@ -1045,9 +804,9 @@ var UserProfileSchema = zod.z.object({
   enable_totp_2fa: zod.z.boolean(),
   viewed_help: zod.z.record(zod.z.boolean()),
   show_editor_migration_mesaging: zod.z.boolean(),
-  switches: zod.z.record(zod.z.any()),
-  organizations: zod.z.array(zod.z.any().nullable()),
-  primary_organization: zod.z.any().nullable(),
+  switches: zod.z.record(zod.z.unknown()),
+  organizations: zod.z.array(zod.z.record(zod.z.unknown()).nullable()),
+  primary_organization: zod.z.record(zod.z.unknown()).nullable(),
   has_active_zaps: zod.z.boolean(),
   has_google_sso: zod.z.boolean(),
   auth_realm: zod.z.string(),
@@ -1063,8 +822,8 @@ zod.z.object({
   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.any()).optional(),
-  // TODO: Define proper service_category type
+  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(),
@@ -1115,7 +874,7 @@ zod.z.object({
   action: zod.z.string(),
   type_of: zod.z.string(),
   authentication_id: zod.z.number().optional(),
-  params: zod.z.record(zod.z.any()).optional()
+  params: zod.z.record(zod.z.unknown()).optional()
 });
 zod.z.object({
   success: zod.z.boolean(),
@@ -1151,18 +910,11 @@ zod.z.object({
 });
 var ImplementationMetaSchema = zod.z.object({
   id: zod.z.string(),
-  // e.g. "ZapierFormatterCLIAPI@1.0.7"
+  // e.g. "100HiresCLIAPI@1.2.1"
   name: zod.z.string(),
   slug: zod.z.string(),
-  images: zod.z.object({
-    url_16x16: zod.z.string().optional(),
-    url_32x32: zod.z.string().optional(),
-    url_64x64: zod.z.string().optional(),
-    url_128x128: zod.z.string().optional()
-  }).optional(),
-  // Include other fields for completeness but we'll only use what we need
-  ageInDays: zod.z.union([zod.z.string(), zod.z.number()]).optional(),
-  authType: zod.z.string().nullable().optional(),
+  age_in_days: zod.z.number().optional(),
+  auth_type: zod.z.string().optional(),
   banner: zod.z.string().optional(),
   categories: zod.z.array(
     zod.z.object({
@@ -1171,18 +923,45 @@ var ImplementationMetaSchema = zod.z.object({
       slug: zod.z.string()
     })
   ).optional(),
-  isBeta: zod.z.boolean().optional(),
-  isBuiltIn: zod.z.boolean().optional(),
-  isDeprecated: zod.z.boolean().optional(),
-  isFeatured: zod.z.boolean().optional(),
-  isHidden: zod.z.boolean().optional(),
-  isInvite: zod.z.boolean().optional(),
-  isPremium: zod.z.boolean().optional(),
-  isPublic: zod.z.boolean().optional(),
-  isUpcoming: zod.z.boolean().optional(),
+  images: zod.z.object({
+    url_16x16: zod.z.string().optional(),
+    url_32x32: zod.z.string().optional(),
+    url_64x64: zod.z.string().optional(),
+    url_128x128: zod.z.string().optional()
+  }).optional(),
   popularity: zod.z.number().optional(),
-  apiDocsUrl: zod.z.string().optional(),
-  classification: zod.z.string().optional()
+  has_filters: zod.z.boolean().optional(),
+  has_reads: zod.z.boolean().optional(),
+  has_searches: zod.z.boolean().optional(),
+  has_searches_or_writes: zod.z.boolean().optional(),
+  has_upfront_fields: zod.z.boolean().optional(),
+  has_writes: zod.z.boolean().optional(),
+  is_beta: zod.z.boolean().optional(),
+  is_built_in: zod.z.boolean().optional(),
+  is_deprecated: zod.z.boolean().optional(),
+  is_featured: zod.z.boolean().optional(),
+  is_hidden: zod.z.boolean().optional(),
+  is_invite: zod.z.boolean().optional(),
+  is_premium: zod.z.boolean().optional(),
+  is_public: zod.z.boolean().optional(),
+  is_upcoming: zod.z.boolean().optional(),
+  version: zod.z.string().optional(),
+  visibility: zod.z.string().optional(),
+  actions: zod.z.object({
+    read: zod.z.number().optional(),
+    read_bulk: zod.z.number().optional(),
+    write: zod.z.number().optional(),
+    search: zod.z.number().optional(),
+    search_or_write: zod.z.number().optional(),
+    search_and_write: zod.z.number().optional(),
+    filter: zod.z.number().optional()
+  }).optional(),
+  description: zod.z.string().optional(),
+  primary_color: zod.z.string().optional(),
+  secondary_color: zod.z.string().optional(),
+  classification: zod.z.string().optional(),
+  api_docs_url: zod.z.string().optional(),
+  image: zod.z.string().optional()
 });
 zod.z.object({
   count: zod.z.number(),
@@ -1204,7 +983,7 @@ zod.z.object({
   authentication_id: 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.any()).optional().describe(
+  params: zod.z.record(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),
@@ -1227,73 +1006,456 @@ zod.z.object({
   links: NeedChoicesResponseLinksSchema.optional()
 });
 
-// src/schemas/Action.ts
-var ActionItemSchema = withFormatter(
-  ActionSchema.omit({ type: true, name: true }).extend({
-    app_key: zod.z.string(),
-    // Mapped from selected_api
-    action_type: ActionSchema.shape.type,
-    // Mapped from original 'type' field
+// src/schemas/App.ts
+var AppItemSchema = withFormatter(
+  ImplementationMetaSchema.omit({ name: true, id: true }).extend({
     title: zod.z.string(),
-    // Mapped from original 'name' field
-    type: zod.z.literal("action")
-    // Fixed type identifier
+    // Mapped from name
+    key: zod.z.string(),
+    // Extracted from id (base part without version)
+    implementation_id: zod.z.string()
+    // Mapped from id (full versioned ID)
   }),
   {
     format: (item) => {
-      const details = [];
-      details.push({
-        text: `Type: ${item.action_type}`,
-        style: "accent"
-      });
-      if (item.app_key) {
-        details.push({
-          text: `App: ${item.app_key}`,
-          style: "normal"
-        });
-      }
-      if (item.description) {
-        details.push({ text: item.description, style: "dim" });
-      }
       return {
-        title: item.title || item.name || item.key,
-        subtitle: `(${item.key})`,
-        details
+        title: item.title,
+        key: item.key,
+        description: item.description,
+        details: []
       };
     }
   }
 );
 
-// src/plugins/listActions/schemas.ts
-var ListActionsSchema = withOutputSchema(
-  zod.z.object({
-    appKey: AppKeyPropertySchema.describe(
-      "App key of actions to list (e.g., 'SlackCLIAPI')"
-    ),
-    actionType: ActionTypePropertySchema.optional().describe(
-      "Filter actions by type"
-    ),
-    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")
-  }).describe("List all actions for a specific app"),
-  ActionItemSchema
-);
-
-// src/plugins/listActions/index.ts
-var listActionsPlugin = ({ context }) => {
-  const listActions = createPaginatedFunction(async function listActionsPage(options) {
-    const { api, getVersionedImplementationId } = context;
-    const selectedApi = await getVersionedImplementationId(options.appKey);
-    if (!selectedApi) {
-      throw new ZapierConfigurationError(
-        "No current_implementation_id found for app",
-        { configType: "current_implementation_id" }
-      );
-    }
-    const searchParams = {
-      global: "true",
-      public_only: "true",
-      selected_apis: selectedApi
+// src/utils/domain-utils.ts
+function splitVersionedKey(versionedKey) {
+  const parts = versionedKey.split("@");
+  if (parts.length >= 2) {
+    const baseKey = parts[0];
+    const version = parts.slice(1).join("@");
+    return [baseKey, version];
+  }
+  return [versionedKey, void 0];
+}
+function normalizeImplementationMetaToAppItem(implementationMeta) {
+  const [selectedApi, appVersion] = splitVersionedKey(implementationMeta.id);
+  const { id, name, ...restOfImplementationMeta } = implementationMeta;
+  return {
+    // Pass through all ImplementationMeta fields except id and name
+    ...restOfImplementationMeta,
+    // Transform key fields
+    title: name,
+    key: selectedApi,
+    implementation_id: id,
+    // Keep the full versioned ID
+    version: appVersion
+    // Extract version separately
+  };
+}
+function normalizeAuthenticationItem(auth, options = {}) {
+  let appKey = options.app_key;
+  let version = options.version;
+  if (auth.selected_api) {
+    const [extractedAppKey, extractedVersion] = splitVersionedKey(
+      auth.selected_api
+    );
+    if (!appKey) {
+      appKey = extractedAppKey;
+    }
+    if (!version) {
+      version = extractedVersion;
+    }
+  }
+  const {
+    selected_api: selectedApi,
+    customuser_id: userId,
+    ...restOfAuth
+  } = auth;
+  return {
+    ...restOfAuth,
+    // Pass through all other API response fields except selected_api
+    implementation_id: selectedApi,
+    // Rename selected_api to implementation_id
+    title: auth.title || auth.label || void 0,
+    // Coerce title from label if missing
+    is_expired: auth.is_stale,
+    // Map is_stale to is_expired
+    expired_at: auth.marked_stale_at,
+    // Map marked_stale_at to expired_at
+    app_key: appKey,
+    // App key from implementations endpoint or parsed from selected_api
+    version,
+    // Version from selected_api or provided
+    user_id: userId
+    // Map customuser_id to user_id
+  };
+}
+function normalizeActionItem(action) {
+  const { name, type, selected_api: appKey, ...restOfAction } = action;
+  return {
+    ...restOfAction,
+    app_key: appKey || "",
+    action_type: type,
+    title: name,
+    // Map name to title
+    type: "action"
+  };
+}
+function isSlug(slug) {
+  return !!slug.match(/^[a-z0-9]+(?:-[a-z0-9]+)*$/);
+}
+function isSnakeCasedSlug(slug) {
+  if (slug.match(/^_[0-9]/)) {
+    slug = slug.slice(1);
+  }
+  return !!slug.match(/^[a-z0-9]+(?:_[a-z0-9]+)*$/);
+}
+function dashifySnakeCasedSlug(slug) {
+  if (!isSnakeCasedSlug(slug)) {
+    return slug;
+  }
+  if (slug.startsWith("_")) {
+    slug = slug.slice(1);
+  }
+  return slug.replace(/_/g, "-");
+}
+function isUuid(appKey) {
+  return /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(
+    appKey
+  );
+}
+function toAppLocator(appKey) {
+  const [appKeyWithoutVersion, version] = splitVersionedKey(appKey);
+  if (isUuid(appKeyWithoutVersion)) {
+    throw new Error(
+      `UUID app keys are not supported. Use app slug or implementation ID instead of: ${appKey}`
+    );
+  }
+  const slug = isSlug(appKeyWithoutVersion) ? appKeyWithoutVersion : isSnakeCasedSlug(appKeyWithoutVersion) ? dashifySnakeCasedSlug(appKeyWithoutVersion) : void 0;
+  return {
+    lookupAppKey: appKeyWithoutVersion,
+    slug,
+    implementationName: slug ? void 0 : appKeyWithoutVersion,
+    version
+  };
+}
+function isResolvedAppLocator(appLocator) {
+  return !!appLocator.implementationName;
+}
+function toImplementationId(appLocator) {
+  return `${appLocator.implementationName}@${appLocator.version || "latest"}`;
+}
+
+// src/plugins/listApps/index.ts
+var listAppsPlugin = ({ context }) => {
+  const listApps = createPaginatedFunction(async function listAppsPage(options) {
+    const api = context.api;
+    const opts = options;
+    const appLocators = await context.resolveAppKeys({
+      appKeys: [...opts.appKeys ?? []]
+    });
+    const implementationNameToLocator = {};
+    for (const locator of appLocators) {
+      implementationNameToLocator[locator.implementationName] = [
+        ...implementationNameToLocator[locator.implementationName] ?? [],
+        locator
+      ];
+    }
+    const duplicatedLookupAppKeys = Object.keys(implementationNameToLocator).filter((key) => implementationNameToLocator[key].length > 1).map((key) => implementationNameToLocator[key]).flat().map((locator) => locator.lookupAppKey);
+    if (duplicatedLookupAppKeys.length > 0) {
+      throw new Error(
+        `Duplicate lookup app keys found: ${duplicatedLookupAppKeys.join(", ")}`
+      );
+    }
+    if (opts.search) {
+      const searchParams2 = {};
+      searchParams2.term = opts.search;
+      const searchEnvelope = await api.get(
+        "/api/v4/implementations-meta/search/",
+        {
+          searchParams: searchParams2
+        }
+      );
+      const implementations = searchEnvelope.results.map(
+        normalizeImplementationMetaToAppItem
+      );
+      const implementationNameSet = new Set(
+        appLocators.map((locator) => locator.implementationName)
+      );
+      for (const implementation of implementations) {
+        const [implementationName] = splitVersionedKey(implementation.key);
+        if (!implementationNameSet.has(implementationName)) {
+          implementationNameSet.add(implementationName);
+          appLocators.push({
+            ...toAppLocator(implementation.key),
+            implementationName
+          });
+        }
+      }
+    }
+    const searchParams = {};
+    if (opts.pageSize) {
+      searchParams.limit = opts.pageSize.toString();
+    }
+    if (appLocators.length === 0) {
+      searchParams.latest_only = "true";
+    }
+    if (opts.cursor) {
+      searchParams.offset = opts.cursor;
+    }
+    searchParams.selected_apis = appLocators.map((locator) => toImplementationId(locator)).join(",");
+    const implementationsEnvelope = await api.get(
+      "/api/v4/implementations-meta/lookup/",
+      {
+        searchParams
+      }
+    );
+    return {
+      data: implementationsEnvelope.results.map(
+        normalizeImplementationMetaToAppItem
+      ),
+      nextCursor: extractCursor(implementationsEnvelope)
+    };
+  }, ListAppsSchema);
+  return {
+    listApps,
+    context: {
+      meta: {
+        listApps: {
+          categories: ["app"],
+          type: "list",
+          itemType: "App",
+          inputSchema: ListAppsSchema,
+          outputSchema: AppItemSchema
+        }
+      }
+    }
+  };
+};
+var ListActionsSchema = zod.z.object({
+  appKey: AppKeyPropertySchema.describe(
+    "App key of actions to list (e.g., 'SlackCLIAPI')"
+  ),
+  actionType: ActionTypePropertySchema.optional().describe(
+    "Filter actions by type"
+  ),
+  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")
+}).describe("List all actions for a specific app");
+var ActionItemSchema = withFormatter(
+  ActionSchema.omit({ type: true, name: true }).extend({
+    app_key: zod.z.string(),
+    // Mapped from selected_api
+    action_type: ActionSchema.shape.type,
+    // Mapped from original 'type' field
+    title: zod.z.string(),
+    // Mapped from original 'name' field
+    type: zod.z.literal("action")
+    // Fixed type identifier
+  }),
+  {
+    format: (item) => {
+      const details = [];
+      details.push({
+        text: `Type: ${item.action_type}`,
+        style: "accent"
+      });
+      if (item.app_key) {
+        details.push({
+          text: `App: ${item.app_key}`,
+          style: "normal"
+        });
+      }
+      if (item.description) {
+        details.push({
+          text: item.description,
+          style: "dim"
+        });
+      }
+      return {
+        title: item.title || item.key,
+        id: item.id,
+        key: item.key,
+        description: item.description,
+        details
+      };
+    }
+  }
+);
+
+// src/resolvers/appKey.ts
+var appKeyResolver = {
+  type: "static",
+  inputType: "text",
+  placeholder: "Enter app key (e.g., 'SlackCLIAPI' or slug like 'github')"
+};
+
+// src/resolvers/actionType.ts
+var actionTypeResolver = {
+  type: "dynamic",
+  depends: ["appKey"],
+  fetch: async (sdk, resolvedParams) => {
+    const actionsResponse = await sdk.listActions({
+      appKey: resolvedParams.appKey
+    });
+    const types = [
+      ...new Set(actionsResponse.data.map((action) => action.action_type))
+    ];
+    return types.map((type) => ({ key: type, name: type }));
+  },
+  prompt: (types) => ({
+    type: "list",
+    name: "actionType",
+    message: "Select action type:",
+    choices: types.map((type) => ({
+      name: type.name,
+      value: type.key
+    }))
+  })
+};
+
+// src/resolvers/actionKey.ts
+var actionKeyResolver = {
+  type: "dynamic",
+  depends: ["appKey", "actionType"],
+  fetch: async (sdk, resolvedParams) => {
+    const actionsResponse = await sdk.listActions({
+      appKey: resolvedParams.appKey
+    });
+    return actionsResponse.data.filter(
+      (action) => action.action_type === resolvedParams.actionType
+    );
+  },
+  prompt: (actions) => ({
+    type: "list",
+    name: "actionKey",
+    message: "Select action:",
+    choices: actions.map((action) => ({
+      name: `${action.title || action.name || action.key} - ${action.description || "No description"}`,
+      value: action.key
+    }))
+  })
+};
+
+// src/resolvers/authenticationId.ts
+var authenticationIdResolver = {
+  type: "dynamic",
+  depends: ["appKey"],
+  fetch: async (sdk, resolvedParams) => {
+    const listOptions = {
+      maxItems: 1e3
+    };
+    if (resolvedParams.appKey) {
+      listOptions.appKey = resolvedParams.appKey;
+    }
+    const myAuths = await sdk.listAuthentications({
+      ...listOptions,
+      owner: "me"
+    });
+    const allAuths = await sdk.listAuthentications(listOptions);
+    const otherAuths = allAuths.data.filter(
+      (auth) => !myAuths.data.some((myAuth) => myAuth.id === auth.id)
+    );
+    return [...myAuths.data, ...otherAuths];
+  },
+  prompt: (auths, params) => ({
+    type: "list",
+    name: "authenticationId",
+    message: params.appKey ? `Select authentication for ${params.appKey}:` : "Select authentication:",
+    choices: [
+      ...auths.map((auth) => ({
+        name: `${auth.title || auth.label || "Authentication"} (ID: ${auth.id})`,
+        value: auth.id
+      })),
+      {
+        name: "\u2197 Skip authentication (may fail)",
+        value: null
+      }
+    ]
+  })
+};
+var authenticationIdGenericResolver = {
+  ...authenticationIdResolver,
+  depends: []
+};
+
+// src/resolvers/inputs.ts
+var inputsResolver = {
+  type: "fields",
+  depends: ["appKey", "actionKey", "actionType", "authenticationId"],
+  fetch: async (sdk, resolvedParams) => {
+    const fieldsResponse = await sdk.listInputFields({
+      appKey: resolvedParams.appKey,
+      actionKey: resolvedParams.actionKey,
+      actionType: resolvedParams.actionType,
+      authenticationId: resolvedParams.authenticationId,
+      inputs: resolvedParams.inputs
+      // Pass along currently resolved inputs
+    });
+    return fieldsResponse.data;
+  }
+};
+var inputsAllOptionalResolver = {
+  type: "fields",
+  depends: ["appKey", "actionKey", "actionType", "authenticationId"],
+  fetch: async (sdk, resolvedParams) => {
+    const fieldsResponse = await sdk.listInputFields({
+      appKey: resolvedParams.appKey,
+      actionKey: resolvedParams.actionKey,
+      actionType: resolvedParams.actionType,
+      authenticationId: resolvedParams.authenticationId,
+      inputs: resolvedParams.inputs
+      // Pass along currently resolved inputs
+    });
+    return fieldsResponse.data.map((field) => ({
+      ...field,
+      is_required: false
+    }));
+  }
+};
+
+// src/resolvers/inputFieldKey.ts
+var inputFieldKeyResolver = {
+  type: "dynamic",
+  depends: ["appKey", "actionKey", "actionType", "authenticationId"],
+  fetch: async (sdk, resolvedParams) => {
+    const fieldsResponse = await sdk.listInputFields({
+      appKey: resolvedParams.appKey,
+      actionKey: resolvedParams.actionKey,
+      actionType: resolvedParams.actionType,
+      authenticationId: resolvedParams.authenticationId,
+      inputs: resolvedParams.inputs
+      // Pass along currently resolved inputs
+    });
+    return fieldsResponse.data;
+  },
+  prompt: (fields) => ({
+    type: "list",
+    name: "inputFieldKey",
+    message: "Select input field:",
+    choices: fields.map((field) => ({
+      name: `${field.title || field.key} - ${field.value_type || "No type"} ${field.is_required ? "(required)" : "(optional)"}`,
+      value: field.key
+    }))
+  })
+};
+
+// src/plugins/listActions/index.ts
+var listActionsPlugin = ({ context }) => {
+  const listActions = createPaginatedFunction(async function listActionsPage(options) {
+    const { api, getVersionedImplementationId } = context;
+    const selectedApi = await getVersionedImplementationId(options.appKey);
+    if (!selectedApi) {
+      throw new ZapierConfigurationError(
+        "No current_implementation_id found for app",
+        { configType: "current_implementation_id" }
+      );
+    }
+    const searchParams = {
+      global: "true",
+      public_only: "true",
+      selected_apis: selectedApi
     };
     const data = await api.get(
       "/api/v4/implementations/",
@@ -1344,7 +1506,14 @@ var listActionsPlugin = ({ context }) => {
       meta: {
         listActions: {
           categories: ["action"],
-          inputSchema: ListActionsSchema
+          type: "list",
+          itemType: "Action",
+          inputSchema: ListActionsSchema,
+          outputSchema: ActionItemSchema,
+          resolvers: {
+            appKey: appKeyResolver,
+            actionType: actionTypeResolver
+          }
         }
       }
     }
@@ -1361,6 +1530,83 @@ var ListInputFieldsSchema = zod.z.object({
   pageSize: zod.z.number().min(1).optional().describe("Number of input fields per page"),
   maxItems: zod.z.number().min(1).optional().describe("Maximum total items to return across all pages")
 }).describe("Get the input fields required for a specific action");
+var InputFieldItemSchema = withFormatter(
+  zod.z.object({
+    key: zod.z.string(),
+    // From need.key
+    default_value: zod.z.string(),
+    // Mapped from 'default' with fallback to ""
+    depends_on: zod.z.array(zod.z.string()),
+    // Mapped from 'depends_on' with fallback to []
+    description: zod.z.string(),
+    // Mapped from 'help_text' with fallback to ""
+    invalidates_input_fields: zod.z.boolean(),
+    // Mapped from 'alters_custom_fields' with fallback to false
+    is_required: zod.z.boolean(),
+    // Mapped from 'required' with fallback to false
+    placeholder: zod.z.string(),
+    // Mapped from 'placeholder' with fallback to ""
+    title: zod.z.string(),
+    // Mapped from 'label' with fallback to ""
+    value_type: zod.z.string(),
+    // Computed from InputFieldType enum
+    format: zod.z.string().optional(),
+    // Computed from InputFieldFormat enum (optional)
+    items: zod.z.object({ type: zod.z.string() }).optional()
+    // Computed from ItemsType enum (optional, only for arrays)
+  }),
+  {
+    format: (item) => {
+      const details = [];
+      const typeInfo = [
+        item.value_type && `Type: ${item.value_type}`,
+        `Required: ${item.is_required ? "Yes" : "No"}`
+      ].filter(Boolean).join(" | ");
+      if (typeInfo) {
+        details.push({ text: typeInfo, style: "dim" });
+      }
+      if (item.description) {
+        details.push({
+          text: item.description,
+          style: "normal"
+        });
+      }
+      if (item.default_value) {
+        details.push({
+          text: `Default: ${item.default_value}`,
+          style: "accent"
+        });
+      }
+      if (item.placeholder) {
+        details.push({
+          text: `Placeholder: ${item.placeholder}`,
+          style: "dim"
+        });
+      }
+      if (item.depends_on && item.depends_on.length > 0) {
+        details.push({
+          text: `Depends on: ${item.depends_on.join(", ")}`,
+          style: "warning"
+        });
+      }
+      if (item.format) {
+        details.push({ text: `Format: ${item.format}`, style: "dim" });
+      }
+      if (item.items) {
+        details.push({
+          text: `Items type: ${item.items.type}`,
+          style: "dim"
+        });
+      }
+      return {
+        title: item.title || item.key,
+        key: item.key,
+        description: item.description,
+        details
+      };
+    }
+  }
+);
 
 // src/plugins/listInputFields/index.ts
 function getInputFieldTypeFromNeed(need) {
@@ -1405,9 +1651,8 @@ function getItemsTypeFromNeed(need) {
 function transformNeedToInputFieldItem(need) {
   const itemsType = getItemsTypeFromNeed(need);
   return {
-    ...need,
-    // Pass through all original Need fields
-    id: need.key,
+    // Only the final computed/mapped fields that are in InputFieldItemSchema
+    key: need.key,
     default_value: need.default || "",
     depends_on: need.depends_on || [],
     description: need.help_text || "",
@@ -1467,7 +1712,17 @@ var listInputFieldsPlugin = ({ context }) => {
       meta: {
         listInputFields: {
           categories: ["action"],
-          inputSchema: ListInputFieldsSchema
+          type: "list",
+          itemType: "InputField",
+          inputSchema: ListInputFieldsSchema,
+          outputSchema: InputFieldItemSchema,
+          resolvers: {
+            appKey: appKeyResolver,
+            actionType: actionTypeResolver,
+            actionKey: actionKeyResolver,
+            authenticationId: authenticationIdResolver,
+            inputs: inputsAllOptionalResolver
+          }
         }
       }
     }
@@ -1477,6 +1732,7 @@ var ListAuthenticationsSchema = zod.z.object({
   appKey: AppKeyPropertySchema.optional().describe(
     "App key of authentications to list (e.g., 'SlackCLIAPI')"
   ),
+  authenticationIds: zod.z.array(zod.z.string()).optional().describe("List of authentication IDs to filter by"),
   search: zod.z.string().optional().describe("Search term to filter authentications by title"),
   title: zod.z.string().optional().describe("Filter authentications by exact title match"),
   accountId: zod.z.string().optional().describe("Filter by account ID"),
@@ -1484,6 +1740,49 @@ var ListAuthenticationsSchema = zod.z.object({
   pageSize: zod.z.number().min(1).optional().describe("Number of authentications per page"),
   maxItems: zod.z.number().min(1).optional().describe("Maximum total items to return across all pages")
 }).describe("List available authentications with optional filtering");
+var AuthenticationItemSchema = withFormatter(
+  AuthenticationSchema.omit({ selected_api: true, customuser_id: true }).extend(
+    {
+      implementation_id: zod.z.string().optional(),
+      // Renamed from selected_api
+      is_expired: zod.z.string().optional(),
+      // Mapped from is_stale
+      expired_at: zod.z.string().nullable().optional(),
+      // Mapped from marked_stale_at
+      app_key: zod.z.string().optional(),
+      // App key from implementations endpoint
+      version: zod.z.string().optional(),
+      // Version extracted from implementation_id
+      user_id: zod.z.number().optional()
+    }
+  ),
+  {
+    format: (item) => {
+      const details = [];
+      if (item.identifier) {
+        details.push({
+          text: `Identifier: ${item.identifier}`,
+          style: "accent"
+        });
+      }
+      details.push({
+        text: `Account: ${item.account_id} | Private: ${item.is_private} | Shared: ${item.shared_with_all}`,
+        style: "dim"
+      });
+      if (item.marked_stale_at) {
+        details.push({
+          text: `\u26A0\uFE0F  Marked stale: ${new Date(item.marked_stale_at).toLocaleDateString()}`,
+          style: "warning"
+        });
+      }
+      return {
+        title: item.title || `Authentication ${item.id}`,
+        id: item.id?.toString(),
+        details
+      };
+    }
+  }
+);
 
 // src/plugins/listAuthentications/index.ts
 var listAuthenticationsPlugin = ({ context }) => {
@@ -1500,6 +1799,9 @@ var listAuthenticationsPlugin = ({ context }) => {
           searchParams.versionless_selected_api = versionlessSelectedApi;
         }
       }
+      if (options.authenticationIds && options.authenticationIds.length > 0) {
+        searchParams.ids = options.authenticationIds.join(",");
+      }
       if (options.search) {
         searchParams.search = options.search;
       } else if (options.title) {
@@ -1556,33 +1858,36 @@ var listAuthenticationsPlugin = ({ context }) => {
       meta: {
         listAuthentications: {
           categories: ["authentication"],
-          inputSchema: ListAuthenticationsSchema
+          type: "list",
+          itemType: "Authentication",
+          inputSchema: ListAuthenticationsSchema,
+          outputSchema: AuthenticationItemSchema,
+          resolvers: {
+            appKey: appKeyResolver
+          }
         }
       }
     }
   };
 };
-var GetAppSchema = withOutputSchema(
-  zod.z.object({
-    appKey: AppKeyPropertySchema.describe(
-      "App key of app to fetch (e.g., 'SlackCLIAPI')"
-    )
-  }).describe("Get detailed information about a specific app"),
-  AppItemSchema
-);
+var GetAppSchema = zod.z.object({
+  appKey: AppKeyPropertySchema.describe(
+    "App key of app to fetch (e.g., 'SlackCLIAPI')"
+  )
+}).describe("Get detailed information about a specific app");
 
 // src/plugins/getApp/index.ts
-var getAppPlugin = ({ context }) => {
+var getAppPlugin = ({ sdk }) => {
   const getApp = createFunction(async function getApp2(options) {
-    const app = await context.getImplementation(options.appKey);
-    if (!app) {
-      throw new ZapierAppNotFoundError("App not found", {
-        appKey: options.appKey
-      });
+    const appsIterator = sdk.listApps({ appKeys: [options.appKey] }).items();
+    for await (const app of appsIterator) {
+      return {
+        data: app
+      };
     }
-    return {
-      data: app
-    };
+    throw new ZapierAppNotFoundError("App not found", {
+      appKey: options.appKey
+    });
   }, GetAppSchema);
   return {
     getApp,
@@ -1590,7 +1895,13 @@ var getAppPlugin = ({ context }) => {
       meta: {
         getApp: {
           categories: ["app"],
-          inputSchema: GetAppSchema
+          type: "item",
+          itemType: "App",
+          inputSchema: GetAppSchema,
+          outputSchema: AppItemSchema,
+          resolvers: {
+            appKey: appKeyResolver
+          }
         }
       }
     }
@@ -1623,7 +1934,15 @@ var getActionPlugin = ({ sdk }) => {
       meta: {
         getAction: {
           categories: ["action"],
-          inputSchema: GetActionSchema
+          type: "item",
+          itemType: "Action",
+          inputSchema: GetActionSchema,
+          outputSchema: ActionItemSchema,
+          resolvers: {
+            appKey: appKeyResolver,
+            actionType: actionTypeResolver,
+            actionKey: actionKeyResolver
+          }
         }
       }
     }
@@ -1678,7 +1997,13 @@ var getAuthenticationPlugin = ({ context }) => {
       meta: {
         getAuthentication: {
           categories: ["authentication"],
-          inputSchema: GetAuthenticationSchema
+          type: "item",
+          itemType: "Authentication",
+          inputSchema: GetAuthenticationSchema,
+          outputSchema: AuthenticationItemSchema,
+          resolvers: {
+            authenticationId: authenticationIdGenericResolver
+          }
         }
       }
     }
@@ -1702,8 +2027,14 @@ var findFirstAuthenticationPlugin = ({ sdk }) => {
         ...options,
         maxItems: 1
       });
+      if (authsResponse.data.length === 0) {
+        throw new ZapierResourceNotFoundError(
+          "No authentication found matching the specified criteria",
+          { resourceType: "Authentication" }
+        );
+      }
       return {
-        data: authsResponse.data.length > 0 ? authsResponse.data[0] : null
+        data: authsResponse.data[0]
       };
     },
     FindFirstAuthenticationSchema
@@ -1714,7 +2045,10 @@ var findFirstAuthenticationPlugin = ({ sdk }) => {
       meta: {
         findFirstAuthentication: {
           categories: ["authentication"],
-          inputSchema: FindFirstAuthenticationSchema
+          type: "item",
+          itemType: "Authentication",
+          inputSchema: FindFirstAuthenticationSchema,
+          outputSchema: AuthenticationItemSchema
         }
       }
     }
@@ -1762,7 +2096,10 @@ var findUniqueAuthenticationPlugin = ({ sdk }) => {
       meta: {
         findUniqueAuthentication: {
           categories: ["authentication"],
-          inputSchema: FindUniqueAuthenticationSchema
+          type: "item",
+          itemType: "Authentication",
+          inputSchema: FindUniqueAuthenticationSchema,
+          outputSchema: AuthenticationItemSchema
         }
       }
     }
@@ -1779,6 +2116,31 @@ var RunActionSchema = zod.z.object({
   pageSize: zod.z.number().min(1).optional().describe("Number of results per page"),
   maxItems: zod.z.number().min(1).optional().describe("Maximum total items to return across all pages")
 }).describe("Execute an action with the given inputs");
+function getStringProperty(obj, key) {
+  if (typeof obj === "object" && obj !== null && key in obj) {
+    const value = obj[key];
+    return typeof value === "string" ? value : void 0;
+  }
+  return void 0;
+}
+function formatActionResult(item) {
+  const obj = typeof item === "object" && item !== null ? item : {};
+  const title = getStringProperty(obj, "title") || getStringProperty(obj, "name") || getStringProperty(obj, "label") || getStringProperty(obj, "subject") || "Action Result";
+  return {
+    title,
+    id: getStringProperty(obj, "id"),
+    key: getStringProperty(obj, "key"),
+    description: getStringProperty(obj, "description"),
+    data: item,
+    // Let formatJsonOutput handle the JSON rendering
+    details: []
+    // Not used when data is provided
+  };
+}
+var ActionResultItemSchema = withFormatter(
+  zod.z.unknown().describe("Action execution result"),
+  { format: formatActionResult }
+);
 
 // src/plugins/runAction/index.ts
 async function executeAction(actionOptions) {
@@ -1870,7 +2232,17 @@ var runActionPlugin = ({ sdk, context }) => {
       meta: {
         runAction: {
           categories: ["action"],
-          inputSchema: RunActionSchema
+          type: "list",
+          itemType: "ActionResult",
+          inputSchema: RunActionSchema,
+          outputSchema: ActionResultItemSchema,
+          resolvers: {
+            appKey: appKeyResolver,
+            actionType: actionTypeResolver,
+            actionKey: actionKeyResolver,
+            authenticationId: authenticationIdResolver,
+            inputs: inputsResolver
+          }
         }
       }
     }
@@ -1942,12 +2314,74 @@ var requestPlugin = ({ context }) => {
       meta: {
         request: {
           categories: ["http"],
+          returnType: "Response",
           inputSchema: RelayRequestSchema
         }
       }
     }
   };
 };
+
+// src/utils/file-utils.ts
+var inMemoryFiles = {};
+var fsPromises = null;
+var pathModule = null;
+async function loadFsPromises() {
+  if (fsPromises) return fsPromises;
+  try {
+    fsPromises = await import('fs/promises');
+    return fsPromises;
+  } catch {
+    return null;
+  }
+}
+async function loadPathModule() {
+  if (pathModule) return pathModule;
+  try {
+    pathModule = await import('path');
+    return pathModule;
+  } catch {
+    return null;
+  }
+}
+async function resolve(path, basePath = "/") {
+  const pathModule2 = await loadPathModule();
+  if (pathModule2) {
+    return pathModule2.resolve(path);
+  }
+  if (path.startsWith("/")) {
+    return path;
+  }
+  if (path.startsWith("./")) {
+    const cleanPath = path.slice(2);
+    return basePath.endsWith("/") ? basePath + cleanPath : basePath + "/" + cleanPath;
+  }
+  if (path.startsWith("../")) {
+    const cleanPath = path.replace(/^(\.\.\/)+/, "");
+    return basePath.endsWith("/") ? basePath + cleanPath : basePath + "/" + cleanPath;
+  }
+  return basePath.endsWith("/") ? basePath + path : basePath + "/" + path;
+}
+async function writeFile(filePath, content) {
+  const fs = await loadFsPromises();
+  if (fs) {
+    await fs.writeFile(filePath, content, "utf8");
+    return;
+  }
+  inMemoryFiles[filePath] = content;
+}
+async function readFile(filePath) {
+  const fs = await loadFsPromises();
+  if (fs) {
+    return await fs.readFile(filePath, "utf8");
+  }
+  const content = inMemoryFiles[filePath];
+  if (content !== void 0) {
+    return content;
+  }
+  throw new Error(`File not found: ${filePath}`);
+}
+var DEFAULT_CONFIG_PATH = ".zapierrc";
 var ManifestSchema = zod.z.object({
   apps: zod.z.record(
     zod.z.string(),
@@ -1970,6 +2404,15 @@ zod.z.object({
   ).optional().describe("Direct manifest object")
 });
 
+// src/utils/array-utils.ts
+async function toArrayFromAsync(asyncIterable) {
+  const result = [];
+  for await (const item of asyncIterable) {
+    result.push(item);
+  }
+  return result;
+}
+
 // src/plugins/manifest/index.ts
 function parseManifestContent(content, source) {
   try {
@@ -1987,172 +2430,239 @@ function parseManifestContent(content, source) {
     return null;
   }
 }
-function loadManifestFromFile(filePath) {
+async function readManifestFromFile(filePath) {
   try {
-    const resolvedPath = path.resolve(filePath);
-    const content = fs.readFileSync(resolvedPath, "utf8");
+    const resolvedPath = await resolve(filePath);
+    const content = await readFile(resolvedPath);
     return parseManifestContent(content, resolvedPath);
   } catch {
-    console.warn(`\u26A0\uFE0F Failed to load manifest from ${filePath}`);
+    console.warn(`\u26A0\uFE0F Failed to read manifest from ${filePath}`);
     return null;
   }
 }
-var emitWarning = (appKey) => {
-  console.warn(
-    `
-${"\u26A0\uFE0F".padEnd(3)} ${"WARNING".padEnd(8)} No manifest version found for '${appKey}'`
-  );
-  console.warn(
-    `   ${"\u21B3".padEnd(3)} Using a manifest ensures version locking and prevents unexpected behavior due to version changes.`
+async function writeManifestToFile(manifest, filePath) {
+  const resolvedPath = await resolve(filePath);
+  await writeFile(resolvedPath, JSON.stringify(manifest, null, 2));
+}
+async function getPreferredManifestEntryKey({
+  appKey,
+  api
+}) {
+  const locator = toAppLocator(appKey);
+  if (locator.slug) {
+    return locator.slug;
+  }
+  if (locator.implementationName) {
+    try {
+      const implementationsEnvelope = await api.get(`/api/v4/implementations-meta/lookup/`, {
+        searchParams: {
+          selected_apis: locator.implementationName
+        }
+      });
+      if (implementationsEnvelope.results.length > 0 && implementationsEnvelope.results[0].slug) {
+        return implementationsEnvelope.results[0].slug;
+      }
+    } catch {
+    }
+    return locator.implementationName;
+  }
+  return locator.lookupAppKey;
+}
+async function listAppsForSlugsPage({
+  slugs,
+  cursor,
+  api
+}) {
+  const searchParams = {};
+  if (slugs.length > 0) {
+    searchParams.slugs = slugs.join(",");
+  }
+  if (cursor) {
+    searchParams.offset = cursor;
+  }
+  const implementationsEnvelope = await api.get(
+    "/api/v4/implementations-meta/lookup/",
+    {
+      searchParams
+    }
   );
-  console.warn(
-    `   ${"\u21B3".padEnd(3)} Generate/update the manifest with: \`zapier-sdk lock-version ${appKey}\`
-`
+  return {
+    data: implementationsEnvelope.results.map(
+      normalizeImplementationMetaToAppItem
+    ),
+    nextCursor: extractCursor(implementationsEnvelope)
+  };
+}
+function findManifestEntry({
+  appKey,
+  manifest
+}) {
+  const [appKeyWithoutVersion] = splitVersionedKey(appKey);
+  if (manifest.apps[appKeyWithoutVersion]) {
+    return [appKeyWithoutVersion, manifest.apps[appKeyWithoutVersion]];
+  }
+  if (isSnakeCasedSlug(appKey)) {
+    const slug = dashifySnakeCasedSlug(appKey);
+    if (manifest.apps[slug]) {
+      return [slug, manifest.apps[slug]];
+    }
+  }
+  for (const [key, entry] of Object.entries(manifest.apps)) {
+    if (entry.implementationName === appKeyWithoutVersion) {
+      return [key, entry];
+    }
+  }
+  return null;
+}
+async function resolveAppKeys({
+  appKeys,
+  api,
+  manifest
+}) {
+  const locators = appKeys.map(toAppLocator);
+  const locatorsWithManifest = locators.map((locator) => {
+    const manifestEntryResult = findManifestEntry({
+      appKey: locator.lookupAppKey,
+      manifest
+    });
+    if (manifestEntryResult) {
+      const [, manifestEntry] = manifestEntryResult;
+      const resolvedVersion = locator.version || manifestEntry.version;
+      const resolvedLocator = {
+        ...locator,
+        implementationName: manifestEntry.implementationName,
+        version: resolvedVersion
+      };
+      return resolvedLocator;
+    }
+    return locator;
+  });
+  const unresolvedLocators = locatorsWithManifest.filter(
+    (locator) => !isResolvedAppLocator(locator)
   );
-};
+  const slugsToResolve = unresolvedLocators.map((locator) => locator.slug).filter((slug) => !!slug).filter((slug, index, array) => array.indexOf(slug) === index);
+  if (slugsToResolve.length === 0) {
+    return locatorsWithManifest.filter(isResolvedAppLocator);
+  }
+  const iterator = paginate(listAppsForSlugsPage, {
+    slugs: slugsToResolve,
+    api
+  });
+  const pages = await toArrayFromAsync(iterator);
+  const apps = pages.flatMap((page) => page.data);
+  const slugToAppData = /* @__PURE__ */ new Map();
+  for (const app of apps) {
+    if (app.slug) {
+      slugToAppData.set(app.slug, app);
+    }
+  }
+  const slugResolvedLocators = locatorsWithManifest.map((locator) => {
+    if (isResolvedAppLocator(locator)) {
+      return locator;
+    }
+    if (locator.slug) {
+      const appData = slugToAppData.get(locator.slug);
+      if (appData) {
+        const manifestEntryByImplementationName = findManifestEntry({
+          appKey: appData.key,
+          // appData.key is the implementation name
+          manifest
+        });
+        let version = locator.version;
+        if (!version) {
+          version = manifestEntryByImplementationName ? manifestEntryByImplementationName[1].version || appData.version : appData.version;
+        }
+        return {
+          ...locator,
+          implementationName: appData.key,
+          version
+        };
+      }
+    }
+    return locator;
+  });
+  return slugResolvedLocators.filter(isResolvedAppLocator);
+}
 var manifestPlugin = (params) => {
-  const { sdk, context } = params;
+  const { context } = params;
   const { api, options } = context;
-  const { manifestPath = ".zapierrc", manifest } = options || {};
+  const { manifestPath = DEFAULT_CONFIG_PATH, manifest } = options || {};
   let resolvedManifest;
-  function resolveManifest() {
+  async function resolveManifest() {
     if (manifest) {
       return manifest;
     }
     if (manifestPath) {
-      return loadManifestFromFile(manifestPath);
+      return await readManifestFromFile(manifestPath);
     }
     return null;
   }
-  const getResolvedManifest = () => {
+  const getResolvedManifest = async () => {
     if (typeof resolvedManifest === "undefined") {
-      resolvedManifest = resolveManifest() ?? null;
+      resolvedManifest = await resolveManifest() ?? null;
     }
     return resolvedManifest;
   };
-  const getManifestEntry = (appKey) => {
-    return getResolvedManifest()?.apps?.[appKey] || null;
+  const getVersionedImplementationId = async (appKey) => {
+    const resolvedApps = await resolveAppKeys({
+      appKeys: [appKey],
+      api,
+      manifest: await getResolvedManifest() ?? { apps: {} }
+    });
+    const resolvedApp = resolvedApps[0];
+    if (!resolvedApp) return null;
+    return `${resolvedApp.implementationName}@${resolvedApp.version || "latest"}`;
   };
-  const getImplementation = async (appKey) => {
-    let selectedApi = null;
-    const manifestImplementation = getResolvedManifest()?.apps?.[appKey];
-    const [versionlessAppKey, version] = splitVersionedKey(appKey);
-    if (version) {
-      selectedApi = `${versionlessAppKey}@${version}`;
-    } else if (manifestImplementation) {
-      selectedApi = `${manifestImplementation.implementationName}@${manifestImplementation.version || "latest"}`;
-    }
-    if (selectedApi) {
-      const searchParams = {
-        selected_apis: selectedApi
-      };
-      const implementationData = await api.get(
-        "/api/v4/implementations/",
-        {
-          searchParams
+  const updateManifestEntry = async (appKey, entry, configPath = DEFAULT_CONFIG_PATH) => {
+    const manifest2 = await readManifestFromFile(configPath) || { apps: {} };
+    let existingEntry = findManifestEntry({
+      appKey,
+      manifest: manifest2
+    });
+    if (!existingEntry) {
+      try {
+        const resolvedApps = await resolveAppKeys({
+          appKeys: [appKey],
+          api,
+          manifest: manifest2
+        });
+        if (resolvedApps.length > 0) {
+          const resolvedImplementationName = resolvedApps[0].implementationName;
+          existingEntry = findManifestEntry({
+            appKey: resolvedImplementationName,
+            manifest: manifest2
+          });
         }
-      );
-      const implementationResults = implementationData.results[0];
-      if (!implementationResults) return null;
-      return normalizeImplementationToAppItem(implementationResults);
-    }
-    emitWarning(appKey);
-    const appsIterator = sdk.listApps({ appKeys: [appKey] }).items();
-    const apps = [];
-    for await (const app2 of appsIterator) {
-      apps.push(app2);
-      break;
-    }
-    if (apps.length === 0) {
-      return null;
-    }
-    const app = apps[0];
-    return app;
-  };
-  const getVersionedImplementationId = async (appKey) => {
-    const manifestEntry = getManifestEntry(appKey);
-    if (manifestEntry) {
-      return `${manifestEntry.implementationName}@${manifestEntry.version || "latest"}`;
+      } catch {
+      }
     }
-    const implementation = await getImplementation(appKey);
-    if (!implementation) return null;
-    return implementation.current_implementation_id;
-  };
-  return {
-    context: {
-      getVersionedImplementationId,
-      getManifestEntry,
-      getImplementation
+    let manifestKey;
+    if (existingEntry) {
+      manifestKey = existingEntry[0];
+    } else {
+      manifestKey = await getPreferredManifestEntryKey({
+        appKey,
+        api
+      });
     }
+    manifest2.apps[manifestKey] = entry;
+    await writeManifestToFile(manifest2, configPath);
+    resolvedManifest = void 0;
+    return [manifestKey, entry];
   };
-};
-var LockVersionSchema = zod.z.object({
-  appKey: zod.z.string().describe("The app key to lock version for (e.g., 'slack', 'gmail')")
-});
-var lockVersionPlugin = ({ sdk }) => {
-  const lockVersion = createFunction(
-    async function lockVersion2(options) {
-      const { appKey, configPath = ".zapierrc" } = options;
-      const resolvedPath = path.resolve(configPath);
-      const appsIterator = sdk.listApps({ appKeys: [appKey] }).items();
-      const apps = [];
-      for await (const app2 of appsIterator) {
-        apps.push(app2);
-        break;
-      }
-      const app = apps[0];
-      const currentImplementationId = app.current_implementation_id;
-      const [implementationName, version] = currentImplementationId.split("@");
-      if (!implementationName || !version) {
-        throw new Error(
-          `Invalid implementation ID format: ${currentImplementationId}. Expected format: <implementationName>@<version>`
-        );
-      }
-      let config = { apps: {} };
-      if (fs.existsSync(resolvedPath)) {
-        try {
-          const configContent = fs.readFileSync(resolvedPath, "utf8");
-          config = JSON.parse(configContent);
-          if (!config.apps) {
-            config.apps = {};
-          }
-        } catch (error) {
-          console.warn(
-            `\u26A0\uFE0F Failed to parse existing config file, creating new one: ${error}`
-          );
-          config = { apps: {} };
-        }
-      }
-      config.apps[appKey] = {
-        implementationName,
-        version
-      };
-      fs.writeFileSync(resolvedPath, JSON.stringify(config, null, 2));
-      return {
-        data: {
-          ...app,
-          implementationName,
-          version
-        },
-        configPath: resolvedPath
-      };
-    },
-    LockVersionSchema.extend({
-      configPath: zod.z.string().optional().describe("Path to .zapierrc file (defaults to '.zapierrc')")
-    })
-  );
   return {
-    lockVersion,
     context: {
-      meta: {
-        lockVersion: {
-          categories: ["utility"],
-          inputSchema: LockVersionSchema
-        }
-      }
+      getVersionedImplementationId,
+      resolveAppKeys: async ({ appKeys }) => resolveAppKeys({
+        appKeys,
+        api,
+        manifest: await getResolvedManifest() ?? { apps: {} }
+      }),
+      updateManifestEntry
     }
   };
 };
+var GetProfileSchema = zod.z.object({}).optional().describe("Get current user's profile information");
 var UserProfileItemSchema = withFormatter(
   UserProfileSchema.omit({ user_id: true }).extend({
     full_name: zod.z.string()
@@ -2161,32 +2671,37 @@ var UserProfileItemSchema = withFormatter(
   {
     format: (item) => {
       const details = [];
-      details.push({ text: item.email, style: "dim" });
-      if (item.timezone) {
+      if (item == null || typeof item !== "object" || !("full_name" in item) || !("username" in item)) {
+        return {
+          title: "User Profile",
+          subtitle: "Malformatted result item",
+          details: []
+        };
+      }
+      if ("email" in item) {
+        details.push({ text: item.email, style: "dim" });
+      }
+      if ("timezone" in item && item.timezone) {
         details.push({
           text: `Timezone: ${item.timezone}`,
           style: "accent"
         });
       }
-      details.push({
-        text: `Member since: ${item.since_signup}`,
-        style: "dim"
-      });
+      if ("since_signup" in item && item.since_signup) {
+        details.push({
+          text: `Member since: ${item.since_signup}`,
+          style: "dim"
+        });
+      }
       return {
         title: item.full_name,
-        subtitle: `@${item.username}`,
+        id: item.id.toString(),
         details
       };
     }
   }
 );
 
-// src/plugins/getProfile/schemas.ts
-var GetProfileSchema = withOutputSchema(
-  zod.z.object({}).optional().describe("Get current user's profile information"),
-  UserProfileItemSchema
-);
-
 // src/plugins/getProfile/index.ts
 var getProfilePlugin = ({ context }) => {
   const getProfile = createFunction(async function getProfile2() {
@@ -2209,7 +2724,10 @@ var getProfilePlugin = ({ context }) => {
       meta: {
         getProfile: {
           categories: ["account"],
-          inputSchema: GetProfileSchema
+          type: "item",
+          itemType: "Profile",
+          inputSchema: GetProfileSchema,
+          outputSchema: UserProfileItemSchema
         }
       }
     }
@@ -2242,6 +2760,38 @@ function createDebugLogger(enabled) {
     console.log(`[Zapier SDK] ${message}`, data || "");
   };
 }
+function censorHeaders(headers) {
+  if (!headers) return headers;
+  const headersObj = new Headers(headers);
+  const authKeys = ["authorization", "x-api-key"];
+  for (const [key, value] of headersObj.entries()) {
+    if (authKeys.some((authKey) => key.toLowerCase() === authKey)) {
+      const spaceIndex = value.indexOf(" ");
+      if (spaceIndex > 0 && spaceIndex < value.length - 1) {
+        const prefix = value.substring(0, spaceIndex + 1);
+        const token = value.substring(spaceIndex + 1);
+        if (token.length > 12) {
+          const start = token.substring(0, 4);
+          const end = token.substring(token.length - 4);
+          headersObj.set(key, `${prefix}${start}...${end}`);
+        } else {
+          const firstChar = token.charAt(0);
+          headersObj.set(key, `${prefix}${firstChar}...`);
+        }
+      } else {
+        if (value.length > 12) {
+          const start = value.substring(0, 4);
+          const end = value.substring(value.length - 4);
+          headersObj.set(key, `${start}...${end}`);
+        } else {
+          const firstChar = value.charAt(0);
+          headersObj.set(key, `${firstChar}...`);
+        }
+      }
+    }
+  }
+  return Object.fromEntries(headersObj);
+}
 function createDebugFetch(options) {
   const { originalFetch, debugLog } = options;
   return async (input, options2) => {
@@ -2249,7 +2799,7 @@ function createDebugFetch(options) {
     const url = typeof input === "string" ? input : input.toString();
     const method = options2?.method || "GET";
     debugLog(`\u2192 ${method} ${url}`, {
-      headers: options2?.headers,
+      headers: censorHeaders(options2?.headers),
       body: options2?.body && typeof options2.body === "string" ? (() => {
         try {
           return JSON.parse(options2.body);
@@ -2600,6 +3150,16 @@ var ZapierApiClient = class {
       if ("errors" in data && Array.isArray(data.errors)) {
         if (this.isApiErrorArray(data.errors)) {
           return data.errors[0].detail || data.errors[0].title;
+        } else if (data.errors.length > 0) {
+          const firstError = data.errors[0];
+          if (typeof firstError === "string") {
+            return firstError;
+          }
+          try {
+            return JSON.stringify(firstError);
+          } catch {
+            return String(firstError);
+          }
         }
       }
     }
@@ -2784,174 +3344,6 @@ var apiPlugin = (params) => {
   };
 };
 
-// src/resolvers/appKey.ts
-var appKeyResolver = {
-  type: "static",
-  inputType: "text",
-  placeholder: "Enter app key (e.g., 'SlackCLIAPI' or slug like 'github')"
-};
-
-// src/resolvers/actionType.ts
-var actionTypeResolver = {
-  type: "dynamic",
-  depends: ["appKey"],
-  fetch: async (sdk, resolvedParams) => {
-    const actionsResponse = await sdk.listActions({
-      appKey: resolvedParams.appKey
-    });
-    const types = [
-      ...new Set(actionsResponse.data.map((action) => action.action_type))
-    ];
-    return types.map((type) => ({ key: type, name: type }));
-  },
-  prompt: (types) => ({
-    type: "list",
-    name: "actionType",
-    message: "Select action type:",
-    choices: types.map((type) => ({
-      name: type.name,
-      value: type.key
-    }))
-  })
-};
-
-// src/resolvers/actionKey.ts
-var actionKeyResolver = {
-  type: "dynamic",
-  depends: ["appKey", "actionType"],
-  fetch: async (sdk, resolvedParams) => {
-    const actionsResponse = await sdk.listActions({
-      appKey: resolvedParams.appKey
-    });
-    return actionsResponse.data.filter(
-      (action) => action.action_type === resolvedParams.actionType
-    );
-  },
-  prompt: (actions) => ({
-    type: "list",
-    name: "actionKey",
-    message: "Select action:",
-    choices: actions.map((action) => ({
-      name: `${action.title || action.name || action.key} - ${action.description || "No description"}`,
-      value: action.key
-    }))
-  })
-};
-
-// src/resolvers/authenticationId.ts
-var authenticationIdResolver = {
-  type: "dynamic",
-  depends: ["appKey"],
-  fetch: async (sdk, resolvedParams) => {
-    const myAuths = await sdk.listAuthentications({
-      appKey: resolvedParams.appKey,
-      maxItems: 1e3,
-      owner: "me"
-    });
-    const allAuths = await sdk.listAuthentications({
-      appKey: resolvedParams.appKey,
-      maxItems: 1e3
-    });
-    const otherAuths = allAuths.data.filter(
-      (auth) => !myAuths.data.some((myAuth) => myAuth.id === auth.id)
-    );
-    return [...myAuths.data, ...otherAuths];
-  },
-  prompt: (auths, params) => ({
-    type: "list",
-    name: "authenticationId",
-    message: `Select authentication for ${params.appKey}:`,
-    choices: [
-      ...auths.map((auth) => ({
-        name: `${auth.title || auth.label || "Authentication"} (ID: ${auth.id})`,
-        value: auth.id
-      })),
-      {
-        name: "\u2197 Skip authentication (may fail)",
-        value: null
-      }
-    ]
-  })
-};
-
-// src/resolvers/inputs.ts
-var inputsResolver = {
-  type: "fields",
-  depends: ["appKey", "actionKey", "actionType", "authenticationId"],
-  fetch: async (sdk, resolvedParams) => {
-    const fieldsResponse = await sdk.listInputFields({
-      appKey: resolvedParams.appKey,
-      actionKey: resolvedParams.actionKey,
-      actionType: resolvedParams.actionType,
-      authenticationId: resolvedParams.authenticationId,
-      inputs: resolvedParams.inputs
-      // Pass along currently resolved inputs
-    });
-    return fieldsResponse.data;
-  }
-};
-
-// src/resolvers/index.ts
-var resolverRegistry = {
-  appKey: appKeyResolver,
-  actionType: actionTypeResolver,
-  actionKey: actionKeyResolver,
-  authenticationId: authenticationIdResolver,
-  inputs: inputsResolver
-};
-function getResolver(name) {
-  return resolverRegistry[name];
-}
-function getResolversForMissingParams(missingParams) {
-  const resolvers = {};
-  for (const param of missingParams) {
-    const resolver = resolverRegistry[param];
-    if (resolver) {
-      resolvers[param] = resolver;
-    }
-  }
-  return resolvers;
-}
-function hasResolver(paramName) {
-  return paramName in resolverRegistry;
-}
-function getResolvableParams() {
-  return Object.keys(resolverRegistry);
-}
-function getResolutionOrder(paramName, resolved = /* @__PURE__ */ new Set()) {
-  const resolver = getResolver(paramName);
-  if (!resolver || resolver.type === "static") {
-    return [paramName];
-  }
-  const order = [];
-  if ("depends" in resolver && resolver.depends) {
-    for (const dependency of resolver.depends) {
-      if (!resolved.has(dependency)) {
-        order.push(...getResolutionOrder(dependency, resolved));
-        resolved.add(dependency);
-      }
-    }
-  }
-  if (!resolved.has(paramName)) {
-    order.push(paramName);
-    resolved.add(paramName);
-  }
-  return order;
-}
-function getResolutionOrderForParams(paramNames) {
-  const resolved = /* @__PURE__ */ new Set();
-  const order = [];
-  for (const paramName of paramNames) {
-    const paramOrder = getResolutionOrder(paramName, resolved);
-    for (const param of paramOrder) {
-      if (!order.includes(param)) {
-        order.push(param);
-      }
-    }
-  }
-  return order;
-}
-
 // src/plugins/registry/index.ts
 var registryPlugin = ({ sdk, context }) => {
   const metaKeys = Object.keys(context.meta || {});
@@ -2981,10 +3373,16 @@ var registryPlugin = ({ sdk, context }) => {
     }
   };
   const functions = metaKeys.filter((key) => typeof sdk[key] === "function").map((key) => {
+    const meta = context.meta[key];
     return {
-      ...context.meta[key],
-      categories: context.meta[key].categories || [],
-      name: key
+      name: key,
+      type: meta.type,
+      itemType: meta.itemType,
+      returnType: meta.returnType,
+      inputSchema: meta.inputSchema,
+      outputSchema: meta.outputSchema,
+      categories: meta.categories || [],
+      resolvers: meta.resolvers
     };
   }).sort((a, b) => a.name.localeCompare(b.name));
   const knownCategories = Object.keys(categoryDefinitions);
@@ -3018,52 +3416,43 @@ var registryPlugin = ({ sdk, context }) => {
     getRegistry
   };
 };
-var InputFieldChoiceItemSchema = withFormatter(
-  zod.z.object({
-    key: zod.z.string().optional().describe("Unique key/value for the choice"),
-    label: zod.z.string().optional().describe("Human readable label for the choice"),
-    sample: zod.z.string().optional().describe("Sample value for the choice"),
-    value: zod.z.string().optional().describe("Value to be submitted when selected")
-  }),
-  {
-    format: (item) => {
-      const title = item.label || item.key || "Choice";
-      const subtitle = item.label && item.key && item.label !== item.key ? `(${item.key})` : void 0;
-      const details = [];
-      if (item.sample && item.sample !== item.key) {
-        details.push({ text: `Sample: ${item.sample}`, style: "dim" });
-      }
-      if (item.value && item.value !== item.key) {
-        details.push({ text: `Value: ${item.value}`, style: "normal" });
-      }
-      return {
-        title,
-        subtitle,
-        details
-      };
+var InputFieldChoiceItemSchema = withFormatter(NeedChoicesSchema, {
+  format: (item) => {
+    const title = item.label || item.key || "Choice";
+    const details = [];
+    if (item.label && item.key && item.label !== item.key) {
+      details.push({ text: `Key: ${item.key}`, style: "dim" });
+    }
+    if (item.sample && item.sample !== item.key) {
+      details.push({ text: `Sample: ${item.sample}`, style: "dim" });
+    }
+    if (item.value && item.value !== item.key) {
+      details.push({ text: `Value: ${item.value}`, style: "normal" });
     }
+    return {
+      title,
+      key: item.key,
+      details
+    };
   }
-);
-var ListInputFieldChoicesSchema = withOutputSchema(
-  zod.z.object({
-    // Required action identification
-    appKey: AppKeyPropertySchema,
-    actionType: ActionTypePropertySchema,
-    actionKey: ActionKeyPropertySchema,
-    // Input field specification
-    inputFieldKey: zod.z.string().min(1).describe("Input field key to get choices for."),
-    // Common parameters
-    authenticationId: AuthenticationIdPropertySchema.nullable().optional(),
-    inputs: InputsPropertySchema.optional().describe(
-      "Current input values that may affect available choices"
-    ),
-    page: zod.z.number().int().min(0).optional().describe("Page number for paginated results"),
-    // Pagination options (SDK-level)
-    pageSize: zod.z.number().min(1).optional().describe("Number of choices per page"),
-    maxItems: zod.z.number().min(1).optional().describe("Maximum total items to return across all pages")
-  }).describe("Get the available choices for a dynamic dropdown input field"),
-  InputFieldChoiceItemSchema
-);
+});
+var ListInputFieldChoicesSchema = zod.z.object({
+  // Required action identification
+  appKey: AppKeyPropertySchema,
+  actionType: ActionTypePropertySchema,
+  actionKey: ActionKeyPropertySchema,
+  // Input field specification
+  inputFieldKey: zod.z.string().min(1).describe("Input field key to get choices for."),
+  // Common parameters
+  authenticationId: AuthenticationIdPropertySchema.nullable().optional(),
+  inputs: InputsPropertySchema.optional().describe(
+    "Current input values that may affect available choices"
+  ),
+  page: zod.z.number().int().min(0).optional().describe("Page number for paginated results"),
+  // Pagination options (SDK-level)
+  pageSize: zod.z.number().min(1).optional().describe("Number of choices per page"),
+  maxItems: zod.z.number().min(1).optional().describe("Maximum total items to return across all pages")
+}).describe("Get the available choices for a dynamic dropdown input field");
 
 // src/plugins/listInputFieldChoices/index.ts
 function transformNeedChoicesToInputFieldChoiceItem(choice) {
@@ -3117,7 +3506,7 @@ var listInputFieldChoicesPlugin = ({ context, sdk }) => {
       transformNeedChoicesToInputFieldChoiceItem
     );
     let nextCursor;
-    if (choicesData.next_page !== void 0) {
+    if (choicesData.next_page != null) {
       nextCursor = choicesData.next_page.toString();
     } else if (choicesData.links?.next) {
       try {
@@ -3141,7 +3530,18 @@ var listInputFieldChoicesPlugin = ({ context, sdk }) => {
       meta: {
         listInputFieldChoices: {
           categories: ["action"],
-          inputSchema: ListInputFieldChoicesSchema
+          type: "list",
+          itemType: "InputFieldChoice",
+          inputSchema: ListInputFieldChoicesSchema,
+          outputSchema: InputFieldChoiceItemSchema,
+          resolvers: {
+            appKey: appKeyResolver,
+            actionType: actionTypeResolver,
+            actionKey: actionKeyResolver,
+            authenticationId: authenticationIdResolver,
+            inputFieldKey: inputFieldKeyResolver,
+            inputs: inputsAllOptionalResolver
+          }
         }
       }
     }
@@ -3197,7 +3597,7 @@ function createSdk(options = {}, initialSdk = {}, initialContext = { meta: {} })
   };
 }
 function createZapierSdkWithoutRegistry(options = {}) {
-  return createSdk(options).addPlugin(apiPlugin).addPlugin(listAppsPlugin).addPlugin(manifestPlugin).addPlugin(getAppPlugin).addPlugin(listActionsPlugin).addPlugin(getActionPlugin).addPlugin(listInputFieldsPlugin).addPlugin(listInputFieldChoicesPlugin).addPlugin(runActionPlugin).addPlugin(lockVersionPlugin).addPlugin(listAuthenticationsPlugin).addPlugin(getAuthenticationPlugin).addPlugin(findFirstAuthenticationPlugin).addPlugin(findUniqueAuthenticationPlugin).addPlugin(requestPlugin).addPlugin(fetchPlugin).addPlugin(appsPlugin).addPlugin(getProfilePlugin);
+  return createSdk(options).addPlugin(apiPlugin).addPlugin(manifestPlugin).addPlugin(listAppsPlugin).addPlugin(getAppPlugin).addPlugin(listActionsPlugin).addPlugin(getActionPlugin).addPlugin(listInputFieldsPlugin).addPlugin(listInputFieldChoicesPlugin).addPlugin(runActionPlugin).addPlugin(listAuthenticationsPlugin).addPlugin(getAuthenticationPlugin).addPlugin(findFirstAuthenticationPlugin).addPlugin(findUniqueAuthenticationPlugin).addPlugin(requestPlugin).addPlugin(fetchPlugin).addPlugin(appsPlugin).addPlugin(getProfilePlugin);
 }
 function createZapierSdk(options = {}) {
   return createZapierSdkWithoutRegistry(options).addPlugin(registryPlugin);
@@ -3207,6 +3607,7 @@ exports.ActionKeyPropertySchema = ActionKeyPropertySchema;
 exports.ActionTypePropertySchema = ActionTypePropertySchema;
 exports.AppKeyPropertySchema = AppKeyPropertySchema;
 exports.AuthenticationIdPropertySchema = AuthenticationIdPropertySchema;
+exports.DEFAULT_CONFIG_PATH = DEFAULT_CONFIG_PATH;
 exports.DebugPropertySchema = DebugPropertySchema;
 exports.InputsPropertySchema = InputsPropertySchema;
 exports.LimitPropertySchema = LimitPropertySchema;
@@ -3232,6 +3633,7 @@ exports.actionTypeResolver = actionTypeResolver;
 exports.apiPlugin = apiPlugin;
 exports.appKeyResolver = appKeyResolver;
 exports.appsPlugin = appsPlugin;
+exports.authenticationIdGenericResolver = authenticationIdGenericResolver;
 exports.authenticationIdResolver = authenticationIdResolver;
 exports.createFunction = createFunction;
 exports.createSdk = createSdk;
@@ -3239,31 +3641,27 @@ exports.createZapierSdk = createZapierSdk;
 exports.createZapierSdkWithoutRegistry = createZapierSdkWithoutRegistry;
 exports.fetchPlugin = fetchPlugin;
 exports.findFirstAuthenticationPlugin = findFirstAuthenticationPlugin;
+exports.findManifestEntry = findManifestEntry;
 exports.findUniqueAuthenticationPlugin = findUniqueAuthenticationPlugin;
 exports.formatErrorMessage = formatErrorMessage;
 exports.getActionPlugin = getActionPlugin;
 exports.getAppPlugin = getAppPlugin;
 exports.getAuthenticationPlugin = getAuthenticationPlugin;
+exports.getPreferredManifestEntryKey = getPreferredManifestEntryKey;
 exports.getProfilePlugin = getProfilePlugin;
-exports.getResolutionOrder = getResolutionOrder;
-exports.getResolutionOrderForParams = getResolutionOrderForParams;
-exports.getResolvableParams = getResolvableParams;
-exports.getResolver = getResolver;
-exports.getResolversForMissingParams = getResolversForMissingParams;
 exports.getTokenFromCliLogin = getTokenFromCliLogin;
 exports.getTokenFromEnv = getTokenFromEnv;
 exports.getTokenFromEnvOrConfig = getTokenFromEnvOrConfig;
-exports.hasResolver = hasResolver;
+exports.inputFieldKeyResolver = inputFieldKeyResolver;
+exports.inputsAllOptionalResolver = inputsAllOptionalResolver;
 exports.inputsResolver = inputsResolver;
 exports.isPositional = isPositional;
 exports.listActionsPlugin = listActionsPlugin;
 exports.listAppsPlugin = listAppsPlugin;
 exports.listAuthenticationsPlugin = listAuthenticationsPlugin;
 exports.listInputFieldsPlugin = listInputFieldsPlugin;
-exports.loadManifestFromFile = loadManifestFromFile;
-exports.lockVersionPlugin = lockVersionPlugin;
 exports.manifestPlugin = manifestPlugin;
+exports.readManifestFromFile = readManifestFromFile;
 exports.registryPlugin = registryPlugin;
 exports.requestPlugin = requestPlugin;
-exports.resolverRegistry = resolverRegistry;
 exports.runActionPlugin = runActionPlugin;