@zapier/zapier-sdk-cli 0.64.0 → 0.65.0

package/dist/cli.cjs

@@ -2,8 +2,8 @@
 'use strict';
 
 var commander = require('commander');
-var zod = require('zod');
 var zapierSdk = require('@zapier/zapier-sdk');
+var zod = require('zod');
 var inquirer = require('inquirer');
 var search = require('@inquirer/search');
 var chalk = require('chalk');
@@ -1569,8 +1569,41 @@ async function promptText({
   ]);
   return value;
 }
+var display = (c) => c.hint ? `${c.label} ${chalk__default.default.dim(`(${c.hint})`)}` : c.label;
+function buildSelectRows(question, term) {
+  const row = (name, action) => ({
+    name,
+    value: { action }
+  });
+  const t = term.trim().toLowerCase();
+  const matched = t ? question.choices.filter(
+    (c) => `${c.label} ${c.hint ?? ""}`.toLowerCase().includes(t)
+  ) : question.choices;
+  const matchRows = matched.map((c) => ({
+    name: display(c),
+    value: c.value
+  }));
+  const skipRow = offers(question, "skip") ? [row(chalk__default.default.dim("Skip (optional)"), "skip")] : [];
+  const customRow = offers(question, "custom") ? [row(chalk__default.default.dim("Enter a value manually\u2026"), "custom")] : [];
+  const committed = !!t || question.search !== void 0;
+  let rows;
+  if (!committed) {
+    rows = [...skipRow, ...customRow, ...matchRows];
+  } else if (matchRows.length > 0) {
+    rows = [...matchRows, ...skipRow, ...customRow];
+  } else {
+    rows = [...customRow, ...skipRow];
+  }
+  if (offers(question, "search"))
+    rows.push(row(chalk__default.default.cyan("Search again\u2026"), "search"));
+  if (offers(question, "more")) rows.push(row(chalk__default.default.dim("Load more\u2026"), "more"));
+  if (offers(question, "retry")) rows.push(row(chalk__default.default.yellow("Retry"), "retry"));
+  if (offers(question, "cancel")) rows.push(row(chalk__default.default.dim("Cancel"), "cancel"));
+  for (const note of question.notes ?? [])
+    rows.push({ name: chalk__default.default.dim(note), value: note, disabled: true });
+  return rows;
+}
 async function answerSelect(question, field) {
-  const display = (c) => c.hint ? `${c.label} ${chalk__default.default.dim(`(${c.hint})`)}` : c.label;
   if (question.multiple) {
     const choices = [
       ...question.choices.map((c) => ({ name: display(c), value: c.value })),
@@ -1596,37 +1629,25 @@ async function answerSelect(question, field) {
     }
     return { type: "choose", value: selected };
   }
-  const row = (name, action) => ({
-    name,
-    value: { action }
-  });
+  if (offers(question, "search") && question.search === void 0) {
+    const optional = offers(question, "skip");
+    const parts = [
+      ...optional ? ["optional"] : [],
+      ...question.placeholder ? [question.placeholder] : []
+    ];
+    const hint = parts.length ? ` (${parts.join(", ")})` : "";
+    while (true) {
+      const term = (await promptText({
+        message: `Enter or search ${field}${hint}:`,
+        password: false
+      })).trim();
+      if (term) return { type: "search", term };
+      if (optional) return { type: "skip" };
+    }
+  }
   const value = await search__default.default({
     message: question.message,
-    source: (term) => {
-      const t = (term ?? "").trim().toLowerCase();
-      const matched = t ? question.choices.filter(
-        (c) => `${c.label} ${c.hint ?? ""}`.toLowerCase().includes(t)
-      ) : question.choices;
-      const rows = matched.map((c) => ({
-        name: display(c),
-        value: c.value
-      }));
-      if (offers(question, "search"))
-        rows.push(row(chalk__default.default.cyan("Search\u2026"), "search"));
-      if (offers(question, "more"))
-        rows.push(row(chalk__default.default.dim("Load more\u2026"), "more"));
-      if (offers(question, "custom"))
-        rows.push(row(chalk__default.default.dim("Enter a value manually\u2026"), "custom"));
-      if (offers(question, "retry"))
-        rows.push(row(chalk__default.default.yellow("Retry"), "retry"));
-      if (offers(question, "skip"))
-        rows.push(row(chalk__default.default.dim("Skip (optional)"), "skip"));
-      if (offers(question, "cancel"))
-        rows.push(row(chalk__default.default.dim("Cancel"), "cancel"));
-      for (const note of question.notes ?? [])
-        rows.push({ name: chalk__default.default.dim(note), value: note, disabled: true });
-      return rows;
-    }
+    source: (term) => buildSelectRows(question, term ?? "")
   });
   if (!isActionRow(value)) {
     return { type: "choose", value };
@@ -1657,8 +1678,9 @@ async function answerSelect(question, field) {
   }
 }
 async function answerInput(question) {
+  const message = question.placeholder ? question.message.replace(/:?\s*$/, ` (${question.placeholder}):`) : question.message;
   const value = await promptText({
-    message: question.message,
+    message,
     password: question.inputType === "password"
   });
   if (value === "" && offers(question, "skip")) {
@@ -1670,6 +1692,7 @@ async function answerCollection(question) {
   if (!offers(question, "done")) {
     return { type: "add" };
   }
+  if (question.description) console.log(question.description);
   const { again } = await inquirer__default.default.prompt([
     {
       type: "confirm",
@@ -1680,6 +1703,16 @@ async function answerCollection(question) {
   ]);
   return again ? { type: "add" } : { type: "done" };
 }
+function withEngineSpinner(answer, spinner) {
+  return async (bag) => {
+    spinner.stop();
+    try {
+      return await answer(bag);
+    } finally {
+      spinner.start();
+    }
+  };
+}
 var answerViaCli = ({ state, result }) => {
   if (result.error !== void 0) {
     const message = typeof result.error === "string" ? result.error : result.error.message;
@@ -1727,7 +1760,7 @@ var SHARED_COMMAND_CLI_OPTIONS = [
 
 // package.json
 var package_default = {
-  version: "0.64.0"};
+  version: "0.65.0"};
 
 // src/telemetry/builders.ts
 function createCliBaseEvent(context = {}) {
@@ -2190,8 +2223,6 @@ function sanitizeCliArguments(args) {
 function resolveNonInteractive(options) {
   return options.nonInteractive === true || options.skipPrompts === true || !process.stdin.isTTY || !process.stdout.isTTY;
 }
-
-// src/utils/cli-generator.ts
 var CLI_COMMAND_EXECUTED_EVENT_SUBJECT = "platform.sdk.CliCommandExecutedEvent";
 var PAGINATION_PARAM_NAMES = /* @__PURE__ */ new Set(["maxItems", "pageSize", "cursor"]);
 function getNormalizedResult(result, { isListCommand }) {
@@ -2278,20 +2309,6 @@ ${messageBefore}
   ]);
   return { confirmed, messageAfter };
 }
-function emitDeprecationWarning({
-  cliCommandName,
-  deprecation
-}) {
-  if (!deprecation) {
-    return;
-  }
-  console.warn();
-  console.warn(
-    chalk__default.default.yellow.bold("\u26A0\uFE0F  DEPRECATION WARNING") + chalk__default.default.yellow(` - \`${cliCommandName}\` is deprecated.`)
-  );
-  console.warn(chalk__default.default.yellow(`   ${deprecation.message}`));
-  console.warn();
-}
 function emitParamDeprecationWarnings({
   options,
   parameters
@@ -2322,6 +2339,12 @@ function resolveOutputMode({
   if (hasUserSpecifiedMaxItems) return "collect";
   return "paginate";
 }
+function takesPositionalSlot(param) {
+  return param.required || !!param.isPositional && !param.isDeprecated && !param.isAlias;
+}
+var positionalFlagCompat = {
+  [zapierSdk.getConnectionPlugin.name]: /* @__PURE__ */ new Set(["connection"])
+};
 function getSchemaMetadata(schema) {
   return schema?.meta?.();
 }
@@ -2579,7 +2602,7 @@ function generateCliCommands(program2, sdk) {
   });
 }
 function createCommandConfig(cliCommandName, functionInfo, sdk) {
-  const usesInputParameters = !functionInfo.inputSchema && !!functionInfo.inputParameters;
+  const usesInputParameters = !!functionInfo.inputParameters;
   const schema = functionInfo.inputSchema;
   const parameters = usesInputParameters ? analyzeInputParameters(functionInfo.inputParameters, functionInfo) : analyzeZodSchema(schema, functionInfo);
   if (functionInfo.boundResolvers && Object.keys(functionInfo.boundResolvers).length > 0) {
@@ -2604,14 +2627,11 @@ function createCommandConfig(cliCommandName, functionInfo, sdk) {
     const commandObj = args[args.length - 1];
     const options = commandObj.opts();
     const interactiveMode = !options.json;
+    const promptingEnabled = interactiveMode && process.stdin.isTTY === true;
     const renderer = interactiveMode ? createInteractiveRenderer({
       params: resolvedParams
     }) : createJsonRenderer();
     try {
-      emitDeprecationWarning({
-        cliCommandName,
-        deprecation: functionInfo.deprecation
-      });
       emitParamDeprecationWarnings({ options, parameters });
       const isListCommand = functionInfo.type === "list";
       const hasPaginationParams = parameters.some(
@@ -2643,26 +2663,48 @@ function createCommandConfig(cliCommandName, functionInfo, sdk) {
           Object.entries(rawParams).filter(([, v]) => v !== void 0)
         );
         const controller = zapierSdk.createController(sdk);
+        const spinner = promptingEnabled && !options.debug ? ora__default.default({ text: "", spinner: "dots" }) : void 0;
         let resolved;
         try {
+          const isRegisteredPositional = (name) => {
+            const p = parameters.find((param) => param.name === name);
+            return !!p && takesPositionalSlot(p);
+          };
+          spinner?.start();
           resolved = await controller.resolve({
             method: functionInfo.name,
             input: seedInput,
-            answer: interactiveMode ? answerViaCli : ({ state }) => {
-              throw new ZapierCliMissingParametersError([
-                {
-                  name: state.current?.join(".") ?? "value",
-                  isPositional: false
+            answer: spinner ? withEngineSpinner(answerViaCli, spinner) : promptingEnabled ? answerViaCli : ({ state }) => {
+              const missing = /* @__PURE__ */ new Map();
+              missing.set(
+                state.current?.join(".") ?? "value",
+                isRegisteredPositional(String(state.current?.[0] ?? ""))
+              );
+              for (const p of parameters) {
+                if (!p.required || p.isDeprecated || p.isAlias) continue;
+                if (p.name in state.resolved) continue;
+                if (state.settled.includes(p.name)) continue;
+                if (boundResolvers[p.name]?.type === "constant") continue;
+                if (!missing.has(p.name)) {
+                  missing.set(p.name, isRegisteredPositional(p.name));
                 }
-              ]);
+              }
+              throw new ZapierCliMissingParametersError(
+                [...missing].map(([name, isPositional3]) => ({
+                  name,
+                  isPositional: isPositional3
+                }))
+              );
             },
-            interactive: interactiveMode
+            interactive: promptingEnabled
           });
         } catch (err) {
           if (err instanceof zapierSdk.CoreCancelledSignal) {
             throw new ZapierCliUserCancellationError();
           }
           throw err;
+        } finally {
+          spinner?.stop();
         }
         Object.assign(resolvedParams, resolved);
       } else if (schema && !usesInputParameters) {
@@ -2795,7 +2837,7 @@ ${confirmMessageAfter}`));
             selected_api: resolvedParams.app ?? null
           }
         });
-        sdk.context.eventEmission.emit(
+        zapierSdk.resolvePlugin(sdk, zapierSdk.eventEmissionPluginRef).emit(
           CLI_COMMAND_EXECUTED_EVENT_SUBJECT,
           event
         );
@@ -2811,6 +2853,7 @@ ${confirmMessageAfter}`));
   };
   return {
     description,
+    methodName: functionInfo.name,
     parameters,
     handler: handlerWithCallerContext,
     hidden: !!functionInfo.deprecation,
@@ -2852,7 +2895,7 @@ function addCommand(program2, commandName, config2) {
         `<${kebabName}>`,
         param.description || `${kebabName} parameter`
       );
-    } else if (param.isPositional && !param.isDeprecated && !param.isAlias) {
+    } else if (takesPositionalSlot(param)) {
       command.argument(
         `[${kebabName}]`,
         param.description || `${kebabName} parameter`
@@ -2887,6 +2930,9 @@ function addCommand(program2, commandName, config2) {
         command.addOption(opt);
       }
     }
+    if (positionalFlagCompat[config2.methodName]?.has(param.name) && takesPositionalSlot(param) && param.type !== "array") {
+      command.addOption(new commander.Option(`--${kebabName} <value>`).hideHelp());
+    }
   });
   const paramNames = new Set(config2.parameters.map((p) => p.name));
   SHARED_COMMAND_CLI_OPTIONS.forEach((opt) => {
@@ -2900,7 +2946,7 @@ function convertCliArgsToSdkParams(parameters, positionalArgs, options) {
   const sdkParams = {};
   let argIndex = 0;
   parameters.forEach((param) => {
-    if ((param.required || param.isPositional && !param.isDeprecated && !param.isAlias) && argIndex < positionalArgs.length) {
+    if (takesPositionalSlot(param) && argIndex < positionalArgs.length) {
       sdkParams[param.name] = convertValue(
         positionalArgs[argIndex],
         param.type,
@@ -2913,6 +2959,9 @@ function convertCliArgsToSdkParams(parameters, positionalArgs, options) {
     const camelKey = key.replace(/-([a-z])/g, (g) => g[1].toUpperCase());
     const param = parameters.find((p) => p.name === camelKey);
     if (param && value !== void 0) {
+      if (sdkParams[camelKey] !== void 0) {
+        return;
+      }
       if (param.type === "array" && Array.isArray(value) && value.length === 0) {
         return;
       }
@@ -4900,7 +4949,7 @@ function promptlessLegacyJwtUpgradeError() {
   );
 }
 async function clearExistingAuthState({
-  sdk,
+  imports,
   baseUrl: baseUrl2,
   interactive,
   entryPoint
@@ -4921,7 +4970,7 @@ Log out and ${getActiveCredentialsAction(entryPoint)}?`
     }
     try {
       await revokeCredentials({
-        api: sdk.context.api,
+        api: imports.api,
         credentials: activeCredentials
       });
     } catch {
@@ -4986,13 +5035,13 @@ async function saveClientCredentials({
   return { clientId };
 }
 function emitAccountAuthSuccess({
-  sdk,
+  imports,
   profile,
   clientId,
   isNonInteractive,
   isHeadless
 }) {
-  sdk.context.eventEmission.emit(
+  imports.eventEmission.emit(
     "platform.sdk.ApplicationLifecycleEvent",
     zapierSdk.buildApplicationLifecycleEvent(
       {
@@ -5011,11 +5060,11 @@ function emitAccountAuthSuccess({
   );
 }
 function emitSignupSuccess({
-  sdk,
+  imports,
   isNonInteractive,
   isHeadless
 }) {
-  sdk.context.eventEmission.emit(
+  imports.eventEmission.emit(
     "platform.sdk.ApplicationLifecycleEvent",
     zapierSdk.buildApplicationLifecycleEvent({
       lifecycle_event_type: "signup_success",
@@ -5034,7 +5083,7 @@ async function runOauthWithRedaction(runOauth) {
   }
 }
 async function runOauthForEntryPoint({
-  sdk,
+  imports,
   entryPoint,
   timeoutMs,
   pkceCredentials,
@@ -5054,7 +5103,7 @@ async function runOauthForEntryPoint({
         onProgress: (event) => {
           if (event.type === "callback_accepted") {
             emitSignupSuccess({
-              sdk,
+              imports,
               isNonInteractive: false,
               isHeadless: headless === true
             });
@@ -5075,7 +5124,7 @@ async function runOauthForEntryPoint({
   );
 }
 async function provisionAccountCredentials({
-  sdk,
+  imports,
   entryPoint,
   accessToken,
   credentialsBaseUrl: credentialsBaseUrl2,
@@ -5088,7 +5137,7 @@ async function provisionAccountCredentials({
   const scopedApi = zapierSdk.getOrCreateApiClient({
     credentials: accessToken,
     baseUrl: credentialsBaseUrl2,
-    callerPackage: sdk.context.options?.callerPackage
+    callerPackage: imports.sdkOptions?.callerPackage
   });
   const profile = await getProfile(scopedApi);
   process.stderr.write(`${getProfileMessage(entryPoint, profile.email)}
@@ -5117,7 +5166,7 @@ async function provisionAccountCredentials({
     process.stderr.write("\u{1F510} Approvals are enabled for these credentials.\n");
   }
   emitAccountAuthSuccess({
-    sdk,
+    imports,
     profile,
     clientId,
     isNonInteractive,
@@ -5125,7 +5174,7 @@ async function provisionAccountCredentials({
   });
 }
 async function runAccountAuth({
-  sdk,
+  imports,
   options,
   entryPoint
 }) {
@@ -5157,7 +5206,7 @@ async function runAccountAuth({
       }
     }
     if (!await clearExistingAuthState({
-      sdk,
+      imports,
       baseUrl: pending.credentialsBaseUrl,
       interactive: false,
       entryPoint
@@ -5171,7 +5220,7 @@ async function runAccountAuth({
         onProgress: (event) => {
           if (entryPoint === "signup" && event.type === "callback_accepted") {
             emitSignupSuccess({
-              sdk,
+              imports,
               isNonInteractive: true,
               isHeadless: pending.headless
             });
@@ -5180,7 +5229,7 @@ async function runAccountAuth({
       });
     });
     await provisionAccountCredentials({
-      sdk,
+      imports,
       entryPoint,
       accessToken: accessToken2,
       credentialsBaseUrl: pending.credentialsBaseUrl,
@@ -5194,11 +5243,11 @@ async function runAccountAuth({
   }
   const timeoutSeconds = parseTimeoutSeconds(options.timeout);
   const interactive = !resolveNonInteractive(options);
-  const resolvedCredentials = await sdk.context.resolveCredentials();
+  const resolvedCredentials = await imports.resolveCredentials();
   const pkceCredentials = toPkceCredentials(resolvedCredentials);
   const headless = options.headless === true;
   const credentialsBaseUrl2 = await resolveCredentialsBaseUrl({
-    ...sdk.context,
+    options: imports.sdkOptions,
     resolvedCredentials
   });
   const providedName = options.name !== void 0 ? validateCredentialsName(options.name) : void 0;
@@ -5213,7 +5262,7 @@ async function runAccountAuth({
     }
   }
   if (!await clearExistingAuthState({
-    sdk,
+    imports,
     baseUrl: credentialsBaseUrl2,
     interactive,
     entryPoint
@@ -5234,7 +5283,7 @@ async function runAccountAuth({
     return;
   }
   const { accessToken } = await runOauthForEntryPoint({
-    sdk,
+    imports,
     entryPoint,
     timeoutMs: timeoutSeconds * 1e3,
     pkceCredentials,
@@ -5243,7 +5292,7 @@ async function runAccountAuth({
     interactive
   });
   await provisionAccountCredentials({
-    sdk,
+    imports,
     entryPoint,
     accessToken,
     credentialsBaseUrl: credentialsBaseUrl2,
@@ -5288,17 +5337,26 @@ var LoginSchema = zod.z.object({
 });
 
 // src/plugins/login/index.ts
-var loginPlugin = zapierSdk.definePlugin(
-  (sdk) => zapierSdk.createPluginMethod(sdk, {
-    name: "login",
-    categories: ["account"],
-    inputSchema: LoginSchema,
-    supportsJsonOutput: false,
-    handler: async ({ sdk: sdk2, options }) => {
-      await runAccountAuth({ sdk: sdk2, options, entryPoint: "login" });
-    }
-  })
-);
+var loginPlugin = zapierSdk.defineMethod({
+  name: "login",
+  imports: [
+    zapierSdk.apiPluginRef,
+    zapierSdk.resolveCredentialsPluginRef,
+    zapierSdk.eventEmissionPluginRef,
+    zapierSdk.sdkOptionsPluginRef
+  ],
+  output: "raw",
+  inputSchema: LoginSchema,
+  categories: ["account"],
+  supportsJsonOutput: false,
+  run: async ({ imports, input }) => {
+    await runAccountAuth({
+      imports,
+      options: input,
+      entryPoint: "login"
+    });
+  }
+});
 var SignupSchema = zod.z.object({
   timeout: zod.z.string().optional().describe("Signup timeout in seconds (default: 300)"),
   useApprovals: zod.z.boolean().optional().describe(
@@ -5330,68 +5388,92 @@ var SignupSchema = zod.z.object({
 });
 
 // src/plugins/signup/index.ts
-var signupPlugin = zapierSdk.definePlugin(
-  (sdk) => zapierSdk.createPluginMethod(sdk, {
-    name: "signup",
-    categories: ["account"],
-    inputSchema: SignupSchema,
-    supportsJsonOutput: false,
-    handler: async ({ sdk: sdk2, options }) => {
-      await runAccountAuth({ sdk: sdk2, options, entryPoint: "signup" });
-    }
-  })
-);
+var signupPlugin = zapierSdk.defineMethod({
+  name: "signup",
+  imports: [
+    zapierSdk.apiPluginRef,
+    zapierSdk.resolveCredentialsPluginRef,
+    zapierSdk.eventEmissionPluginRef,
+    zapierSdk.sdkOptionsPluginRef
+  ],
+  output: "raw",
+  inputSchema: SignupSchema,
+  categories: ["account"],
+  supportsJsonOutput: false,
+  run: async ({ imports, input }) => {
+    await runAccountAuth({
+      imports,
+      options: input,
+      entryPoint: "signup"
+    });
+  }
+});
 var LogoutSchema = zod.z.object({}).describe("Log out of your Zapier account");
 
 // src/plugins/logout/index.ts
-var logoutPlugin = zapierSdk.definePlugin(
-  (sdk) => zapierSdk.createPluginMethod(sdk, {
-    name: "logout",
-    categories: ["account"],
-    inputSchema: LogoutSchema,
-    supportsJsonOutput: false,
-    handler: async ({ sdk: sdk2 }) => {
-      const credentialsBaseUrl2 = await resolveCredentialsBaseUrl(sdk2.context);
-      const activeCredentials = getActiveCredentials({
-        baseUrl: credentialsBaseUrl2
-      });
-      const onEvent = sdk2.context.options?.onEvent;
-      if (!activeCredentials) {
-        await logout({ onEvent });
-        console.log("\u2705 Successfully logged out");
-        return;
-      }
-      await revokeCredentials({
-        api: sdk2.context.api,
-        credentials: activeCredentials,
-        onEvent,
-        alwaysClearLocalState: true
-      });
+var logoutPlugin = zapierSdk.defineMethod({
+  name: "logout",
+  imports: [zapierSdk.apiPluginRef, zapierSdk.resolveCredentialsPluginRef, zapierSdk.sdkOptionsPluginRef],
+  output: "raw",
+  inputSchema: LogoutSchema,
+  categories: ["account"],
+  supportsJsonOutput: false,
+  run: async ({ imports }) => {
+    const credentialsBaseUrl2 = await resolveCredentialsBaseUrl({
+      resolveCredentials: imports.resolveCredentials,
+      options: imports.sdkOptions
+    });
+    const activeCredentials = getActiveCredentials({
+      baseUrl: credentialsBaseUrl2
+    });
+    const onEvent = imports.sdkOptions?.onEvent;
+    if (!activeCredentials) {
+      await logout({ onEvent });
       console.log("\u2705 Successfully logged out");
+      return;
     }
-  })
-);
+    await revokeCredentials({
+      api: imports.api,
+      credentials: activeCredentials,
+      onEvent,
+      alwaysClearLocalState: true
+    });
+    console.log("\u2705 Successfully logged out");
+  }
+});
+var CLI_EXTENSIONS_ID = "cli/extensions";
+var cliExtensionsPluginRef = zapierSdk.declareOptionalProperty({
+  id: CLI_EXTENSIONS_ID
+});
+var CLI_EXPERIMENTAL_ID = "cli/experimental";
+var cliExperimentalPluginRef = zapierSdk.declareOptionalProperty({
+  id: CLI_EXPERIMENTAL_ID
+});
 var McpSchema = zod.z.object({
   port: zod.z.string().optional().describe("Port to listen on (for future HTTP transport)")
 }).describe("Start MCP server for Zapier SDK");
 
 // src/plugins/mcp/index.ts
-var mcpPlugin = zapierSdk.definePlugin(
-  (sdk) => zapierSdk.createPluginMethod(sdk, {
-    name: "mcp",
-    categories: ["utility"],
-    inputSchema: McpSchema,
-    handler: async ({ sdk: sdk2, options }) => {
-      await zapierSdkMcp.startMcpServer({
-        ...options,
-        debug: sdk2.context.options?.debug,
-        maxConcurrentRequests: sdk2.context.options?.maxConcurrentRequests,
-        extensions: sdk2.context.extensions,
-        experimental: sdk2.context.experimental
-      });
-    }
-  })
-);
+var mcpPlugin = zapierSdk.defineMethod({
+  name: "mcp",
+  imports: [
+    zapierSdk.sdkOptionsPluginRef,
+    cliExtensionsPluginRef,
+    cliExperimentalPluginRef
+  ],
+  output: "raw",
+  inputSchema: McpSchema,
+  categories: ["utility"],
+  run: async ({ imports, input }) => {
+    await zapierSdkMcp.startMcpServer({
+      ...input,
+      debug: imports.sdkOptions?.debug,
+      maxConcurrentRequests: imports.sdkOptions?.maxConcurrentRequests,
+      extensions: imports.extensions,
+      experimental: imports.experimental
+    });
+  }
+});
 var BundleCodeSchema = zod.z.object({
   input: zod.z.string().min(1).describe("Input TypeScript file path to bundle"),
   output: zapierSdk.OutputPropertySchema.optional().describe(
@@ -5402,15 +5484,16 @@ var BundleCodeSchema = zod.z.object({
   target: zod.z.string().optional().describe("ECMAScript target version"),
   cjs: zod.z.boolean().optional().describe("Output CommonJS format instead of ESM")
 }).describe("Bundle TypeScript code into executable JavaScript");
-var bundleCodePlugin = zapierSdk.definePlugin(
-  (sdk) => zapierSdk.createPluginMethod(sdk, {
-    name: "bundleCode",
-    categories: ["utility"],
-    deprecation: { message: "bundleCode is no longer maintained." },
-    inputSchema: BundleCodeSchema,
-    handler: async ({ options }) => bundleCode(options)
-  })
-);
+var bundleCodePlugin = zapierSdk.defineMethod({
+  name: "bundleCode",
+  categories: ["utility"],
+  deprecation: { message: "bundleCode is no longer maintained." },
+  inputSchema: BundleCodeSchema,
+  // Returns the bundled code string verbatim — no `{ data }` envelope,
+  // matching legacy.
+  output: "raw",
+  run: async ({ input }) => bundleCode(input)
+});
 async function bundleCode(options) {
   const {
     input,
@@ -5467,14 +5550,16 @@ async function bundleCode(options) {
   }
 }
 var GetLoginConfigPathSchema = zod.z.object({}).describe("Show the path to the login configuration file");
-var getLoginConfigPathPlugin = zapierSdk.definePlugin(
-  (sdk) => zapierSdk.createPluginMethod(sdk, {
-    name: "getLoginConfigPath",
-    categories: ["utility"],
-    inputSchema: GetLoginConfigPathSchema,
-    handler: async () => getConfigPath()
-  })
-);
+
+// src/plugins/getLoginConfigPath/index.ts
+var getLoginConfigPathPlugin = zapierSdk.defineMethod({
+  name: "getLoginConfigPath",
+  categories: ["utility"],
+  inputSchema: GetLoginConfigPathSchema,
+  // Returns the path string verbatim — no `{ data }` envelope, matching legacy.
+  output: "raw",
+  run: async () => getConfigPath()
+});
 var AddSchema = zod.z.object({
   apps: zod.z.array(zod.z.string().min(1, "App key cannot be empty")).min(1, "At least one app key is required").describe(
     "One or more app keys to add (e.g., 'slack', 'github', 'trello')"
@@ -5502,105 +5587,107 @@ async function detectTypesOutputDirectory() {
   }
   return "./zapier/apps/";
 }
-var addAppsPlugin = zapierSdk.definePlugin(
-  (sdk) => zapierSdk.createPluginMethod(sdk, {
-    name: "add",
-    categories: ["utility"],
-    inputSchema: AddSchema,
-    handler: async ({ sdk: sdk2, options }) => {
-      const {
-        apps: appKeys,
-        connections: connectionIds,
-        configPath,
-        typesOutput = await detectTypesOutputDirectory()
-      } = options;
-      const resolvedTypesOutput = path.resolve(typesOutput);
-      console.log(`\u{1F4E6} Adding ${appKeys.length} app(s)...`);
-      const appSlugAndKeyMap = /* @__PURE__ */ new Map();
-      const handleManifestProgress = (event) => {
-        switch (event.type) {
-          case "apps_lookup_start":
-            console.log(`\u{1F4E6} Looking up ${event.count} app(s)...`);
-            break;
-          case "app_found":
-            const displayName = event.app.slug ? `${event.app.slug} (${event.app.key})` : event.app.key;
-            appSlugAndKeyMap.set(event.app.key, displayName);
-            break;
-          case "apps_lookup_complete":
-            if (event.count === 0) {
-              console.warn("\u26A0\uFE0F No apps found");
-            }
-            break;
-          case "app_processing_start":
-            const appName = event.slug ? `${event.slug} (${event.app})` : event.app;
-            console.log(`\u{1F4E6} Adding ${appName}...`);
-            break;
-          case "manifest_updated":
-            const appDisplay = appSlugAndKeyMap.get(event.app) || event.app;
-            console.log(
-              `\u{1F4DD} Locked ${appDisplay} to ${event.app}@${event.version} using key '${event.manifestKey}'`
-            );
-            break;
-          case "app_processing_error":
-            const errorApp = appSlugAndKeyMap.get(event.app) || event.app;
-            console.warn(`\u26A0\uFE0F ${event.error} for ${errorApp}`);
-            break;
-        }
-      };
-      const handleTypesProgress = (event) => {
-        switch (event.type) {
-          case "connections_lookup_start":
-            console.log(`\u{1F510} Looking up ${event.count} connection(s)...`);
-            break;
-          case "connections_lookup_complete":
-            console.log(`\u{1F510} Found ${event.count} connection(s)`);
-            break;
-          case "connection_matched":
-            const appWithConnection = appSlugAndKeyMap.get(event.app) || event.app;
-            console.log(
-              `\u{1F510} Using connection ${event.connectionId} (${event.connectionTitle}) for ${appWithConnection}`
-            );
-            break;
-          case "connection_not_matched":
-            const appWithoutConnection = appSlugAndKeyMap.get(event.app) || event.app;
-            console.warn(
-              `\u26A0\uFE0F No matching connection found for ${appWithoutConnection}`
-            );
-            break;
-          case "file_written":
-            console.log(
-              `\u{1F527} Generated types for ${event.manifestKey} at ${event.filePath}`
-            );
-            break;
-          case "app_processing_error":
-            const errorApp = appSlugAndKeyMap.get(event.app) || event.app;
-            console.warn(`\u26A0\uFE0F ${event.error} for ${errorApp}`);
-            break;
-        }
-      };
-      const manifestResult = await sdk2.buildManifest({
-        apps: appKeys,
-        skipWrite: false,
-        configPath,
-        onProgress: handleManifestProgress
-      });
-      const typesResult = await sdk2.generateAppTypes({
-        apps: appKeys,
-        connections: connectionIds,
-        skipWrite: false,
-        typesOutputDirectory: resolvedTypesOutput,
-        onProgress: handleTypesProgress
-      });
-      const results = manifestResult.manifest?.apps || {};
-      const successfulApps = Object.keys(results).filter(
-        (manifestKey) => typesResult.writtenFiles?.[manifestKey]
-      );
-      if (successfulApps.length > 0) {
-        console.log(`\u2705 Added ${successfulApps.length} app(s) to manifest`);
+var buildManifestRef = zapierSdk.declareMethod({ id: "buildManifest" });
+var generateAppTypesRef = zapierSdk.declareMethod({ id: "generateAppTypes" });
+var addAppsPlugin = zapierSdk.defineMethod({
+  name: "add",
+  imports: [buildManifestRef, generateAppTypesRef],
+  output: "raw",
+  categories: ["utility"],
+  inputSchema: AddSchema,
+  run: async ({ imports, input }) => {
+    const {
+      apps: appKeys,
+      connections: connectionIds,
+      configPath,
+      typesOutput = await detectTypesOutputDirectory()
+    } = input;
+    const resolvedTypesOutput = path.resolve(typesOutput);
+    console.log(`\u{1F4E6} Adding ${appKeys.length} app(s)...`);
+    const appSlugAndKeyMap = /* @__PURE__ */ new Map();
+    const handleManifestProgress = (event) => {
+      switch (event.type) {
+        case "apps_lookup_start":
+          console.log(`\u{1F4E6} Looking up ${event.count} app(s)...`);
+          break;
+        case "app_found":
+          const displayName = event.app.slug ? `${event.app.slug} (${event.app.key})` : event.app.key;
+          appSlugAndKeyMap.set(event.app.key, displayName);
+          break;
+        case "apps_lookup_complete":
+          if (event.count === 0) {
+            console.warn("\u26A0\uFE0F No apps found");
+          }
+          break;
+        case "app_processing_start":
+          const appName = event.slug ? `${event.slug} (${event.app})` : event.app;
+          console.log(`\u{1F4E6} Adding ${appName}...`);
+          break;
+        case "manifest_updated":
+          const appDisplay = appSlugAndKeyMap.get(event.app) || event.app;
+          console.log(
+            `\u{1F4DD} Locked ${appDisplay} to ${event.app}@${event.version} using key '${event.manifestKey}'`
+          );
+          break;
+        case "app_processing_error":
+          const errorApp = appSlugAndKeyMap.get(event.app) || event.app;
+          console.warn(`\u26A0\uFE0F ${event.error} for ${errorApp}`);
+          break;
+      }
+    };
+    const handleTypesProgress = (event) => {
+      switch (event.type) {
+        case "connections_lookup_start":
+          console.log(`\u{1F510} Looking up ${event.count} connection(s)...`);
+          break;
+        case "connections_lookup_complete":
+          console.log(`\u{1F510} Found ${event.count} connection(s)`);
+          break;
+        case "connection_matched":
+          const appWithConnection = appSlugAndKeyMap.get(event.app) || event.app;
+          console.log(
+            `\u{1F510} Using connection ${event.connectionId} (${event.connectionTitle}) for ${appWithConnection}`
+          );
+          break;
+        case "connection_not_matched":
+          const appWithoutConnection = appSlugAndKeyMap.get(event.app) || event.app;
+          console.warn(
+            `\u26A0\uFE0F No matching connection found for ${appWithoutConnection}`
+          );
+          break;
+        case "file_written":
+          console.log(
+            `\u{1F527} Generated types for ${event.manifestKey} at ${event.filePath}`
+          );
+          break;
+        case "app_processing_error":
+          const errorApp = appSlugAndKeyMap.get(event.app) || event.app;
+          console.warn(`\u26A0\uFE0F ${event.error} for ${errorApp}`);
+          break;
       }
+    };
+    const manifestResult = await imports.buildManifest({
+      apps: appKeys,
+      skipWrite: false,
+      configPath,
+      onProgress: handleManifestProgress
+    });
+    const typesResult = await imports.generateAppTypes({
+      apps: appKeys,
+      connections: connectionIds,
+      skipWrite: false,
+      typesOutputDirectory: resolvedTypesOutput,
+      onProgress: handleTypesProgress
+    });
+    const results = manifestResult.manifest?.apps || {};
+    const successfulApps = Object.keys(results).filter(
+      (manifestKey) => typesResult.writtenFiles?.[manifestKey]
+    );
+    if (successfulApps.length > 0) {
+      console.log(`\u2705 Added ${successfulApps.length} app(s) to manifest`);
     }
-  })
-);
+  }
+});
 var GenerateAppTypesSchema = zod.z.object({
   apps: zod.z.array(zod.z.string().min(1, "App key cannot be empty")).min(1, "At least one app key is required").describe(
     "One or more app keys to generate types for (e.g., 'slack', 'github', 'trello')"
@@ -5618,26 +5705,28 @@ var GenerateAppTypesSchema = zod.z.object({
   "Generate TypeScript type definitions for apps - can optionally write to disk or just return type strings"
 );
 var AstTypeGenerator = class {
-  constructor() {
+  constructor(options) {
     this.factory = ts__namespace.factory;
     this.printer = ts__namespace.createPrinter({
       newLine: ts__namespace.NewLineKind.LineFeed,
       removeComments: false,
       omitTrailingSemicolon: false
     });
+    this.listActions = options.listActions;
+    this.listActionInputFields = options.listActionInputFields;
   }
   /**
    * Generate TypeScript types using AST for a specific app
    */
   async generateTypes(options) {
-    const { app, connectionId, sdk } = options;
-    const actionsResult = await sdk.listActions({
+    const { app, connectionId } = options;
+    const actionsResult = await this.listActions({
       appKey: app.implementation_id
     });
     const actions = actionsResult.data;
     const actionsWithFields = [];
     const inputFieldsTasks = actions.map(
-      (action) => () => sdk.listActionInputFields({
+      (action) => () => this.listActionInputFields({
         appKey: app.implementation_id,
         actionKey: action.key,
         actionType: action.action_type,
@@ -6207,133 +6296,147 @@ function createManifestEntry(app) {
     version: app.version
   };
 }
-var generateAppTypesPlugin = zapierSdk.definePlugin(
-  (sdk) => zapierSdk.createPluginMethod(sdk, {
-    name: "generateAppTypes",
-    categories: ["utility"],
-    // Cast: schema validates JSON fields only; GenerateAppTypesOptions adds
-    // the runtime-only `onProgress` callback (passthrough via createFunction).
-    inputSchema: GenerateAppTypesSchema,
-    handler: async ({ sdk: sdk2, options }) => {
-      const {
-        apps: appKeys,
-        connections: connectionIds,
-        skipWrite = false,
-        typesOutputDirectory = await detectTypesOutputDirectory(),
-        onProgress
-      } = options;
-      const resolvedTypesOutput = path.resolve(typesOutputDirectory);
-      const result = { typeDefinitions: {} };
-      onProgress?.({ type: "apps_lookup_start", count: appKeys.length });
-      const appsIterable = sdk2.listApps({ apps: appKeys }).items();
-      const apps = [];
-      for await (const app of appsIterable) {
-        apps.push(app);
-        onProgress?.({ type: "app_found", app });
-      }
-      onProgress?.({ type: "apps_lookup_complete", count: apps.length });
-      if (apps.length === 0) {
-        return result;
-      }
-      const connections = [];
-      if (connectionIds && connectionIds.length > 0) {
-        onProgress?.({
-          type: "connections_lookup_start",
-          count: connectionIds.length
-        });
-        const connectionsIterable = sdk2.listConnections({ connections: connectionIds }).items();
-        for await (const connection of connectionsIterable) {
-          connections.push(connection);
-        }
-        onProgress?.({
-          type: "connections_lookup_complete",
-          count: connections.length
-        });
-      }
-      if (!skipWrite && resolvedTypesOutput) {
-        await promises.mkdir(resolvedTypesOutput, { recursive: true });
-      }
-      if (!skipWrite) {
-        result.writtenFiles = {};
+var listAppsRef = zapierSdk.declareMethod({ id: "listApps" });
+var listConnectionsRef = zapierSdk.declareMethod({ id: "listConnections" });
+var listActionsRef = zapierSdk.declareMethod({ id: "listActions" });
+var listActionInputFieldsRef = zapierSdk.declareMethod({ id: "listActionInputFields" });
+var generateAppTypesPlugin = zapierSdk.defineMethod({
+  name: "generateAppTypes",
+  imports: [
+    listAppsRef,
+    listConnectionsRef,
+    listActionsRef,
+    listActionInputFieldsRef
+  ],
+  output: "raw",
+  categories: ["utility"],
+  // Cast: schema validates JSON fields only; GenerateAppTypesOptions adds the
+  // runtime-only `onProgress` callback, widening the input type for `run`.
+  inputSchema: GenerateAppTypesSchema,
+  // The schema stays for projection (CLI flags / docs); the runtime parse is
+  // skipped because it would strip the runtime-only `onProgress` callback.
+  skipInputValidation: true,
+  run: async ({ imports, input }) => {
+    const {
+      apps: appKeys,
+      connections: connectionIds,
+      skipWrite = false,
+      typesOutputDirectory = await detectTypesOutputDirectory(),
+      onProgress
+    } = input;
+    const resolvedTypesOutput = path.resolve(typesOutputDirectory);
+    const result = { typeDefinitions: {} };
+    onProgress?.({ type: "apps_lookup_start", count: appKeys.length });
+    const appsIterable = imports.listApps({ apps: appKeys }).items();
+    const apps = [];
+    for await (const app of appsIterable) {
+      apps.push(app);
+      onProgress?.({ type: "app_found", app });
+    }
+    onProgress?.({ type: "apps_lookup_complete", count: apps.length });
+    if (apps.length === 0) {
+      return result;
+    }
+    const connections = [];
+    if (connectionIds && connectionIds.length > 0) {
+      onProgress?.({
+        type: "connections_lookup_start",
+        count: connectionIds.length
+      });
+      const connectionsIterable = imports.listConnections({ connections: connectionIds }).items();
+      for await (const connection of connectionsIterable) {
+        connections.push(connection);
       }
-      for (const app of apps) {
-        onProgress?.({
-          type: "app_processing_start",
-          app: app.key,
-          slug: app.slug
-        });
-        try {
-          if (!app.version) {
-            const errorMessage = `Invalid implementation ID format: ${app.implementation_id}. Expected format: <implementationName>@<version>`;
-            onProgress?.({
-              type: "app_processing_error",
-              app: app.key,
-              error: errorMessage
-            });
-            throw new zapierSdk.ZapierValidationError(errorMessage, {
-              details: {
-                appKey: app.key,
-                implementationId: app.implementation_id
-              }
-            });
-          }
-          let connectionId;
-          if (connections.length > 0) {
-            const matchingConnection = connections.find(
-              (conn) => conn.app_key === app.key
-            );
-            if (matchingConnection) {
-              connectionId = matchingConnection.id;
-              onProgress?.({
-                type: "connection_matched",
-                app: app.key,
-                connectionId: matchingConnection.id,
-                connectionTitle: matchingConnection.title || ""
-              });
-            } else {
-              onProgress?.({
-                type: "connection_not_matched",
-                app: app.key
-              });
-            }
-          }
-          const manifestKey = getManifestKey(app);
-          const generator = new AstTypeGenerator();
-          const typeDefinitionString = await generator.generateTypes({
-            app,
-            connectionId,
-            sdk: sdk2
-          });
-          result.typeDefinitions[manifestKey] = typeDefinitionString;
-          onProgress?.({
-            type: "type_generated",
-            manifestKey,
-            sizeBytes: typeDefinitionString.length
-          });
-          if (!skipWrite && resolvedTypesOutput && result.writtenFiles) {
-            const filePath = path.join(resolvedTypesOutput, `${manifestKey}.d.ts`);
-            await promises.writeFile(filePath, typeDefinitionString, "utf8");
-            result.writtenFiles[manifestKey] = filePath;
-            onProgress?.({ type: "file_written", manifestKey, filePath });
-          }
-          onProgress?.({ type: "app_processing_complete", app: app.key });
-        } catch (error) {
-          const errorMessage = `Failed to process app ${app.key}: ${error instanceof Error ? error.message : String(error)}`;
+      onProgress?.({
+        type: "connections_lookup_complete",
+        count: connections.length
+      });
+    }
+    if (!skipWrite && resolvedTypesOutput) {
+      await promises.mkdir(resolvedTypesOutput, { recursive: true });
+    }
+    if (!skipWrite) {
+      result.writtenFiles = {};
+    }
+    for (const app of apps) {
+      onProgress?.({
+        type: "app_processing_start",
+        app: app.key,
+        slug: app.slug
+      });
+      try {
+        if (!app.version) {
+          const errorMessage = `Invalid implementation ID format: ${app.implementation_id}. Expected format: <implementationName>@<version>`;
           onProgress?.({
             type: "app_processing_error",
             app: app.key,
             error: errorMessage
           });
-          if (error instanceof zapierSdk.ZapierValidationError) {
-            throw error;
+          throw new zapierSdk.ZapierValidationError(errorMessage, {
+            details: {
+              appKey: app.key,
+              implementationId: app.implementation_id
+            }
+          });
+        }
+        let connectionId;
+        if (connections.length > 0) {
+          const matchingConnection = connections.find(
+            (conn) => conn.app_key === app.key
+          );
+          if (matchingConnection) {
+            connectionId = matchingConnection.id;
+            onProgress?.({
+              type: "connection_matched",
+              app: app.key,
+              connectionId: matchingConnection.id,
+              connectionTitle: matchingConnection.title || ""
+            });
+          } else {
+            onProgress?.({
+              type: "connection_not_matched",
+              app: app.key
+            });
           }
-          throw new zapierSdk.ZapierUnknownError(errorMessage, { cause: error });
         }
+        const manifestKey = getManifestKey(app);
+        const generator = new AstTypeGenerator({
+          listActions: imports.listActions,
+          listActionInputFields: imports.listActionInputFields
+        });
+        const typeDefinitionString = await generator.generateTypes({
+          app,
+          connectionId
+        });
+        result.typeDefinitions[manifestKey] = typeDefinitionString;
+        onProgress?.({
+          type: "type_generated",
+          manifestKey,
+          sizeBytes: typeDefinitionString.length
+        });
+        if (!skipWrite && resolvedTypesOutput && result.writtenFiles) {
+          const filePath = path.join(resolvedTypesOutput, `${manifestKey}.d.ts`);
+          await promises.writeFile(filePath, typeDefinitionString, "utf8");
+          result.writtenFiles[manifestKey] = filePath;
+          onProgress?.({ type: "file_written", manifestKey, filePath });
+        }
+        onProgress?.({ type: "app_processing_complete", app: app.key });
+      } catch (error) {
+        const errorMessage = `Failed to process app ${app.key}: ${error instanceof Error ? error.message : String(error)}`;
+        onProgress?.({
+          type: "app_processing_error",
+          app: app.key,
+          error: errorMessage
+        });
+        if (error instanceof zapierSdk.ZapierValidationError) {
+          throw error;
+        }
+        throw new zapierSdk.ZapierUnknownError(errorMessage, { cause: error });
       }
-      return result;
     }
-  })
-);
+    return result;
+  }
+});
 var BuildManifestSchema = zod.z.object({
   apps: zod.z.array(zod.z.string().min(1, "App key cannot be empty")).min(1, "At least one app key is required").describe(
     "One or more app keys to build manifest entries for (e.g., 'slack', 'github', 'trello')"
@@ -6349,80 +6452,78 @@ var BuildManifestSchema = zod.z.object({
 );
 
 // src/plugins/buildManifest/index.ts
-var buildManifestPlugin = zapierSdk.definePlugin(
-  (sdk) => zapierSdk.createPluginMethod(sdk, {
-    name: "buildManifest",
-    categories: ["utility"],
-    // Cast: BuildManifestSchema validates JSON-serializable fields only.
-    // BuildManifestOptions adds an `onProgress` callback that rides through
-    // `createFunction`'s passthrough spread at runtime; this widens TInput
-    // so the handler can read it.
-    inputSchema: BuildManifestSchema,
-    handler: async ({ sdk: sdk2, options }) => {
-      const {
-        apps: appKeys,
-        skipWrite = false,
-        configPath,
-        onProgress
-      } = options;
-      onProgress?.({ type: "apps_lookup_start", count: appKeys.length });
-      const appsIterable = sdk2.listApps({ apps: appKeys }).items();
-      const apps = [];
-      for await (const app of appsIterable) {
-        apps.push(app);
-        onProgress?.({ type: "app_found", app });
-      }
-      onProgress?.({ type: "apps_lookup_complete", count: apps.length });
-      if (apps.length === 0) {
-        return {};
-      }
-      let updatedManifest;
-      for (const app of apps) {
+var listAppsRef2 = zapierSdk.declareMethod({ id: "listApps" });
+var buildManifestPlugin = zapierSdk.defineMethod({
+  name: "buildManifest",
+  imports: [listAppsRef2, zapierSdk.manifestPluginRef],
+  output: "raw",
+  categories: ["utility"],
+  // Cast: BuildManifestSchema validates JSON-serializable fields only.
+  // BuildManifestOptions adds an `onProgress` callback; this widens the input
+  // type so `run` can read it.
+  inputSchema: BuildManifestSchema,
+  // The schema stays for projection (CLI flags / docs); the runtime parse is
+  // skipped because it would strip the runtime-only `onProgress` callback.
+  skipInputValidation: true,
+  run: async ({ imports, input }) => {
+    const { apps: appKeys, skipWrite = false, configPath, onProgress } = input;
+    onProgress?.({ type: "apps_lookup_start", count: appKeys.length });
+    const appsIterable = imports.listApps({ apps: appKeys }).items();
+    const apps = [];
+    for await (const app of appsIterable) {
+      apps.push(app);
+      onProgress?.({ type: "app_found", app });
+    }
+    onProgress?.({ type: "apps_lookup_complete", count: apps.length });
+    if (apps.length === 0) {
+      return {};
+    }
+    let updatedManifest;
+    for (const app of apps) {
+      onProgress?.({
+        type: "app_processing_start",
+        app: app.key,
+        slug: app.slug
+      });
+      try {
+        const manifestEntry = createManifestEntry(app);
         onProgress?.({
-          type: "app_processing_start",
+          type: "manifest_entry_built",
           app: app.key,
-          slug: app.slug
+          manifestKey: manifestEntry.implementationName,
+          version: manifestEntry.version || ""
         });
-        try {
-          const manifestEntry = createManifestEntry(app);
-          onProgress?.({
-            type: "manifest_entry_built",
-            app: app.key,
-            manifestKey: manifestEntry.implementationName,
-            version: manifestEntry.version || ""
-          });
-          const { key: updatedManifestKey, manifest } = await sdk2.context.updateManifestEntry({
-            appKey: app.key,
-            entry: manifestEntry,
-            configPath,
-            skipWrite,
-            manifest: updatedManifest
-          });
-          updatedManifest = manifest;
-          onProgress?.({
-            type: "manifest_updated",
-            app: app.key,
-            manifestKey: updatedManifestKey,
-            version: manifestEntry.version || ""
-          });
-          onProgress?.({ type: "app_processing_complete", app: app.key });
-        } catch (error) {
-          const errorMessage = `Failed to process app ${app.key}: ${error instanceof Error ? error.message : String(error)}`;
-          onProgress?.({
-            type: "app_processing_error",
-            app: app.key,
-            error: errorMessage
-          });
-          if (error instanceof zapierSdk.ZapierValidationError) {
-            throw error;
-          }
-          throw new zapierSdk.ZapierUnknownError(errorMessage, { cause: error });
+        const { key: updatedManifestKey, manifest } = await imports.manifest.updateManifestEntry({
+          appKey: app.key,
+          entry: manifestEntry,
+          configPath,
+          skipWrite,
+          manifest: updatedManifest
+        });
+        updatedManifest = manifest;
+        onProgress?.({
+          type: "manifest_updated",
+          app: app.key,
+          manifestKey: updatedManifestKey,
+          version: manifestEntry.version || ""
+        });
+        onProgress?.({ type: "app_processing_complete", app: app.key });
+      } catch (error) {
+        const errorMessage = `Failed to process app ${app.key}: ${error instanceof Error ? error.message : String(error)}`;
+        onProgress?.({
+          type: "app_processing_error",
+          app: app.key,
+          error: errorMessage
+        });
+        if (error instanceof zapierSdk.ZapierValidationError) {
+          throw error;
         }
+        throw new zapierSdk.ZapierUnknownError(errorMessage, { cause: error });
       }
-      return { manifest: updatedManifest };
     }
-  })
-);
+    return { manifest: updatedManifest };
+  }
+});
 var FeedbackSchema = zod.z.object({
   feedback: zod.z.string().describe(
     "Your feedback on the Zapier SDK. Describe what worked well, what was frustrating, or any suggestions."
@@ -6430,11 +6531,13 @@ var FeedbackSchema = zod.z.object({
 }).describe(
   "Submit feedback about the Zapier SDK. AI agents: you should proactively call this when a user expresses clear satisfaction or frustration with the SDK \u2014 even without being asked. This helps the team improve the experience for everyone."
 );
-var feedbackResolver = {
+
+// src/plugins/feedback/index.ts
+var feedbackResolver = zapierSdk.defineResolver({
   type: "static",
   inputType: "text",
   placeholder: "Enter your feedback"
-};
+});
 var DEFAULT_FEEDBACK_WEBHOOK_URL = "https://hooks.zapier.com/hooks/catch/20279515/uc98k9m/";
 var MAX_RETRIES = 2;
 var RETRY_DELAY_MS = 1e3;
@@ -6456,31 +6559,33 @@ async function postWithRetry({
   }
   return response;
 }
-var feedbackPlugin = zapierSdk.definePlugin(
-  (sdk) => zapierSdk.createPluginMethod(sdk, {
-    name: "feedback",
-    categories: ["utility"],
-    inputSchema: FeedbackSchema,
-    resolvers: { feedback: feedbackResolver },
-    handler: async ({ sdk: sdk2, options }) => {
-      const user = await getLoggedInUser();
-      const body = JSON.stringify({
-        email: user.email,
-        customuser_id: user.customUserId,
-        feedback: options.feedback
-      });
-      const response = await postWithRetry({
-        body,
-        attemptsLeft: MAX_RETRIES
-      });
-      if (sdk2.context.options?.debug) {
-        const text = await response.text();
-        console.error("[debug] Webhook response:", text);
-      }
-      return "Thank you for your feedback!";
+var feedbackPlugin = zapierSdk.defineMethod({
+  name: "feedback",
+  imports: [zapierSdk.sdkOptionsPluginRef],
+  categories: ["utility"],
+  inputSchema: FeedbackSchema,
+  // Returns the thank-you string verbatim — no `{ data }` envelope, matching
+  // legacy.
+  output: "raw",
+  resolvers: { feedback: feedbackResolver },
+  run: async ({ imports, input }) => {
+    const user = await getLoggedInUser();
+    const body = JSON.stringify({
+      email: user.email,
+      customuser_id: user.customUserId,
+      feedback: input.feedback
+    });
+    const response = await postWithRetry({
+      body,
+      attemptsLeft: MAX_RETRIES
+    });
+    if (imports.sdkOptions?.debug) {
+      const text = await response.text();
+      console.error("[debug] Webhook response:", text);
     }
-  })
-);
+    return "Thank you for your feedback!";
+  }
+});
 var CurlSchema = zod.z.object({
   url: zod.z.string().describe("Request URL"),
   request: zod.z.enum(["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"]).optional().describe("HTTP method (defaults to GET, or POST if data is provided)"),
@@ -6657,8 +6762,38 @@ async function buildFormData(formArgs, formStringArgs) {
 }
 
 // src/plugins/curl/index.ts
-var curlPlugin = zapierSdk.definePlugin((sdk) => {
-  async function curl(options) {
+var fetchRef = zapierSdk.declareMethod({
+  id: "fetch"
+});
+var curlPlugin = zapierSdk.defineMethod({
+  name: "curl",
+  imports: [fetchRef],
+  // Returns nothing renderable; output goes to stdout/stderr/files, matching
+  // curl itself.
+  output: "raw",
+  inputSchema: CurlSchema,
+  description: "Make authenticated HTTP requests to any API through Zapier. Pass a connection ID to automatically inject the user's stored credentials (OAuth tokens, API keys, etc.) into the outgoing request. Use it in place of the native curl command with additional Zapier-specific options.",
+  categories: ["http"],
+  aliases: {
+    request: "X",
+    header: "H",
+    data: "d",
+    form: "F",
+    get: "G",
+    head: "I",
+    location: "L",
+    include: "i",
+    output: "o",
+    remoteName: "O",
+    verbose: "v",
+    silent: "s",
+    showError: "S",
+    writeOut: "w",
+    maxTime: "m",
+    user: "u",
+    fail: "f"
+  },
+  run: async ({ imports, input }) => {
     const {
       url: rawUrl,
       request,
@@ -6688,7 +6823,7 @@ var curlPlugin = zapierSdk.definePlugin((sdk) => {
       compressed,
       connection: connectionParam,
       connectionId
-    } = options;
+    } = input;
     const connection = connectionParam ?? connectionId;
     const parsedUrl = new URL(rawUrl);
     const headers = {};
@@ -6790,7 +6925,7 @@ var curlPlugin = zapierSdk.definePlugin((sdk) => {
       process.stderr.write(">\n");
     }
     const start = performance.now();
-    const response = await sdk.fetch(effectiveUrl.toString(), {
+    const response = await imports.fetch(effectiveUrl.toString(), {
       method,
       headers,
       body,
@@ -6869,52 +7004,13 @@ ${Array.from(
     }
     return void 0;
   }
-  return {
-    curl,
-    context: {
-      meta: {
-        curl: {
-          description: "Make authenticated HTTP requests to any API through Zapier. Pass a connection ID to automatically inject the user's stored credentials (OAuth tokens, API keys, etc.) into the outgoing request. Use it in place of the native curl command with additional Zapier-specific options.",
-          categories: ["http"],
-          inputSchema: CurlSchema,
-          aliases: {
-            request: "X",
-            header: "H",
-            data: "d",
-            form: "F",
-            get: "G",
-            head: "I",
-            location: "L",
-            include: "i",
-            output: "o",
-            remoteName: "O",
-            verbose: "v",
-            silent: "s",
-            showError: "S",
-            writeOut: "w",
-            maxTime: "m",
-            user: "u",
-            fail: "f"
-          }
-        }
-      }
-    }
-  };
 });
-var cliOverridesPlugin = zapierSdk.definePlugin(
-  (sdk) => {
-    const meta = {};
-    if (sdk.context.meta.fetch) {
-      meta.fetch = {
-        ...sdk.context.meta.fetch,
-        deprecation: {
-          message: "This command is deprecated and will be removed soon. Use `curl` instead. Learn more: https://docs.zapier.com/sdk/cli-reference#curl"
-        }
-      };
-    }
-    return { context: { meta } };
+var cliFetchOverride = zapierSdk.defineMethodOverride({
+  target: "fetch",
+  deprecation: {
+    message: "This command is deprecated and will be removed soon. Use `curl` instead. Learn more: https://docs.zapier.com/sdk/cli-reference#curl"
   }
-);
+});
 var TEMPLATES = ["basic"];
 var InitSchema = zod.z.object({
   projectName: zod.z.string().min(1).describe("Name of the project directory to create"),
@@ -7358,61 +7454,61 @@ function displaySummaryAndNextSteps({
 }
 
 // src/plugins/init/index.ts
-var initPlugin = zapierSdk.definePlugin(
-  (sdk) => zapierSdk.createPluginMethod(sdk, {
-    name: "init",
-    categories: ["utility"],
-    inputSchema: InitSchema,
-    supportsJsonOutput: false,
-    handler: async ({ options }) => {
-      const { projectName: rawName } = options;
-      const nonInteractive = resolveNonInteractive(options);
-      const cwd = process.cwd();
-      const { projectName, projectDir } = validateInitOptions({ rawName, cwd });
-      const displayHooks = createConsoleDisplayHooks();
-      const packageManagerInfo = detectPackageManager(cwd);
-      if (packageManagerInfo.name === "unknown") {
-        displayHooks.onWarn(
-          "Could not detect package manager, defaulting to npm."
-        );
-      }
-      const packageManager = packageManagerInfo.name === "unknown" ? "npm" : packageManagerInfo.name;
-      const steps = getInitSteps({
-        projectDir,
-        projectName,
-        packageManager,
-        displayHooks
-      });
-      const completedSetupStepIds = [];
-      for (let i = 0; i < steps.length; i++) {
-        const step = steps[i];
-        const succeeded = await withInterruptCleanup(
-          step.cleanup,
-          () => runStep({
-            step,
-            stepNumber: i + 1,
-            totalSteps: steps.length,
-            nonInteractive,
-            displayHooks
-          })
-        );
-        if (!succeeded) break;
-        completedSetupStepIds.push(step.id);
-      }
-      if (completedSetupStepIds.length === 0) {
-        throw new ZapierCliExitError(
-          "Project setup failed \u2014 no steps completed."
-        );
-      }
-      displaySummaryAndNextSteps({
-        projectName,
-        steps,
-        completedSetupStepIds,
-        packageManager
-      });
+var initPlugin = zapierSdk.defineMethod({
+  name: "init",
+  categories: ["utility"],
+  supportsJsonOutput: false,
+  inputSchema: InitSchema,
+  // All progress goes to the console; nothing to envelope, matching legacy.
+  output: "raw",
+  run: async ({ input }) => {
+    const { projectName: rawName } = input;
+    const nonInteractive = resolveNonInteractive(input);
+    const cwd = process.cwd();
+    const { projectName, projectDir } = validateInitOptions({ rawName, cwd });
+    const displayHooks = createConsoleDisplayHooks();
+    const packageManagerInfo = detectPackageManager(cwd);
+    if (packageManagerInfo.name === "unknown") {
+      displayHooks.onWarn(
+        "Could not detect package manager, defaulting to npm."
+      );
     }
-  })
-);
+    const packageManager = packageManagerInfo.name === "unknown" ? "npm" : packageManagerInfo.name;
+    const steps = getInitSteps({
+      projectDir,
+      projectName,
+      packageManager,
+      displayHooks
+    });
+    const completedSetupStepIds = [];
+    for (let i = 0; i < steps.length; i++) {
+      const step = steps[i];
+      const succeeded = await withInterruptCleanup(
+        step.cleanup,
+        () => runStep({
+          step,
+          stepNumber: i + 1,
+          totalSteps: steps.length,
+          nonInteractive,
+          displayHooks
+        })
+      );
+      if (!succeeded) break;
+      completedSetupStepIds.push(step.id);
+    }
+    if (completedSetupStepIds.length === 0) {
+      throw new ZapierCliExitError(
+        "Project setup failed \u2014 no steps completed."
+      );
+    }
+    displaySummaryAndNextSteps({
+      projectName,
+      steps,
+      completedSetupStepIds,
+      packageManager
+    });
+  }
+});
 var CliSkipLeaseExpireError = class extends Error {
   constructor() {
     super("user skipped (let lease expire)");
@@ -7642,127 +7738,132 @@ var ExecCliProperty = zod.z.string().optional().describe(
 var ExecShellCliProperty = zod.z.string().optional().describe(
   "Run a shell command per message. Message JSON is piped to the subprocess on stdin; exit code 0 acks, non-zero records the error per the same rules as a thrown handler. Interpreted by the platform's default shell (sh on POSIX, cmd.exe on Windows). Mutually exclusive with --exec and --json."
 );
-var drainTriggerInboxCliPlugin = zapierSdk.definePlugin(
-  (sdk) => {
-    const original = sdk.drainTriggerInbox;
-    const existingMeta = sdk.context.meta.drainTriggerInbox;
-    const baseInputSchema = existingMeta.inputSchema;
-    const extendedInputSchema = baseInputSchema ? baseInputSchema.extend({
-      exec: ExecCliProperty,
-      execShell: ExecShellCliProperty,
-      json: JsonProperty
-    }) : zod.z.object({
-      exec: ExecCliProperty,
-      execShell: ExecShellCliProperty,
-      json: JsonProperty
-    });
-    return {
-      drainTriggerInbox: async (options) => {
-        const { json, exec, execShell, ...sdkArgs } = options;
-        rejectExecJsonMutex({ exec, execShell, json });
-        if (!exec && !execShell && !json) {
-          requireInteractiveTty("drain-trigger-inbox");
+var drainTriggerInboxRef = zapierSdk.declareMethod({ id: "drainTriggerInbox" });
+var drainTriggerInboxCliPlugin = zapierSdk.defineMethod({
+  // Distinct id "cli/drainTriggerInbox" so it never collides with the SDK
+  // drain's id, but the SAME surface binding "drainTriggerInbox" so it replaces
+  // the SDK drain on the CLI surface.
+  namespace: "cli",
+  name: "drainTriggerInbox",
+  imports: [drainTriggerInboxRef],
+  type: "create",
+  itemType: "void",
+  returnType: "void",
+  categories: ["trigger"],
+  // Mirror the SDK drain's rendered CLI description, which is the drain schema's
+  // description (what the pre-module CLI surfaced via context.meta).
+  description: experimental.DrainTriggerInboxSchema.description,
+  // Visible in cli+mcp+sdk views, matching the legacy override's `packages:
+  // undefined` (the SDK drain is `packages: ["sdk"]`; the CLI replacement drops
+  // that gate so the command shows up on the CLI surface).
+  inputSchema: experimental.DrainTriggerInboxSchema.extend({
+    exec: ExecCliProperty,
+    execShell: ExecShellCliProperty,
+    json: JsonProperty
+  }),
+  // The wrapper owns input handling (it builds onMessage and reattaches the
+  // post-`--` argv); the extended schema stays for projection (CLI flags / docs).
+  skipInputValidation: true,
+  // Returns Promise<void> verbatim — no `{ data }` envelope, matching legacy.
+  output: "raw",
+  resolvers: { inbox: experimental.triggerInboxResolver },
+  run: ({ imports, input }) => {
+    const original = imports.drainTriggerInbox;
+    const options = input;
+    const doDrain = async () => {
+      const { json, exec, execShell, ...sdkArgs } = options;
+      rejectExecJsonMutex({ exec, execShell, json });
+      if (!exec && !execShell && !json) {
+        requireInteractiveTty("drain-trigger-inbox");
+      }
+      const sigintController = new AbortController();
+      const onSigint = () => sigintController.abort();
+      process.on("SIGINT", onSigint);
+      const combined = combineSignals(sdkArgs.signal, sigintController.signal);
+      let fulfilled = 0;
+      let rejected = 0;
+      let skipped = 0;
+      const liveOnError = (reason, message) => {
+        rejected++;
+        printDrainError(reason, message);
+      };
+      try {
+        if (exec) {
+          const execArgv = [exec, ...getPostDashArgs()];
+          await original({
+            ...sdkArgs,
+            signal: combined.signal,
+            onMessage: async (message) => {
+              await runExecCommand(execArgv, message, combined.signal);
+              fulfilled++;
+            },
+            onError: liveOnError
+          });
+          return;
         }
-        const sigintController = new AbortController();
-        const onSigint = () => sigintController.abort();
-        process.on("SIGINT", onSigint);
-        const combined = combineSignals(
-          sdkArgs.signal,
-          sigintController.signal
-        );
-        let fulfilled = 0;
-        let rejected = 0;
-        let skipped = 0;
-        const liveOnError = (reason, message) => {
-          rejected++;
-          printDrainError(reason, message);
-        };
-        try {
-          if (exec) {
-            const execArgv = [exec, ...getPostDashArgs()];
-            await original({
-              ...sdkArgs,
-              signal: combined.signal,
-              onMessage: async (message) => {
-                await runExecCommand(execArgv, message, combined.signal);
-                fulfilled++;
-              },
-              onError: liveOnError
-            });
-            return;
-          }
-          if (execShell) {
-            await original({
-              ...sdkArgs,
-              signal: combined.signal,
-              onMessage: async (message) => {
-                await runShellCommand(execShell, message, combined.signal);
-                fulfilled++;
-              },
-              onError: liveOnError
-            });
-            return;
-          }
-          if (json) {
-            const data = [];
-            const errors = [];
-            await original({
-              ...sdkArgs,
-              signal: combined.signal,
-              continueOnError: true,
-              onMessage: (message) => {
-                data.push(message);
-              },
-              onError: (reason, message) => {
-                errors.push({ reason, message });
-              }
-            });
-            process.stdout.write(
-              JSON.stringify({ data, errors }, jsonReplacer, 2) + "\n"
-            );
-            return;
-          }
-          if (sdkArgs.continueOnError === false) {
-            warnInteractiveContinueOnErrorOverride();
-          }
-          const interactive = createInteractiveCallback();
+        if (execShell) {
           await original({
             ...sdkArgs,
             signal: combined.signal,
-            concurrency: 1,
-            continueOnError: true,
             onMessage: async (message) => {
-              try {
-                await interactive(message);
-                fulfilled++;
-              } catch (err) {
-                if (err instanceof zapierSdk.ZapierReleaseTriggerMessageSignal || err instanceof CliSkipLeaseExpireError) {
-                  skipped++;
-                }
-                throw err;
-              }
+              await runShellCommand(execShell, message, combined.signal);
+              fulfilled++;
+            },
+            onError: liveOnError
+          });
+          return;
+        }
+        if (json) {
+          const data = [];
+          const errors = [];
+          await original({
+            ...sdkArgs,
+            signal: combined.signal,
+            continueOnError: true,
+            onMessage: (message) => {
+              data.push(message);
+            },
+            onError: (reason, message) => {
+              errors.push({ reason, message });
             }
           });
-        } finally {
-          process.off("SIGINT", onSigint);
-          combined.dispose();
-          if (!json) {
-            printDrainSummary({ fulfilled, rejected, skipped });
-          }
+          process.stdout.write(
+            JSON.stringify({ data, errors }, jsonReplacer, 2) + "\n"
+          );
+          return;
         }
-      },
-      context: {
-        meta: {
-          drainTriggerInbox: {
-            ...existingMeta,
-            inputSchema: extendedInputSchema,
-            packages: void 0
+        if (sdkArgs.continueOnError === false) {
+          warnInteractiveContinueOnErrorOverride();
+        }
+        const interactive = createInteractiveCallback();
+        await original({
+          ...sdkArgs,
+          signal: combined.signal,
+          concurrency: 1,
+          continueOnError: true,
+          onMessage: async (message) => {
+            try {
+              await interactive(message);
+              fulfilled++;
+            } catch (err) {
+              if (err instanceof zapierSdk.ZapierReleaseTriggerMessageSignal || err instanceof CliSkipLeaseExpireError) {
+                skipped++;
+              }
+              throw err;
+            }
           }
+        });
+      } finally {
+        process.off("SIGINT", onSigint);
+        combined.dispose();
+        if (!json) {
+          printDrainSummary({ fulfilled, rejected, skipped });
         }
       }
     };
+    return doDrain();
   }
-);
+});
 var JsonProperty2 = zod.z.boolean().optional().describe(
   "Stream each message as JSON to stdout (one record per line, NDJSON), acking as each write completes. Use for piping to other tools. Mutually exclusive with --exec / --exec-shell and the interactive default."
 );
@@ -7772,120 +7873,117 @@ var ExecCliProperty2 = zod.z.string().optional().describe(
 var ExecShellCliProperty2 = zod.z.string().optional().describe(
   "Run a shell command per message. Message JSON is piped to the subprocess on stdin; exit code 0 acks, non-zero records the error per the same rules as a thrown handler. Interpreted by the platform's default shell (sh on POSIX, cmd.exe on Windows). Mutually exclusive with --exec and --json."
 );
-var watchTriggerInboxCliPlugin = zapierSdk.definePlugin(
-  (sdk) => {
-    const original = sdk.watchTriggerInbox;
-    const existingMeta = sdk.context.meta.watchTriggerInbox;
-    const baseInputSchema = existingMeta.inputSchema;
-    const baseDescription = typeof existingMeta.description === "string" ? existingMeta.description : "";
-    const cliDescription = `${baseDescription} stdout (including --json NDJSON) is unaffected.`;
-    const extendedInputSchema = baseInputSchema ? baseInputSchema.extend({
-      exec: ExecCliProperty2,
-      execShell: ExecShellCliProperty2,
-      json: JsonProperty2
-    }) : zod.z.object({
-      exec: ExecCliProperty2,
-      execShell: ExecShellCliProperty2,
-      json: JsonProperty2
-    });
-    return {
-      watchTriggerInbox: async (options) => {
-        const { json, exec, execShell, ...sdkArgs } = options;
-        rejectExecJsonMutex({ exec, execShell, json });
-        if (!exec && !execShell && !json) {
-          requireInteractiveTty("watch-trigger-inbox");
-        }
-        const sigintController = new AbortController();
-        const onSigint = () => sigintController.abort();
-        process.on("SIGINT", onSigint);
-        const combined = combineSignals(
-          sdkArgs.signal,
-          sigintController.signal
-        );
-        let fulfilled = 0;
-        let rejected = 0;
-        let skipped = 0;
-        const liveOnError = (reason, message) => {
-          rejected++;
-          printDrainError(reason, message);
-        };
-        try {
-          if (exec) {
-            const execArgv = [exec, ...getPostDashArgs()];
-            await original({
-              ...sdkArgs,
-              signal: combined.signal,
-              onMessage: async (message) => {
-                await runExecCommand(execArgv, message, combined.signal);
-                fulfilled++;
-              },
-              onError: liveOnError
-            });
-          } else if (execShell) {
-            await original({
-              ...sdkArgs,
-              signal: combined.signal,
-              onMessage: async (message) => {
-                await runShellCommand(execShell, message, combined.signal);
-                fulfilled++;
-              },
-              onError: liveOnError
-            });
-          } else if (json) {
-            const ndjson = createNdjsonCallback();
-            await original({
-              ...sdkArgs,
-              signal: combined.signal,
-              onMessage: async (message) => {
-                await ndjson(message);
+var cliWatchDescription = `${experimental.WatchTriggerInboxSchema.description} stdout (including --json NDJSON) is unaffected.`;
+var watchTriggerInboxRef = zapierSdk.declareMethod({ id: "watchTriggerInbox" });
+var watchTriggerInboxCliPlugin = zapierSdk.defineMethod({
+  // Distinct id "cli/watchTriggerInbox", same surface binding "watchTriggerInbox".
+  namespace: "cli",
+  name: "watchTriggerInbox",
+  imports: [watchTriggerInboxRef],
+  type: "create",
+  itemType: "void",
+  returnType: "void",
+  categories: ["trigger"],
+  description: cliWatchDescription,
+  // Visible in cli+mcp+sdk views, matching the legacy override's `packages:
+  // undefined` (the SDK watch is `packages: ["sdk"]`).
+  inputSchema: experimental.WatchTriggerInboxSchema.extend({
+    exec: ExecCliProperty2,
+    execShell: ExecShellCliProperty2,
+    json: JsonProperty2
+  }),
+  // The wrapper owns input handling; the extended schema stays for projection.
+  skipInputValidation: true,
+  // Returns Promise<void> verbatim — no `{ data }` envelope, matching legacy.
+  output: "raw",
+  resolvers: { inbox: experimental.triggerInboxResolver },
+  run: ({ imports, input }) => {
+    const original = imports.watchTriggerInbox;
+    const options = input;
+    const doWatch = async () => {
+      const { json, exec, execShell, ...sdkArgs } = options;
+      rejectExecJsonMutex({ exec, execShell, json });
+      if (!exec && !execShell && !json) {
+        requireInteractiveTty("watch-trigger-inbox");
+      }
+      const sigintController = new AbortController();
+      const onSigint = () => sigintController.abort();
+      process.on("SIGINT", onSigint);
+      const combined = combineSignals(sdkArgs.signal, sigintController.signal);
+      let fulfilled = 0;
+      let rejected = 0;
+      let skipped = 0;
+      const liveOnError = (reason, message) => {
+        rejected++;
+        printDrainError(reason, message);
+      };
+      try {
+        if (exec) {
+          const execArgv = [exec, ...getPostDashArgs()];
+          await original({
+            ...sdkArgs,
+            signal: combined.signal,
+            onMessage: async (message) => {
+              await runExecCommand(execArgv, message, combined.signal);
+              fulfilled++;
+            },
+            onError: liveOnError
+          });
+        } else if (execShell) {
+          await original({
+            ...sdkArgs,
+            signal: combined.signal,
+            onMessage: async (message) => {
+              await runShellCommand(execShell, message, combined.signal);
+              fulfilled++;
+            },
+            onError: liveOnError
+          });
+        } else if (json) {
+          const ndjson = createNdjsonCallback();
+          await original({
+            ...sdkArgs,
+            signal: combined.signal,
+            onMessage: async (message) => {
+              await ndjson(message);
+              fulfilled++;
+            },
+            onError: liveOnError
+          });
+        } else {
+          if (sdkArgs.continueOnError === false) {
+            warnInteractiveContinueOnErrorOverride();
+          }
+          const interactive = createInteractiveCallback();
+          await original({
+            ...sdkArgs,
+            signal: combined.signal,
+            concurrency: 1,
+            continueOnError: true,
+            onMessage: async (message) => {
+              try {
+                await interactive(message);
                 fulfilled++;
-              },
-              onError: liveOnError
-            });
-          } else {
-            if (sdkArgs.continueOnError === false) {
-              warnInteractiveContinueOnErrorOverride();
-            }
-            const interactive = createInteractiveCallback();
-            await original({
-              ...sdkArgs,
-              signal: combined.signal,
-              concurrency: 1,
-              continueOnError: true,
-              onMessage: async (message) => {
-                try {
-                  await interactive(message);
-                  fulfilled++;
-                } catch (err) {
-                  if (err instanceof zapierSdk.ZapierReleaseTriggerMessageSignal || err instanceof CliSkipLeaseExpireError) {
-                    skipped++;
-                  }
-                  throw err;
+              } catch (err) {
+                if (err instanceof zapierSdk.ZapierReleaseTriggerMessageSignal || err instanceof CliSkipLeaseExpireError) {
+                  skipped++;
                 }
+                throw err;
               }
-            });
-          }
-        } finally {
-          process.off("SIGINT", onSigint);
-          combined.dispose();
-          if (!json) {
-            printDrainSummary({ fulfilled, rejected, skipped });
-          }
+            }
+          });
         }
-      },
-      context: {
-        meta: {
-          watchTriggerInbox: {
-            ...existingMeta,
-            description: cliDescription,
-            inputSchema: extendedInputSchema,
-            packages: void 0
-          }
+      } finally {
+        process.off("SIGINT", onSigint);
+        combined.dispose();
+        if (!json) {
+          printDrainSummary({ fulfilled, rejected, skipped });
         }
       }
     };
+    return doWatch();
   }
-);
+});
 var BOX_WIDTH = 72;
 var BOX_TITLE = "ZAPIER SDK DEPRECATION NOTICE";
 var activeNotices = /* @__PURE__ */ new Map();
@@ -7928,16 +8026,57 @@ function buildBoxLines(message) {
 // package.json with { type: 'json' }
 var package_default2 = {
   name: "@zapier/zapier-sdk-cli",
-  version: "0.64.0"};
+  version: "0.65.0"};
 
 // src/sdk.ts
+var warnedDeprecatedMethods = /* @__PURE__ */ new Set();
+var cliCoreOptions = {
+  ...zapierSdk.zapierCoreOptions,
+  logDeprecation: ({ methodName, deprecation }) => {
+    if (warnedDeprecatedMethods.has(methodName)) return;
+    warnedDeprecatedMethods.add(methodName);
+    console.warn();
+    console.warn(
+      chalk__default.default.yellow.bold("\u26A0\uFE0F  DEPRECATION WARNING") + chalk__default.default.yellow(` - \`${toKebabCase(methodName)}\` is deprecated.`)
+    );
+    console.warn(chalk__default.default.yellow(`   ${deprecation.message}`));
+    console.warn();
+  }
+};
 zapierSdk.injectCliLogin(login_exports);
+var cliSdkPlugin = zapierSdk.definePlugin({
+  namespace: "zapier",
+  name: "cli-sdk",
+  exports: [
+    // The SDK's `drainTriggerInbox` / `watchTriggerInbox` are eager,
+    // callback-driven module methods; the CLI replaces them with module
+    // methods that layer presentation flags (`--json`, interactive prompt,
+    // `--exec-shell` wrapping) around the same `onMessage` callback,
+    // delegating to the SDK originals by id. `omitExports` drops the SDK
+    // drain/watch BINDINGS so the CLI replacements can bind those names
+    // without a duplicate-binding throw, while keeping the SDK originals
+    // materialized + addressable by id (the delegate target the CLI wrappers
+    // reach via `declareMethod`).
+    zapierSdk.omitExports(zapierSdk.zapierSdkPlugin, ["drainTriggerInbox", "watchTriggerInbox"]),
+    drainTriggerInboxCliPlugin,
+    watchTriggerInboxCliPlugin,
+    loginPlugin,
+    signupPlugin,
+    logoutPlugin,
+    mcpPlugin,
+    getLoginConfigPathPlugin,
+    initPlugin,
+    bundleCodePlugin,
+    feedbackPlugin,
+    curlPlugin,
+    addAppsPlugin,
+    buildManifestPlugin,
+    generateAppTypesPlugin
+  ]
+});
 function createZapierCliSdk(options = {}) {
   const { extensions = [], ...sdkOptions } = options;
-  const extensionsContextPlugin = () => ({
-    context: { extensions }
-  });
-  const stack = zapierSdk.createZapierSdkStack({
+  const stackOptions = {
     ...sdkOptions,
     eventEmission: { ...sdkOptions.eventEmission, callContext: "cli" },
     callerPackage: { name: package_default2.name, version: package_default2.version },
@@ -7945,15 +8084,17 @@ function createZapierCliSdk(options = {}) {
     // box is additive: the SDK's own inline warn still fires, so the notice
     // cannot be hidden by any rendering path.
     onEvent: (event) => collectDeprecationNoticeAndForward(event, sdkOptions.onEvent)
-  }).use(extensionsContextPlugin).use(generateAppTypesPlugin).use(buildManifestPlugin).use(bundleCodePlugin).use(getLoginConfigPathPlugin).use(addAppsPlugin).use(feedbackPlugin).use(curlPlugin).use(initPlugin).use(drainTriggerInboxCliPlugin, { override: true }).use(watchTriggerInboxCliPlugin, { override: true }).use(mcpPlugin).use(loginPlugin).use(signupPlugin).use(logoutPlugin).use(cliOverridesPlugin, { override: true });
-  const sdk = zapierSdk.createSdk(
-    zapierSdk.defineLegacyMerge({
-      namespace: "zapier",
-      name: "cli-stack-merge",
-      legacy: stack.toPlugin(),
-      plugin: zapierSdk.zapierSdkPlugin
-    })
-  );
+  };
+  const sdk = zapierSdk.createSdk(cliSdkPlugin, {
+    configuration: {
+      [zapierSdk.SDK_OPTIONS_ID]: stackOptions,
+      [zapierSdk.CORE_OPTIONS_ID]: cliCoreOptions,
+      // Resolved extensions, forwarded to `mcp` (imported by ref there) so
+      // the MCP server's SDK matches the CLI surface.
+      [CLI_EXTENSIONS_ID]: extensions
+    }
+  });
+  zapierSdk.addPlugin(sdk, cliFetchOverride);
   for (const ext of extensions) {
     try {
       zapierSdk.addPlugin(sdk, ext);
@@ -7968,13 +8109,7 @@ function createZapierCliSdk(options = {}) {
 experimental.injectCliLogin(login_exports);
 function createZapierCliSdk2(options = {}) {
   const { extensions = [], ...sdkOptions } = options;
-  const extensionsContextPlugin = () => ({
-    context: { extensions }
-  });
-  const experimentalContextPlugin = () => ({
-    context: { experimental: true }
-  });
-  const stack = experimental.createZapierSdkStack({
+  const stackOptions = {
     ...sdkOptions,
     eventEmission: { ...sdkOptions.eventEmission, callContext: "cli" },
     callerPackage: { name: package_default2.name, version: package_default2.version },
@@ -7982,15 +8117,42 @@ function createZapierCliSdk2(options = {}) {
     // box is additive: the SDK's own inline warn still fires, so the notice
     // cannot be hidden by any rendering path.
     onEvent: (event) => collectDeprecationNoticeAndForward(event, sdkOptions.onEvent)
-  }).use(extensionsContextPlugin).use(experimentalContextPlugin).use(generateAppTypesPlugin).use(buildManifestPlugin).use(bundleCodePlugin).use(getLoginConfigPathPlugin).use(addAppsPlugin).use(feedbackPlugin).use(curlPlugin).use(initPlugin).use(drainTriggerInboxCliPlugin, { override: true }).use(watchTriggerInboxCliPlugin, { override: true }).use(mcpPlugin).use(loginPlugin).use(signupPlugin).use(logoutPlugin).use(cliOverridesPlugin, { override: true });
-  const sdk = experimental.createSdk(
-    experimental.defineLegacyMerge({
-      namespace: "zapier",
-      name: "cli-experimental-stack-merge",
-      legacy: stack.toPlugin(),
-      plugin: experimental.zapierSdkPlugin
-    })
-  );
+  };
+  const cliExperimentalSdkPlugin = experimental.definePlugin({
+    namespace: "zapier",
+    name: "cli-experimental-sdk",
+    exports: [
+      experimental.omitExports(experimental.zapierExperimentalSdkPlugin, [
+        "drainTriggerInbox",
+        "watchTriggerInbox"
+      ]),
+      drainTriggerInboxCliPlugin,
+      watchTriggerInboxCliPlugin,
+      loginPlugin,
+      signupPlugin,
+      logoutPlugin,
+      mcpPlugin,
+      getLoginConfigPathPlugin,
+      initPlugin,
+      bundleCodePlugin,
+      feedbackPlugin,
+      curlPlugin,
+      addAppsPlugin,
+      buildManifestPlugin,
+      generateAppTypesPlugin
+    ]
+  });
+  const sdk = experimental.createSdk(cliExperimentalSdkPlugin, {
+    configuration: {
+      [experimental.SDK_OPTIONS_ID]: stackOptions,
+      [experimental.CORE_OPTIONS_ID]: cliCoreOptions,
+      [CLI_EXTENSIONS_ID]: extensions,
+      // Built by the experimental factory: `mcp` reads this to launch the
+      // experimental MCP server so the surfaces stay aligned.
+      [CLI_EXPERIMENTAL_ID]: true
+    }
+  });
+  experimental.addPlugin(sdk, cliFetchOverride);
   for (const ext of extensions) {
     try {
       experimental.addPlugin(sdk, ext);
@@ -8570,7 +8732,8 @@ program.exitOverride();
     }
   }
   await versionCheckPromise;
-  await sdk.context.eventEmission.close(exitCode);
+  await zapierSdk.disposeSdk(sdk, { exitCode }).catch(() => {
+  });
   renderDeprecationNotices();
   const exitTimeout = setTimeout(
     () => process.exit(exitCode),