@zapier/zapier-sdk 0.9.0 → 0.11.0

package/dist/index.cjs

@@ -5,19 +5,22 @@ 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) {
@@ -604,243 +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 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 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"],
-          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(),
@@ -940,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()]),
@@ -1030,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(),
@@ -1048,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(),
@@ -1100,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(),
@@ -1136,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({
@@ -1156,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(),
@@ -1189,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),
@@ -1212,25 +1006,261 @@ 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"
-      });
+      return {
+        title: item.title,
+        key: item.key,
+        description: item.description,
+        details: []
+      };
+    }
+  }
+);
+
+// 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}`,
@@ -1238,31 +1268,208 @@ var ActionItemSchema = withFormatter(
         });
       }
       if (item.description) {
-        details.push({ text: item.description, style: "dim" });
+        details.push({
+          text: item.description,
+          style: "dim"
+        });
       }
       return {
-        title: item.title || item.name || item.key,
-        subtitle: `(${item.key})`,
+        title: item.title || item.key,
+        id: item.id,
+        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/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
+function makeFieldsOptional(fields) {
+  return fields.map((field) => {
+    if (field.type === "input_field") {
+      return {
+        ...field,
+        is_required: false
+      };
+    } else if (field.type === "fieldset") {
+      return {
+        ...field,
+        fields: makeFieldsOptional(field.fields)
+      };
+    } else {
+      return field;
+    }
+  });
+}
+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 makeFieldsOptional(fieldsResponse.data);
+  }
+};
+
+// src/resolvers/inputFieldKey.ts
+function flattenRootFieldset(rootFieldset) {
+  const result = [];
+  function processItem(item) {
+    if (item.type === "input_field") {
+      result.push(item);
+    } else if (item.type === "fieldset") {
+      for (const field of item.fields) {
+        processItem(field);
+      }
+    }
+  }
+  for (const item of rootFieldset) {
+    processItem(item);
+  }
+  return result;
+}
+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 flattenRootFieldset(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 }) => {
@@ -1329,23 +1536,152 @@ var listActionsPlugin = ({ context }) => {
       meta: {
         listActions: {
           categories: ["action"],
-          inputSchema: ListActionsSchema
+          type: "list",
+          itemType: "Action",
+          inputSchema: ListActionsSchema,
+          outputSchema: ActionItemSchema,
+          resolvers: {
+            appKey: appKeyResolver,
+            actionType: actionTypeResolver
+          }
         }
       }
     }
-  };
-};
-var ListInputFieldsSchema = zod.z.object({
-  appKey: AppKeyPropertySchema,
-  actionType: ActionTypePropertySchema,
-  actionKey: ActionKeyPropertySchema,
-  authenticationId: AuthenticationIdPropertySchema.nullable().optional(),
-  inputs: InputsPropertySchema.optional().describe(
-    "Current input values that may affect available fields"
-  ),
-  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 ListInputFieldsSchema = zod.z.object({
+  appKey: AppKeyPropertySchema,
+  actionType: ActionTypePropertySchema,
+  actionKey: ActionKeyPropertySchema,
+  authenticationId: AuthenticationIdPropertySchema.nullable().optional(),
+  inputs: InputsPropertySchema.optional().describe(
+    "Current input values that may affect available fields"
+  ),
+  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 BaseFieldItemSchema = zod.z.object({
+  type: zod.z.string(),
+  // "input_field", "info_field", or "fieldset"
+  key: zod.z.string()
+  // From need.key
+});
+var InputFieldItemSchema = withFormatter(
+  BaseFieldItemSchema.extend({
+    type: zod.z.literal("input_field"),
+    default_value: zod.z.string(),
+    // Mapped from 'default' with fallback to ""
+    depends_on: zod.z.array(zod.z.string()),
+    // Mapped from 'depends_on' with fallback to []
+    description: zod.z.string(),
+    // Mapped from 'help_text' with fallback to ""
+    invalidates_input_fields: zod.z.boolean(),
+    // Mapped from 'alters_custom_fields' with fallback to false
+    is_required: zod.z.boolean(),
+    // Mapped from 'required' with fallback to false
+    placeholder: zod.z.string(),
+    // Mapped from 'placeholder' with fallback to ""
+    title: zod.z.string(),
+    // Mapped from 'label' with fallback to ""
+    value_type: zod.z.string(),
+    // Computed from InputFieldType enum
+    format: zod.z.string().optional(),
+    // Computed from InputFieldFormat enum (optional)
+    items: zod.z.object({ type: zod.z.string() }).optional()
+    // Computed from ItemsType enum (optional, only for arrays)
+  }),
+  {
+    format: (item) => {
+      const details = [];
+      const typeInfo = [
+        item.value_type && `Type: ${item.value_type}`,
+        `Required: ${item.is_required ? "Yes" : "No"}`
+      ].filter(Boolean).join(" | ");
+      if (typeInfo) {
+        details.push({ text: typeInfo, style: "dim" });
+      }
+      if (item.description) {
+        details.push({
+          text: item.description,
+          style: "normal"
+        });
+      }
+      if (item.default_value) {
+        details.push({
+          text: `Default: ${item.default_value}`,
+          style: "accent"
+        });
+      }
+      if (item.placeholder) {
+        details.push({
+          text: `Placeholder: ${item.placeholder}`,
+          style: "dim"
+        });
+      }
+      if (item.depends_on && item.depends_on.length > 0) {
+        details.push({
+          text: `Depends on: ${item.depends_on.join(", ")}`,
+          style: "warning"
+        });
+      }
+      if (item.format) {
+        details.push({ text: `Format: ${item.format}`, style: "dim" });
+      }
+      if (item.items) {
+        details.push({
+          text: `Items type: ${item.items.type}`,
+          style: "dim"
+        });
+      }
+      return {
+        title: item.title || item.key,
+        key: item.key,
+        description: item.description,
+        details
+      };
+    }
+  }
+);
+var InfoFieldItemSchema = withFormatter(
+  BaseFieldItemSchema.extend({
+    type: zod.z.literal("info_field"),
+    description: zod.z.string(),
+    // From need.help_text
+    title: zod.z.string().optional()
+    // Optional title
+  }),
+  {
+    format: (item) => ({
+      title: item.title || "Info",
+      key: item.key,
+      description: item.description,
+      details: [{ text: item.description, style: "normal" }]
+    })
+  }
+);
+var FieldsetItemSchema = BaseFieldItemSchema.extend({
+  type: zod.z.literal("fieldset"),
+  title: zod.z.string(),
+  fields: zod.z.lazy(
+    () => zod.z.array(
+      zod.z.union([
+        InputFieldItemSchema,
+        InfoFieldItemSchema,
+        FieldsetItemSchema
+      ])
+    )
+  )
+});
+var RootFieldItemSchema = zod.z.union([
+  InputFieldItemSchema,
+  InfoFieldItemSchema,
+  FieldsetItemSchema
+]);
+
+// src/utils/string-utils.ts
+function toTitleCase(input) {
+  return input.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/[_\-]+/g, " ").replace(/\s+/g, " ").trim().split(" ").map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join(" ");
+}
 
 // src/plugins/listInputFields/index.ts
 function getInputFieldTypeFromNeed(need) {
@@ -1390,9 +1726,8 @@ function getItemsTypeFromNeed(need) {
 function transformNeedToInputFieldItem(need) {
   const itemsType = getItemsTypeFromNeed(need);
   return {
-    ...need,
-    // Pass through all original Need fields
-    id: need.key,
+    type: "input_field",
+    key: need.key,
     default_value: need.default || "",
     depends_on: need.depends_on || [],
     description: need.help_text || "",
@@ -1405,6 +1740,48 @@ function transformNeedToInputFieldItem(need) {
     items: itemsType ? { type: itemsType } : void 0
   };
 }
+function transformNeedToInfoFieldItem(need) {
+  return {
+    type: "info_field",
+    key: need.key,
+    description: need.help_text || "",
+    title: need.label
+  };
+}
+function transformNeedsToFields(needs) {
+  const rootFields = [];
+  const fieldsetMap = /* @__PURE__ */ new Map();
+  for (const need of needs) {
+    if (need.computed) {
+      continue;
+    }
+    if (need.parent_key) {
+      let fieldset = fieldsetMap.get(need.parent_key);
+      if (!fieldset) {
+        fieldset = {
+          type: "fieldset",
+          key: need.parent_key,
+          title: toTitleCase(need.parent_key),
+          fields: []
+        };
+        fieldsetMap.set(need.parent_key, fieldset);
+        rootFields.push(fieldset);
+      }
+      if (need.type === "copy" && need.help_text) {
+        fieldset.fields.push(transformNeedToInfoFieldItem(need));
+      } else {
+        fieldset.fields.push(transformNeedToInputFieldItem(need));
+      }
+    } else {
+      if (need.type === "copy" && need.help_text) {
+        rootFields.push(transformNeedToInfoFieldItem(need));
+      } else {
+        rootFields.push(transformNeedToInputFieldItem(need));
+      }
+    }
+  }
+  return rootFields;
+}
 var listInputFieldsPlugin = ({ context }) => {
   const listInputFields = createPaginatedFunction(
     async function listInputFieldsPage(options) {
@@ -1435,11 +1812,9 @@ var listInputFieldsPlugin = ({ context }) => {
           `Failed to get action fields: ${needsData.errors?.join(", ") || "Unknown error"}`
         );
       }
-      const inputFields = (needsData.needs || []).map(
-        transformNeedToInputFieldItem
-      );
+      const rootFieldset = transformNeedsToFields(needsData.needs || []);
       return {
-        data: inputFields,
+        data: rootFieldset,
         nextCursor: void 0
         // No pagination needed since we return all input fields
       };
@@ -1452,7 +1827,17 @@ var listInputFieldsPlugin = ({ context }) => {
       meta: {
         listInputFields: {
           categories: ["action"],
-          inputSchema: ListInputFieldsSchema
+          type: "list",
+          itemType: "RootFieldItem",
+          inputSchema: ListInputFieldsSchema,
+          outputSchema: RootFieldItemSchema,
+          resolvers: {
+            appKey: appKeyResolver,
+            actionType: actionTypeResolver,
+            actionKey: actionKeyResolver,
+            authenticationId: authenticationIdResolver,
+            inputs: inputsAllOptionalResolver
+          }
         }
       }
     }
@@ -1470,6 +1855,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 }) => {
@@ -1545,20 +1973,23 @@ 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 = ({ sdk }) => {
@@ -1579,7 +2010,13 @@ var getAppPlugin = ({ sdk }) => {
       meta: {
         getApp: {
           categories: ["app"],
-          inputSchema: GetAppSchema
+          type: "item",
+          itemType: "App",
+          inputSchema: GetAppSchema,
+          outputSchema: AppItemSchema,
+          resolvers: {
+            appKey: appKeyResolver
+          }
         }
       }
     }
@@ -1612,7 +2049,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
+          }
         }
       }
     }
@@ -1667,7 +2112,13 @@ var getAuthenticationPlugin = ({ context }) => {
       meta: {
         getAuthentication: {
           categories: ["authentication"],
-          inputSchema: GetAuthenticationSchema
+          type: "item",
+          itemType: "Authentication",
+          inputSchema: GetAuthenticationSchema,
+          outputSchema: AuthenticationItemSchema,
+          resolvers: {
+            authenticationId: authenticationIdGenericResolver
+          }
         }
       }
     }
@@ -1691,8 +2142,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
@@ -1703,7 +2160,10 @@ var findFirstAuthenticationPlugin = ({ sdk }) => {
       meta: {
         findFirstAuthentication: {
           categories: ["authentication"],
-          inputSchema: FindFirstAuthenticationSchema
+          type: "item",
+          itemType: "Authentication",
+          inputSchema: FindFirstAuthenticationSchema,
+          outputSchema: AuthenticationItemSchema
         }
       }
     }
@@ -1751,7 +2211,10 @@ var findUniqueAuthenticationPlugin = ({ sdk }) => {
       meta: {
         findUniqueAuthentication: {
           categories: ["authentication"],
-          inputSchema: FindUniqueAuthenticationSchema
+          type: "item",
+          itemType: "Authentication",
+          inputSchema: FindUniqueAuthenticationSchema,
+          outputSchema: AuthenticationItemSchema
         }
       }
     }
@@ -1768,6 +2231,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) {
@@ -1859,7 +2347,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
+          }
         }
       }
     }
@@ -1931,6 +2429,7 @@ var requestPlugin = ({ context }) => {
       meta: {
         request: {
           categories: ["http"],
+          returnType: "Response",
           inputSchema: RelayRequestSchema
         }
       }
@@ -2278,6 +2777,7 @@ var manifestPlugin = (params) => {
     }
   };
 };
+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()
@@ -2286,32 +2786,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() {
@@ -2334,7 +2839,10 @@ var getProfilePlugin = ({ context }) => {
       meta: {
         getProfile: {
           categories: ["account"],
-          inputSchema: GetProfileSchema
+          type: "item",
+          itemType: "Profile",
+          inputSchema: GetProfileSchema,
+          outputSchema: UserProfileItemSchema
         }
       }
     }
@@ -2367,6 +2875,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) => {
@@ -2374,7 +2914,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);
@@ -2725,6 +3265,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);
+          }
         }
       }
     }
@@ -2909,174 +3459,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 || {});
@@ -3106,10 +3488,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);
@@ -3143,52 +3531,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) {
@@ -3242,7 +3621,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 {
@@ -3266,7 +3645,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
+          }
         }
       }
     }
@@ -3358,6 +3748,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;
@@ -3373,15 +3764,11 @@ 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;
@@ -3392,5 +3779,4 @@ exports.manifestPlugin = manifestPlugin;
 exports.readManifestFromFile = readManifestFromFile;
 exports.registryPlugin = registryPlugin;
 exports.requestPlugin = requestPlugin;
-exports.resolverRegistry = resolverRegistry;
 exports.runActionPlugin = runActionPlugin;