@zapier/zapier-sdk 0.4.1 → 0.5.1

package/dist/index.cjs

@@ -2,22 +2,7 @@
 
 var zod = require('zod');
 
-// src/types/domain.ts
-var ZapierSdkError = class extends Error {
-  constructor(message, code) {
-    super(message);
-    this.code = code;
-    this.name = "ZapierSdkError";
-  }
-};
-var AppNotFoundError = class extends ZapierSdkError {
-  constructor(appKey) {
-    super(`App "${appKey}" not found`);
-    this.name = "AppNotFoundError";
-    this.code = "APP_NOT_FOUND";
-    this.appKey = appKey;
-  }
-};
+// src/types/properties.ts
 function withFormatter(schema, formatMeta) {
   schema._def.formatMeta = formatMeta;
   return schema;
@@ -43,9 +28,12 @@ function isPositional(schema) {
   return false;
 }
 
+// src/constants.ts
+var MAX_PAGE_LIMIT = 1e4;
+
 // src/types/properties.ts
 var AppKeyPropertySchema = withPositional(
-  zod.z.string().min(1).describe("App slug (e.g., 'slack', 'github')")
+  zod.z.string().min(1).describe("App key (e.g., 'SlackCLIAPI')")
 );
 var ActionTypePropertySchema = zod.z.enum([
   "read",
@@ -60,20 +48,155 @@ var ActionTypePropertySchema = zod.z.enum([
 var ActionKeyPropertySchema = zod.z.string().min(1).describe("Action key to execute");
 var AuthenticationIdPropertySchema = zod.z.number().int().describe("Authentication ID to use for this action");
 var InputsPropertySchema = zod.z.record(zod.z.any()).describe("Input parameters for the action");
-var LimitPropertySchema = zod.z.number().int().min(1).max(1e3).default(50).describe("Maximum number of items to return");
+var LimitPropertySchema = zod.z.number().int().min(1).max(MAX_PAGE_LIMIT).default(50).describe("Maximum number of items to return");
 var OffsetPropertySchema = zod.z.number().int().min(0).default(0).describe("Number of items to skip for pagination");
 var OutputPropertySchema = zod.z.string().describe("Output file path");
 var DebugPropertySchema = zod.z.boolean().default(false).describe("Enable debug logging");
 var ParamsPropertySchema = zod.z.record(zod.z.any()).describe("Additional parameters");
 
+// src/types/errors.ts
+var ZapierError = class extends Error {
+  constructor(message, options = {}) {
+    super(message);
+    this.statusCode = options.statusCode;
+    this.errors = options.errors;
+    this.cause = options.cause;
+    this.response = options.response;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var ZapierApiError = class extends ZapierError {
+  constructor(message, options = {}) {
+    super(message, options);
+    this.name = "ZapierApiError";
+  }
+};
+var ZapierAppNotFoundError = class extends ZapierError {
+  constructor(message, options = {}) {
+    super(message, options);
+    this.name = "ZapierAppNotFoundError";
+    this.appKey = options.appKey;
+  }
+};
+var ZapierValidationError = class extends ZapierError {
+  constructor(message, options = {}) {
+    super(message, options);
+    this.name = "ZapierValidationError";
+    this.details = options.details;
+  }
+};
+var ZapierUnknownError = class extends ZapierError {
+  constructor(message, options = {}) {
+    super(message, options);
+    this.name = "ZapierUnknownError";
+  }
+};
+var ZapierAuthenticationError = class extends ZapierError {
+  constructor(message, options = {}) {
+    super(message, options);
+    this.name = "ZapierAuthenticationError";
+  }
+};
+var ZapierResourceNotFoundError = class extends ZapierError {
+  constructor(message, options = {}) {
+    super(message, options);
+    this.name = "ZapierResourceNotFoundError";
+    this.resourceType = options.resourceType;
+    this.resourceId = options.resourceId;
+  }
+};
+var ZapierConfigurationError = class extends ZapierError {
+  constructor(message, options = {}) {
+    super(message, options);
+    this.name = "ZapierConfigurationError";
+    this.configType = options.configType;
+  }
+};
+var ZapierBundleError = class extends ZapierError {
+  constructor(message, options = {}) {
+    super(message, options);
+    this.name = "ZapierBundleError";
+    this.buildErrors = options.buildErrors;
+  }
+};
+var ZapierTimeoutError = class extends ZapierError {
+  constructor(message, options = {}) {
+    super(message, options);
+    this.name = "ZapierTimeoutError";
+    this.attempts = options.attempts;
+    this.maxAttempts = options.maxAttempts;
+  }
+};
+var ZapierActionError = class extends ZapierError {
+  constructor(message, options = {}) {
+    super(message, options);
+    this.name = "ZapierActionError";
+    this.appKey = options.appKey;
+    this.actionKey = options.actionKey;
+  }
+  // Legacy accessor for backward compatibility
+  get actionErrors() {
+    return this.errors;
+  }
+};
+var ZapierNotFoundError = class extends ZapierError {
+  constructor(message, options = {}) {
+    super(message, options);
+    this.name = "ZapierNotFoundError";
+  }
+};
+function formatErrorMessage(error) {
+  let message = error.message;
+  if (error.errors && error.errors.length > 0) {
+    const additionalErrors = error.errors.slice(1);
+    if (additionalErrors.length > 0) {
+      const errorDetails = additionalErrors.map((err) => `  \u2022 ${err.detail || err.title || err.code}`).join("\n");
+      message += "\n\nAdditional errors:\n" + errorDetails;
+    }
+  }
+  if (error instanceof ZapierAppNotFoundError && error.appKey) {
+    message += `
+App key: ${error.appKey}`;
+  }
+  if (error instanceof ZapierActionError && (error.appKey || error.actionKey)) {
+    const context = [];
+    if (error.appKey) context.push(`App: ${error.appKey}`);
+    if (error.actionKey) context.push(`Action: ${error.actionKey}`);
+    message += `
+${context.join(", ")}`;
+  }
+  if (error instanceof ZapierResourceNotFoundError && (error.resourceType || error.resourceId)) {
+    const context = [];
+    if (error.resourceType) context.push(`Type: ${error.resourceType}`);
+    if (error.resourceId) context.push(`ID: ${error.resourceId}`);
+    message += `
+${context.join(", ")}`;
+  }
+  if (error instanceof ZapierTimeoutError && (error.attempts || error.maxAttempts)) {
+    const context = [];
+    if (error.attempts) context.push(`Attempts: ${error.attempts}`);
+    if (error.maxAttempts) context.push(`Max attempts: ${error.maxAttempts}`);
+    message += `
+${context.join(", ")}`;
+  }
+  if (error instanceof ZapierBundleError && error.buildErrors && error.buildErrors.length > 0) {
+    message += "\n\nBuild errors:\n" + error.buildErrors.map((err) => `  \u2022 ${err}`).join("\n");
+  }
+  if (error.statusCode && !message.includes(`${error.statusCode}`)) {
+    message += `
+HTTP Status: ${error.statusCode}`;
+  }
+  return message;
+}
+
 // src/plugins/apps/index.ts
 function createActionFunction(appKey, actionType, actionKey, options, pinnedAuthId) {
-  return async (actionOptions = {}) => {
+  return (actionOptions = {}) => {
     const { sdk } = options;
     const { inputs, authenticationId: providedAuthenticationId } = actionOptions;
     const authenticationId = pinnedAuthId || providedAuthenticationId;
     if (!authenticationId) {
-      throw new Error(
+      throw new ZapierValidationError(
         `Authentication ID is required. Either use the factory pattern: sdk.apps.${appKey}({ authenticationId }) or provide authenticationId in the action call.`
       );
     }
@@ -92,7 +215,7 @@ function createActionTypeProxy(appKey, actionType, options, pinnedAuthId) {
       const { sdk } = options;
       const authenticationId = pinnedAuthId || init?.authenticationId;
       if (!authenticationId) {
-        throw new Error(
+        throw new ZapierValidationError(
           `Authentication ID is required for fetch. Either use the factory pattern: sdk.apps.${appKey}({ authenticationId }).fetch(...) or provide authenticationId in the fetch call.`
         );
       }
@@ -166,57 +289,40 @@ function createAppsProxy(options) {
   });
   return appsProxy;
 }
-function createAppsPlugin(options) {
-  return createAppsProxy(options);
-}
+var appsPlugin = ({ sdk }) => {
+  return {
+    apps: createAppsProxy({ sdk })
+  };
+};
 
 // src/plugins/fetch/index.ts
-function createFetchPlugin(options) {
-  const { sdk } = options;
-  return async function fetch(url, init) {
-    const {
-      authenticationId,
-      callbackUrl,
-      authenticationTemplate,
-      ...fetchInit
-    } = init || {};
-    return sdk.request({
-      url: url.toString(),
-      method: fetchInit.method,
-      body: fetchInit.body,
-      headers: fetchInit.headers,
-      authenticationId,
-      callbackUrl,
-      authenticationTemplate
-    });
+var fetchPlugin = ({ sdk }) => {
+  return {
+    fetch: async function fetch(url, init) {
+      const {
+        authenticationId,
+        callbackUrl,
+        authenticationTemplate,
+        ...fetchInit
+      } = init || {};
+      return sdk.request({
+        url: url.toString(),
+        method: fetchInit.method,
+        body: fetchInit.body,
+        headers: fetchInit.headers,
+        authenticationId,
+        callbackUrl,
+        authenticationTemplate
+      });
+    }
   };
-}
-
-// 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/resolvers/appKey.ts
 var appKeyResolver = {
   type: "static",
   inputType: "text",
-  placeholder: "Enter app slug (e.g., 'slack', 'github')"
+  placeholder: "Enter app key (e.g., 'SlackCLIAPI' or slug like 'github')"
 };
 
 // src/resolvers/actionType.ts
@@ -224,8 +330,12 @@ var actionTypeResolver = {
   type: "dynamic",
   depends: ["appKey"],
   fetch: async (sdk, resolvedParams) => {
-    const actions = await sdk.listActions({ appKey: resolvedParams.appKey });
-    const types = [...new Set(actions.map((action) => action.type))];
+    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) => ({
@@ -244,9 +354,11 @@ var actionKeyResolver = {
   type: "dynamic",
   depends: ["appKey", "actionType"],
   fetch: async (sdk, resolvedParams) => {
-    const actions = await sdk.listActions({ appKey: resolvedParams.appKey });
-    return actions.filter(
-      (action) => action.type === resolvedParams.actionType
+    const actionsResponse = await sdk.listActions({
+      appKey: resolvedParams.appKey
+    });
+    return actionsResponse.data.filter(
+      (action) => action.action_type === resolvedParams.actionType
     );
   },
   prompt: (actions) => ({
@@ -254,7 +366,7 @@ var actionKeyResolver = {
     name: "actionKey",
     message: "Select action:",
     choices: actions.map((action) => ({
-      name: `${action.name || action.key} - ${action.description || "No description"}`,
+      name: `${action.title || action.name || action.key} - ${action.description || "No description"}`,
       value: action.key
     }))
   })
@@ -265,10 +377,19 @@ var authenticationIdResolver = {
   type: "dynamic",
   depends: ["appKey"],
   fetch: async (sdk, resolvedParams) => {
-    return await sdk.listAuthentications({
+    const myAuths = await sdk.listAuthentications({
+      appKey: resolvedParams.appKey,
+      maxItems: 1e3,
+      owner: "me"
+    });
+    const allAuths = await sdk.listAuthentications({
       appKey: resolvedParams.appKey,
-      limit: 1e3
+      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",
@@ -292,12 +413,15 @@ var inputsResolver = {
   type: "fields",
   depends: ["appKey", "actionKey", "actionType", "authenticationId"],
   fetch: async (sdk, resolvedParams) => {
-    return await sdk.listFields({
+    const fieldsResponse = await sdk.listInputFields({
       appKey: resolvedParams.appKey,
       actionKey: resolvedParams.actionKey,
       actionType: resolvedParams.actionType,
-      authenticationId: resolvedParams.authenticationId
+      authenticationId: resolvedParams.authenticationId,
+      inputs: resolvedParams.inputs
+      // Pass along currently resolved inputs
     });
+    return fieldsResponse.data;
   }
 };
 
@@ -362,6 +486,59 @@ function getResolutionOrderForParams(paramNames) {
   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 registryEntries = metaKeys.map((key) => {
+    return {
+      ...context.meta[key],
+      name: key,
+      implementation: sdk[key]
+    };
+  });
+  return {
+    __registry: registryEntries
+  };
+};
+
 // src/api/auth.ts
 function isJwt(token) {
   const parts = token.split(".");
@@ -396,7 +573,13 @@ function createDebugFetch(options) {
     const method = options2?.method || "GET";
     debugLog(`\u2192 ${method} ${url}`, {
       headers: options2?.headers,
-      body: options2?.body ? JSON.parse(options2.body) : void 0
+      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);
@@ -431,1168 +614,1360 @@ async function pollUntilComplete(options) {
     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((resolve) => setTimeout(resolve, delay));
         delay = Math.min(delay * 2, maxDelay);
         continue;
       }
     } else {
-      throw new Error(
-        `Poll request failed: ${response.status} ${response.statusText}`
-      );
+      errorCount++;
+      if (errorCount >= 3) {
+        throw new ZapierApiError(
+          `Poll request failed: ${response.status} ${response.statusText}`,
+          { statusCode: response.status }
+        );
+      }
+      if (attempt < maxAttempts - 1) {
+        await new Promise((resolve) => setTimeout(resolve, delay));
+        delay = Math.min(delay * 2, maxDelay);
+        continue;
+      }
     }
   }
-  throw new Error(`Operation timed out after ${maxAttempts} attempts`);
+  throw new ZapierTimeoutError(
+    `Operation timed out after ${maxAttempts} attempts`,
+    { attempts: maxAttempts, maxAttempts }
+  );
 }
 
 // src/api/client.ts
-var SUBDOMAIN_PREFIXES = {
+var SubdomainConfigMap = {
+  // e.g. https://relay.zapier.com
   relay: {
     authHeader: "X-Relay-Authorization"
   }
 };
-function createZapierApi(options) {
-  const {
-    baseUrl,
-    token,
-    getToken,
-    debug = false,
-    fetch: originalFetch = globalThis.fetch,
-    onEvent
-  } = options;
-  const debugLog = createDebugLogger(debug);
-  const fetch = createDebugFetch({ originalFetch, debugLog });
-  function buildUrl(path, searchParams) {
-    const pathSegments = path.split("/").filter(Boolean);
-    let finalBaseUrl = baseUrl;
-    let subdomainConfig;
-    if (pathSegments.length > 0 && pathSegments[0] in SUBDOMAIN_PREFIXES) {
-      const subdomain = pathSegments[0];
-      subdomainConfig = SUBDOMAIN_PREFIXES[subdomain];
-      const baseUrlObj = new URL(baseUrl);
-      baseUrlObj.hostname = `${subdomain}.${baseUrlObj.hostname}`;
-      finalBaseUrl = baseUrlObj.toString();
-      path = "/" + pathSegments.slice(1).join("/");
-    }
-    const url = new URL(path, finalBaseUrl);
-    if (searchParams) {
-      Object.entries(searchParams).forEach(([key, value]) => {
-        url.searchParams.set(key, value);
+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
       });
+    };
+  }
+  // Helper to parse response data
+  async parseResult(response) {
+    try {
+      return { type: "json", data: await response.json() };
+    } catch {
+      return { type: "text", data: await response.text() };
     }
-    return { url: url.toString(), subdomainConfig };
   }
-  async function buildHeaders(options2 = {}, subdomainConfig) {
-    const headers = {
-      ...options2.headers
-    };
-    if (options2.authRequired !== false) {
-      let resolvedToken = token;
-      if (!resolvedToken && getToken) {
-        resolvedToken = await getToken();
-      }
-      if (!resolvedToken) {
-        resolvedToken = await getTokenFromEnvOrConfig({
-          onEvent,
-          fetch: originalFetch
-        });
-      }
-      if (resolvedToken) {
-        const authHeaderName = subdomainConfig?.authHeader || "Authorization";
-        headers[authHeaderName] = getAuthorizationHeader(resolvedToken);
+  // 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 headers;
+    return getTokenFromEnvOrConfig({
+      onEvent: this.options.onEvent,
+      fetch: this.options.fetch
+    });
   }
-  async function handleResponse(response, customErrorHandler, hadAuthToken) {
-    if (!response.ok) {
-      if (customErrorHandler) {
-        const customError = customErrorHandler(response);
-        if (customError) {
+  // 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)}`
+          );
         }
       }
-      if (response.status >= 400 && response.status < 500 && true) {
-        throw new Error(
-          `Authentication required (HTTP ${response.status}). Please provide a token in options or set ZAPIER_TOKEN environment variable.`
+    }
+    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 Error(`HTTP ${response.status}: ${response.statusText}`);
+      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;
+      }
+      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 void 0;
+  }
+  // Helper to parse API error response
+  parseErrorResponse(errorInfo) {
+    const fallbackMessage = `HTTP ${errorInfo.status}: ${errorInfo.statusText}`;
     try {
-      return await response.json();
+      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)
+            }))
+          };
+        }
+      }
+      return { message: errorMessage };
     } catch {
-      return await response.text();
+      return { message: fallbackMessage };
     }
   }
-  async function plainFetch(path, init) {
-    if (!path.startsWith("/")) {
-      throw new Error(
-        `plainFetch expects a path starting with '/', got: ${path}`
-      );
+  // 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 };
     }
-    const { url, subdomainConfig } = buildUrl(path, init?.searchParams);
-    const headers = await buildHeaders(init, subdomainConfig);
-    const finalHeaders = {
-      ...headers,
-      ...init?.headers ? init.headers instanceof Headers ? Object.fromEntries(init.headers.entries()) : init.headers : {}
+    return {
+      url: new URL(path, this.options.baseUrl),
+      subdomainConfig: void 0
     };
-    return await fetch(url, {
-      ...init,
-      headers: finalHeaders
-    });
   }
-  async function fetchJson(method, path, data, options2 = {}) {
-    const headers = { ...options2.headers };
+  // 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);
+      });
+    }
+    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 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 response = await plainFetch(path, {
+    const wasMissingAuthToken = options.authRequired && await this.getAuthToken() == null;
+    const response = await this.plainFetch(path, {
+      ...options,
       method,
-      body: data ? JSON.stringify(data) : void 0,
-      headers,
-      searchParams: options2.searchParams,
-      authRequired: options2.authRequired
+      body: data != null ? JSON.stringify(data) : void 0,
+      headers
     });
-    return handleResponse(response, options2.customErrorHandler);
+    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;
   }
-  return {
-    async get(path, options2 = {}) {
-      return fetchJson("GET", path, void 0, options2);
-    },
-    async post(path, data, options2 = {}) {
-      return fetchJson("POST", path, data, options2);
-    },
-    async put(path, data, options2 = {}) {
-      return fetchJson("PUT", path, data, options2);
-    },
-    async delete(path, options2 = {}) {
-      return fetchJson("DELETE", path, void 0, options2);
-    },
-    async poll(path, options2 = {}) {
-      return pollUntilComplete({
-        fetchPoll: () => plainFetch(path, {
-          method: "GET",
-          searchParams: options2.searchParams,
-          authRequired: options2.authRequired
-        }),
-        maxAttempts: options2.maxAttempts,
-        initialDelay: options2.initialDelay,
-        maxDelay: options2.maxDelay,
-        successStatus: options2.successStatus,
-        pendingStatus: options2.pendingStatus,
-        resultExtractor: options2.resultExtractor
-      });
-    },
-    async fetch(path, init) {
-      return plainFetch(path, init);
+  // 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}`
+      );
     }
-  };
-}
-
-// src/api/index.ts
-function generateRequestId() {
-  return Math.random().toString(36).substring(2) + Date.now().toString(36);
-}
-function getOrCreateApiClient(config) {
+    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 = "https://zapier.com",
+    baseUrl,
     token,
     getToken,
-    api: providedApi,
     debug = false,
-    fetch: customFetch
-  } = config;
-  if (providedApi) {
-    return providedApi;
-  }
-  return createZapierApi({
+    fetch: originalFetch = globalThis.fetch,
+    onEvent
+  } = options;
+  const debugLog = createDebugLogger(debug);
+  const debugFetch = createDebugFetch({ originalFetch, debugLog });
+  return new ZapierApiClient({
     baseUrl,
     token,
     getToken,
     debug,
-    fetch: customFetch
-  });
-}
-
-// src/functions/getApp/index.ts
-async function getApp(options) {
-  const api = getOrCreateApiClient(options);
-  const { appKey } = options;
-  const app = await api.get(`/api/v4/apps/${appKey}/`, {
-    customErrorHandler: (response) => {
-      if (response.status === 404) {
-        return new AppNotFoundError(appKey);
-      }
-      return void 0;
-    }
+    fetch: debugFetch,
+    onEvent
   });
-  return {
-    key: app.slug,
-    name: app.name,
-    description: app.description,
-    version: "1.0.0",
-    category: app.category?.name,
-    actions: [],
-    triggers: [],
-    current_implementation_id: app.current_implementation_id
-  };
-}
+};
 
-// src/functions/listAuthentications/index.ts
-async function listAuthentications(options = {}) {
-  const api = getOrCreateApiClient(options);
-  const listAuthenticationsInternal = async (options2 = {}) => {
-    const searchParams = {};
-    if (options2.appKey) {
-      try {
-        const app = await getApp({
-          appKey: options2.appKey,
-          api,
-          token: options2.token,
-          baseUrl: options2.baseUrl,
-          debug: options2.debug,
-          fetch: options2.fetch
-        });
-        const selectedApi = app.current_implementation_id;
-        if (selectedApi) {
-          const versionlessApi = selectedApi.split("@")[0];
-          searchParams.versionless_selected_api = versionlessApi;
-        }
-      } catch (error) {
-        if (error instanceof Error && error.name === "AppNotFoundError") {
-          throw error;
-        }
-        console.warn(
-          `Warning: Could not filter by app ${options2.appKey}:`,
-          error instanceof Error ? error.message : "Unknown error"
-        );
-      }
-    }
-    if (options2.search) {
-      searchParams.search = options2.search;
-    } else if (options2.title) {
-      searchParams.search = options2.title;
+// src/plugins/api/index.ts
+var apiPlugin = (params) => {
+  const {
+    fetch: customFetch = globalThis.fetch,
+    baseUrl = "https://zapier.com",
+    token,
+    getToken,
+    onEvent,
+    debug = false
+  } = params;
+  const api = createZapierApi({
+    baseUrl,
+    token,
+    getToken,
+    debug,
+    fetch: customFetch,
+    onEvent
+  });
+  return {
+    context: {
+      api
+      // Provide API client in context for other plugins to use
     }
-    if (options2.account_id) {
-      searchParams.account_id = options2.account_id;
+  };
+};
+
+// 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];
     }
-    if (options2.owner) {
-      searchParams.owner = options2.owner;
+    const [marker, offset, currentCursor] = parsedCursor;
+    if (marker !== offsetCursorMarker) {
+      return [0, cursor];
     }
-    if (options2.limit) {
-      searchParams.limit = options2.limit.toString();
+    if (typeof offset !== "number") {
+      return [0, cursor];
     }
-    if (options2.offset) {
-      searchParams.offset = options2.offset.toString();
+    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;
+      }
     }
-    const data = await api.get(
-      "/api/v4/authentications/",
-      {
-        searchParams,
-        customErrorHandler: (response) => {
-          if (response.status === 401) {
-            return new Error(
-              `Authentication failed. Your token may not have permission to access authentications or may be expired. (HTTP ${response.status})`
-            );
-          }
-          if (response.status === 403) {
-            return new Error(
-              `Access forbidden. Your token may not have the required scopes to list authentications. (HTTP ${response.status})`
-            );
-          }
-          return void 0;
-        }
+    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
     );
-    let auths = data.results || [];
-    auths = auths.map((auth) => ({
-      ...auth,
-      title: auth.title || auth.label || void 0
-    }));
-    if (options2.title) {
-      auths = auths.filter((auth) => auth.title === options2.title);
-    }
-    if (auths.length > 0) {
-      auths.__pagination = {
-        count: data.count,
-        hasNext: !!data.next,
-        hasPrevious: !!data.previous,
-        nextUrl: data.next,
-        previousUrl: data.previous
+    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;
     }
-    return auths;
-  };
-  if (options.limit && options.owner === void 0) {
-    const ownedAuths = await listAuthenticationsInternal({
-      ...options,
-      owner: "me"
-    });
-    if (ownedAuths.length >= options.limit) {
-      return ownedAuths.slice(0, options.limit);
+    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
+        )
+      };
     }
-    const allAuths = await listAuthenticationsInternal({
-      ...options,
-      owner: void 0
-    });
-    const ownedAuthenticationIds = new Set(ownedAuths.map((auth) => auth.id));
-    const additionalAuths = allAuths.filter(
-      (auth) => !ownedAuthenticationIds.has(auth.id)
-    );
-    const combined = [...ownedAuths, ...additionalAuths];
-    return combined.slice(0, options.limit);
+    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 listAuthenticationsInternal(options);
 }
+var paginate = paginateBuffered;
 
-// src/functions/getAuthentication/index.ts
-async function getAuthentication(options) {
-  const { authenticationId } = options;
-  const api = getOrCreateApiClient(options);
-  const data = await api.get(
-    `/api/v4/authentications/${authenticationId}/`,
-    {
-      customErrorHandler: (response) => {
-        if (response.status === 401) {
-          return new Error(
-            `Authentication failed. Your token may not have permission to access authentications or may be expired. (HTTP ${response.status})`
-          );
-        }
-        if (response.status === 403) {
-          return new Error(
-            `Access forbidden. Your token may not have the required scopes to get authentication ${authenticationId}. (HTTP ${response.status})`
-          );
-        }
-        if (response.status === 404) {
-          return new Error(
-            `Authentication ${authenticationId} not found. It may not exist or you may not have access to it. (HTTP ${response.status})`
-          );
-        }
-        return void 0;
+// 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 {
-    ...data,
-    title: data.title || data.label || void 0
+    });
+  }
+  return result.data;
+};
+function createValidator(schema) {
+  return function validateFn(input) {
+    return validate(schema, input);
   };
 }
+var validateOptions = (schema, options) => {
+  return validate(schema, options);
+};
 
-// src/functions/findFirstAuthentication/index.ts
-async function findFirstAuthentication(options = {}) {
-  const auths = await listAuthentications({
-    ...options,
-    limit: 1
-  });
-  return auths.length > 0 ? auths[0] : null;
-}
-
-// src/functions/findUniqueAuthentication/index.ts
-async function findUniqueAuthentication(options = {}) {
-  const auths = await listAuthentications({
-    ...options,
-    limit: 2
-    // Get up to 2 to check for uniqueness
-  });
-  if (auths.length === 0) {
-    throw new Error("No authentication found matching the specified criteria");
+// src/utils/function-utils.ts
+function extractCursor(data) {
+  if (!data?.next) {
+    return void 0;
   }
-  if (auths.length > 1) {
-    throw new Error(
-      "Multiple authentications found matching the specified criteria. Expected exactly one."
-    );
+  try {
+    const urlObj = new URL(data.next);
+    const offset = urlObj.searchParams.get("offset");
+    return offset || void 0;
+  } catch {
+    return void 0;
   }
-  return auths[0];
 }
-
-// src/functions/listApps/index.ts
-async function listApps(options = {}) {
-  const api = getOrCreateApiClient(options);
-  const searchParams = {};
-  if (options.category) {
-    searchParams.category = options.category;
-  }
-  if (options.limit) {
-    searchParams.limit = options.limit.toString();
-  }
-  if (options.offset) {
-    searchParams.offset = options.offset.toString();
-  }
-  const data = await api.get("/api/v4/apps/", { searchParams });
-  const apps = data.results?.map(
-    (app) => ({
-      key: app.slug,
-      name: app.name,
-      description: app.description,
-      version: "1.0.0",
-      // API doesn't provide version
-      category: app.category?.name,
-      actions: [],
-      // Will be populated separately
-      triggers: [],
-      current_implementation_id: app.current_implementation_id
-    })
-  ) || [];
-  if (apps.length > 0) {
-    apps.__pagination = {
-      count: data.count,
-      hasNext: !!data.next,
-      hasPrevious: !!data.previous,
-      nextUrl: data.next,
-      previousUrl: data.previous
-    };
+function normalizeError(error) {
+  if (error instanceof ZapierError) {
+    return error;
   }
-  return apps;
+  const message = error instanceof Error ? error.message : String(error);
+  return new ZapierUnknownError(`Unknown error: ${message}`, { cause: error });
 }
-
-// src/functions/listActions/index.ts
-async function listActions(options = {}) {
-  const api = getOrCreateApiClient(options);
-  if (options.appKey) {
-    try {
-      const appData = await getApp({
-        appKey: options.appKey,
-        api,
-        token: options.token,
-        baseUrl: options.baseUrl,
-        debug: options.debug,
-        fetch: options.fetch
-      });
-      const implementationId = appData.current_implementation_id?.split("@")[0];
-      if (!implementationId) {
-        throw new Error("No current_implementation_id found for app");
-      }
-      const searchParams2 = {
-        global: "true",
-        public_only: "true",
-        selected_apis: implementationId
-      };
-      const data2 = await api.get("/api/v4/implementations/", {
-        searchParams: searchParams2
-      });
-      const actions2 = [];
-      for (const implementation of data2.results || []) {
-        if (implementation.actions) {
-          for (const action of implementation.actions) {
-            const transformedAction = {
-              key: action.key,
-              name: action.name || action.label,
-              description: action.description || "",
-              appKey: implementation.slug || "",
-              type: action.type || action.type_of || "read",
-              inputFields: [],
-              // Would need additional API call for detailed fields
-              outputFields: []
-            };
-            if (options?.type && transformedAction.type !== options.type) {
-              continue;
-            }
-            actions2.push(transformedAction);
-          }
+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);
       }
-      if (actions2.length > 0) {
-        actions2.__pagination = {
-          count: data2.count,
-          hasNext: !!data2.next,
-          hasPrevious: !!data2.previous,
-          nextUrl: data2.next,
-          previousUrl: data2.previous
-        };
-      }
-      return actions2;
-    } catch (error) {
-      if (error instanceof Error && error.name === "AppNotFoundError") {
-        throw 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);
       }
-      console.warn(
-        "Optimized app lookup failed, falling back to full scan:",
-        error
-      );
     }
-  }
-  const searchParams = {
-    global: "true",
-    public_only: "true"
   };
-  const data = await api.get("/api/v4/implementations/", { searchParams });
-  const actions = [];
-  for (const implementation of data.results || []) {
-    if (implementation.actions) {
-      for (const action of implementation.actions) {
-        const transformedAction = {
-          key: action.key,
-          name: action.name || action.label,
-          description: action.description || "",
-          appKey: implementation.slug || "",
-          type: action.type || action.type_of || "read",
-          inputFields: [],
-          // Would need additional API call for detailed fields
-          outputFields: []
-        };
-        if (options?.appKey && transformedAction.appKey !== options.appKey) {
-          continue;
+  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");
         }
-        if (options?.type && transformedAction.type !== options.type) {
-          continue;
+        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;
+                }
+              }
+            }
+          };
         }
-        actions.push(transformedAction);
+      });
+    }
+  };
+  return namedFunctions[functionName];
+}
+var NeedChoicesSchema = zod.z.object({
+  key: zod.z.string().optional(),
+  label: zod.z.string().optional(),
+  sample: zod.z.string().optional(),
+  value: zod.z.string().optional()
+});
+var NeedSchema = zod.z.object({
+  key: zod.z.string(),
+  alters_custom_fields: zod.z.boolean().nullable().optional(),
+  capabilities: zod.z.array(zod.z.string()).optional(),
+  choices: zod.z.array(NeedChoicesSchema).optional(),
+  computed: zod.z.boolean().nullable().optional(),
+  custom_field: zod.z.boolean().optional(),
+  default: zod.z.string().optional(),
+  depends_on: zod.z.array(zod.z.string()).optional(),
+  format: zod.z.literal("SELECT").optional(),
+  from_search: zod.z.boolean().optional(),
+  from_write: zod.z.boolean().optional(),
+  help_text: zod.z.string().optional(),
+  help_text_html: zod.z.string().optional(),
+  input_format: zod.z.array(zod.z.string()).optional(),
+  label: zod.z.string().optional(),
+  language: zod.z.string().optional(),
+  parent_key: zod.z.string().optional(),
+  placeholder: zod.z.string().optional(),
+  prefill: zod.z.string().optional(),
+  required: zod.z.boolean().optional(),
+  searchfill: zod.z.string().optional(),
+  send_in_json: zod.z.boolean().optional(),
+  regex: zod.z.string().optional(),
+  type: zod.z.enum([
+    "integer",
+    "string",
+    "text",
+    "datetime",
+    "boolean",
+    "file",
+    "decimal",
+    "copy",
+    "password",
+    "dict",
+    "code",
+    "filter",
+    "json"
+  ]).optional(),
+  list: zod.z.boolean().optional()
+});
+var ActionLinksSchema = zod.z.object({
+  action_url: zod.z.string().optional()
+});
+var ActionPermissionsSchema = zod.z.object({
+  can_use: zod.z.boolean().optional()
+});
+var ActionSchema = zod.z.object({
+  id: zod.z.string().optional(),
+  type: zod.z.enum([
+    "filter",
+    "read",
+    "read_bulk",
+    "run",
+    "search",
+    "search_and_write",
+    "search_or_write",
+    "write"
+  ]),
+  key: zod.z.string(),
+  name: zod.z.string(),
+  noun: zod.z.string().optional(),
+  description: zod.z.string(),
+  description_html: zod.z.string().optional(),
+  is_important: zod.z.boolean().optional(),
+  is_hidden: zod.z.boolean().optional(),
+  needs: zod.z.array(NeedSchema).optional(),
+  meta: zod.z.string().optional(),
+  selected_api: zod.z.string().optional(),
+  links: ActionLinksSchema.optional(),
+  permissions: ActionPermissionsSchema.optional()
+});
+var ChoiceSchema = zod.z.object({
+  value: zod.z.union([zod.z.string(), zod.z.number()]),
+  label: zod.z.string()
+});
+zod.z.object({
+  key: zod.z.string(),
+  label: zod.z.string(),
+  type: zod.z.enum([
+    "string",
+    "number",
+    "boolean",
+    "datetime",
+    "file",
+    "object",
+    "array"
+  ]),
+  required: zod.z.boolean(),
+  description: zod.z.string().optional(),
+  choices: zod.z.array(ChoiceSchema).optional()
+});
+zod.z.object({
+  data: zod.z.array(zod.z.any())
+});
+var ActionFieldChoiceSchema = zod.z.object({
+  value: zod.z.union([zod.z.string(), zod.z.number()]),
+  label: zod.z.string()
+});
+zod.z.object({
+  key: zod.z.string(),
+  label: zod.z.string().optional(),
+  required: zod.z.boolean(),
+  type: zod.z.string().optional(),
+  helpText: zod.z.string().optional(),
+  helpTextHtml: zod.z.string().optional(),
+  choices: zod.z.array(ActionFieldChoiceSchema).optional(),
+  default: zod.z.string().optional(),
+  placeholder: zod.z.string().optional(),
+  computed: zod.z.boolean().optional(),
+  customField: zod.z.boolean().optional(),
+  dependsOn: zod.z.array(zod.z.string()).optional(),
+  format: zod.z.string().optional(),
+  inputFormat: zod.z.array(zod.z.string()).optional()
+});
+var AuthenticationSchema = zod.z.object({
+  id: zod.z.number(),
+  date: zod.z.string(),
+  lastchanged: zod.z.string().optional(),
+  account_id: zod.z.number(),
+  customuser_id: zod.z.number().optional(),
+  selected_api: zod.z.string(),
+  destination_selected_api: zod.z.string().nullable().optional(),
+  is_invite_only: zod.z.boolean(),
+  is_private: zod.z.boolean(),
+  shared_with_all: zod.z.boolean(),
+  is_stale: zod.z.string().optional(),
+  is_shared: zod.z.string().optional(),
+  marked_stale_at: zod.z.string().nullable().optional(),
+  label: zod.z.string().nullable().optional(),
+  identifier: zod.z.string().nullable().optional(),
+  title: zod.z.string().nullable().optional(),
+  url: zod.z.string().optional(),
+  groups: zod.z.string().optional(),
+  members: zod.z.string().optional(),
+  permissions: zod.z.record(zod.z.boolean()).optional()
+});
+zod.z.object({
+  count: zod.z.number(),
+  next: zod.z.string().nullable().optional(),
+  previous: zod.z.string().nullable().optional(),
+  results: zod.z.array(AuthenticationSchema)
+});
+var UserProfileSchema = zod.z.object({
+  id: zod.z.number(),
+  code: zod.z.string(),
+  user_id: zod.z.number(),
+  auto_provisioned: zod.z.boolean(),
+  first_name: zod.z.string(),
+  last_name: zod.z.string(),
+  username: zod.z.string(),
+  personas: zod.z.string(),
+  user_generated_personas: zod.z.string(),
+  last_login: zod.z.string(),
+  email: zod.z.string(),
+  email_hash: zod.z.string(),
+  email_confirmed: zod.z.boolean(),
+  timezone: zod.z.string(),
+  photo_url: zod.z.string(),
+  has_seen_notifications: zod.z.record(zod.z.boolean().nullable()),
+  signup: zod.z.string(),
+  since_signup: zod.z.string(),
+  has_activated: zod.z.boolean(),
+  enable_gz_creator: zod.z.boolean(),
+  should_see_nps_survey: zod.z.boolean(),
+  is_developer: zod.z.boolean(),
+  is_expert: zod.z.boolean(),
+  tos_agreement: zod.z.boolean(),
+  should_renew_tos: zod.z.boolean(),
+  is_gdpr_consented: zod.z.boolean(),
+  disable_ssl_check: zod.z.boolean(),
+  identity: zod.z.number(),
+  summary_schedule: zod.z.string(),
+  alert_triggers: zod.z.string(),
+  alert_actions: zod.z.string(),
+  is_staff: zod.z.boolean(),
+  is_zt_reviewer: zod.z.boolean(),
+  is_high_value: zod.z.boolean(),
+  is_temporary: zod.z.boolean(),
+  banner_message: zod.z.string(),
+  enable_totp_2fa: zod.z.boolean(),
+  viewed_help: zod.z.record(zod.z.boolean()),
+  show_editor_migration_mesaging: zod.z.boolean(),
+  switches: zod.z.record(zod.z.any()),
+  organizations: zod.z.array(zod.z.any().nullable()),
+  primary_organization: zod.z.any().nullable(),
+  has_active_zaps: zod.z.boolean(),
+  has_google_sso: zod.z.boolean(),
+  auth_realm: zod.z.string(),
+  roles: zod.z.array(
+    zod.z.object({
+      account_id: zod.z.number(),
+      role: zod.z.string()
+    })
+  )
+});
+zod.z.object({
+  age_in_days: zod.z.string().optional(),
+  api_docs_url: zod.z.string().nullable().optional(),
+  app_profile_url: zod.z.string(),
+  banner: zod.z.string().optional(),
+  categories: zod.z.array(zod.z.any()).optional(),
+  // TODO: Define proper service_category type
+  canonical_id: zod.z.string().optional(),
+  current_implementation_id: zod.z.string(),
+  days_since_last_update: zod.z.string().optional(),
+  description: zod.z.string(),
+  external_url: zod.z.string(),
+  hashtag: zod.z.string().optional(),
+  id: zod.z.number().optional(),
+  image: zod.z.string().optional(),
+  images: zod.z.string().optional(),
+  integration_overview_html: zod.z.string().nullable().optional(),
+  internal_id: zod.z.string(),
+  invite_url: zod.z.string().nullable().optional(),
+  is_beta: zod.z.string().optional(),
+  is_built_in: zod.z.string().optional(),
+  is_featured: zod.z.string().optional(),
+  is_premium: zod.z.boolean().optional(),
+  is_public: zod.z.string().optional(),
+  is_upcoming: zod.z.string().optional(),
+  learn_more_url: zod.z.string(),
+  name: zod.z.string(),
+  popularity: zod.z.number(),
+  primary_color: zod.z.string(),
+  request_count: zod.z.string().optional(),
+  slug: zod.z.string(),
+  zap_usage_count: zod.z.number().nullable().optional()
+});
+var ServiceSchema = zod.z.object({
+  id: zod.z.number().optional(),
+  canonical_id: zod.z.string().optional(),
+  current_implementation_id: zod.z.string(),
+  name: zod.z.string(),
+  slug: zod.z.string(),
+  app_url: zod.z.string().optional(),
+  learn_more_url: zod.z.string().optional(),
+  description: zod.z.string(),
+  primary_color: zod.z.string(),
+  popularity: zod.z.number(),
+  image: zod.z.string().optional(),
+  images: zod.z.string().optional()
+});
+zod.z.object({
+  results: zod.z.array(ServiceSchema),
+  next: zod.z.string().nullable().optional(),
+  previous: zod.z.string().nullable().optional()
+});
+zod.z.object({
+  selected_api: zod.z.string(),
+  action: zod.z.string(),
+  type_of: zod.z.string(),
+  authentication_id: zod.z.number().optional(),
+  params: zod.z.record(zod.z.any()).optional()
+});
+zod.z.object({
+  success: zod.z.boolean(),
+  needs: zod.z.array(NeedSchema).optional(),
+  errors: zod.z.array(zod.z.string()).optional(),
+  last_fetched_at: zod.z.string().optional()
+});
+var ImplementationSchema = zod.z.object({
+  selected_api: zod.z.string(),
+  app_id: zod.z.number().optional(),
+  auth_type: zod.z.string().optional(),
+  auth_fields: zod.z.string().optional(),
+  actions: zod.z.array(ActionSchema).optional(),
+  is_deprecated: zod.z.boolean().optional(),
+  is_private_only: zod.z.boolean().optional(),
+  is_invite_only: zod.z.boolean().optional(),
+  is_beta: zod.z.boolean().optional().default(false),
+  is_premium: zod.z.boolean().optional().default(false),
+  is_hidden: zod.z.string().optional(),
+  name: zod.z.string().optional(),
+  slug: zod.z.string().optional(),
+  images: zod.z.record(zod.z.string().nullable()).optional(),
+  primary_color: zod.z.string().optional(),
+  secondary_color: zod.z.string().optional(),
+  current_implementation: zod.z.string().optional(),
+  other_implementations: zod.z.string().optional()
+});
+zod.z.object({
+  count: zod.z.number(),
+  next: zod.z.string().nullable().optional(),
+  previous: zod.z.string().nullable().optional(),
+  results: zod.z.array(ImplementationSchema)
+});
+var ImplementationMetaSchema = zod.z.object({
+  id: zod.z.string(),
+  // e.g. "ZapierFormatterCLIAPI@1.0.7"
+  name: zod.z.string(),
+  slug: zod.z.string(),
+  images: zod.z.object({
+    url_16x16: zod.z.string().optional(),
+    url_32x32: zod.z.string().optional(),
+    url_64x64: zod.z.string().optional(),
+    url_128x128: zod.z.string().optional()
+  }).optional(),
+  // Include other fields for completeness but we'll only use what we need
+  ageInDays: zod.z.union([zod.z.string(), zod.z.number()]).optional(),
+  authType: zod.z.string().nullable().optional(),
+  banner: zod.z.string().optional(),
+  categories: zod.z.array(
+    zod.z.object({
+      id: zod.z.number(),
+      name: zod.z.string(),
+      slug: zod.z.string()
+    })
+  ).optional(),
+  isBeta: zod.z.boolean().optional(),
+  isBuiltIn: zod.z.boolean().optional(),
+  isDeprecated: zod.z.boolean().optional(),
+  isFeatured: zod.z.boolean().optional(),
+  isHidden: zod.z.boolean().optional(),
+  isInvite: zod.z.boolean().optional(),
+  isPremium: zod.z.boolean().optional(),
+  isPublic: zod.z.boolean().optional(),
+  isUpcoming: zod.z.boolean().optional(),
+  popularity: zod.z.number().optional(),
+  apiDocsUrl: zod.z.string().optional(),
+  classification: zod.z.string().optional()
+});
+zod.z.object({
+  count: zod.z.number(),
+  next: zod.z.string().nullable().optional(),
+  previous: zod.z.string().nullable().optional(),
+  results: zod.z.array(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
+  }),
+  {
+    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
+      };
     }
   }
-  if (actions.length > 0) {
-    actions.__pagination = {
-      count: data.count,
-      hasNext: !!data.next,
-      hasPrevious: !!data.previous,
-      nextUrl: data.next,
-      previousUrl: data.previous
+);
+
+// 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);
+  return {
+    getProfile,
+    context: {
+      meta: {
+        getProfile: {
+          inputSchema: GetProfileSchema
+        }
+      }
+    }
+  };
+};
+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: []
+      };
+    }
   }
-  return actions;
-}
+);
 
-// src/functions/getAction/index.ts
-async function getAction(options) {
-  const { appKey, actionKey, actionType } = options;
-  const actions = await listActions({
-    ...options,
-    appKey
-  });
-  const action = actions.find(
-    (a) => a.key === actionKey && a.type === actionType
-  );
-  if (!action) {
-    throw new Error(`Action not found: ${actionKey} with type ${actionType}`);
-  }
-  return action;
-}
+// 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/functions/runAction/index.ts
-async function runAction(options) {
-  const {
-    appKey,
-    actionType,
-    actionKey,
-    inputs,
-    authenticationId: providedAuthenticationId
-  } = options;
-  const api = getOrCreateApiClient(options);
-  const actionData = await getAction({
-    ...options,
-    appKey,
-    actionKey,
-    actionType
-  });
-  if (actionData.type !== actionType) {
-    throw new Error(
-      `Action type mismatch: expected ${actionType}, got ${actionData.type}`
-    );
+// 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];
   }
-  const startTime = Date.now();
-  const result = await executeAction({
-    api,
-    appSlug: appKey,
-    actionKey,
-    actionType: actionData.type,
-    executionOptions: { inputs: inputs || {} },
-    authenticationId: providedAuthenticationId,
-    options
-  });
-  const executionTime = Date.now() - startTime;
+  return [versionedKey, void 0];
+}
+function normalizeImplementationMetaToAppItem(implementationMeta) {
+  const [selectedApi, appVersion] = splitVersionedKey(implementationMeta.id);
   return {
-    success: true,
-    data: result,
-    metadata: {
-      executionTime,
-      requestId: generateRequestId()
-    }
+    title: implementationMeta.name,
+    key: selectedApi,
+    current_implementation_id: implementationMeta.id,
+    // Keep the full versioned ID
+    version: appVersion,
+    // Extract version separately
+    slug: implementationMeta.slug
   };
 }
-async function executeAction(actionOptions) {
-  const {
-    api,
-    appSlug,
-    actionKey,
-    actionType,
-    executionOptions,
-    authenticationId,
-    options
-  } = actionOptions;
-  const appData = await getApp({
-    appKey: appSlug,
-    api,
-    token: options.token,
-    baseUrl: options.baseUrl,
-    debug: options.debug,
-    fetch: options.fetch
-  });
-  const selectedApi = appData.current_implementation_id;
-  if (!selectedApi) {
-    throw new Error("No current_implementation_id found for app");
-  }
-  const runRequest = {
-    data: {
-      authentication_id: authenticationId || 1,
-      selected_api: selectedApi,
-      action_key: actionKey,
-      action_type: actionType,
-      inputs: executionOptions.inputs || {}
+function normalizeAuthenticationItem(auth, options = {}) {
+  let appKey = options.app_key;
+  let version = options.version;
+  if (auth.selected_api) {
+    const [extractedAppKey, extractedVersion] = splitVersionedKey(
+      auth.selected_api
+    );
+    if (!appKey) {
+      appKey = extractedAppKey;
+    }
+    if (!version) {
+      version = extractedVersion;
     }
-  };
-  const 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/functions/listFields/index.ts
-async function listFields(options) {
-  const api = getOrCreateApiClient(options);
-  const { appKey, actionKey, actionType, authenticationId, params } = options;
-  const appData = await getApp({
-    appKey,
-    api,
-    token: options.token,
-    baseUrl: options.baseUrl,
-    debug: options.debug,
-    fetch: options.fetch
-  });
-  const selectedApi = appData.current_implementation_id;
-  if (!selectedApi) {
-    throw new Error("No current_implementation_id found for app");
   }
-  const needsRequest = {
+  const {
     selected_api: selectedApi,
-    action: actionKey,
-    type_of: actionType,
-    authentication_id: authenticationId,
-    params: params || {}
+    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
   };
-  const needsData = await api.post(
-    "/api/v4/implementations/needs/",
-    needsRequest
-  );
-  if (!needsData.success) {
-    throw new Error(
-      `Failed to get action fields: ${needsData.errors?.join(", ") || "Unknown error"}`
-    );
-  }
-  return (needsData.needs || []).map((need) => ({
-    key: need.key,
-    label: need.label,
-    required: need.required || false,
-    type: need.type,
-    helpText: need.help_text,
-    helpTextHtml: need.help_text_html,
-    choices: need.choices?.map((choice) => ({
-      value: choice.value,
-      label: choice.label
-    })),
-    default: need.default,
-    placeholder: need.placeholder,
-    computed: need.computed,
-    customField: need.custom_field,
-    dependsOn: need.depends_on,
-    format: need.format,
-    inputFormat: need.input_format
-  }));
 }
-
-// src/functions/generateTypes/index.ts
-function generateFetchMethodSignature() {
-  return `  /** Make authenticated HTTP requests through Zapier's Relay service */
-  fetch: (options: Omit<z.infer<typeof RelayFetchSchema>, 'authenticationId'>) => Promise<Response>`;
+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"
+  };
 }
-async function generateTypes(options) {
-  const {
-    appKey,
-    authenticationId,
-    output = `./types/${appKey}.d.ts`
-  } = options;
-  const { app, version } = parseAppIdentifier(appKey);
-  const actions = await listActions({
-    ...options,
-    appKey: app
-  });
-  if (actions.length === 0) {
-    const typeDefinitions2 = generateEmptyTypesFile(app, version);
-    if (output) {
-      const fs = await import('fs');
-      const path = await import('path');
-      fs.mkdirSync(path.dirname(output), { recursive: true });
-      fs.writeFileSync(output, typeDefinitions2, "utf8");
-    }
-    return typeDefinitions2;
-  }
-  const actionsWithFields = [];
-  if (authenticationId) {
-    for (const action of actions) {
-      try {
-        const fields = await listFields({
-          ...options,
-          appKey: action.appKey,
-          actionKey: action.key,
-          actionType: action.type,
-          authenticationId
-        });
-        actionsWithFields.push({ ...action, inputFields: fields });
-      } catch {
-        actionsWithFields.push({ ...action, inputFields: [] });
+function groupVersionedAppKeysByType(appKeys) {
+  const result = {
+    selectedApi: [],
+    slug: []
+  };
+  const seenSelectedApi = /* @__PURE__ */ new Set();
+  const seenSlugs = /* @__PURE__ */ new Set();
+  for (const key of appKeys) {
+    const [keyWithoutVersion, version] = splitVersionedKey(key);
+    const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+    if (uuidRegex.test(keyWithoutVersion)) {
+      throw new Error(
+        `UUID app keys are not supported. Use app slug or implementation ID instead of: ${key}`
+      );
+    }
+    if (isSnakeCasedSlug(keyWithoutVersion)) {
+      const dashified = dashifySnakeCasedSlug(keyWithoutVersion);
+      const slugWithVersion = version ? `${dashified}@${version}` : dashified;
+      if (!seenSlugs.has(slugWithVersion)) {
+        seenSlugs.add(slugWithVersion);
+        result.slug.push(slugWithVersion);
       }
+      continue;
+    }
+    if (keyWithoutVersion.match(/^[a-z0-9]+(?:-[a-z0-9]+)*$/)) {
+      seenSlugs.add(key);
+      result.slug.push(key);
+      continue;
+    }
+    if (!seenSelectedApi.has(key)) {
+      seenSelectedApi.add(key);
+      result.selectedApi.push(key);
     }
-  } else {
-    actions.forEach((action) => {
-      actionsWithFields.push({ ...action, inputFields: [] });
-    });
-  }
-  const typeDefinitions = generateTypeDefinitions(
-    app,
-    actionsWithFields,
-    version
-  );
-  if (output) {
-    const fs = await import('fs');
-    const path = await import('path');
-    fs.mkdirSync(path.dirname(output), { recursive: true });
-    fs.writeFileSync(output, typeDefinitions, "utf8");
   }
-  return typeDefinitions;
+  return result;
 }
-function parseAppIdentifier(identifier) {
-  const parts = identifier.split("@");
+function groupAppKeysByType(appKeys) {
+  const grouped = groupVersionedAppKeysByType(appKeys);
   return {
-    app: parts[0],
-    version: parts[1]
+    selectedApi: [
+      ...new Set(grouped.selectedApi.map((key) => key.split("@")[0]))
+    ],
+    slug: [...new Set(grouped.slug.map((key) => key.split("@")[0]))]
   };
 }
-function generateTypeDefinitions(appKey, actions, version) {
-  if (actions.length === 0) {
-    return generateEmptyTypesFile(appKey, version);
+function isSnakeCasedSlug(slug) {
+  if (slug.match(/^_[0-9]/)) {
+    slug = slug.slice(1);
   }
-  const actionsByType = actions.reduce(
-    (acc, action) => {
-      if (!acc[action.type]) {
-        acc[action.type] = [];
-      }
-      acc[action.type].push(action);
-      return acc;
-    },
-    {}
-  );
-  const appName = capitalize(appKey);
-  const versionComment = version ? ` * Generated for ${appKey}@${version}` : ` * Generated for ${appKey}`;
-  let output = `/* eslint-disable @typescript-eslint/naming-convention */
-/**
- * Auto-generated TypeScript types for Zapier ${appKey} actions
-${versionComment}
- * Generated on: ${(/* @__PURE__ */ new Date()).toISOString()}
- * 
- * Usage:
- *   import type { ${appName}Sdk } from './path/to/this/file'
- *   const sdk = createZapierSdk() as unknown as ${appName}Sdk
- *   
- *   // Direct usage (per-call auth):
- *   await sdk.apps.${appKey}.search.user_by_email({ authenticationId: 123, inputs: { email } })
- *   
- *   // Factory usage (pinned auth):
- *   const my${appName} = sdk.apps.${appKey}({ authenticationId: 123 })
- *   await my${appName}.search.user_by_email({ inputs: { email } })
- */
-
-import type { ActionExecutionOptions, ActionExecutionResult } from '@zapier/zapier-sdk'
-import { z } from 'zod'
-import { RelayFetchSchema } from '@zapier/zapier-sdk'
-
-`;
-  actions.forEach((action) => {
-    if (action.inputFields.length > 0) {
-      const inputTypeName = `${appName}${capitalize(action.type)}${capitalize(
-        sanitizeActionName(action.key)
-      )}Inputs`;
-      output += `interface ${inputTypeName} {
-`;
-      action.inputFields.forEach((field) => {
-        const isOptional = !field.required;
-        const fieldType = mapFieldTypeToTypeScript(field);
-        const description = field.helpText ? `  /** ${escapeComment(field.helpText)} */
-` : "";
-        output += `${description}  ${sanitizeFieldName(field.key)}${isOptional ? "?" : ""}: ${fieldType}
-`;
-      });
-      output += `}
+  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, "-");
+}
 
-`;
-    }
-  });
-  Object.entries(actionsByType).forEach(([actionType, typeActions]) => {
-    const typeName = `${appName}${capitalize(actionType)}Actions`;
-    output += `interface ${typeName} {
-`;
-    typeActions.forEach((action) => {
-      const actionName = sanitizeActionName(action.key);
-      const description = action.description ? `  /** ${escapeComment(action.description)} */
-` : "";
-      if (action.inputFields.length > 0) {
-        const inputTypeName = `${appName}${capitalize(action.type)}${capitalize(
-          sanitizeActionName(action.key)
-        )}Inputs`;
-        output += `${description}  ${actionName}: (options: { inputs: ${inputTypeName} } & Omit<ActionExecutionOptions, 'inputs'>) => Promise<ActionExecutionResult>
-`;
-      } else {
-        output += `${description}  ${actionName}: (options?: { inputs?: Record<string, any> } & ActionExecutionOptions) => Promise<ActionExecutionResult>
-`;
-      }
-    });
-    output += `}
-
-`;
-  });
-  output += `interface ${appName}AppProxy {
-`;
-  Object.keys(actionsByType).forEach((actionType) => {
-    const typeName = `${appName}${capitalize(actionType)}Actions`;
-    output += `  ${actionType}: ${typeName}
-`;
-  });
-  output += generateFetchMethodSignature() + "\n";
-  output += `}
-
-`;
-  output += `interface ${appName}AppFactory {
-`;
-  output += `  (options: { authenticationId: number }): ${appName}AppProxy
-`;
-  output += `}
-
-`;
-  output += `type ${appName}AppWithFactory = ${appName}AppFactory & ${appName}AppProxy
-
-`;
-  output += `export interface ${appName}Sdk {
-`;
-  output += `  apps: {
-`;
-  output += `    ${appKey}: ${appName}AppWithFactory
-`;
-  output += `  }
-`;
-  output += `}
-`;
-  return output;
-}
-function generateEmptyTypesFile(appKey, version) {
-  const appName = capitalize(appKey);
-  const versionComment = version ? ` * Generated for ${appKey}@${version}` : ` * Generated for ${appKey}`;
-  return `/* eslint-disable @typescript-eslint/naming-convention */
-/**
- * Auto-generated TypeScript types for Zapier ${appKey} actions
-${versionComment}
- * Generated on: ${(/* @__PURE__ */ new Date()).toISOString()}
- * 
- * No actions found for this app.
- */
-
-import type { ActionExecutionOptions, ActionExecutionResult } from '@zapier/zapier-sdk'
-import { z } from 'zod'
-import { RelayFetchSchema } from '@zapier/zapier-sdk'
-
-interface ${appName}AppProxy {
-  // No actions available
-${generateFetchMethodSignature()}
-}
-
-interface ${appName}AppFactory {
-  (options: { authenticationId: number }): ${appName}AppProxy
-}
-
-type ${appName}AppWithFactory = ${appName}AppFactory & ${appName}AppProxy
-
-export interface ${appName}Sdk {
-  apps: {
-    ${appKey}: ${appName}AppWithFactory
-  }
-}
-`;
-}
-function capitalize(str) {
-  return str.charAt(0).toUpperCase() + str.slice(1).replace(/[-_]/g, "");
-}
-function sanitizeActionName(actionKey) {
-  let sanitized = actionKey.replace(/[^a-zA-Z0-9_$]/g, "_");
-  if (/^[0-9]/.test(sanitized)) {
-    sanitized = "_" + sanitized;
-  }
-  return sanitized;
-}
-function sanitizeFieldName(fieldKey) {
-  let sanitized = fieldKey.replace(/[^a-zA-Z0-9_$]/g, "_");
-  if (/^[0-9]/.test(sanitized)) {
-    sanitized = "_" + sanitized;
-  }
-  return sanitized;
-}
-function escapeComment(comment) {
-  return comment.replace(/\*\//g, "*\\/").replace(/\r?\n/g, " ");
-}
-function mapFieldTypeToTypeScript(field) {
-  if (field.choices && field.choices.length > 0) {
-    const choiceValues = field.choices.filter(
-      (choice) => choice.value !== void 0 && choice.value !== null && choice.value !== ""
-    ).map(
-      (choice) => typeof choice.value === "string" ? `"${choice.value}"` : choice.value
+// 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 (choiceValues.length > 0) {
-      return choiceValues.join(" | ");
-    }
-  }
-  switch (field.type?.toLowerCase()) {
-    case "string":
-    case "text":
-    case "email":
-    case "url":
-    case "password":
-      return "string";
-    case "integer":
-    case "number":
-      return "number";
-    case "boolean":
-      return "boolean";
-    case "datetime":
-    case "date":
-      return "string";
-    // ISO date strings
-    case "file":
-      return "string";
-    // File URL or content
-    case "array":
-      return "any[]";
-    case "object":
-      return "Record<string, any>";
-    default:
-      return "string | number | boolean";
-  }
-}
-
-// src/functions/bundleCode/index.ts
-async function bundleCode(options) {
-  const {
-    input,
-    output,
-    target = "es2020",
-    cjs = false,
-    minify = false,
-    string: returnString = false
-  } = options;
-  const { buildSync } = await import('esbuild');
-  const fs = await import('fs');
-  const path = await import('path');
-  const resolvedInput = path.resolve(process.cwd(), input);
-  try {
-    const result = buildSync({
-      entryPoints: [resolvedInput],
-      bundle: true,
-      platform: "node",
-      target,
-      format: cjs ? "cjs" : "esm",
-      minify,
-      write: false,
-      external: [],
-      // Bundle everything
-      banner: {
-        js: "#!/usr/bin/env node"
-      }
-    });
-    if (result.errors.length > 0) {
-      throw new Error(
-        `Bundle failed: ${result.errors.map((e) => e.text).join(", ")}`
+    if (opts.search) {
+      const searchParams2 = {};
+      searchParams2.term = opts.search;
+      const searchEnvelope = await api.get(
+        "/api/v4/implementations-meta/search/",
+        {
+          searchParams: searchParams2
+        }
       );
+      const implementations = searchEnvelope.results.map(
+        normalizeImplementationMetaToAppItem
+      );
+      const appKeysSet = new Set(appKeys);
+      for (const implementation of implementations) {
+        if (!appKeysSet.has(implementation.key)) {
+          appKeysSet.add(implementation.key);
+          appKeys.push(implementation.key);
+        }
+      }
     }
-    const bundledCode = result.outputFiles?.[0]?.text;
-    if (!bundledCode) {
-      throw new Error("No output generated");
-    }
-    let finalOutput = bundledCode;
-    if (returnString) {
-      finalOutput = JSON.stringify(bundledCode);
+    const searchParams = {};
+    if (opts.pageSize) {
+      searchParams.limit = opts.pageSize.toString();
     }
-    if (output) {
-      fs.mkdirSync(path.dirname(output), { recursive: true });
-      fs.writeFileSync(output, finalOutput, "utf8");
+    searchParams.latest_only = "true";
+    if (opts.cursor) {
+      searchParams.offset = opts.cursor;
     }
-    return finalOutput;
-  } catch (error) {
-    throw new Error(
-      `Bundle failed: ${error instanceof Error ? error.message : "Unknown error"}`
-    );
-  }
-}
-
-// src/functions/request/index.ts
-function transformUrlToRelayPath(url) {
-  const targetUrl = new URL(url);
-  const relayPath = `/relay/${targetUrl.hostname}${targetUrl.pathname}${targetUrl.search}${targetUrl.hash}`;
-  return relayPath;
-}
-async function request(options) {
-  const {
-    url,
-    method = "GET",
-    body,
-    headers,
-    authenticationId,
-    callbackUrl,
-    authenticationTemplate,
-    ...config
-  } = options;
-  return relayFetch(
-    url,
-    {
-      method,
-      body,
-      headers,
-      authenticationId,
-      callbackUrl,
-      authenticationTemplate
-    },
-    config
-  );
-}
-async function relayFetch(url, options = {}, config = {}) {
-  const api = getOrCreateApiClient(config);
-  const {
-    authenticationId,
-    callbackUrl,
-    authenticationTemplate,
-    method = "GET",
-    body,
-    ...fetchOptions
-  } = options;
-  const relayPath = transformUrlToRelayPath(url);
-  const headers = {};
-  if (fetchOptions.headers) {
-    const headerEntries = fetchOptions.headers instanceof Headers ? Array.from(fetchOptions.headers.entries()) : Object.entries(fetchOptions.headers);
-    for (const [key, value] of headerEntries) {
-      headers[key] = value;
+    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(",");
+      }
     }
-  }
-  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
-  });
-}
-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.string().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.record(zod.z.string()).optional().describe("Request headers")
-}).describe("Make authenticated HTTP requests through Zapier's Relay service");
-var RelayFetchSchema = RelayRequestSchema;
-var AppItemSchema = withFormatter(
-  zod.z.object({
-    key: zod.z.string(),
-    name: zod.z.string().optional(),
-    description: zod.z.string().optional(),
-    category: zod.z.string().optional()
-  }),
-  {
-    format: (item) => {
-      const details = [];
-      if (item.description) {
-        details.push({ text: item.description, style: "dim" });
+    const implementationsEnvelope = await api.get(
+      "/api/v4/implementations-meta/lookup/",
+      {
+        searchParams
       }
-      if (item.category) {
-        details.push({
-          text: `Category: ${item.category}`,
-          style: "accent"
-        });
+    );
+    return {
+      data: implementationsEnvelope.results.map(
+        normalizeImplementationMetaToAppItem
+      ),
+      nextCursor: extractCursor(implementationsEnvelope)
+    };
+  }, ListAppsSchema);
+  return {
+    listApps,
+    context: {
+      meta: {
+        listApps: {
+          inputSchema: ListAppsSchema
+        }
       }
-      return {
-        title: item.name || item.key,
-        subtitle: `(${item.key})`,
-        details
-      };
     }
-  }
-);
-
-// src/functions/listApps/schemas.ts
-var ListAppsSchema = withOutputSchema(
+  };
+};
+var GetAppSchema = withOutputSchema(
   zod.z.object({
-    category: zod.z.string().optional().describe("Filter apps by category"),
-    limit: LimitPropertySchema.optional().describe(
-      "Maximum number of items to return (1-200)"
-    ),
-    offset: OffsetPropertySchema.optional().describe(
-      "Number of items to skip for pagination"
+    appKey: AppKeyPropertySchema.describe(
+      "App key of app to fetch (e.g., 'SlackCLIAPI')"
     )
-  }).describe("List all available apps with optional filtering"),
+  }).describe("Get detailed information about a specific app"),
   AppItemSchema
 );
 
-// src/functions/listApps/info.ts
-var listAppsInfo = {
-  name: listApps.name,
-  inputSchema: ListAppsSchema,
-  implementation: listApps
-};
-var GetAppSchema = zod.z.object({
-  appKey: AppKeyPropertySchema.describe(
-    "App key or slug to fetch (e.g., google-sheets, slack, github)"
-  )
-}).describe("Get detailed information about a specific app");
-
-// src/functions/getApp/info.ts
-var getAppInfo = {
-  name: getApp.name,
-  inputSchema: GetAppSchema,
-  implementation: getApp
+// src/plugins/getApp/index.ts
+var getAppPlugin = ({ sdk }) => {
+  const getApp = createFunction(async function getApp2(options) {
+    const { appKey } = options;
+    const appsIterator = sdk.listApps({
+      ...options,
+      appKeys: [appKey]
+    }).items();
+    const apps = [];
+    for await (const app of appsIterator) {
+      apps.push(app);
+      break;
+    }
+    if (apps.length === 0) {
+      throw new ZapierAppNotFoundError(appKey);
+    }
+    return {
+      data: apps[0]
+    };
+  }, GetAppSchema);
+  return {
+    getApp,
+    context: {
+      meta: {
+        getApp: {
+          inputSchema: GetAppSchema
+        }
+      }
+    }
+  };
 };
 var ActionItemSchema = withFormatter(
-  zod.z.object({
-    key: zod.z.string(),
-    name: zod.z.string().optional(),
-    type: zod.z.string(),
-    appKey: zod.z.string().optional(),
-    description: zod.z.string().optional()
+  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.type}`, style: "accent" });
-      if (item.appKey) {
-        details.push({ text: `App: ${item.appKey}`, style: "normal" });
+      details.push({
+        text: `Type: ${item.action_type}`,
+        style: "accent"
+      });
+      if (item.app_key) {
+        details.push({
+          text: `App: ${item.app_key}`,
+          style: "normal"
+        });
       }
       if (item.description) {
         details.push({ text: item.description, style: "dim" });
       }
       return {
-        title: item.name || item.key,
+        title: item.title || item.name || item.key,
         subtitle: `(${item.key})`,
         details
       };
@@ -1600,22 +1975,88 @@ var ActionItemSchema = withFormatter(
   }
 );
 
-// src/functions/listActions/schemas.ts
+// src/plugins/listActions/schemas.ts
 var ListActionsSchema = withOutputSchema(
   zod.z.object({
-    appKey: AppKeyPropertySchema.optional(),
-    type: ActionTypePropertySchema.optional().describe(
+    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/functions/listActions/info.ts
-var listActionsInfo = {
-  name: listActions.name,
-  inputSchema: ListActionsSchema,
-  implementation: listActions
+// src/plugins/listActions/index.ts
+var listActionsPlugin = ({ sdk, context }) => {
+  const listActions = createPaginatedFunction(async function listActionsPage(options) {
+    const { api } = context;
+    const app = await sdk.getApp({ appKey: options.appKey });
+    const implementationId = app.data.current_implementation_id?.split("@")[0];
+    if (!implementationId) {
+      throw new ZapierConfigurationError(
+        "No current_implementation_id found for app",
+        { configType: "current_implementation_id" }
+      );
+    }
+    const searchParams = {
+      global: "true",
+      public_only: "true",
+      selected_apis: implementationId
+    };
+    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: {
+          inputSchema: ListActionsSchema
+        }
+      }
+    }
+  };
 };
 var GetActionSchema = zod.z.object({
   appKey: AppKeyPropertySchema,
@@ -1623,300 +2064,589 @@ var GetActionSchema = zod.z.object({
   actionKey: ActionKeyPropertySchema
 }).describe("Get detailed information about a specific action");
 
-// src/functions/getAction/info.ts
-var getActionInfo = {
-  name: getAction.name,
-  inputSchema: GetActionSchema,
-  implementation: getAction
+// 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 {
+    getAction,
+    context: {
+      meta: {
+        getAction: {
+          inputSchema: GetActionSchema
+        }
+      }
+    }
+  };
 };
 var RunActionSchema = zod.z.object({
   appKey: AppKeyPropertySchema,
   actionType: ActionTypePropertySchema,
   actionKey: ActionKeyPropertySchema,
+  authenticationId: AuthenticationIdPropertySchema.nullable().optional(),
   inputs: InputsPropertySchema.optional().describe(
     "Input parameters for the action"
   ),
-  authenticationId: AuthenticationIdPropertySchema.optional()
+  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/functions/runAction/info.ts
-var runActionInfo = {
-  name: runAction.name,
-  inputSchema: RunActionSchema,
-  implementation: runAction
+// src/plugins/runAction/index.ts
+async function executeAction(actionOptions) {
+  const {
+    api,
+    sdk,
+    appKey,
+    actionKey,
+    actionType,
+    executionOptions,
+    authenticationId
+  } = actionOptions;
+  const appData = await sdk.getApp({ appKey });
+  const selectedApi = appData.data.current_implementation_id;
+  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);
+  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}`
+      );
+    }
+    const result = await executeAction({
+      api,
+      sdk,
+      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
+      });
+    }
+    return {
+      data: result.results || [],
+      nextCursor: void 0
+      // No pagination implemented yet
+    };
+  }, RunActionSchema);
+  return {
+    runAction,
+    context: {
+      meta: {
+        runAction: {
+          inputSchema: RunActionSchema
+        }
+      }
+    }
+  };
 };
-var AuthItemSchema = withFormatter(
-  zod.z.object({
-    id: zod.z.number(),
-    title: zod.z.string().optional(),
-    identifier: zod.z.string().optional(),
-    account_id: zod.z.string().optional(),
-    is_private: zod.z.boolean().optional(),
-    shared_with_all: zod.z.boolean().optional(),
-    marked_stale_at: zod.z.string().optional()
-  }),
-  {
-    format: (item) => {
-      const details = [];
-      if (item.identifier) {
-        details.push({
-          text: `Identifier: ${item.identifier}`,
-          style: "accent"
+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 = ({ sdk, context }) => {
+  const listAuthentications = createPaginatedFunction(
+    async function listAuthenticationsPage(options) {
+      const { api } = context;
+      const searchParams = {};
+      if (options.appKey) {
+        const app = await sdk.getApp({
+          appKey: options.appKey
         });
+        const selectedApi = app.data.current_implementation_id;
+        if (selectedApi) {
+          const versionlessApi = selectedApi.split("@")[0];
+          searchParams.versionless_selected_api = versionlessApi;
+        }
       }
-      details.push({
-        text: `Account: ${item.account_id || "unknown"} | Private: ${item.is_private || false} | Shared: ${item.shared_with_all || false}`,
-        style: "dim"
-      });
-      if (item.marked_stale_at) {
-        details.push({
-          text: `\u26A0\uFE0F  Marked stale: ${new Date(item.marked_stale_at).toLocaleDateString()}`,
-          style: "warning"
-        });
+      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;
+      }
+      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.title || `Authentication ${item.id}`,
-        subtitle: `(ID: ${item.id})`,
-        details
+        data: auths,
+        nextCursor: extractCursor(data)
       };
+    },
+    ListAuthenticationsSchema
+  );
+  return {
+    listAuthentications,
+    context: {
+      meta: {
+        listAuthentications: {
+          inputSchema: ListAuthenticationsSchema
+        }
+      }
     }
-  }
-);
-
-// src/functions/listAuthentications/schemas.ts
-var ListAuthenticationsSchema = withOutputSchema(
-  zod.z.object({
-    appKey: AppKeyPropertySchema.optional().describe(
-      "App slug to get authentications for (e.g., 'slack', 'github')"
-    ),
-    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"),
-    limit: LimitPropertySchema.optional().describe(
-      "Maximum number of items to return (1-200)"
-    ),
-    offset: OffsetPropertySchema.optional().describe(
-      "Number of items to skip for pagination"
-    )
-  }).describe("List available authentications with optional filtering"),
-  AuthItemSchema
-);
-
-// src/functions/listAuthentications/info.ts
-var listAuthenticationsInfo = {
-  name: listAuthentications.name,
-  inputSchema: ListAuthenticationsSchema,
-  implementation: listAuthentications
+  };
 };
-var GetAuthenticationSchema = withOutputSchema(
-  zod.z.object({
-    authenticationId: zod.z.number().int().positive().describe("Authentication ID to retrieve")
-  }).describe("Get a specific authentication by ID"),
-  AuthItemSchema
-);
+var GetAuthenticationSchema = zod.z.object({
+  authenticationId: zod.z.number().int().positive().describe("Authentication ID to retrieve")
+}).describe("Get a specific authentication by ID");
 
-// src/functions/getAuthentication/info.ts
-var getAuthenticationInfo = {
-  name: getAuthentication.name,
-  inputSchema: GetAuthenticationSchema,
-  implementation: getAuthentication
-};
-var FindFirstAuthenticationSchema = withOutputSchema(
-  zod.z.object({
-    appKey: AppKeyPropertySchema.optional().describe(
-      "App slug to get authentications for (e.g., 'slack', 'github')"
-    ),
-    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"),
-    limit: LimitPropertySchema.optional().describe(
-      "Maximum number of items to return (1-200)"
-    ),
-    offset: OffsetPropertySchema.optional().describe(
-      "Number of items to skip for pagination"
-    )
-  }).describe("Find the first authentication matching the criteria"),
-  AuthItemSchema
-);
-
-// src/functions/findFirstAuthentication/info.ts
-var findFirstAuthenticationInfo = {
-  name: findFirstAuthentication.name,
-  inputSchema: FindFirstAuthenticationSchema,
-  implementation: findFirstAuthentication
+// 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)
+    };
+  }, GetAuthenticationSchema);
+  return {
+    getAuthentication,
+    context: {
+      meta: {
+        getAuthentication: {
+          inputSchema: GetAuthenticationSchema
+        }
+      }
+    }
+  };
 };
-var FindUniqueAuthenticationSchema = withOutputSchema(
-  zod.z.object({
-    appKey: AppKeyPropertySchema.optional().describe(
-      "App slug to get authentications for (e.g., 'slack', 'github')"
-    ),
-    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"),
-    limit: LimitPropertySchema.optional().describe(
-      "Maximum number of items to return (1-200)"
-    ),
-    offset: OffsetPropertySchema.optional().describe(
-      "Number of items to skip for pagination"
-    )
-  }).describe("Find a unique authentication matching the criteria"),
-  AuthItemSchema
-);
+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/functions/findUniqueAuthentication/info.ts
-var findUniqueAuthenticationInfo = {
-  name: findUniqueAuthentication.name,
-  inputSchema: FindUniqueAuthenticationSchema,
-  implementation: findUniqueAuthentication
-};
-var FieldItemSchema = withFormatter(
-  zod.z.object({
-    key: zod.z.string(),
-    name: zod.z.string().optional(),
-    description: zod.z.string().optional()
-  }),
-  {
-    format: (item) => {
-      const details = [];
-      if (item.description) {
-        details.push({ text: item.description, style: "dim" });
-      }
+// src/plugins/findFirstAuthentication/index.ts
+var findFirstAuthenticationPlugin = ({ sdk }) => {
+  const findFirstAuthentication = createFunction(
+    async function findFirstAuthentication2(options = {}) {
+      const authsResponse = await sdk.listAuthentications({
+        ...options,
+        maxItems: 1
+      });
       return {
-        title: item.name || item.key,
-        subtitle: `(${item.key})`,
-        details
+        data: authsResponse.data.length > 0 ? authsResponse.data[0] : null
       };
+    },
+    FindFirstAuthenticationSchema
+  );
+  return {
+    findFirstAuthentication,
+    context: {
+      meta: {
+        findFirstAuthentication: {
+          inputSchema: FindFirstAuthenticationSchema
+        }
+      }
     }
-  }
-);
-
-// src/functions/listFields/schemas.ts
-var ListFieldsSchema = withOutputSchema(
-  zod.z.object({
-    appKey: AppKeyPropertySchema,
-    actionType: ActionTypePropertySchema,
-    actionKey: ActionKeyPropertySchema,
-    authenticationId: AuthenticationIdPropertySchema.optional(),
-    params: ParamsPropertySchema.optional().describe(
-      "Additional parameters that may affect available fields"
-    )
-  }).describe("Get the input fields required for a specific action"),
-  FieldItemSchema
-);
-
-// src/functions/listFields/info.ts
-var listFieldsInfo = {
-  name: listFields.name,
-  inputSchema: ListFieldsSchema,
-  implementation: listFields
+  };
 };
-var GenerateTypesSchema = zod.z.object({
-  appKey: AppKeyPropertySchema.describe("App key to generate SDK code for"),
-  authenticationId: AuthenticationIdPropertySchema.optional(),
-  output: OutputPropertySchema.optional().describe(
-    "Output file path (defaults to generated/<appKey>.ts)"
+var FindUniqueAuthenticationSchema = zod.z.object({
+  appKey: AppKeyPropertySchema.optional().describe(
+    "App key of authentication to find (e.g., 'SlackCLIAPI')"
   ),
-  debug: DebugPropertySchema.describe(
-    "Enable debug logging during generation"
-  )
-}).describe("Generate TypeScript SDK code for a specific app");
+  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/functions/generateTypes/info.ts
-var generateTypesInfo = {
-  name: generateTypes.name,
-  inputSchema: GenerateTypesSchema,
-  implementation: generateTypes
+// 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 {
+    findUniqueAuthentication,
+    context: {
+      meta: {
+        findUniqueAuthentication: {
+          inputSchema: FindUniqueAuthenticationSchema
+        }
+      }
+    }
+  };
 };
-var BundleCodeSchema = zod.z.object({
-  input: zod.z.string().min(1).describe("Input TypeScript file path to bundle"),
-  output: OutputPropertySchema.optional().describe(
-    "Output file path (defaults to input with .js extension)"
+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"
   ),
-  string: zod.z.boolean().default(false).describe("Return bundled code as string instead of writing to file"),
-  minify: zod.z.boolean().default(false).describe("Minify the bundled output"),
-  target: zod.z.string().default("es2017").describe("ECMAScript target version"),
-  cjs: zod.z.boolean().default(false).describe("Output CommonJS format instead of ESM")
-}).describe("Bundle TypeScript code into executable JavaScript");
+  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/functions/bundleCode/info.ts
-var bundleCodeInfo = {
-  name: bundleCode.name,
-  inputSchema: BundleCodeSchema,
-  implementation: bundleCode
+// 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 = ({ sdk, context }) => {
+  const listInputFields = createPaginatedFunction(
+    async function listInputFieldsPage(options) {
+      const { api } = context;
+      const { appKey, actionKey, actionType, authenticationId, inputs } = options;
+      const appData = await sdk.getApp({ appKey });
+      const selectedApi = appData.data.current_implementation_id;
+      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: {
+          inputSchema: ListInputFieldsSchema
+        }
+      }
+    }
+  };
 };
 
-// src/functions/request/info.ts
-var requestInfo = {
-  name: "request",
-  inputSchema: RelayRequestSchema,
-  implementation: request
+// 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;
+      }
+    }
+    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 {
+    request,
+    context: {
+      meta: {
+        request: {
+          inputSchema: RelayRequestSchema
+        }
+      }
+    }
+  };
 };
 
 // src/sdk.ts
-var functionRegistry = [
-  listAppsInfo,
-  getAppInfo,
-  listActionsInfo,
-  getActionInfo,
-  runActionInfo,
-  listAuthenticationsInfo,
-  getAuthenticationInfo,
-  findFirstAuthenticationInfo,
-  findUniqueAuthenticationInfo,
-  listFieldsInfo,
-  generateTypesInfo,
-  bundleCodeInfo,
-  requestInfo
-];
-function createZapierSdk(options = {}) {
-  const {
-    fetch: customFetch = globalThis.fetch,
-    baseUrl = "https://zapier.com",
-    token,
-    getToken,
-    onEvent,
-    debug = false
-  } = options;
-  const api = createZapierApi({
-    baseUrl,
-    token,
-    getToken,
-    debug,
-    fetch: customFetch,
-    onEvent
-  });
-  const baseSdk = {
-    // Registry for CLI
-    __registry: functionRegistry,
-    // Function implementations with API config injection
-    listApps: (options2 = {}) => listApps({ ...options2, api }),
-    getApp: (options2) => getApp({ ...options2, api }),
-    listActions: (options2 = {}) => listActions({ ...options2, api }),
-    getAction: (options2) => getAction({ ...options2, api }),
-    runAction: (options2) => runAction({ ...options2, api }),
-    listAuthentications: (options2 = {}) => listAuthentications({ ...options2, api }),
-    getAuthentication: (options2) => getAuthentication({ ...options2, api }),
-    findFirstAuthentication: (options2 = {}) => findFirstAuthentication({ ...options2, api }),
-    findUniqueAuthentication: (options2 = {}) => findUniqueAuthentication({ ...options2, api }),
-    listFields: (options2) => listFields({ ...options2, api }),
-    generateTypes: (options2) => generateTypes({ ...options2, api }),
-    bundleCode: (options2) => bundleCode(options2),
-    // No API config needed
-    request: (options2) => request({ ...options2, api })
+function createSdk(initialSdk = {}, initialContext = { meta: {} }) {
+  return {
+    ...initialSdk,
+    getContext: () => initialContext,
+    addPlugin(plugin, options = {}) {
+      const currentSdkWithContext = {
+        ...initialSdk,
+        getContext: () => initialContext
+      };
+      const pluginResult = plugin({
+        sdk: currentSdkWithContext,
+        context: initialContext,
+        ...options
+      });
+      const { context: pluginContext, ...sdkProperties } = pluginResult;
+      const newSdk = { ...initialSdk, ...sdkProperties };
+      let newContext = {
+        ...initialContext,
+        meta: initialContext.meta || {}
+      };
+      if (pluginContext) {
+        const { meta: pluginMeta, ...otherPluginContext } = pluginContext;
+        newContext = {
+          ...newContext,
+          ...otherPluginContext
+        };
+        if (pluginMeta) {
+          newContext = {
+            ...newContext,
+            meta: {
+              ...newContext.meta,
+              // Existing meta (now guaranteed to exist)
+              ...pluginMeta
+              // New meta from plugin
+            }
+          };
+        }
+      }
+      return createSdk(newSdk, newContext);
+    }
   };
-  const fullSdk = baseSdk;
-  fullSdk.apps = createAppsPlugin({ sdk: fullSdk });
-  fullSdk.fetch = createFetchPlugin({ sdk: fullSdk });
-  return fullSdk;
+}
+function createZapierSdk(options = {}) {
+  return createSdk().addPlugin(apiPlugin, options).addPlugin(listAppsPlugin).addPlugin(getAppPlugin).addPlugin(listActionsPlugin).addPlugin(getActionPlugin).addPlugin(listInputFieldsPlugin).addPlugin(runActionPlugin).addPlugin(listAuthenticationsPlugin).addPlugin(getAuthenticationPlugin).addPlugin(findFirstAuthenticationPlugin).addPlugin(findUniqueAuthenticationPlugin).addPlugin(requestPlugin).addPlugin(fetchPlugin).addPlugin(appsPlugin).addPlugin(getProfilePlugin).addPlugin(registryPlugin);
 }
 
 exports.ActionKeyPropertySchema = ActionKeyPropertySchema;
 exports.ActionTypePropertySchema = ActionTypePropertySchema;
 exports.AppKeyPropertySchema = AppKeyPropertySchema;
-exports.AppNotFoundError = AppNotFoundError;
 exports.AuthenticationIdPropertySchema = AuthenticationIdPropertySchema;
 exports.DebugPropertySchema = DebugPropertySchema;
 exports.InputsPropertySchema = InputsPropertySchema;
@@ -1926,21 +2656,27 @@ exports.OutputPropertySchema = OutputPropertySchema;
 exports.ParamsPropertySchema = ParamsPropertySchema;
 exports.RelayFetchSchema = RelayFetchSchema;
 exports.RelayRequestSchema = RelayRequestSchema;
-exports.ZapierSdkError = ZapierSdkError;
+exports.ZapierActionError = ZapierActionError;
+exports.ZapierApiError = ZapierApiError;
+exports.ZapierAppNotFoundError = ZapierAppNotFoundError;
+exports.ZapierAuthenticationError = ZapierAuthenticationError;
+exports.ZapierBundleError = ZapierBundleError;
+exports.ZapierConfigurationError = ZapierConfigurationError;
+exports.ZapierError = ZapierError;
+exports.ZapierNotFoundError = ZapierNotFoundError;
+exports.ZapierResourceNotFoundError = ZapierResourceNotFoundError;
+exports.ZapierTimeoutError = ZapierTimeoutError;
+exports.ZapierUnknownError = ZapierUnknownError;
+exports.ZapierValidationError = ZapierValidationError;
 exports.actionKeyResolver = actionKeyResolver;
 exports.actionTypeResolver = actionTypeResolver;
 exports.appKeyResolver = appKeyResolver;
+exports.appsPlugin = appsPlugin;
 exports.authenticationIdResolver = authenticationIdResolver;
-exports.bundleCode = bundleCode;
-exports.createAppsPlugin = createAppsPlugin;
-exports.createFetchPlugin = createFetchPlugin;
+exports.createSdk = createSdk;
 exports.createZapierSdk = createZapierSdk;
-exports.findFirstAuthentication = findFirstAuthentication;
-exports.findUniqueAuthentication = findUniqueAuthentication;
-exports.generateTypes = generateTypes;
-exports.getAction = getAction;
-exports.getApp = getApp;
-exports.getAuthentication = getAuthentication;
+exports.fetchPlugin = fetchPlugin;
+exports.formatErrorMessage = formatErrorMessage;
 exports.getResolutionOrder = getResolutionOrder;
 exports.getResolutionOrderForParams = getResolutionOrderForParams;
 exports.getResolvableParams = getResolvableParams;
@@ -1952,11 +2688,4 @@ exports.getTokenFromEnvOrConfig = getTokenFromEnvOrConfig;
 exports.hasResolver = hasResolver;
 exports.inputsResolver = inputsResolver;
 exports.isPositional = isPositional;
-exports.listActions = listActions;
-exports.listApps = listApps;
-exports.listAuthentications = listAuthentications;
-exports.listFields = listFields;
-exports.relayFetch = relayFetch;
-exports.request = request;
 exports.resolverRegistry = resolverRegistry;
-exports.runAction = runAction;