@zapier/zapier-sdk 0.6.3 → 0.6.4

package/dist/index.cjs

@@ -320,1003 +320,541 @@ var fetchPlugin = ({ sdk }) => {
   };
 };
 
-// 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/utils/pagination-utils.ts
+var offsetCursorMarker = "$$offset$$";
+function splitOffsetCursor(cursor) {
+  if (!cursor) {
+    return [0, cursor];
   }
-};
-
-// 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;
+  try {
+    const parsedCursor = JSON.parse(cursor);
+    if (!Array.isArray(parsedCursor)) {
+      return [0, cursor];
+    }
+    const [marker, offset, currentCursor] = parsedCursor;
+    if (marker !== offsetCursorMarker) {
+      return [0, cursor];
     }
+    if (typeof offset !== "number") {
+      return [0, cursor];
+    }
+    return [offset, currentCursor];
+  } catch {
+    return [0, cursor];
   }
-  return resolvers;
-}
-function hasResolver(paramName) {
-  return paramName in resolverRegistry;
 }
-function getResolvableParams() {
-  return Object.keys(resolverRegistry);
+function createOffsetCursor(offset, currentCursor) {
+  return JSON.stringify([offsetCursorMarker, offset, currentCursor]);
 }
-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);
+async function* paginateMaxItems(pageFunction, pageOptions) {
+  let cursor = pageOptions?.cursor;
+  let totalItemsYielded = 0;
+  const maxItems = pageOptions?.maxItems;
+  const pageSize = pageOptions?.pageSize;
+  do {
+    const options = {
+      ...pageOptions || {},
+      cursor,
+      pageSize: maxItems !== void 0 && pageSize !== void 0 ? Math.min(pageSize, maxItems) : pageSize
+    };
+    const page = await pageFunction(options);
+    if (maxItems !== void 0) {
+      const remainingItems = maxItems - totalItemsYielded;
+      if (page.data.length >= remainingItems) {
+        const yieldedPage = {
+          ...page,
+          data: page.data.slice(0, remainingItems),
+          nextCursor: void 0
+        };
+        yield yieldedPage;
+        break;
       }
     }
-  }
-  if (!resolved.has(paramName)) {
-    order.push(paramName);
-    resolved.add(paramName);
-  }
-  return order;
+    yield page;
+    totalItemsYielded += page.data.length;
+    cursor = page.nextCursor;
+  } while (cursor);
 }
-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);
+async function* paginateBuffered(pageFunction, pageOptions) {
+  const pageSize = pageOptions?.pageSize;
+  const [cursorOffset, currentCursor] = splitOffsetCursor(pageOptions?.cursor);
+  const options = {
+    ...pageOptions || {},
+    cursor: currentCursor
+  };
+  const iterator = paginateMaxItems(pageFunction, options);
+  let bufferedPages = [];
+  let isFirstPage = true;
+  let cursor;
+  for await (let page of iterator) {
+    if (isFirstPage) {
+      isFirstPage = false;
+      if (cursorOffset) {
+        page = {
+          ...page,
+          data: page.data.slice(cursorOffset)
+        };
       }
     }
-  }
-  return order;
-}
-
-// src/auth.ts
-function getTokenFromEnv() {
-  return process.env.ZAPIER_TOKEN;
-}
-async function getTokenFromCliLogin(options = {}) {
-  try {
-    const { getToken } = await import('@zapier/zapier-sdk-cli-login');
-    return await getToken(options);
-  } catch {
-    return void 0;
-  }
-}
-async function getTokenFromEnvOrConfig(options = {}) {
-  const envToken = getTokenFromEnv();
-  if (envToken) {
-    return envToken;
-  }
-  return getTokenFromCliLogin(options);
-}
-var RelayRequestSchema = zod.z.object({
-  url: zod.z.string().url().describe("The URL to request (will be proxied through Relay)"),
-  method: zod.z.enum(["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"]).optional().describe("HTTP method"),
-  body: zod.z.any().optional().describe("Request body as a string"),
-  authenticationId: zod.z.number().int().optional().describe("Zapier authentication ID to use for the request"),
-  callbackUrl: zod.z.string().url().optional().describe("URL to send async response to (makes request async)"),
-  authenticationTemplate: zod.z.string().optional().describe(
-    "Optional JSON string authentication template to bypass Notary lookup"
-  ),
-  headers: zod.z.union([
-    zod.z.record(zod.z.string()),
-    zod.z.instanceof(Headers),
-    zod.z.array(zod.z.tuple([zod.z.string(), zod.z.string()]))
-  ]).optional().describe("Request headers")
-}).extend({
-  relayBaseUrl: zod.z.string().optional().describe("Base URL for Relay service")
-}).describe("Make authenticated HTTP requests through Zapier's Relay service");
-var RelayFetchSchema = RelayRequestSchema;
-
-// src/plugins/registry/index.ts
-var registryPlugin = ({ sdk, context }) => {
-  const metaKeys = Object.keys(context.meta || {});
-  const categoryDefinitions = {
-    app: {
-      title: "App",
-      titlePlural: "Apps"
-    },
-    authentication: {
-      title: "Authentication"
-    },
-    action: {
-      title: "Action"
-    },
-    http: {
-      title: "HTTP Request"
-    },
-    user: {
-      title: "User"
-    },
-    utility: {
-      title: "Utility",
-      titlePlural: "Utilities"
-    },
-    other: {
-      title: "Other"
+    if (!pageSize) {
+      yield page;
+      cursor = page.nextCursor;
+      continue;
     }
-  };
-  const functions = metaKeys.filter((key) => typeof sdk[key] === "function").map((key) => {
-    return {
-      ...context.meta[key],
-      categories: context.meta[key].categories || [],
-      name: key
-    };
-  }).sort((a, b) => a.name.localeCompare(b.name));
-  const knownCategories = Object.keys(categoryDefinitions);
-  const categories = knownCategories.sort((a, b) => {
-    if (a === "other") return 1;
-    if (b === "other") return -1;
-    const titleA = categoryDefinitions[a].title;
-    const titleB = categoryDefinitions[b].title;
-    return titleA.localeCompare(titleB);
-  }).map((categoryKey) => {
-    const categoryFunctions = functions.filter(
-      (f) => f.categories.includes(categoryKey) || // If the category is "other" and the function is not in any other category, include it
-      categoryKey === "other" && !f.categories.some((c) => knownCategories.includes(c))
-    ).map((f) => f.name).sort();
-    const definition = categoryDefinitions[categoryKey];
-    const title = definition.title;
-    return {
-      key: categoryKey,
-      title,
-      titlePlural: definition.titlePlural ?? `${title}s`,
-      functions: categoryFunctions
+    const bufferedLength = bufferedPages.reduce(
+      (acc, page2) => acc + page2.data.length,
+      0
+    );
+    if (bufferedLength + page.data.length < pageSize) {
+      bufferedPages.push(page);
+      cursor = page.nextCursor;
+      continue;
+    }
+    const bufferedItems = bufferedPages.map((p) => p.data).flat();
+    const allItems = [...bufferedItems, ...page.data];
+    const pageItems = allItems.slice(0, pageSize);
+    const remainingItems = allItems.slice(pageItems.length);
+    if (remainingItems.length === 0) {
+      yield {
+        ...page,
+        data: pageItems,
+        nextCursor: page.nextCursor
+      };
+      bufferedPages = [];
+      cursor = page.nextCursor;
+      continue;
+    }
+    yield {
+      ...page,
+      data: pageItems,
+      nextCursor: createOffsetCursor(
+        page.data.length - remainingItems.length,
+        cursor
+      )
     };
-  });
-  function getRegistry() {
-    return {
-      functions,
-      categories
+    while (remainingItems.length > pageSize) {
+      const pageItems2 = remainingItems.splice(0, pageSize);
+      yield {
+        ...page,
+        data: pageItems2,
+        nextCursor: createOffsetCursor(
+          page.data.length - remainingItems.length,
+          cursor
+        )
+      };
+    }
+    bufferedPages = [
+      {
+        ...page,
+        data: remainingItems
+      }
+    ];
+    cursor = page.nextCursor;
+  }
+  if (bufferedPages.length > 0) {
+    const lastBufferedPage = bufferedPages.slice(-1)[0];
+    const bufferedItems = bufferedPages.map((p) => p.data).flat();
+    yield {
+      ...lastBufferedPage,
+      data: bufferedItems
     };
   }
-  return {
-    getRegistry
+}
+var paginate = paginateBuffered;
+
+// src/utils/validation.ts
+var validate = (schema, input) => {
+  const result = schema.safeParse(input);
+  if (!result.success) {
+    const errorMessages = result.error.errors.map((error) => {
+      const path = error.path.length > 0 ? error.path.join(".") : "input";
+      return `${path}: ${error.message}`;
+    });
+    const message = `Validation failed:
+  ${errorMessages.join("\n  ")}`;
+    throw new ZapierValidationError(message, {
+      details: {
+        zodErrors: result.error.errors,
+        input
+      }
+    });
+  }
+  return result.data;
+};
+function createValidator(schema) {
+  return function validateFn(input) {
+    return validate(schema, input);
   };
+}
+var validateOptions = (schema, options) => {
+  return validate(schema, options);
 };
 
-// src/api/auth.ts
-function isJwt(token) {
-  const parts = token.split(".");
-  if (parts.length !== 3) {
-    return false;
+// src/utils/function-utils.ts
+function extractCursor(data) {
+  if (!data?.next) {
+    return void 0;
   }
-  const base64UrlPattern = /^[A-Za-z0-9_-]+$/;
-  return parts.every((part) => part.length > 0 && base64UrlPattern.test(part));
-}
-function getAuthorizationHeader(token) {
-  if (isJwt(token)) {
-    return `JWT ${token}`;
+  try {
+    const urlObj = new URL(data.next);
+    const offset = urlObj.searchParams.get("offset");
+    return offset || void 0;
+  } catch {
+    return void 0;
   }
-  return `Bearer ${token}`;
 }
-
-// src/api/debug.ts
-function createDebugLogger(enabled) {
-  if (!enabled) {
-    return () => {
-    };
+function normalizeError(error) {
+  if (error instanceof ZapierError) {
+    return error;
   }
-  return (message, data) => {
-    console.log(`[Zapier SDK] ${message}`, data || "");
-  };
+  const message = error instanceof Error ? error.message : String(error);
+  return new ZapierUnknownError(`Unknown error: ${message}`, { cause: error });
 }
-function createDebugFetch(options) {
-  const { originalFetch, debugLog } = options;
-  return async (input, options2) => {
-    const startTime = Date.now();
-    const url = typeof input === "string" ? input : input.toString();
-    const method = options2?.method || "GET";
-    debugLog(`\u2192 ${method} ${url}`, {
-      headers: options2?.headers,
-      body: options2?.body && typeof options2.body === "string" ? (() => {
-        try {
-          return JSON.parse(options2.body);
-        } catch {
-          return options2.body;
+function createFunction(coreFn, schema) {
+  const functionName = coreFn.name;
+  const namedFunctions = {
+    [functionName]: async function(options) {
+      try {
+        const normalizedOptions = options ?? {};
+        if (schema) {
+          const validatedOptions = validateOptions(schema, normalizedOptions);
+          return await coreFn({
+            ...normalizedOptions,
+            ...validatedOptions
+          });
         }
-      })() : options2?.body
-    });
-    try {
-      const response = await originalFetch(input, options2);
-      const duration = Date.now() - startTime;
-      debugLog(`\u2190 ${response.status} ${response.statusText} (${duration}ms)`, {
-        url,
-        method,
-        status: response.status
-      });
-      return response;
-    } catch (error) {
-      const duration = Date.now() - startTime;
-      debugLog(`\u2716 Request failed (${duration}ms)`, {
-        url,
-        method,
-        error: error instanceof Error ? error.message : error
-      });
-      throw error;
+        return await coreFn(normalizedOptions);
+      } catch (error) {
+        throw normalizeError(error);
+      }
     }
   };
+  return namedFunctions[functionName];
 }
-
-// src/api/polling.ts
-async function pollUntilComplete(options) {
-  const {
-    fetchPoll,
-    maxAttempts = 30,
-    initialDelay = 50,
-    maxDelay = 1e3,
-    successStatus = 200,
-    pendingStatus = 202,
-    resultExtractor = (response) => response
-  } = options;
-  let delay = initialDelay;
-  let errorCount = 0;
-  for (let attempt = 0; attempt < maxAttempts; attempt++) {
-    const response = await fetchPoll();
-    if (response.status === successStatus) {
-      errorCount = 0;
-      const result = await response.json();
-      return resultExtractor(result);
-    } else if (response.status === pendingStatus) {
-      errorCount = 0;
-      if (attempt < maxAttempts - 1) {
-        await new Promise((resolve3) => setTimeout(resolve3, delay));
-        delay = Math.min(delay * 2, maxDelay);
-        continue;
-      }
-    } else {
-      errorCount++;
-      if (errorCount >= 3) {
-        throw new ZapierApiError(
-          `Poll request failed: ${response.status} ${response.statusText}`,
-          { statusCode: response.status }
-        );
-      }
-      if (attempt < maxAttempts - 1) {
-        await new Promise((resolve3) => setTimeout(resolve3, delay));
-        delay = Math.min(delay * 2, maxDelay);
-        continue;
+function createPageFunction(coreFn) {
+  const functionName = coreFn.name + "Page";
+  const namedFunctions = {
+    [functionName]: async function(options) {
+      try {
+        const result = await coreFn(options);
+        if (result && typeof result === "object" && "data" in result) {
+          const data = result.data;
+          return {
+            data: Array.isArray(data) ? data : [data],
+            nextCursor: result.nextCursor
+          };
+        }
+        if (Array.isArray(result)) {
+          return { data: result };
+        }
+        return { data: [result] };
+      } catch (error) {
+        throw normalizeError(error);
       }
     }
-  }
-  throw new ZapierTimeoutError(
-    `Operation timed out after ${maxAttempts} attempts`,
-    { attempts: maxAttempts, maxAttempts }
-  );
+  };
+  return namedFunctions[functionName];
 }
-
-// src/api/client.ts
-var SubdomainConfigMap = {
-  // e.g. https://relay.zapier.com
-  relay: {
-    authHeader: "X-Relay-Authorization"
-  }
-};
-var ZapierApiClient = class {
-  constructor(options) {
-    this.options = options;
-    this.fetch = async (path, init) => {
-      return this.plainFetch(path, init);
-    };
-    this.get = async (path, options = {}) => {
-      return this.fetchJson("GET", path, void 0, options);
-    };
-    this.post = async (path, data, options = {}) => {
-      return this.fetchJson("POST", path, data, options);
-    };
-    this.put = async (path, data, options = {}) => {
-      return this.fetchJson("PUT", path, data, options);
-    };
-    this.delete = async (path, options = {}) => {
-      return this.fetchJson("DELETE", path, void 0, options);
-    };
-    this.poll = async (path, options = {}) => {
-      return pollUntilComplete({
-        fetchPoll: () => this.plainFetch(path, {
-          method: "GET",
-          searchParams: options.searchParams,
-          authRequired: options.authRequired
-        }),
-        maxAttempts: options.maxAttempts,
-        initialDelay: options.initialDelay,
-        maxDelay: options.maxDelay,
-        successStatus: options.successStatus,
-        pendingStatus: options.pendingStatus,
-        resultExtractor: options.resultExtractor
+function createPaginatedFunction(coreFn, schema) {
+  const pageFunction = createPageFunction(coreFn);
+  const functionName = coreFn.name;
+  const validator = schema ? createValidator(schema) : null;
+  const namedFunctions = {
+    [functionName]: function(options) {
+      const normalizedOptions = options ?? {};
+      const validatedOptions = {
+        ...normalizedOptions,
+        ...validator ? validator(normalizedOptions) : normalizedOptions
+      };
+      const pageSize = validatedOptions.pageSize || 100;
+      const optimizedOptions = {
+        ...validatedOptions,
+        pageSize
+      };
+      const iterator = paginate(pageFunction, optimizedOptions);
+      const firstPagePromise = iterator.next().then((result) => {
+        if (result.done) {
+          throw new Error("Paginate should always iterate at least once");
+        }
+        return result.value;
       });
-    };
-  }
-  // Helper to parse response data
-  async parseResult(response) {
-    try {
-      return { type: "json", data: await response.json() };
-    } catch {
-      return { type: "text", data: await response.text() };
-    }
-  }
-  // Helper to get a token from the different places it could be gotten
-  async getAuthToken() {
-    if (this.options.token) {
-      return this.options.token;
-    }
-    if (this.options.getToken) {
-      const token = await this.options.getToken();
-      if (token) {
-        return token;
-      }
-    }
-    return getTokenFromEnvOrConfig({
-      onEvent: this.options.onEvent,
-      fetch: this.options.fetch
-    });
-  }
-  // Helper to handle responses
-  async handleResponse(params) {
-    const { response, customErrorHandler, wasMissingAuthToken } = params;
-    const { data: responseData } = await this.parseResult(response);
-    if (response.ok) {
-      return responseData;
-    }
-    const errorInfo = {
-      status: response.status,
-      statusText: response.statusText,
-      data: responseData
-    };
-    if (customErrorHandler) {
-      const customError = customErrorHandler(errorInfo);
-      if (customError) {
-        if (customError instanceof Error) {
-          throw customError;
-        } else {
-          throw new Error(
-            `customErrorHandler returned a non-Error: ${JSON.stringify(customError)}`
-          );
+      return Object.assign(firstPagePromise, {
+        [Symbol.asyncIterator]: async function* () {
+          yield await firstPagePromise;
+          for await (const page of iterator) {
+            yield page;
+          }
+        },
+        items: function() {
+          return {
+            [Symbol.asyncIterator]: async function* () {
+              const firstPage = await firstPagePromise;
+              for (const item of firstPage.data) {
+                yield item;
+              }
+              for await (const page of iterator) {
+                for (const item of page.data) {
+                  yield item;
+                }
+              }
+            }
+          };
         }
-      }
-    }
-    const { message, errors } = this.parseErrorResponse(errorInfo);
-    const errorOptions = {
-      statusCode: response.status,
-      errors
-    };
-    if (response.status === 404) {
-      throw new ZapierNotFoundError(message, errorOptions);
-    }
-    if (response.status === 401 || response.status === 403) {
-      if (wasMissingAuthToken) {
-        throw new ZapierAuthenticationError(
-          `Authentication required (HTTP ${response.status}). Please provide a token in options or set ZAPIER_TOKEN environment variable.`,
-          errorOptions
-        );
-      }
-      throw new ZapierAuthenticationError(message, errorOptions);
+      });
     }
-    if (response.status === 400) {
-      throw new ZapierValidationError(message, errorOptions);
+  };
+  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: []
+      };
     }
-    throw new ZapierApiError(message, errorOptions);
   }
-  hasErrorArray(data) {
-    return typeof data === "object" && data !== null && "errors" in data && Array.isArray(data.errors);
-  }
-  // Helper to check if data has API errors
-  isApiErrorArray(dataArray) {
-    const data = dataArray[0];
-    return typeof data === "object" && data !== null && "message" in data && "code" in data && "title" in data && "detail" in data;
+);
+
+// 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];
   }
-  // Do our best to extract an error message from the response data
-  extractErrorMessage(data) {
-    if (typeof data === "string") {
-      return data;
-    }
-    if (typeof data === "object" && data !== null) {
-      if ("message" in data && typeof data.message === "string") {
-        return data.message;
-      }
-      if ("error" in data) {
-        if (typeof data.error === "string") {
-          return data.error;
-        }
-        if (typeof data.error === "object" && data.error !== null) {
-          if ("message" in data.error && typeof data.error.message === "string") {
-            return data.error.message;
-          }
-        }
-        try {
-          return JSON.stringify(data.error);
-        } catch {
-        }
-      }
-      if ("errors" in data && Array.isArray(data.errors)) {
-        if (this.isApiErrorArray(data.errors)) {
-          return data.errors[0].detail || data.errors[0].title;
-        }
-      }
+  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;
     }
-    return void 0;
   }
-  // Helper to parse API error response
-  parseErrorResponse(errorInfo) {
-    const fallbackMessage = `HTTP ${errorInfo.status}: ${errorInfo.statusText}`;
-    try {
-      if (typeof errorInfo.data === "string") {
-        return { message: `${fallbackMessage}: ${errorInfo.data}` };
-      }
-      const errorMessage = this.extractErrorMessage(errorInfo.data) || fallbackMessage;
-      if (this.hasErrorArray(errorInfo.data)) {
-        if (this.isApiErrorArray(errorInfo.data.errors)) {
-          return {
-            message: errorMessage,
-            errors: errorInfo.data.errors
-          };
-        } else {
-          return {
-            message: errorMessage,
-            errors: errorInfo.data.errors.map((e) => ({
-              status: errorInfo.status,
-              code: String(errorInfo.status),
-              title: errorInfo.statusText,
-              detail: JSON.stringify(e)
-            }))
-          };
-        }
+  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);
       }
-      return { message: errorMessage };
-    } catch {
-      return { message: fallbackMessage };
+      continue;
     }
-  }
-  // Check if this is a path that needs subdomain routing
-  // e.g. /relay/workflows -> relay.zapier.com/workflows
-  applySubdomainBehavior(path) {
-    const pathSegments = path.split("/").filter(Boolean);
-    if (pathSegments.length > 0 && pathSegments[0] in SubdomainConfigMap) {
-      const domainPrefix = pathSegments[0];
-      const subdomainConfig = SubdomainConfigMap[domainPrefix];
-      const originalBaseUrl = new URL(this.options.baseUrl);
-      const finalBaseUrl = `https://${domainPrefix}.${originalBaseUrl.hostname}`;
-      const pathWithoutPrefix = "/" + pathSegments.slice(1).join("/");
-      return { url: new URL(pathWithoutPrefix, finalBaseUrl), subdomainConfig };
+    if (keyWithoutVersion.match(/^[a-z0-9]+(?:-[a-z0-9]+)*$/)) {
+      seenSlugs.add(key);
+      result.slug.push(key);
+      continue;
     }
-    return {
-      url: new URL(path, this.options.baseUrl),
-      subdomainConfig: void 0
-    };
-  }
-  // Helper to build full URLs and return routing info
-  buildUrl(path, searchParams) {
-    const { url, subdomainConfig } = this.applySubdomainBehavior(path);
-    if (searchParams) {
-      Object.entries(searchParams).forEach(([key, value]) => {
-        url.searchParams.set(key, value);
-      });
+    if (!seenSelectedApi.has(key)) {
+      seenSelectedApi.add(key);
+      result.selectedApi.push(key);
     }
-    return { url: url.toString(), subdomainConfig };
   }
-  // Helper to build headers
-  async buildHeaders(options = {}, subdomainConfig) {
-    const headers = new Headers(options.headers ?? {});
-    const authToken = await this.getAuthToken();
-    if (authToken) {
-      const authHeaderName = subdomainConfig?.authHeader || "Authorization";
-      headers.set(authHeaderName, getAuthorizationHeader(authToken));
-    }
-    if (options.authRequired) {
-      if (headers.get("Authorization") == null && authToken == null) {
-        throw new ZapierAuthenticationError(
-          `Authentication required but no token available. Please set ZAPIER_TOKEN, or run the 'login' command with the CLI.`
-        );
+  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);
+        }
       }
     }
-    return headers;
-  }
-  // Helper to perform HTTP requests with JSON handling
-  async fetchJson(method, path, data, options = {}) {
-    const headers = { ...options.headers };
-    if (data && typeof data === "object") {
-      headers["Content-Type"] = "application/json";
+    const searchParams = {};
+    if (opts.pageSize) {
+      searchParams.limit = opts.pageSize.toString();
     }
-    const wasMissingAuthToken = options.authRequired && await this.getAuthToken() == null;
-    const response = await this.plainFetch(path, {
-      ...options,
-      method,
-      body: data != null ? JSON.stringify(data) : void 0,
-      headers
-    });
-    const result = await this.handleResponse({
-      response,
-      customErrorHandler: options.customErrorHandler,
-      wasMissingAuthToken
-    });
-    if (typeof result === "string") {
-      throw new ZapierValidationError(
-        `Response could not be parsed as JSON: ${result}`
-      );
-    }
-    return result;
-  }
-  // Plain fetch method for API paths (must start with /)
-  async plainFetch(path, fetchOptions) {
-    if (!path.startsWith("/")) {
-      throw new ZapierValidationError(
-        `plainFetch expects a path starting with '/', got: ${path}`
-      );
+    searchParams.latest_only = "true";
+    if (opts.cursor) {
+      searchParams.offset = opts.cursor;
     }
-    if (fetchOptions?.body && typeof fetchOptions.body === "object") {
-      fetchOptions.body = JSON.stringify(fetchOptions.body);
+    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 { url, subdomainConfig } = this.buildUrl(
-      path,
-      fetchOptions?.searchParams
-    );
-    const builtHeaders = await this.buildHeaders(
-      fetchOptions,
-      subdomainConfig
+    const implementationsEnvelope = await api.get(
+      "/api/v4/implementations-meta/lookup/",
+      {
+        searchParams
+      }
     );
-    const inputHeaders = new Headers(fetchOptions?.headers ?? {});
-    const mergedHeaders = new Headers();
-    builtHeaders.forEach((value, key) => {
-      mergedHeaders.set(key, value);
-    });
-    inputHeaders.forEach((value, key) => {
-      mergedHeaders.set(key, value);
-    });
-    return await this.options.fetch(url, {
-      ...fetchOptions,
-      headers: mergedHeaders
-    });
-  }
-};
-var createZapierApi = (options) => {
-  const {
-    baseUrl,
-    token,
-    getToken,
-    debug = false,
-    fetch: originalFetch = globalThis.fetch,
-    onEvent
-  } = options;
-  const debugLog = createDebugLogger(debug);
-  const debugFetch = createDebugFetch({ originalFetch, debugLog });
-  return new ZapierApiClient({
-    baseUrl,
-    token,
-    getToken,
-    debug,
-    fetch: debugFetch,
-    onEvent
-  });
-};
-
-// src/plugins/api/index.ts
-var apiPlugin = (params) => {
-  const {
-    fetch: customFetch = globalThis.fetch,
-    baseUrl = "https://zapier.com",
-    token,
-    getToken,
-    onEvent,
-    debug = false
-  } = params.context.options;
-  const api = createZapierApi({
-    baseUrl,
-    token,
-    getToken,
-    debug,
-    fetch: customFetch,
-    onEvent
-  });
+    return {
+      data: implementationsEnvelope.results.map(
+        normalizeImplementationMetaToAppItem
+      ),
+      nextCursor: extractCursor(implementationsEnvelope)
+    };
+  }, ListAppsSchema);
   return {
+    listApps,
     context: {
-      api
-      // Provide API client in context for other plugins to use
-    }
-  };
-};
-
-// src/utils/pagination-utils.ts
-var offsetCursorMarker = "$$offset$$";
-function splitOffsetCursor(cursor) {
-  if (!cursor) {
-    return [0, cursor];
-  }
-  try {
-    const parsedCursor = JSON.parse(cursor);
-    if (!Array.isArray(parsedCursor)) {
-      return [0, cursor];
-    }
-    const [marker, offset, currentCursor] = parsedCursor;
-    if (marker !== offsetCursorMarker) {
-      return [0, cursor];
-    }
-    if (typeof offset !== "number") {
-      return [0, cursor];
-    }
-    return [offset, currentCursor];
-  } catch {
-    return [0, cursor];
-  }
-}
-function createOffsetCursor(offset, currentCursor) {
-  return JSON.stringify([offsetCursorMarker, offset, currentCursor]);
-}
-async function* paginateMaxItems(pageFunction, pageOptions) {
-  let cursor = pageOptions?.cursor;
-  let totalItemsYielded = 0;
-  const maxItems = pageOptions?.maxItems;
-  const pageSize = pageOptions?.pageSize;
-  do {
-    const options = {
-      ...pageOptions || {},
-      cursor,
-      pageSize: maxItems !== void 0 && pageSize !== void 0 ? Math.min(pageSize, maxItems) : pageSize
-    };
-    const page = await pageFunction(options);
-    if (maxItems !== void 0) {
-      const remainingItems = maxItems - totalItemsYielded;
-      if (page.data.length >= remainingItems) {
-        const yieldedPage = {
-          ...page,
-          data: page.data.slice(0, remainingItems),
-          nextCursor: void 0
-        };
-        yield yieldedPage;
-        break;
+      meta: {
+        listApps: {
+          categories: ["app"],
+          inputSchema: ListAppsSchema
+        }
       }
     }
-    yield page;
-    totalItemsYielded += page.data.length;
-    cursor = page.nextCursor;
-  } while (cursor);
-}
-async function* paginateBuffered(pageFunction, pageOptions) {
-  const pageSize = pageOptions?.pageSize;
-  const [cursorOffset, currentCursor] = splitOffsetCursor(pageOptions?.cursor);
-  const options = {
-    ...pageOptions || {},
-    cursor: currentCursor
   };
-  const iterator = paginateMaxItems(pageFunction, options);
-  let bufferedPages = [];
-  let isFirstPage = true;
-  let cursor;
-  for await (let page of iterator) {
-    if (isFirstPage) {
-      isFirstPage = false;
-      if (cursorOffset) {
-        page = {
-          ...page,
-          data: page.data.slice(cursorOffset)
-        };
-      }
-    }
-    if (!pageSize) {
-      yield page;
-      cursor = page.nextCursor;
-      continue;
-    }
-    const bufferedLength = bufferedPages.reduce(
-      (acc, page2) => acc + page2.data.length,
-      0
-    );
-    if (bufferedLength + page.data.length < pageSize) {
-      bufferedPages.push(page);
-      cursor = page.nextCursor;
-      continue;
-    }
-    const bufferedItems = bufferedPages.map((p) => p.data).flat();
-    const allItems = [...bufferedItems, ...page.data];
-    const pageItems = allItems.slice(0, pageSize);
-    const remainingItems = allItems.slice(pageItems.length);
-    if (remainingItems.length === 0) {
-      yield {
-        ...page,
-        data: pageItems,
-        nextCursor: page.nextCursor
-      };
-      bufferedPages = [];
-      cursor = page.nextCursor;
-      continue;
-    }
-    yield {
-      ...page,
-      data: pageItems,
-      nextCursor: createOffsetCursor(
-        page.data.length - remainingItems.length,
-        cursor
-      )
-    };
-    while (remainingItems.length > pageSize) {
-      const pageItems2 = remainingItems.splice(0, pageSize);
-      yield {
-        ...page,
-        data: pageItems2,
-        nextCursor: createOffsetCursor(
-          page.data.length - remainingItems.length,
-          cursor
-        )
-      };
-    }
-    bufferedPages = [
-      {
-        ...page,
-        data: remainingItems
-      }
-    ];
-    cursor = page.nextCursor;
-  }
-  if (bufferedPages.length > 0) {
-    const lastBufferedPage = bufferedPages.slice(-1)[0];
-    const bufferedItems = bufferedPages.map((p) => p.data).flat();
-    yield {
-      ...lastBufferedPage,
-      data: bufferedItems
-    };
-  }
-}
-var paginate = paginateBuffered;
-
-// src/utils/validation.ts
-var validate = (schema, input) => {
-  const result = schema.safeParse(input);
-  if (!result.success) {
-    const errorMessages = result.error.errors.map((error) => {
-      const path = error.path.length > 0 ? error.path.join(".") : "input";
-      return `${path}: ${error.message}`;
-    });
-    const message = `Validation failed:
-  ${errorMessages.join("\n  ")}`;
-    throw new ZapierValidationError(message, {
-      details: {
-        zodErrors: result.error.errors,
-        input
-      }
-    });
-  }
-  return result.data;
-};
-function createValidator(schema) {
-  return function validateFn(input) {
-    return validate(schema, input);
-  };
-}
-var validateOptions = (schema, options) => {
-  return validate(schema, options);
 };
-
-// src/utils/function-utils.ts
-function extractCursor(data) {
-  if (!data?.next) {
-    return void 0;
-  }
-  try {
-    const urlObj = new URL(data.next);
-    const offset = urlObj.searchParams.get("offset");
-    return offset || void 0;
-  } catch {
-    return void 0;
-  }
-}
-function normalizeError(error) {
-  if (error instanceof ZapierError) {
-    return error;
-  }
-  const message = error instanceof Error ? error.message : String(error);
-  return new ZapierUnknownError(`Unknown error: ${message}`, { cause: error });
-}
-function createFunction(coreFn, schema) {
-  const functionName = coreFn.name;
-  const namedFunctions = {
-    [functionName]: async function(options) {
-      try {
-        const normalizedOptions = options ?? {};
-        if (schema) {
-          const validatedOptions = validateOptions(schema, normalizedOptions);
-          return await coreFn({
-            ...normalizedOptions,
-            ...validatedOptions
-          });
-        }
-        return await coreFn(normalizedOptions);
-      } catch (error) {
-        throw normalizeError(error);
-      }
-    }
-  };
-  return namedFunctions[functionName];
-}
-function createPageFunction(coreFn) {
-  const functionName = coreFn.name + "Page";
-  const namedFunctions = {
-    [functionName]: async function(options) {
-      try {
-        const result = await coreFn(options);
-        if (result && typeof result === "object" && "data" in result) {
-          const data = result.data;
-          return {
-            data: Array.isArray(data) ? data : [data],
-            nextCursor: result.nextCursor
-          };
-        }
-        if (Array.isArray(result)) {
-          return { data: result };
-        }
-        return { data: [result] };
-      } catch (error) {
-        throw normalizeError(error);
-      }
-    }
-  };
-  return namedFunctions[functionName];
-}
-function createPaginatedFunction(coreFn, schema) {
-  const pageFunction = createPageFunction(coreFn);
-  const functionName = coreFn.name;
-  const validator = schema ? createValidator(schema) : null;
-  const namedFunctions = {
-    [functionName]: function(options) {
-      const normalizedOptions = options ?? {};
-      const validatedOptions = {
-        ...normalizedOptions,
-        ...validator ? validator(normalizedOptions) : normalizedOptions
-      };
-      const pageSize = validatedOptions.pageSize || 100;
-      const optimizedOptions = {
-        ...validatedOptions,
-        pageSize
-      };
-      const iterator = paginate(pageFunction, optimizedOptions);
-      const firstPagePromise = iterator.next().then((result) => {
-        if (result.done) {
-          throw new Error("Paginate should always iterate at least once");
-        }
-        return result.value;
-      });
-      return Object.assign(firstPagePromise, {
-        [Symbol.asyncIterator]: async function* () {
-          yield await firstPagePromise;
-          for await (const page of iterator) {
-            yield page;
-          }
-        },
-        items: function() {
-          return {
-            [Symbol.asyncIterator]: async function* () {
-              const firstPage = await firstPagePromise;
-              for (const item of firstPage.data) {
-                yield item;
-              }
-              for await (const page of iterator) {
-                for (const item of page.data) {
-                  yield item;
-                }
-              }
-            }
-          };
-        }
-      });
-    }
-  };
-  return namedFunctions[functionName];
-}
 var NeedChoicesSchema = zod.z.object({
   key: zod.z.string().optional(),
   label: zod.z.string().optional(),
@@ -1652,1225 +1190,1687 @@ zod.z.object({
   results: zod.z.array(ImplementationMetaSchema)
 });
 
-// src/schemas/UserProfile.ts
-var UserProfileItemSchema = withFormatter(
-  UserProfileSchema.omit({ user_id: true }).extend({
-    full_name: zod.z.string()
-    // Computed field: first_name + " " + last_name
+// 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
+    title: zod.z.string(),
+    // Mapped from original 'name' field
+    type: zod.z.literal("action")
+    // Fixed type identifier
   }),
   {
     format: (item) => {
       const details = [];
-      details.push({ text: item.email, style: "dim" });
-      if (item.timezone) {
+      details.push({
+        text: `Type: ${item.action_type}`,
+        style: "accent"
+      });
+      if (item.app_key) {
         details.push({
-          text: `Timezone: ${item.timezone}`,
-          style: "accent"
+          text: `App: ${item.app_key}`,
+          style: "normal"
         });
       }
-      details.push({
-        text: `Member since: ${item.since_signup}`,
-        style: "dim"
-      });
+      if (item.description) {
+        details.push({ text: item.description, style: "dim" });
+      }
+      return {
+        title: item.title || item.name || item.key,
+        subtitle: `(${item.key})`,
+        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
+    };
+    const data = await api.get(
+      "/api/v4/implementations/",
+      {
+        searchParams,
+        customErrorHandler: ({ status }) => {
+          if (status === 401) {
+            return new ZapierAuthenticationError(
+              `Authentication failed. Your token may not have permission to access implementations or may be expired. (HTTP ${status})`,
+              { statusCode: status }
+            );
+          }
+          if (status === 403) {
+            return new ZapierAuthenticationError(
+              `Access forbidden. Your token may not have the required scopes to list implementations. (HTTP ${status})`,
+              { statusCode: status }
+            );
+          }
+          return void 0;
+        }
+      }
+    );
+    let allActions = [];
+    for (const implementation of data.results || []) {
+      if (implementation.actions) {
+        for (const action of implementation.actions) {
+          const actionWithContext = {
+            ...action,
+            selected_api: action.selected_api || implementation.selected_api
+          };
+          allActions.push(normalizeActionItem(actionWithContext));
+        }
+      }
+    }
+    if (options.actionType) {
+      allActions = allActions.filter(
+        (action) => action.action_type === options.actionType
+      );
+    }
+    return {
+      data: allActions,
+      nextCursor: void 0
+    };
+  }, ListActionsSchema);
+  return {
+    listActions,
+    context: {
+      meta: {
+        listActions: {
+          categories: ["action"],
+          inputSchema: ListActionsSchema
+        }
+      }
+    }
+  };
+};
+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");
+
+// src/plugins/listInputFields/index.ts
+function getInputFieldTypeFromNeed(need) {
+  if (need.list) {
+    return "ARRAY" /* ARRAY */;
+  }
+  const typeMap = {
+    string: "STRING" /* STRING */,
+    decimal: "NUMBER" /* NUMBER */,
+    integer: "INTEGER" /* INTEGER */,
+    boolean: "BOOLEAN" /* BOOLEAN */,
+    dict: "OBJECT" /* OBJECT */
+  };
+  return typeMap[need.type || ""] || "STRING" /* STRING */;
+}
+function getInputFieldFormatFromNeed(need) {
+  if (need.prefill || need.choices) {
+    return "SELECT" /* SELECT */;
+  }
+  const formatMap = {
+    text: "MULTILINE" /* MULTILINE */,
+    datetime: "DATETIME" /* DATETIME */,
+    file: "FILE" /* FILE */,
+    password: "PASSWORD" /* PASSWORD */,
+    code: "CODE" /* CODE */
+  };
+  return formatMap[need.type || ""];
+}
+function getItemsTypeFromNeed(need) {
+  if (!need.list) {
+    return void 0;
+  }
+  const typeMap = {
+    string: "STRING" /* STRING */,
+    decimal: "NUMBER" /* NUMBER */,
+    integer: "INTEGER" /* INTEGER */,
+    boolean: "BOOLEAN" /* BOOLEAN */,
+    dict: "OBJECT" /* OBJECT */
+  };
+  return typeMap[need.type || ""] || "STRING" /* STRING */;
+}
+function transformNeedToInputFieldItem(need) {
+  const itemsType = getItemsTypeFromNeed(need);
+  return {
+    ...need,
+    // Pass through all original Need fields
+    id: need.key,
+    default_value: need.default || "",
+    depends_on: need.depends_on || [],
+    description: need.help_text || "",
+    invalidates_input_fields: need.alters_custom_fields || false,
+    is_required: need.required || false,
+    placeholder: need.placeholder || "",
+    title: need.label || "",
+    value_type: getInputFieldTypeFromNeed(need),
+    format: getInputFieldFormatFromNeed(need),
+    items: itemsType ? { type: itemsType } : void 0
+  };
+}
+var listInputFieldsPlugin = ({ context }) => {
+  const listInputFields = createPaginatedFunction(
+    async function listInputFieldsPage(options) {
+      const { api, getVersionedImplementationId } = context;
+      const { appKey, actionKey, actionType, authenticationId, inputs } = options;
+      const selectedApi = await getVersionedImplementationId(appKey);
+      if (!selectedApi) {
+        throw new ZapierConfigurationError(
+          "No current_implementation_id found for app",
+          { configType: "current_implementation_id" }
+        );
+      }
+      const needsRequest = {
+        selected_api: selectedApi,
+        action: actionKey,
+        type_of: actionType,
+        params: inputs || {}
+      };
+      if (authenticationId !== null) {
+        needsRequest.authentication_id = authenticationId;
+      }
+      const needsData = await api.post(
+        "/api/v4/implementations/needs/",
+        needsRequest
+      );
+      if (!needsData.success) {
+        throw new ZapierApiError(
+          `Failed to get action fields: ${needsData.errors?.join(", ") || "Unknown error"}`
+        );
+      }
+      const inputFields = (needsData.needs || []).map(
+        transformNeedToInputFieldItem
+      );
+      return {
+        data: inputFields,
+        nextCursor: void 0
+        // No pagination needed since we return all input fields
+      };
+    },
+    ListInputFieldsSchema
+  );
+  return {
+    listInputFields,
+    context: {
+      meta: {
+        listInputFields: {
+          categories: ["action"],
+          inputSchema: ListInputFieldsSchema
+        }
+      }
+    }
+  };
+};
+var ListAuthenticationsSchema = zod.z.object({
+  appKey: AppKeyPropertySchema.optional().describe(
+    "App key of authentications to list (e.g., 'SlackCLIAPI')"
+  ),
+  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"),
+  account_id: zod.z.string().optional().describe("Filter by account ID"),
+  owner: zod.z.string().optional().describe("Filter by owner"),
+  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");
+
+// src/plugins/listAuthentications/index.ts
+var listAuthenticationsPlugin = ({ context }) => {
+  const listAuthentications = createPaginatedFunction(
+    async function listAuthenticationsPage(options) {
+      const { api, getVersionedImplementationId } = context;
+      const searchParams = {};
+      if (options.appKey) {
+        const implementationId = await getVersionedImplementationId(
+          options.appKey
+        );
+        if (implementationId) {
+          const [versionlessSelectedApi] = splitVersionedKey(implementationId);
+          searchParams.versionless_selected_api = versionlessSelectedApi;
+        }
+      }
+      if (options.search) {
+        searchParams.search = options.search;
+      } else if (options.title) {
+        searchParams.search = options.title;
+      }
+      if (options.account_id) {
+        searchParams.account_id = options.account_id;
+      }
+      if (options.owner) {
+        searchParams.owner = options.owner;
+      }
+      searchParams.limit = options.pageSize.toString();
+      if (options.cursor) {
+        searchParams.offset = options.cursor;
+      }
+      console.log({ searchParams });
+      const data = await api.get(
+        "/api/v4/authentications/",
+        {
+          searchParams,
+          customErrorHandler: ({ status }) => {
+            if (status === 401) {
+              return new ZapierAuthenticationError(
+                `Authentication failed. Your token may not have permission to access authentications or may be expired. (HTTP ${status})`,
+                { statusCode: status }
+              );
+            }
+            if (status === 403) {
+              return new ZapierAuthenticationError(
+                `Access forbidden. Your token may not have the required scopes to list authentications. (HTTP ${status})`,
+                { statusCode: status }
+              );
+            }
+            return void 0;
+          },
+          authRequired: true
+        }
+      );
+      let auths = (data.results || []).map(
+        (auth) => normalizeAuthenticationItem(auth)
+      );
+      if (options.title) {
+        auths = auths.filter((auth) => auth.title === options.title);
+      }
       return {
-        title: item.full_name,
-        subtitle: `@${item.username}`,
-        details
+        data: auths,
+        nextCursor: extractCursor(data)
       };
-    }
-  }
-);
-
-// 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() {
-    const profile = await context.api.get("/api/v4/profile/", {
-      authRequired: true
-    });
-    const { user_id: _unusedUserId, ...data } = profile;
-    return {
-      data: {
-        ...data,
-        // Pass through all API response fields
-        full_name: `${profile.first_name} ${profile.last_name}`
-        // Computed field
-      }
-    };
-  }, GetProfileSchema);
+    },
+    ListAuthenticationsSchema
+  );
   return {
-    getProfile,
+    listAuthentications,
     context: {
       meta: {
-        getProfile: {
-          categories: ["user"],
-          inputSchema: GetProfileSchema
+        listAuthentications: {
+          categories: ["authentication"],
+          inputSchema: ListAuthenticationsSchema
         }
       }
     }
   };
 };
-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(
+var GetAppSchema = 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"),
+    appKey: AppKeyPropertySchema.describe(
+      "App key of app to fetch (e.g., 'SlackCLIAPI')"
+    )
+  }).describe("Get detailed information about a specific app"),
   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];
+// src/plugins/getApp/index.ts
+var getAppPlugin = ({ context }) => {
+  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
+      });
+    }
+    return {
+      data: app
+    };
+  }, GetAppSchema);
   return {
-    title: implementation.name || selectedApi,
-    key: selectedApi,
-    current_implementation_id: implementation.selected_api || "",
-    version: appVersion
-    // Extract version separately
+    getApp,
+    context: {
+      meta: {
+        getApp: {
+          categories: ["app"],
+          inputSchema: GetAppSchema
+        }
+      }
+    }
   };
-}
-function normalizeImplementationMetaToAppItem(implementationMeta) {
-  const [selectedApi, appVersion] = splitVersionedKey(implementationMeta.id);
+};
+var GetActionSchema = zod.z.object({
+  appKey: AppKeyPropertySchema,
+  actionType: ActionTypePropertySchema,
+  actionKey: ActionKeyPropertySchema
+}).describe("Get detailed information about a specific action");
+
+// src/plugins/getAction/index.ts
+var getActionPlugin = ({ sdk }) => {
+  const getAction = createFunction(async function getAction2(options) {
+    const { actionKey, actionType, appKey } = options;
+    const actionsResult = await sdk.listActions({ appKey });
+    for (const action of actionsResult.data) {
+      if (action.key === actionKey && action.action_type === actionType) {
+        return { data: action };
+      }
+    }
+    throw new ZapierResourceNotFoundError(
+      `Action not found: ${actionKey} with type ${actionType}`,
+      { resourceType: "Action", resourceId: `${actionKey} (${actionType})` }
+    );
+  }, GetActionSchema);
   return {
-    title: implementationMeta.name,
-    key: selectedApi,
-    current_implementation_id: implementationMeta.id,
-    // Keep the full versioned ID
-    version: appVersion,
-    // Extract version separately
-    slug: implementationMeta.slug
+    getAction,
+    context: {
+      meta: {
+        getAction: {
+          categories: ["action"],
+          inputSchema: GetActionSchema
+        }
+      }
+    }
   };
-}
-function normalizeAuthenticationItem(auth, options = {}) {
-  let appKey = options.app_key;
-  let version = options.version;
-  if (auth.selected_api) {
-    const [extractedAppKey, extractedVersion] = splitVersionedKey(
-      auth.selected_api
+};
+var GetAuthenticationSchema = zod.z.object({
+  authenticationId: zod.z.number().int().positive().describe("Authentication ID to retrieve")
+}).describe("Get a specific authentication by ID");
+
+// src/plugins/getAuthentication/index.ts
+var getAuthenticationPlugin = ({ context }) => {
+  const getAuthentication = createFunction(async function getAuthentication2(options) {
+    const { api } = context;
+    const { authenticationId } = options;
+    const data = await api.get(
+      `/api/v4/authentications/${authenticationId}/`,
+      {
+        customErrorHandler: ({ status }) => {
+          if (status === 401) {
+            return new ZapierAuthenticationError(
+              `Authentication failed. Your token may not have permission to access authentications or may be expired. (HTTP ${status})`,
+              { statusCode: status }
+            );
+          }
+          if (status === 403) {
+            return new ZapierAuthenticationError(
+              `Access forbidden. Your token may not have the required scopes to get authentication ${authenticationId}. (HTTP ${status})`,
+              { statusCode: status }
+            );
+          }
+          if (status === 404) {
+            return new ZapierResourceNotFoundError(
+              `Authentication ${authenticationId} not found. It may not exist or you may not have access to it. (HTTP ${status})`,
+              {
+                resourceType: "Authentication",
+                resourceId: String(authenticationId)
+              }
+            );
+          }
+          return void 0;
+        },
+        authRequired: true
+      }
     );
-    if (!appKey) {
-      appKey = extractedAppKey;
-    }
-    if (!version) {
-      version = extractedVersion;
+    return {
+      data: normalizeAuthenticationItem(data)
+    };
+  }, GetAuthenticationSchema);
+  return {
+    getAuthentication,
+    context: {
+      meta: {
+        getAuthentication: {
+          categories: ["authentication"],
+          inputSchema: GetAuthenticationSchema
+        }
+      }
     }
-  }
-  const {
-    selected_api: selectedApi,
-    customuser_id: userId,
-    ...restOfAuth
-  } = auth;
+  };
+};
+var FindFirstAuthenticationSchema = zod.z.object({
+  appKey: AppKeyPropertySchema.optional().describe(
+    "App key of authentication to find (e.g., 'SlackCLIAPI')"
+  ),
+  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"),
+  account_id: zod.z.string().optional().describe("Filter by account ID"),
+  owner: zod.z.string().optional().describe("Filter by owner")
+}).describe("Find the first authentication matching the criteria");
+
+// src/plugins/findFirstAuthentication/index.ts
+var findFirstAuthenticationPlugin = ({ sdk }) => {
+  const findFirstAuthentication = createFunction(
+    async function findFirstAuthentication2(options = {}) {
+      const authsResponse = await sdk.listAuthentications({
+        ...options,
+        maxItems: 1
+      });
+      return {
+        data: authsResponse.data.length > 0 ? authsResponse.data[0] : null
+      };
+    },
+    FindFirstAuthenticationSchema
+  );
   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
+    findFirstAuthentication,
+    context: {
+      meta: {
+        findFirstAuthentication: {
+          categories: ["authentication"],
+          inputSchema: FindFirstAuthenticationSchema
+        }
+      }
+    }
   };
-}
-function normalizeActionItem(action) {
-  const { name, type, selected_api: appKey, ...restOfAction } = action;
+};
+var FindUniqueAuthenticationSchema = zod.z.object({
+  appKey: AppKeyPropertySchema.optional().describe(
+    "App key of authentication to find (e.g., 'SlackCLIAPI')"
+  ),
+  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"),
+  account_id: zod.z.string().optional().describe("Filter by account ID"),
+  owner: zod.z.string().optional().describe("Filter by owner")
+}).describe("Find a unique authentication matching the criteria");
+
+// src/plugins/findUniqueAuthentication/index.ts
+var findUniqueAuthenticationPlugin = ({ sdk }) => {
+  const findUniqueAuthentication = createFunction(
+    async function findUniqueAuthentication2(options = {}) {
+      const authsResponse = await sdk.listAuthentications({
+        ...options,
+        maxItems: 2
+        // Get up to 2 to check for uniqueness
+      });
+      if (authsResponse.data.length === 0) {
+        throw new ZapierResourceNotFoundError(
+          "No authentication found matching the specified criteria",
+          { resourceType: "Authentication" }
+        );
+      }
+      if (authsResponse.data.length > 1) {
+        throw new ZapierValidationError(
+          "Multiple authentications found matching the specified criteria. Expected exactly one."
+        );
+      }
+      return {
+        data: authsResponse.data[0]
+      };
+    },
+    FindUniqueAuthenticationSchema
+  );
   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);
+    findUniqueAuthentication,
+    context: {
+      meta: {
+        findUniqueAuthentication: {
+          categories: ["authentication"],
+          inputSchema: FindUniqueAuthenticationSchema
+        }
       }
-      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;
+};
+var RunActionSchema = zod.z.object({
+  appKey: AppKeyPropertySchema,
+  actionType: ActionTypePropertySchema,
+  actionKey: ActionKeyPropertySchema,
+  authenticationId: AuthenticationIdPropertySchema.nullable().optional(),
+  inputs: InputsPropertySchema.optional().describe(
+    "Input parameters for the action"
+  ),
+  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");
+
+// src/plugins/runAction/index.ts
+async function executeAction(actionOptions) {
+  const {
+    api,
+    context,
+    appKey,
+    actionKey,
+    actionType,
+    executionOptions,
+    authenticationId
+  } = actionOptions;
+  const selectedApi = await context.getVersionedImplementationId(appKey);
+  if (!selectedApi) {
+    throw new ZapierConfigurationError(
+      "No current_implementation_id found for app",
+      { configType: "current_implementation_id" }
+    );
   }
-  if (slug.startsWith("_")) {
-    slug = slug.slice(1);
+  const runRequestData = {
+    selected_api: selectedApi,
+    action_key: actionKey,
+    action_type: actionType,
+    inputs: executionOptions.inputs || {}
+  };
+  if (authenticationId !== null && authenticationId !== void 0) {
+    runRequestData.authentication_id = authenticationId;
   }
-  return slug.replace(/_/g, "-");
+  const runRequest = {
+    data: runRequestData
+  };
+  const runData = await api.post(
+    "/api/actions/v1/runs",
+    runRequest
+  );
+  const runId = runData.data.id;
+  return await api.poll(`/api/actions/v1/runs/${runId}`, {
+    successStatus: 200,
+    pendingStatus: 202,
+    resultExtractor: (result) => result.data
+  });
 }
-
-// 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
+var runActionPlugin = ({ sdk, context }) => {
+  const runAction = createPaginatedFunction(async function runActionPage(options) {
+    const { api } = context;
+    const {
+      appKey,
+      actionKey,
+      actionType,
+      authenticationId,
+      inputs = {}
+    } = options;
+    const actionData = await sdk.getAction({
+      appKey,
+      actionKey,
+      actionType
+    });
+    if (actionData.data.action_type !== actionType) {
+      throw new ZapierValidationError(
+        `Action type mismatch: expected ${actionType}, got ${actionData.data.action_type}`
       );
-      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 result = await executeAction({
+      api,
+      context,
+      appKey,
+      actionKey,
+      actionType,
+      executionOptions: { inputs },
+      authenticationId});
+    if (result.errors && result.errors.length > 0) {
+      const errorMessage = result.errors.map(
+        (error) => error.detail || error.title || "Unknown error"
+      ).join("; ");
+      throw new ZapierActionError(`Action execution failed: ${errorMessage}`, {
+        appKey,
+        actionKey
+      });
     }
-    const implementationsEnvelope = await api.get(
-      "/api/v4/implementations-meta/lookup/",
-      {
-        searchParams
-      }
-    );
     return {
-      data: implementationsEnvelope.results.map(
-        normalizeImplementationMetaToAppItem
-      ),
-      nextCursor: extractCursor(implementationsEnvelope)
+      data: result.results || [],
+      nextCursor: void 0
+      // No pagination implemented yet
     };
-  }, ListAppsSchema);
+  }, RunActionSchema);
   return {
-    listApps,
+    runAction,
     context: {
       meta: {
-        listApps: {
-          categories: ["app"],
-          inputSchema: ListAppsSchema
+        runAction: {
+          categories: ["action"],
+          inputSchema: RunActionSchema
         }
       }
     }
   };
 };
-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 RelayRequestSchema = zod.z.object({
+  url: zod.z.string().url().describe("The URL to request (will be proxied through Relay)"),
+  method: zod.z.enum(["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"]).optional().describe("HTTP method"),
+  body: zod.z.any().optional().describe("Request body as a string"),
+  authenticationId: zod.z.number().int().optional().describe("Zapier authentication ID to use for the request"),
+  callbackUrl: zod.z.string().url().optional().describe("URL to send async response to (makes request async)"),
+  authenticationTemplate: zod.z.string().optional().describe(
+    "Optional JSON string authentication template to bypass Notary lookup"
+  ),
+  headers: zod.z.union([
+    zod.z.record(zod.z.string()),
+    zod.z.instanceof(Headers),
+    zod.z.array(zod.z.tuple([zod.z.string(), zod.z.string()]))
+  ]).optional().describe("Request headers")
+}).extend({
+  relayBaseUrl: zod.z.string().optional().describe("Base URL for Relay service")
+}).describe("Make authenticated HTTP requests through Zapier's Relay service");
+var RelayFetchSchema = RelayRequestSchema;
 
-// src/plugins/getApp/index.ts
-var getAppPlugin = ({ context }) => {
-  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
-      });
+// src/plugins/request/index.ts
+function transformUrlToRelayPath(url) {
+  const targetUrl = new URL(url);
+  const relayPath = `/relay/${targetUrl.host}${targetUrl.pathname}${targetUrl.search}${targetUrl.hash}`;
+  return relayPath;
+}
+var requestPlugin = ({ context }) => {
+  const request = createFunction(async function request2(options) {
+    const { api } = context;
+    const {
+      url,
+      method = "GET",
+      body,
+      headers: optionsHeaders,
+      authenticationId,
+      callbackUrl,
+      authenticationTemplate
+    } = options;
+    const relayPath = transformUrlToRelayPath(url);
+    const headers = {};
+    if (optionsHeaders) {
+      const headerEntries = optionsHeaders instanceof Headers ? Array.from(optionsHeaders.entries()) : Array.isArray(optionsHeaders) ? optionsHeaders : Object.entries(optionsHeaders);
+      for (const [key, value] of headerEntries) {
+        headers[key] = value;
+      }
     }
-    return {
-      data: app
-    };
-  }, GetAppSchema);
+    if (authenticationId) {
+      headers["X-Relay-Authentication-Id"] = authenticationId.toString();
+    }
+    if (callbackUrl) {
+      headers["X-Relay-Callback-Url"] = callbackUrl;
+    }
+    if (authenticationTemplate) {
+      headers["X-Authentication-Template"] = authenticationTemplate;
+    }
+    return await api.fetch(relayPath, {
+      method,
+      body,
+      headers
+    });
+  }, RelayRequestSchema);
   return {
-    getApp,
+    request,
     context: {
       meta: {
-        getApp: {
-          categories: ["app"],
-          inputSchema: GetAppSchema
+        request: {
+          categories: ["http"],
+          inputSchema: RelayRequestSchema
         }
       }
     }
   };
 };
-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" });
+var ManifestSchema = zod.z.object({
+  apps: zod.z.record(
+    zod.z.string(),
+    zod.z.object({
+      implementationName: zod.z.string().describe(
+        "Base implementation name without version (e.g., 'SlackCLIAPI')"
+      ),
+      version: zod.z.string().describe("Version string (e.g., '1.21.1')")
+    })
+  )
+}).describe("Manifest mapping app keys to version information");
+zod.z.object({
+  manifestPath: zod.z.string().optional().describe("Path to manifest file"),
+  manifest: zod.z.record(
+    zod.z.string(),
+    zod.z.object({
+      implementationName: zod.z.string(),
+      version: zod.z.string().optional()
+    })
+  ).optional().describe("Direct manifest object")
+});
+
+// src/plugins/manifest/index.ts
+function parseManifestContent(content, source) {
+  try {
+    const parsed = JSON.parse(content);
+    if (parsed?.apps && typeof parsed?.apps === "object") {
+      const result = ManifestSchema.safeParse(parsed);
+      if (result.success) {
+        return result.data;
       }
-      return {
-        title: item.title || item.name || item.key,
-        subtitle: `(${item.key})`,
-        details
-      };
+      console.warn(`\u26A0\uFE0F Invalid manifest format in ${source}: ${result.error}`);
     }
+    return null;
+  } catch (error) {
+    console.warn(`\u26A0\uFE0F Failed to parse manifest from ${source}:`, error);
+    return null;
   }
-);
-
-// 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" }
-      );
+}
+function loadManifestFromFile(filePath) {
+  try {
+    const resolvedPath = path.resolve(filePath);
+    const content = fs.readFileSync(resolvedPath, "utf8");
+    return parseManifestContent(content, resolvedPath);
+  } catch {
+    console.warn(`\u26A0\uFE0F Failed to load 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.`
+  );
+  console.warn(
+    `   ${"\u21B3".padEnd(3)} Generate/update the manifest with: \`zapier-sdk lock-version ${appKey}\`
+`
+  );
+};
+var manifestPlugin = (params) => {
+  const { sdk, context } = params;
+  const { api, options } = context;
+  const { manifestPath = ".zapierrc", manifest } = options || {};
+  let resolvedManifest;
+  function resolveManifest() {
+    if (manifest) {
+      return manifest;
+    }
+    if (manifestPath) {
+      return loadManifestFromFile(manifestPath);
+    }
+    return null;
+  }
+  const getResolvedManifest = () => {
+    if (typeof resolvedManifest === "undefined") {
+      resolvedManifest = resolveManifest() ?? null;
+    }
+    return resolvedManifest;
+  };
+  const getManifestEntry = (appKey) => {
+    return getResolvedManifest()?.apps?.[appKey] || null;
+  };
+  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"}`;
     }
-    const searchParams = {
-      global: "true",
-      public_only: "true",
-      selected_apis: selectedApi
-    };
-    const data = await api.get(
-      "/api/v4/implementations/",
-      {
-        searchParams,
-        customErrorHandler: ({ status }) => {
-          if (status === 401) {
-            return new ZapierAuthenticationError(
-              `Authentication failed. Your token may not have permission to access implementations or may be expired. (HTTP ${status})`,
-              { statusCode: status }
-            );
-          }
-          if (status === 403) {
-            return new ZapierAuthenticationError(
-              `Access forbidden. Your token may not have the required scopes to list implementations. (HTTP ${status})`,
-              { statusCode: status }
-            );
-          }
-          return void 0;
-        }
-      }
-    );
-    let allActions = [];
-    for (const implementation of data.results || []) {
-      if (implementation.actions) {
-        for (const action of implementation.actions) {
-          const actionWithContext = {
-            ...action,
-            selected_api: action.selected_api || implementation.selected_api
-          };
-          allActions.push(normalizeActionItem(actionWithContext));
+    if (selectedApi) {
+      const searchParams = {
+        selected_apis: selectedApi
+      };
+      const implementationData = await api.get(
+        "/api/v4/implementations/",
+        {
+          searchParams
         }
-      }
-    }
-    if (options.actionType) {
-      allActions = allActions.filter(
-        (action) => action.action_type === options.actionType
       );
+      const implementationResults = implementationData.results[0];
+      if (!implementationResults) return null;
+      return normalizeImplementationToAppItem(implementationResults);
     }
-    return {
-      data: allActions,
-      nextCursor: void 0
-    };
-  }, ListActionsSchema);
-  return {
-    listActions,
-    context: {
-      meta: {
-        listActions: {
-          categories: ["action"],
-          inputSchema: ListActionsSchema
-        }
-      }
+    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;
   };
-};
-var GetActionSchema = zod.z.object({
-  appKey: AppKeyPropertySchema,
-  actionType: ActionTypePropertySchema,
-  actionKey: ActionKeyPropertySchema
-}).describe("Get detailed information about a specific action");
-
-// src/plugins/getAction/index.ts
-var getActionPlugin = ({ sdk }) => {
-  const getAction = createFunction(async function getAction2(options) {
-    const { actionKey, actionType, appKey } = options;
-    const actionsResult = await sdk.listActions({ appKey });
-    for (const action of actionsResult.data) {
-      if (action.key === actionKey && action.action_type === actionType) {
-        return { data: action };
-      }
+  const getVersionedImplementationId = async (appKey) => {
+    const manifestEntry = getManifestEntry(appKey);
+    if (manifestEntry) {
+      return `${manifestEntry.implementationName}@${manifestEntry.version || "latest"}`;
     }
-    throw new ZapierResourceNotFoundError(
-      `Action not found: ${actionKey} with type ${actionType}`,
-      { resourceType: "Action", resourceId: `${actionKey} (${actionType})` }
-    );
-  }, GetActionSchema);
+    const implementation = await getImplementation(appKey);
+    if (!implementation) return null;
+    return implementation.current_implementation_id;
+  };
   return {
-    getAction,
     context: {
-      meta: {
-        getAction: {
-          categories: ["action"],
-          inputSchema: GetActionSchema
-        }
-      }
+      getVersionedImplementationId,
+      getManifestEntry,
+      getImplementation
     }
   };
 };
-var RunActionSchema = zod.z.object({
-  appKey: AppKeyPropertySchema,
-  actionType: ActionTypePropertySchema,
-  actionKey: ActionKeyPropertySchema,
-  authenticationId: AuthenticationIdPropertySchema.nullable().optional(),
-  inputs: InputsPropertySchema.optional().describe(
-    "Input parameters for the action"
-  ),
-  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");
-
-// src/plugins/runAction/index.ts
-async function executeAction(actionOptions) {
-  const {
-    api,
-    context,
-    appKey,
-    actionKey,
-    actionType,
-    executionOptions,
-    authenticationId
-  } = actionOptions;
-  const selectedApi = await context.getVersionedImplementationId(appKey);
-  if (!selectedApi) {
-    throw new ZapierConfigurationError(
-      "No current_implementation_id found for app",
-      { configType: "current_implementation_id" }
-    );
-  }
-  const runRequestData = {
-    selected_api: selectedApi,
-    action_key: actionKey,
-    action_type: actionType,
-    inputs: executionOptions.inputs || {}
-  };
-  if (authenticationId !== null && authenticationId !== void 0) {
-    runRequestData.authentication_id = authenticationId;
-  }
-  const runRequest = {
-    data: runRequestData
-  };
-  const runData = await api.post(
-    "/api/actions/v1/runs",
-    runRequest
+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')")
+    })
   );
-  const runId = runData.data.id;
-  return await api.poll(`/api/actions/v1/runs/${runId}`, {
-    successStatus: 200,
-    pendingStatus: 202,
-    resultExtractor: (result) => result.data
-  });
-}
-var runActionPlugin = ({ sdk, context }) => {
-  const runAction = createPaginatedFunction(async function runActionPage(options) {
-    const { api } = context;
-    const {
-      appKey,
-      actionKey,
-      actionType,
-      authenticationId,
-      inputs = {}
-    } = options;
-    const actionData = await sdk.getAction({
-      appKey,
-      actionKey,
-      actionType
-    });
-    if (actionData.data.action_type !== actionType) {
-      throw new ZapierValidationError(
-        `Action type mismatch: expected ${actionType}, got ${actionData.data.action_type}`
-      );
+  return {
+    lockVersion,
+    context: {
+      meta: {
+        lockVersion: {
+          categories: ["utility"],
+          inputSchema: LockVersionSchema
+        }
+      }
     }
-    const result = await executeAction({
-      api,
-      context,
-      appKey,
-      actionKey,
-      actionType,
-      executionOptions: { inputs },
-      authenticationId});
-    if (result.errors && result.errors.length > 0) {
-      const errorMessage = result.errors.map(
-        (error) => error.detail || error.title || "Unknown error"
-      ).join("; ");
-      throw new ZapierActionError(`Action execution failed: ${errorMessage}`, {
-        appKey,
-        actionKey
+  };
+};
+var UserProfileItemSchema = withFormatter(
+  UserProfileSchema.omit({ user_id: true }).extend({
+    full_name: zod.z.string()
+    // Computed field: first_name + " " + last_name
+  }),
+  {
+    format: (item) => {
+      const details = [];
+      details.push({ text: item.email, style: "dim" });
+      if (item.timezone) {
+        details.push({
+          text: `Timezone: ${item.timezone}`,
+          style: "accent"
+        });
+      }
+      details.push({
+        text: `Member since: ${item.since_signup}`,
+        style: "dim"
       });
+      return {
+        title: item.full_name,
+        subtitle: `@${item.username}`,
+        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() {
+    const profile = await context.api.get("/api/v4/profile/", {
+      authRequired: true
+    });
+    const { user_id: _unusedUserId, ...data } = profile;
     return {
-      data: result.results || [],
-      nextCursor: void 0
-      // No pagination implemented yet
+      data: {
+        ...data,
+        // Pass through all API response fields
+        full_name: `${profile.first_name} ${profile.last_name}`
+        // Computed field
+      }
     };
-  }, RunActionSchema);
+  }, GetProfileSchema);
   return {
-    runAction,
+    getProfile,
     context: {
       meta: {
-        runAction: {
-          categories: ["action"],
-          inputSchema: RunActionSchema
+        getProfile: {
+          categories: ["account"],
+          inputSchema: GetProfileSchema
         }
       }
     }
   };
 };
-var ListAuthenticationsSchema = zod.z.object({
-  appKey: AppKeyPropertySchema.optional().describe(
-    "App key of authentications to list (e.g., 'SlackCLIAPI')"
-  ),
-  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"),
-  account_id: zod.z.string().optional().describe("Filter by account ID"),
-  owner: zod.z.string().optional().describe("Filter by owner"),
-  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");
 
-// src/plugins/listAuthentications/index.ts
-var listAuthenticationsPlugin = ({ context }) => {
-  const listAuthentications = createPaginatedFunction(
-    async function listAuthenticationsPage(options) {
-      const { api, getVersionedImplementationId } = context;
-      const searchParams = {};
-      if (options.appKey) {
-        const implementationId = await getVersionedImplementationId(
-          options.appKey
-        );
-        if (implementationId) {
-          const [versionlessSelectedApi] = splitVersionedKey(implementationId);
-          searchParams.versionless_selected_api = versionlessSelectedApi;
+// src/api/auth.ts
+function isJwt(token) {
+  const parts = token.split(".");
+  if (parts.length !== 3) {
+    return false;
+  }
+  const base64UrlPattern = /^[A-Za-z0-9_-]+$/;
+  return parts.every((part) => part.length > 0 && base64UrlPattern.test(part));
+}
+function getAuthorizationHeader(token) {
+  if (isJwt(token)) {
+    return `JWT ${token}`;
+  }
+  return `Bearer ${token}`;
+}
+
+// src/api/debug.ts
+function createDebugLogger(enabled) {
+  if (!enabled) {
+    return () => {
+    };
+  }
+  return (message, data) => {
+    console.log(`[Zapier SDK] ${message}`, data || "");
+  };
+}
+function createDebugFetch(options) {
+  const { originalFetch, debugLog } = options;
+  return async (input, options2) => {
+    const startTime = Date.now();
+    const url = typeof input === "string" ? input : input.toString();
+    const method = options2?.method || "GET";
+    debugLog(`\u2192 ${method} ${url}`, {
+      headers: options2?.headers,
+      body: options2?.body && typeof options2.body === "string" ? (() => {
+        try {
+          return JSON.parse(options2.body);
+        } catch {
+          return options2.body;
         }
+      })() : options2?.body
+    });
+    try {
+      const response = await originalFetch(input, options2);
+      const duration = Date.now() - startTime;
+      debugLog(`\u2190 ${response.status} ${response.statusText} (${duration}ms)`, {
+        url,
+        method,
+        status: response.status
+      });
+      return response;
+    } catch (error) {
+      const duration = Date.now() - startTime;
+      debugLog(`\u2716 Request failed (${duration}ms)`, {
+        url,
+        method,
+        error: error instanceof Error ? error.message : error
+      });
+      throw error;
+    }
+  };
+}
+
+// src/api/polling.ts
+async function pollUntilComplete(options) {
+  const {
+    fetchPoll,
+    maxAttempts = 30,
+    initialDelay = 50,
+    maxDelay = 1e3,
+    successStatus = 200,
+    pendingStatus = 202,
+    resultExtractor = (response) => response
+  } = options;
+  let delay = initialDelay;
+  let errorCount = 0;
+  for (let attempt = 0; attempt < maxAttempts; attempt++) {
+    const response = await fetchPoll();
+    if (response.status === successStatus) {
+      errorCount = 0;
+      const result = await response.json();
+      return resultExtractor(result);
+    } else if (response.status === pendingStatus) {
+      errorCount = 0;
+      if (attempt < maxAttempts - 1) {
+        await new Promise((resolve3) => setTimeout(resolve3, delay));
+        delay = Math.min(delay * 2, maxDelay);
+        continue;
       }
-      if (options.search) {
-        searchParams.search = options.search;
-      } else if (options.title) {
-        searchParams.search = options.title;
-      }
-      if (options.account_id) {
-        searchParams.account_id = options.account_id;
-      }
-      if (options.owner) {
-        searchParams.owner = options.owner;
-      }
-      searchParams.limit = options.pageSize.toString();
-      if (options.cursor) {
-        searchParams.offset = options.cursor;
-      }
-      console.log({ searchParams });
-      const data = await api.get(
-        "/api/v4/authentications/",
-        {
-          searchParams,
-          customErrorHandler: ({ status }) => {
-            if (status === 401) {
-              return new ZapierAuthenticationError(
-                `Authentication failed. Your token may not have permission to access authentications or may be expired. (HTTP ${status})`,
-                { statusCode: status }
-              );
-            }
-            if (status === 403) {
-              return new ZapierAuthenticationError(
-                `Access forbidden. Your token may not have the required scopes to list authentications. (HTTP ${status})`,
-                { statusCode: status }
-              );
-            }
-            return void 0;
-          },
-          authRequired: true
-        }
-      );
-      let auths = (data.results || []).map(
-        (auth) => normalizeAuthenticationItem(auth)
-      );
-      if (options.title) {
-        auths = auths.filter((auth) => auth.title === options.title);
+    } else {
+      errorCount++;
+      if (errorCount >= 3) {
+        throw new ZapierApiError(
+          `Poll request failed: ${response.status} ${response.statusText}`,
+          { statusCode: response.status }
+        );
       }
-      return {
-        data: auths,
-        nextCursor: extractCursor(data)
-      };
-    },
-    ListAuthenticationsSchema
-  );
-  return {
-    listAuthentications,
-    context: {
-      meta: {
-        listAuthentications: {
-          categories: ["authentication"],
-          inputSchema: ListAuthenticationsSchema
-        }
+      if (attempt < maxAttempts - 1) {
+        await new Promise((resolve3) => setTimeout(resolve3, delay));
+        delay = Math.min(delay * 2, maxDelay);
+        continue;
       }
     }
-  };
-};
-var GetAuthenticationSchema = zod.z.object({
-  authenticationId: zod.z.number().int().positive().describe("Authentication ID to retrieve")
-}).describe("Get a specific authentication by ID");
+  }
+  throw new ZapierTimeoutError(
+    `Operation timed out after ${maxAttempts} attempts`,
+    { attempts: maxAttempts, maxAttempts }
+  );
+}
 
-// src/plugins/getAuthentication/index.ts
-var getAuthenticationPlugin = ({ context }) => {
-  const getAuthentication = createFunction(async function getAuthentication2(options) {
-    const { api } = context;
-    const { authenticationId } = options;
-    const data = await api.get(
-      `/api/v4/authentications/${authenticationId}/`,
-      {
-        customErrorHandler: ({ status }) => {
-          if (status === 401) {
-            return new ZapierAuthenticationError(
-              `Authentication failed. Your token may not have permission to access authentications or may be expired. (HTTP ${status})`,
-              { statusCode: status }
-            );
-          }
-          if (status === 403) {
-            return new ZapierAuthenticationError(
-              `Access forbidden. Your token may not have the required scopes to get authentication ${authenticationId}. (HTTP ${status})`,
-              { statusCode: status }
-            );
-          }
-          if (status === 404) {
-            return new ZapierResourceNotFoundError(
-              `Authentication ${authenticationId} not found. It may not exist or you may not have access to it. (HTTP ${status})`,
-              {
-                resourceType: "Authentication",
-                resourceId: String(authenticationId)
-              }
-            );
-          }
-          return void 0;
-        },
-        authRequired: true
-      }
-    );
-    return {
-      data: normalizeAuthenticationItem(data)
+// src/auth.ts
+function getTokenFromEnv() {
+  return process.env.ZAPIER_TOKEN;
+}
+async function getTokenFromCliLogin(options = {}) {
+  try {
+    const { getToken } = await import('@zapier/zapier-sdk-cli-login');
+    return await getToken(options);
+  } catch {
+    return void 0;
+  }
+}
+async function getTokenFromEnvOrConfig(options = {}) {
+  const envToken = getTokenFromEnv();
+  if (envToken) {
+    return envToken;
+  }
+  return getTokenFromCliLogin(options);
+}
+
+// src/api/client.ts
+var SubdomainConfigMap = {
+  // e.g. https://relay.zapier.com
+  relay: {
+    authHeader: "X-Relay-Authorization"
+  }
+};
+var ZapierApiClient = class {
+  constructor(options) {
+    this.options = options;
+    this.fetch = async (path, init) => {
+      return this.plainFetch(path, init);
     };
-  }, GetAuthenticationSchema);
-  return {
-    getAuthentication,
-    context: {
-      meta: {
-        getAuthentication: {
-          categories: ["authentication"],
-          inputSchema: GetAuthenticationSchema
-        }
+    this.get = async (path, options = {}) => {
+      return this.fetchJson("GET", path, void 0, options);
+    };
+    this.post = async (path, data, options = {}) => {
+      return this.fetchJson("POST", path, data, options);
+    };
+    this.put = async (path, data, options = {}) => {
+      return this.fetchJson("PUT", path, data, options);
+    };
+    this.delete = async (path, options = {}) => {
+      return this.fetchJson("DELETE", path, void 0, options);
+    };
+    this.poll = async (path, options = {}) => {
+      return pollUntilComplete({
+        fetchPoll: () => this.plainFetch(path, {
+          method: "GET",
+          searchParams: options.searchParams,
+          authRequired: options.authRequired
+        }),
+        maxAttempts: options.maxAttempts,
+        initialDelay: options.initialDelay,
+        maxDelay: options.maxDelay,
+        successStatus: options.successStatus,
+        pendingStatus: options.pendingStatus,
+        resultExtractor: options.resultExtractor
+      });
+    };
+  }
+  // Helper to parse response data
+  async parseResult(response) {
+    try {
+      return { type: "json", data: await response.json() };
+    } catch {
+      return { type: "text", data: await response.text() };
+    }
+  }
+  // Helper to get a token from the different places it could be gotten
+  async getAuthToken() {
+    if (this.options.token) {
+      return this.options.token;
+    }
+    if (this.options.getToken) {
+      const token = await this.options.getToken();
+      if (token) {
+        return token;
       }
     }
-  };
-};
-var FindFirstAuthenticationSchema = zod.z.object({
-  appKey: AppKeyPropertySchema.optional().describe(
-    "App key of authentication to find (e.g., 'SlackCLIAPI')"
-  ),
-  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"),
-  account_id: zod.z.string().optional().describe("Filter by account ID"),
-  owner: zod.z.string().optional().describe("Filter by owner")
-}).describe("Find the first authentication matching the criteria");
-
-// src/plugins/findFirstAuthentication/index.ts
-var findFirstAuthenticationPlugin = ({ sdk }) => {
-  const findFirstAuthentication = createFunction(
-    async function findFirstAuthentication2(options = {}) {
-      const authsResponse = await sdk.listAuthentications({
-        ...options,
-        maxItems: 1
-      });
-      return {
-        data: authsResponse.data.length > 0 ? authsResponse.data[0] : null
-      };
-    },
-    FindFirstAuthenticationSchema
-  );
-  return {
-    findFirstAuthentication,
-    context: {
-      meta: {
-        findFirstAuthentication: {
-          categories: ["authentication"],
-          inputSchema: FindFirstAuthenticationSchema
+    return getTokenFromEnvOrConfig({
+      onEvent: this.options.onEvent,
+      fetch: this.options.fetch
+    });
+  }
+  // Helper to handle responses
+  async handleResponse(params) {
+    const { response, customErrorHandler, wasMissingAuthToken } = params;
+    const { data: responseData } = await this.parseResult(response);
+    if (response.ok) {
+      return responseData;
+    }
+    const errorInfo = {
+      status: response.status,
+      statusText: response.statusText,
+      data: responseData
+    };
+    if (customErrorHandler) {
+      const customError = customErrorHandler(errorInfo);
+      if (customError) {
+        if (customError instanceof Error) {
+          throw customError;
+        } else {
+          throw new Error(
+            `customErrorHandler returned a non-Error: ${JSON.stringify(customError)}`
+          );
         }
       }
     }
-  };
-};
-var FindUniqueAuthenticationSchema = zod.z.object({
-  appKey: AppKeyPropertySchema.optional().describe(
-    "App key of authentication to find (e.g., 'SlackCLIAPI')"
-  ),
-  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"),
-  account_id: zod.z.string().optional().describe("Filter by account ID"),
-  owner: zod.z.string().optional().describe("Filter by owner")
-}).describe("Find a unique authentication matching the criteria");
-
-// src/plugins/findUniqueAuthentication/index.ts
-var findUniqueAuthenticationPlugin = ({ sdk }) => {
-  const findUniqueAuthentication = createFunction(
-    async function findUniqueAuthentication2(options = {}) {
-      const authsResponse = await sdk.listAuthentications({
-        ...options,
-        maxItems: 2
-        // Get up to 2 to check for uniqueness
-      });
-      if (authsResponse.data.length === 0) {
-        throw new ZapierResourceNotFoundError(
-          "No authentication found matching the specified criteria",
-          { resourceType: "Authentication" }
+    const { message, errors } = this.parseErrorResponse(errorInfo);
+    const errorOptions = {
+      statusCode: response.status,
+      errors
+    };
+    if (response.status === 404) {
+      throw new ZapierNotFoundError(message, errorOptions);
+    }
+    if (response.status === 401 || response.status === 403) {
+      if (wasMissingAuthToken) {
+        throw new ZapierAuthenticationError(
+          `Authentication required (HTTP ${response.status}). Please provide a token in options or set ZAPIER_TOKEN environment variable.`,
+          errorOptions
         );
       }
-      if (authsResponse.data.length > 1) {
-        throw new ZapierValidationError(
-          "Multiple authentications found matching the specified criteria. Expected exactly one."
-        );
+      throw new ZapierAuthenticationError(message, errorOptions);
+    }
+    if (response.status === 400) {
+      throw new ZapierValidationError(message, errorOptions);
+    }
+    throw new ZapierApiError(message, errorOptions);
+  }
+  hasErrorArray(data) {
+    return typeof data === "object" && data !== null && "errors" in data && Array.isArray(data.errors);
+  }
+  // Helper to check if data has API errors
+  isApiErrorArray(dataArray) {
+    const data = dataArray[0];
+    return typeof data === "object" && data !== null && "message" in data && "code" in data && "title" in data && "detail" in data;
+  }
+  // Do our best to extract an error message from the response data
+  extractErrorMessage(data) {
+    if (typeof data === "string") {
+      return data;
+    }
+    if (typeof data === "object" && data !== null) {
+      if ("message" in data && typeof data.message === "string") {
+        return data.message;
       }
-      return {
-        data: authsResponse.data[0]
-      };
-    },
-    FindUniqueAuthenticationSchema
-  );
-  return {
-    findUniqueAuthentication,
-    context: {
-      meta: {
-        findUniqueAuthentication: {
-          categories: ["authentication"],
-          inputSchema: FindUniqueAuthenticationSchema
+      if ("error" in data) {
+        if (typeof data.error === "string") {
+          return data.error;
+        }
+        if (typeof data.error === "object" && data.error !== null) {
+          if ("message" in data.error && typeof data.error.message === "string") {
+            return data.error.message;
+          }
+        }
+        try {
+          return JSON.stringify(data.error);
+        } catch {
+        }
+      }
+      if ("errors" in data && Array.isArray(data.errors)) {
+        if (this.isApiErrorArray(data.errors)) {
+          return data.errors[0].detail || data.errors[0].title;
         }
       }
     }
-  };
-};
-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");
-
-// src/plugins/listInputFields/index.ts
-function getInputFieldTypeFromNeed(need) {
-  if (need.list) {
-    return "ARRAY" /* ARRAY */;
-  }
-  const typeMap = {
-    string: "STRING" /* STRING */,
-    decimal: "NUMBER" /* NUMBER */,
-    integer: "INTEGER" /* INTEGER */,
-    boolean: "BOOLEAN" /* BOOLEAN */,
-    dict: "OBJECT" /* OBJECT */
-  };
-  return typeMap[need.type || ""] || "STRING" /* STRING */;
-}
-function getInputFieldFormatFromNeed(need) {
-  if (need.prefill || need.choices) {
-    return "SELECT" /* SELECT */;
-  }
-  const formatMap = {
-    text: "MULTILINE" /* MULTILINE */,
-    datetime: "DATETIME" /* DATETIME */,
-    file: "FILE" /* FILE */,
-    password: "PASSWORD" /* PASSWORD */,
-    code: "CODE" /* CODE */
-  };
-  return formatMap[need.type || ""];
-}
-function getItemsTypeFromNeed(need) {
-  if (!need.list) {
     return void 0;
   }
-  const typeMap = {
-    string: "STRING" /* STRING */,
-    decimal: "NUMBER" /* NUMBER */,
-    integer: "INTEGER" /* INTEGER */,
-    boolean: "BOOLEAN" /* BOOLEAN */,
-    dict: "OBJECT" /* OBJECT */
-  };
-  return typeMap[need.type || ""] || "STRING" /* STRING */;
-}
-function transformNeedToInputFieldItem(need) {
-  const itemsType = getItemsTypeFromNeed(need);
-  return {
-    ...need,
-    // Pass through all original Need fields
-    id: need.key,
-    default_value: need.default || "",
-    depends_on: need.depends_on || [],
-    description: need.help_text || "",
-    invalidates_input_fields: need.alters_custom_fields || false,
-    is_required: need.required || false,
-    placeholder: need.placeholder || "",
-    title: need.label || "",
-    value_type: getInputFieldTypeFromNeed(need),
-    format: getInputFieldFormatFromNeed(need),
-    items: itemsType ? { type: itemsType } : void 0
-  };
-}
-var listInputFieldsPlugin = ({ context }) => {
-  const listInputFields = createPaginatedFunction(
-    async function listInputFieldsPage(options) {
-      const { api, getVersionedImplementationId } = context;
-      const { appKey, actionKey, actionType, authenticationId, inputs } = options;
-      const selectedApi = await getVersionedImplementationId(appKey);
-      if (!selectedApi) {
-        throw new ZapierConfigurationError(
-          "No current_implementation_id found for app",
-          { configType: "current_implementation_id" }
-        );
-      }
-      const needsRequest = {
-        selected_api: selectedApi,
-        action: actionKey,
-        type_of: actionType,
-        params: inputs || {}
-      };
-      if (authenticationId !== null) {
-        needsRequest.authentication_id = authenticationId;
-      }
-      const needsData = await api.post(
-        "/api/v4/implementations/needs/",
-        needsRequest
-      );
-      if (!needsData.success) {
-        throw new ZapierApiError(
-          `Failed to get action fields: ${needsData.errors?.join(", ") || "Unknown error"}`
-        );
+  // Helper to parse API error response
+  parseErrorResponse(errorInfo) {
+    const fallbackMessage = `HTTP ${errorInfo.status}: ${errorInfo.statusText}`;
+    try {
+      if (typeof errorInfo.data === "string") {
+        return { message: `${fallbackMessage}: ${errorInfo.data}` };
       }
-      const inputFields = (needsData.needs || []).map(
-        transformNeedToInputFieldItem
-      );
-      return {
-        data: inputFields,
-        nextCursor: void 0
-        // No pagination needed since we return all input fields
-      };
-    },
-    ListInputFieldsSchema
-  );
-  return {
-    listInputFields,
-    context: {
-      meta: {
-        listInputFields: {
-          categories: ["action"],
-          inputSchema: ListInputFieldsSchema
+      const errorMessage = this.extractErrorMessage(errorInfo.data) || fallbackMessage;
+      if (this.hasErrorArray(errorInfo.data)) {
+        if (this.isApiErrorArray(errorInfo.data.errors)) {
+          return {
+            message: errorMessage,
+            errors: errorInfo.data.errors
+          };
+        } else {
+          return {
+            message: errorMessage,
+            errors: errorInfo.data.errors.map((e) => ({
+              status: errorInfo.status,
+              code: String(errorInfo.status),
+              title: errorInfo.statusText,
+              detail: JSON.stringify(e)
+            }))
+          };
         }
       }
+      return { message: errorMessage };
+    } catch {
+      return { message: fallbackMessage };
     }
-  };
-};
-
-// src/plugins/request/index.ts
-function transformUrlToRelayPath(url) {
-  const targetUrl = new URL(url);
-  const relayPath = `/relay/${targetUrl.host}${targetUrl.pathname}${targetUrl.search}${targetUrl.hash}`;
-  return relayPath;
-}
-var requestPlugin = ({ context }) => {
-  const request = createFunction(async function request2(options) {
-    const { api } = context;
-    const {
-      url,
-      method = "GET",
-      body,
-      headers: optionsHeaders,
-      authenticationId,
-      callbackUrl,
-      authenticationTemplate
-    } = options;
-    const relayPath = transformUrlToRelayPath(url);
-    const headers = {};
-    if (optionsHeaders) {
-      const headerEntries = optionsHeaders instanceof Headers ? Array.from(optionsHeaders.entries()) : Array.isArray(optionsHeaders) ? optionsHeaders : Object.entries(optionsHeaders);
-      for (const [key, value] of headerEntries) {
-        headers[key] = value;
-      }
+  }
+  // Check if this is a path that needs subdomain routing
+  // e.g. /relay/workflows -> relay.zapier.com/workflows
+  applySubdomainBehavior(path) {
+    const pathSegments = path.split("/").filter(Boolean);
+    if (pathSegments.length > 0 && pathSegments[0] in SubdomainConfigMap) {
+      const domainPrefix = pathSegments[0];
+      const subdomainConfig = SubdomainConfigMap[domainPrefix];
+      const originalBaseUrl = new URL(this.options.baseUrl);
+      const finalBaseUrl = `https://${domainPrefix}.${originalBaseUrl.hostname}`;
+      const pathWithoutPrefix = "/" + pathSegments.slice(1).join("/");
+      return { url: new URL(pathWithoutPrefix, finalBaseUrl), subdomainConfig };
     }
-    if (authenticationId) {
-      headers["X-Relay-Authentication-Id"] = authenticationId.toString();
+    return {
+      url: new URL(path, this.options.baseUrl),
+      subdomainConfig: void 0
+    };
+  }
+  // Helper to build full URLs and return routing info
+  buildUrl(path, searchParams) {
+    const { url, subdomainConfig } = this.applySubdomainBehavior(path);
+    if (searchParams) {
+      Object.entries(searchParams).forEach(([key, value]) => {
+        url.searchParams.set(key, value);
+      });
     }
-    if (callbackUrl) {
-      headers["X-Relay-Callback-Url"] = callbackUrl;
+    return { url: url.toString(), subdomainConfig };
+  }
+  // Helper to build headers
+  async buildHeaders(options = {}, subdomainConfig) {
+    const headers = new Headers(options.headers ?? {});
+    const authToken = await this.getAuthToken();
+    if (authToken) {
+      const authHeaderName = subdomainConfig?.authHeader || "Authorization";
+      headers.set(authHeaderName, getAuthorizationHeader(authToken));
     }
-    if (authenticationTemplate) {
-      headers["X-Authentication-Template"] = authenticationTemplate;
+    if (options.authRequired) {
+      if (headers.get("Authorization") == null && authToken == null) {
+        throw new ZapierAuthenticationError(
+          `Authentication required but no token available. Please set ZAPIER_TOKEN, or run the 'login' command with the CLI.`
+        );
+      }
+    }
+    return headers;
+  }
+  // Helper to perform HTTP requests with JSON handling
+  async fetchJson(method, path, data, options = {}) {
+    const headers = { ...options.headers };
+    if (data && typeof data === "object") {
+      headers["Content-Type"] = "application/json";
     }
-    return await api.fetch(relayPath, {
+    const wasMissingAuthToken = options.authRequired && await this.getAuthToken() == null;
+    const response = await this.plainFetch(path, {
+      ...options,
       method,
-      body,
+      body: data != null ? JSON.stringify(data) : void 0,
       headers
     });
-  }, RelayRequestSchema);
+    const result = await this.handleResponse({
+      response,
+      customErrorHandler: options.customErrorHandler,
+      wasMissingAuthToken
+    });
+    if (typeof result === "string") {
+      throw new ZapierValidationError(
+        `Response could not be parsed as JSON: ${result}`
+      );
+    }
+    return result;
+  }
+  // Plain fetch method for API paths (must start with /)
+  async plainFetch(path, fetchOptions) {
+    if (!path.startsWith("/")) {
+      throw new ZapierValidationError(
+        `plainFetch expects a path starting with '/', got: ${path}`
+      );
+    }
+    if (fetchOptions?.body && typeof fetchOptions.body === "object") {
+      fetchOptions.body = JSON.stringify(fetchOptions.body);
+    }
+    const { url, subdomainConfig } = this.buildUrl(
+      path,
+      fetchOptions?.searchParams
+    );
+    const builtHeaders = await this.buildHeaders(
+      fetchOptions,
+      subdomainConfig
+    );
+    const inputHeaders = new Headers(fetchOptions?.headers ?? {});
+    const mergedHeaders = new Headers();
+    builtHeaders.forEach((value, key) => {
+      mergedHeaders.set(key, value);
+    });
+    inputHeaders.forEach((value, key) => {
+      mergedHeaders.set(key, value);
+    });
+    return await this.options.fetch(url, {
+      ...fetchOptions,
+      headers: mergedHeaders
+    });
+  }
+};
+var createZapierApi = (options) => {
+  const {
+    baseUrl,
+    token,
+    getToken,
+    debug = false,
+    fetch: originalFetch = globalThis.fetch,
+    onEvent
+  } = options;
+  const debugLog = createDebugLogger(debug);
+  const debugFetch = createDebugFetch({ originalFetch, debugLog });
+  return new ZapierApiClient({
+    baseUrl,
+    token,
+    getToken,
+    debug,
+    fetch: debugFetch,
+    onEvent
+  });
+};
+
+// src/plugins/api/index.ts
+var apiPlugin = (params) => {
+  const {
+    fetch: customFetch = globalThis.fetch,
+    baseUrl = "https://zapier.com",
+    token,
+    getToken,
+    onEvent,
+    debug = false
+  } = params.context.options;
+  const api = createZapierApi({
+    baseUrl,
+    token,
+    getToken,
+    debug,
+    fetch: customFetch,
+    onEvent
+  });
   return {
-    request,
     context: {
-      meta: {
-        request: {
-          categories: ["http"],
-          inputSchema: RelayRequestSchema
-        }
-      }
+      api
+      // Provide API client in context for other plugins to use
     }
   };
 };
-var ManifestSchema = zod.z.object({
-  apps: zod.z.record(
-    zod.z.string(),
-    zod.z.object({
-      implementationName: zod.z.string().describe(
-        "Base implementation name without version (e.g., 'SlackCLIAPI')"
-      ),
-      version: zod.z.string().describe("Version string (e.g., '1.21.1')")
-    })
-  )
-}).describe("Manifest mapping app keys to version information");
-zod.z.object({
-  manifestPath: zod.z.string().optional().describe("Path to manifest file"),
-  manifest: zod.z.record(
-    zod.z.string(),
-    zod.z.object({
-      implementationName: zod.z.string(),
-      version: zod.z.string().optional()
-    })
-  ).optional().describe("Direct manifest object")
-});
 
-// src/plugins/manifest/index.ts
-function parseManifestContent(content, source) {
-  try {
-    const parsed = JSON.parse(content);
-    if (parsed?.apps && typeof parsed?.apps === "object") {
-      const result = ManifestSchema.safeParse(parsed);
-      if (result.success) {
-        return result.data;
+// 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);
       }
-      console.warn(`\u26A0\uFE0F Invalid manifest format in ${source}: ${result.error}`);
     }
-    return null;
-  } catch (error) {
-    console.warn(`\u26A0\uFE0F Failed to parse manifest from ${source}:`, error);
-    return null;
   }
-}
-function loadManifestFromFile(filePath) {
-  try {
-    const resolvedPath = path.resolve(filePath);
-    const content = fs.readFileSync(resolvedPath, "utf8");
-    return parseManifestContent(content, resolvedPath);
-  } catch {
-    console.warn(`\u26A0\uFE0F Failed to load manifest from ${filePath}`);
-    return null;
+  if (!resolved.has(paramName)) {
+    order.push(paramName);
+    resolved.add(paramName);
   }
+  return order;
 }
-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.`
-  );
-  console.warn(
-    `   ${"\u21B3".padEnd(3)} Generate/update the manifest with: \`zapier-sdk lock-version ${appKey}\`
-`
-  );
-};
-var manifestPlugin = (params) => {
-  const { sdk, context } = params;
-  const { api, options } = context;
-  const { manifestPath = ".zapierrc", manifest } = options || {};
-  let resolvedManifest;
-  function resolveManifest() {
-    if (manifest) {
-      return manifest;
-    }
-    if (manifestPath) {
-      return loadManifestFromFile(manifestPath);
+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 null;
   }
-  const getResolvedManifest = () => {
-    if (typeof resolvedManifest === "undefined") {
-      resolvedManifest = resolveManifest() ?? null;
-    }
-    return resolvedManifest;
-  };
-  const getManifestEntry = (appKey) => {
-    return getResolvedManifest()?.apps?.[appKey] || null;
-  };
-  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 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"}`;
-    }
-    const implementation = await getImplementation(appKey);
-    if (!implementation) return null;
-    return implementation.current_implementation_id;
-  };
-  return {
-    context: {
-      getVersionedImplementationId,
-      getManifestEntry,
-      getImplementation
+  return order;
+}
+
+// src/plugins/registry/index.ts
+var registryPlugin = ({ sdk, context }) => {
+  const metaKeys = Object.keys(context.meta || {});
+  const categoryDefinitions = {
+    account: {
+      title: "Account"
+    },
+    app: {
+      title: "App",
+      titlePlural: "Apps"
+    },
+    authentication: {
+      title: "Authentication"
+    },
+    action: {
+      title: "Action"
+    },
+    http: {
+      title: "HTTP Request"
+    },
+    utility: {
+      title: "Utility",
+      titlePlural: "Utilities"
+    },
+    other: {
+      title: "Other"
     }
   };
-};
-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')")
-    })
-  );
+  const functions = metaKeys.filter((key) => typeof sdk[key] === "function").map((key) => {
+    return {
+      ...context.meta[key],
+      categories: context.meta[key].categories || [],
+      name: key
+    };
+  }).sort((a, b) => a.name.localeCompare(b.name));
+  const knownCategories = Object.keys(categoryDefinitions);
+  const categories = knownCategories.sort((a, b) => {
+    if (a === "other") return 1;
+    if (b === "other") return -1;
+    const titleA = categoryDefinitions[a].title;
+    const titleB = categoryDefinitions[b].title;
+    return titleA.localeCompare(titleB);
+  }).map((categoryKey) => {
+    const categoryFunctions = functions.filter(
+      (f) => f.categories.includes(categoryKey) || // If the category is "other" and the function is not in any other category, include it
+      categoryKey === "other" && !f.categories.some((c) => knownCategories.includes(c))
+    ).map((f) => f.name).sort();
+    const definition = categoryDefinitions[categoryKey];
+    const title = definition.title;
+    return {
+      key: categoryKey,
+      title,
+      titlePlural: definition.titlePlural ?? `${title}s`,
+      functions: categoryFunctions
+    };
+  });
+  function getRegistry() {
+    return {
+      functions,
+      categories
+    };
+  }
   return {
-    lockVersion,
-    context: {
-      meta: {
-        lockVersion: {
-          categories: ["utility"],
-          inputSchema: LockVersionSchema
-        }
-      }
-    }
+    getRegistry
   };
 };
 
@@ -2922,8 +2922,11 @@ 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(runActionPlugin).addPlugin(lockVersionPlugin).addPlugin(listAuthenticationsPlugin).addPlugin(getAuthenticationPlugin).addPlugin(findFirstAuthenticationPlugin).addPlugin(findUniqueAuthenticationPlugin).addPlugin(requestPlugin).addPlugin(fetchPlugin).addPlugin(appsPlugin).addPlugin(getProfilePlugin);
+}
 function createZapierSdk(options = {}) {
-  return createSdk(options).addPlugin(apiPlugin).addPlugin(listAppsPlugin).addPlugin(manifestPlugin).addPlugin(getAppPlugin).addPlugin(listActionsPlugin).addPlugin(getActionPlugin).addPlugin(listInputFieldsPlugin).addPlugin(runActionPlugin).addPlugin(lockVersionPlugin).addPlugin(listAuthenticationsPlugin).addPlugin(getAuthenticationPlugin).addPlugin(findFirstAuthenticationPlugin).addPlugin(findUniqueAuthenticationPlugin).addPlugin(requestPlugin).addPlugin(fetchPlugin).addPlugin(appsPlugin).addPlugin(getProfilePlugin).addPlugin(registryPlugin);
+  return createZapierSdkWithoutRegistry(options).addPlugin(registryPlugin);
 }
 
 exports.ActionKeyPropertySchema = ActionKeyPropertySchema;
@@ -2952,13 +2955,22 @@ exports.ZapierUnknownError = ZapierUnknownError;
 exports.ZapierValidationError = ZapierValidationError;
 exports.actionKeyResolver = actionKeyResolver;
 exports.actionTypeResolver = actionTypeResolver;
+exports.apiPlugin = apiPlugin;
 exports.appKeyResolver = appKeyResolver;
 exports.appsPlugin = appsPlugin;
 exports.authenticationIdResolver = authenticationIdResolver;
+exports.createFunction = createFunction;
 exports.createSdk = createSdk;
 exports.createZapierSdk = createZapierSdk;
+exports.createZapierSdkWithoutRegistry = createZapierSdkWithoutRegistry;
 exports.fetchPlugin = fetchPlugin;
+exports.findFirstAuthenticationPlugin = findFirstAuthenticationPlugin;
+exports.findUniqueAuthenticationPlugin = findUniqueAuthenticationPlugin;
 exports.formatErrorMessage = formatErrorMessage;
+exports.getActionPlugin = getActionPlugin;
+exports.getAppPlugin = getAppPlugin;
+exports.getAuthenticationPlugin = getAuthenticationPlugin;
+exports.getProfilePlugin = getProfilePlugin;
 exports.getResolutionOrder = getResolutionOrder;
 exports.getResolutionOrderForParams = getResolutionOrderForParams;
 exports.getResolvableParams = getResolvableParams;
@@ -2970,4 +2982,14 @@ exports.getTokenFromEnvOrConfig = getTokenFromEnvOrConfig;
 exports.hasResolver = hasResolver;
 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.registryPlugin = registryPlugin;
+exports.requestPlugin = requestPlugin;
 exports.resolverRegistry = resolverRegistry;
+exports.runActionPlugin = runActionPlugin;