@zapier/zapier-sdk 0.9.0 → 0.11.0

package/src/plugins/listApps/index.ts

@@ -3,6 +3,7 @@ import { createPaginatedFunction } from "../../utils/function-utils";
 import { ListAppsSchema } from "./schemas";
 import type { ListAppsOptions, ListAppsPage } from "./schemas";
 import type { AppItem } from "../../types/domain";
+import { AppItemSchema } from "../../schemas/App";
 import type { ResolvedAppLocator } from "../../utils/domain-utils";
 import {
   normalizeImplementationMetaToAppItem,
@@ -135,7 +136,10 @@ export const listAppsPlugin: Plugin<
       meta: {
         listApps: {
           categories: ["app"],
+          type: "list",
+          itemType: "App",
           inputSchema: ListAppsSchema,
+          outputSchema: AppItemSchema,
         },
       },
     },

package/src/plugins/listApps/schemas.ts

@@ -2,8 +2,6 @@ import { z } from "zod";
 import type { AppItem } from "../../types/domain";
 import type { PaginatedSdkFunction } from "../../types/functions";
 import type { ZapierApiError, ZapierValidationError } from "../../types/errors";
-import { AppItemSchema } from "../../schemas/App";
-import { withOutputSchema } from "../../utils/schema-utils";
 
 // Union of all possible errors for listApps
 export type ListAppsError = ZapierApiError | ZapierValidationError;
@@ -15,30 +13,23 @@ export interface ListAppsPage {
 }
 
 // Pure Zod schema - no pagination metadata exposed
-export const ListAppsSchema = withOutputSchema(
-  z
-    .object({
-      appKeys: z
-        .array(z.string())
-        .optional()
-        .describe(
-          "Filter apps by app keys (e.g., 'SlackCLIAPI' or slug like 'github')",
-        ),
-      search: z.string().optional().describe("Search for apps by name"),
-      pageSize: z
-        .number()
-        .min(1)
-        .optional()
-        .describe("Number of apps per page"),
-      maxItems: z
-        .number()
-        .min(1)
-        .optional()
-        .describe("Maximum total items to return across all pages"),
-    })
-    .describe("List all available apps with optional filtering"),
-  AppItemSchema,
-);
+export const ListAppsSchema = z
+  .object({
+    appKeys: z
+      .array(z.string())
+      .optional()
+      .describe(
+        "Filter apps by app keys (e.g., 'SlackCLIAPI' or slug like 'github')",
+      ),
+    search: z.string().optional().describe("Search for apps by name"),
+    pageSize: z.number().min(1).optional().describe("Number of apps per page"),
+    maxItems: z
+      .number()
+      .min(1)
+      .optional()
+      .describe("Maximum total items to return across all pages"),
+  })
+  .describe("List all available apps with optional filtering");
 
 // Type inferred from schema
 export type ListAppsOptions = z.infer<typeof ListAppsSchema>;

package/src/plugins/listAuthentications/index.ts

@@ -18,6 +18,8 @@ import {
 } from "../../utils/function-utils";
 import type { GetVersionedImplementationId } from "../manifest/schemas";
 import type { ManifestPluginProvides } from "../manifest";
+import { appKeyResolver } from "../../resolvers";
+import { AuthenticationItemSchema } from "../../schemas/Auth";
 
 export interface ListAuthenticationsPluginProvides {
   listAuthentications: (options?: ListAuthenticationsOptions) => Promise<{
@@ -135,7 +137,13 @@ export const listAuthenticationsPlugin: Plugin<
       meta: {
         listAuthentications: {
           categories: ["authentication"],
+          type: "list",
+          itemType: "Authentication",
           inputSchema: ListAuthenticationsSchema,
+          outputSchema: AuthenticationItemSchema,
+          resolvers: {
+            appKey: appKeyResolver,
+          },
         },
       },
     },

package/src/plugins/listInputFieldChoices/index.ts

@@ -10,10 +10,19 @@ import {
   ListInputFieldChoicesSchema,
   type ListInputFieldChoicesOptions,
   type ListInputFieldChoicesPage,
+  InputFieldChoiceItemSchema,
 } from "./schemas";
 import { ZapierApiError } from "../../types/errors";
 import { createPaginatedFunction } from "../../utils/function-utils";
 import type { GetActionPluginProvides } from "../getAction";
+import {
+  appKeyResolver,
+  actionTypeResolver,
+  actionKeyResolver,
+  authenticationIdResolver,
+  inputFieldKeyResolver,
+  inputsAllOptionalResolver,
+} from "../../resolvers";
 
 // Transform NeedChoices to InputFieldChoiceItem
 function transformNeedChoicesToInputFieldChoiceItem(
@@ -116,7 +125,7 @@ export const listInputFieldChoicesPlugin: Plugin<
 
     // Handle pagination
     let nextCursor: string | undefined;
-    if (choicesData.next_page !== undefined) {
+    if (choicesData.next_page != null) {
       nextCursor = choicesData.next_page.toString();
     } else if (choicesData.links?.next) {
       // Extract page from next URL for external actions
@@ -144,7 +153,18 @@ export const listInputFieldChoicesPlugin: Plugin<
       meta: {
         listInputFieldChoices: {
           categories: ["action"],
+          type: "list",
+          itemType: "InputFieldChoice",
           inputSchema: ListInputFieldChoicesSchema,
+          outputSchema: InputFieldChoiceItemSchema,
+          resolvers: {
+            appKey: appKeyResolver,
+            actionType: actionTypeResolver,
+            actionKey: actionKeyResolver,
+            authenticationId: authenticationIdResolver,
+            inputFieldKey: inputFieldKeyResolver,
+            inputs: inputsAllOptionalResolver,
+          },
         },
       },
     },

package/src/plugins/listInputFieldChoices/schemas.ts

@@ -6,7 +6,8 @@ import {
   ActionKeyPropertySchema,
   InputsPropertySchema,
 } from "../../types/properties";
-import { withFormatter, withOutputSchema } from "../../utils/schema-utils";
+import { withFormatter } from "../../utils/schema-utils";
+import { NeedChoicesSchema } from "../../api/schemas";
 import type { PaginatedSdkFunction } from "../../types/functions";
 import type {
   ZapierConfigurationError,
@@ -21,46 +22,33 @@ import type {
 // Input Field Choice Item Schema
 // ============================================================================
 
-export const InputFieldChoiceItemSchema = withFormatter(
-  z.object({
-    key: z.string().optional().describe("Unique key/value for the choice"),
-    label: z
-      .string()
-      .optional()
-      .describe("Human readable label for the choice"),
-    sample: z.string().optional().describe("Sample value for the choice"),
-    value: z
-      .string()
-      .optional()
-      .describe("Value to be submitted when selected"),
-  }),
-  {
-    format: (item) => {
-      const title = item.label || item.key || "Choice";
-      const subtitle =
-        item.label && item.key && item.label !== item.key
-          ? `(${item.key})`
-          : undefined;
-      const details: Array<{
-        text: string;
-        style: "success" | "dim" | "normal" | "accent" | "warning";
-      }> = [];
+export const InputFieldChoiceItemSchema = withFormatter(NeedChoicesSchema, {
+  format: (item) => {
+    const title = item.label || item.key || "Choice";
+    const details: Array<{
+      text: string;
+      style: "success" | "dim" | "normal" | "accent" | "warning";
+    }> = [];
+
+    // Show key as detail if different from label
+    if (item.label && item.key && item.label !== item.key) {
+      details.push({ text: `Key: ${item.key}`, style: "dim" });
+    }
 
-      if (item.sample && item.sample !== item.key) {
-        details.push({ text: `Sample: ${item.sample}`, style: "dim" });
-      }
-      if (item.value && item.value !== item.key) {
-        details.push({ text: `Value: ${item.value}`, style: "normal" });
-      }
+    if (item.sample && item.sample !== item.key) {
+      details.push({ text: `Sample: ${item.sample}`, style: "dim" });
+    }
+    if (item.value && item.value !== item.key) {
+      details.push({ text: `Value: ${item.value}`, style: "normal" });
+    }
 
-      return {
-        title,
-        subtitle,
-        details,
-      };
-    },
+    return {
+      title,
+      key: item.key,
+      details,
+    };
   },
-);
+});
 
 export type InputFieldChoiceItem = z.infer<typeof InputFieldChoiceItemSchema>;
 
@@ -68,47 +56,44 @@ export type InputFieldChoiceItem = z.infer<typeof InputFieldChoiceItemSchema>;
 // Plugin Schema Definition
 // ============================================================================
 
-export const ListInputFieldChoicesSchema = withOutputSchema(
-  z
-    .object({
-      // Required action identification
-      appKey: AppKeyPropertySchema,
-      actionType: ActionTypePropertySchema,
-      actionKey: ActionKeyPropertySchema,
+export const ListInputFieldChoicesSchema = z
+  .object({
+    // Required action identification
+    appKey: AppKeyPropertySchema,
+    actionType: ActionTypePropertySchema,
+    actionKey: ActionKeyPropertySchema,
 
-      // Input field specification
-      inputFieldKey: z
-        .string()
-        .min(1)
-        .describe("Input field key to get choices for."),
+    // Input field specification
+    inputFieldKey: z
+      .string()
+      .min(1)
+      .describe("Input field key to get choices for."),
 
-      // Common parameters
-      authenticationId: AuthenticationIdPropertySchema.nullable().optional(),
-      inputs: InputsPropertySchema.optional().describe(
-        "Current input values that may affect available choices",
-      ),
-      page: z
-        .number()
-        .int()
-        .min(0)
-        .optional()
-        .describe("Page number for paginated results"),
+    // Common parameters
+    authenticationId: AuthenticationIdPropertySchema.nullable().optional(),
+    inputs: InputsPropertySchema.optional().describe(
+      "Current input values that may affect available choices",
+    ),
+    page: z
+      .number()
+      .int()
+      .min(0)
+      .optional()
+      .describe("Page number for paginated results"),
 
-      // Pagination options (SDK-level)
-      pageSize: z
-        .number()
-        .min(1)
-        .optional()
-        .describe("Number of choices per page"),
-      maxItems: z
-        .number()
-        .min(1)
-        .optional()
-        .describe("Maximum total items to return across all pages"),
-    })
-    .describe("Get the available choices for a dynamic dropdown input field"),
-  InputFieldChoiceItemSchema,
-);
+    // Pagination options (SDK-level)
+    pageSize: z
+      .number()
+      .min(1)
+      .optional()
+      .describe("Number of choices per page"),
+    maxItems: z
+      .number()
+      .min(1)
+      .optional()
+      .describe("Maximum total items to return across all pages"),
+  })
+  .describe("Get the available choices for a dynamic dropdown input field");
 
 // Type inferred from schema
 export type ListInputFieldChoicesOptions = z.infer<

package/src/plugins/listInputFields/index.test.ts

@@ -217,7 +217,7 @@ describe("listInputFields plugin", () => {
       // Check message field transformation
       expect(result.data[0]).toEqual(
         expect.objectContaining({
-          id: "message",
+          key: "message",
           title: "Message",
           description: "The message to send",
           is_required: true,
@@ -227,26 +227,22 @@ describe("listInputFields plugin", () => {
         }),
       );
 
-      // Check channel field with choices (SELECT format)
+      // Check channel field with SELECT format
       expect(result.data[1]).toEqual(
         expect.objectContaining({
-          id: "channel",
+          key: "channel",
           title: "Channel",
           description: "The channel to send to",
           is_required: true,
           value_type: "STRING",
           format: "SELECT",
-          choices: [
-            { value: "#general", label: "General", sample: "#general" },
-            { value: "#random", label: "Random", sample: "#random" },
-          ],
         }),
       );
 
       // Check array field
       expect(result.data[2]).toEqual(
         expect.objectContaining({
-          id: "tags",
+          key: "tags",
           title: "Tags",
           description: "List of tags",
           value_type: "ARRAY",
@@ -405,7 +401,7 @@ describe("listInputFields plugin", () => {
       }
 
       expect(items).toHaveLength(3);
-      expect(items[0].id).toBe("message");
+      expect(items[0].key).toBe("message");
     });
   });
 });

package/src/plugins/listInputFields/index.ts

@@ -1,7 +1,12 @@
 import type { Plugin, GetSdkType } from "../../types/plugin";
 import type { ApiClient } from "../../api";
 import type { NeedsRequest, NeedsResponse, Need } from "../../api/types";
-import type { InputFieldItem } from "../../types/domain";
+import type {
+  InputFieldItem,
+  InfoFieldItem,
+  FieldsetItem,
+  RootFieldItem,
+} from "../../types/domain";
 import {
   ListInputFieldsSchema,
   type ListInputFieldsOptions,
@@ -11,6 +16,15 @@ import { ZapierConfigurationError, ZapierApiError } from "../../types/errors";
 import { createPaginatedFunction } from "../../utils/function-utils";
 import type { GetAppPluginProvides } from "../getApp";
 import type { GetVersionedImplementationId } from "../manifest/schemas";
+import {
+  appKeyResolver,
+  actionTypeResolver,
+  actionKeyResolver,
+  authenticationIdResolver,
+  inputsAllOptionalResolver,
+} from "../../resolvers";
+import { RootFieldItemSchema } from "../../schemas/Field";
+import { toTitleCase } from "../../utils/string-utils";
 
 // Enums for input field transformation
 enum InputFieldType {
@@ -93,8 +107,8 @@ function transformNeedToInputFieldItem(need: Need): InputFieldItem {
   const itemsType = getItemsTypeFromNeed(need);
 
   return {
-    ...need, // Pass through all original Need fields
-    id: need.key,
+    type: "input_field",
+    key: need.key,
     default_value: need.default || "",
     depends_on: need.depends_on || [],
     description: need.help_text || "",
@@ -108,12 +122,68 @@ function transformNeedToInputFieldItem(need: Need): InputFieldItem {
   };
 }
 
+// Transform Need to InfoFieldItem (for copy fields)
+function transformNeedToInfoFieldItem(need: Need): InfoFieldItem {
+  return {
+    type: "info_field",
+    key: need.key,
+    description: need.help_text || "",
+    title: need.label,
+  };
+}
+
+// Transform needs to fields (similar to partnerapi compute_root_fieldset_from_needs)
+function transformNeedsToFields(needs: Need[]): RootFieldItem[] {
+  const rootFields: (InputFieldItem | InfoFieldItem | FieldsetItem)[] = [];
+  const fieldsetMap = new Map<string, FieldsetItem>();
+
+  for (const need of needs) {
+    if (need.computed) {
+      // Computed needs (i.e zap_id for CodeAPI steps) are not shown by the
+      // editor, hide them here too.
+      continue;
+    }
+
+    // If parent_key is set, we need to ensure that a corresponding
+    // fieldset exists, since we'll be adding this need to that fieldset
+    if (need.parent_key) {
+      let fieldset = fieldsetMap.get(need.parent_key);
+      if (!fieldset) {
+        fieldset = {
+          type: "fieldset",
+          key: need.parent_key,
+          title: toTitleCase(need.parent_key),
+          fields: [],
+        };
+        fieldsetMap.set(need.parent_key, fieldset);
+        rootFields.push(fieldset);
+      }
+
+      // Add field to fieldset
+      if (need.type === "copy" && need.help_text) {
+        fieldset.fields.push(transformNeedToInfoFieldItem(need));
+      } else {
+        fieldset.fields.push(transformNeedToInputFieldItem(need));
+      }
+    } else {
+      // Add field to root
+      if (need.type === "copy" && need.help_text) {
+        rootFields.push(transformNeedToInfoFieldItem(need));
+      } else {
+        rootFields.push(transformNeedToInputFieldItem(need));
+      }
+    }
+  }
+
+  return rootFields;
+}
+
 export interface ListInputFieldsPluginProvides {
   listInputFields: (options?: ListInputFieldsOptions) => Promise<{
-    data: InputFieldItem[];
+    data: RootFieldItem[];
   }> &
-    AsyncIterable<{ data: InputFieldItem[]; nextCursor?: string }> & {
-      items(): AsyncIterable<InputFieldItem>;
+    AsyncIterable<{ data: RootFieldItem[]; nextCursor?: string }> & {
+      items(): AsyncIterable<InputFieldItem | InfoFieldItem | FieldsetItem>;
     };
   context: {
     meta: {
@@ -181,13 +251,11 @@ export const listInputFieldsPlugin: Plugin<
         );
       }
 
-      // Transform Need objects to InputFieldItem objects
-      const inputFields: InputFieldItem[] = (needsData.needs || []).map(
-        transformNeedToInputFieldItem,
-      );
+      // Transform Need objects to Root Fieldset with proper nesting
+      const rootFieldset = transformNeedsToFields(needsData.needs || []);
 
       return {
-        data: inputFields,
+        data: rootFieldset,
         nextCursor: undefined, // No pagination needed since we return all input fields
       };
     },
@@ -200,7 +268,17 @@ export const listInputFieldsPlugin: Plugin<
       meta: {
         listInputFields: {
           categories: ["action"],
+          type: "list",
+          itemType: "RootFieldItem",
           inputSchema: ListInputFieldsSchema,
+          outputSchema: RootFieldItemSchema,
+          resolvers: {
+            appKey: appKeyResolver,
+            actionType: actionTypeResolver,
+            actionKey: actionKeyResolver,
+            authenticationId: authenticationIdResolver,
+            inputs: inputsAllOptionalResolver,
+          },
         },
       },
     },

package/src/plugins/listInputFields/schemas.ts

@@ -6,7 +6,7 @@ import {
   AuthenticationIdPropertySchema,
   InputsPropertySchema,
 } from "../../types/properties";
-import type { InputFieldItem } from "../../types/domain";
+import type { RootFieldItem } from "../../types/domain";
 import type { PaginatedSdkFunction } from "../../types/functions";
 import type {
   ZapierConfigurationError,
@@ -54,11 +54,14 @@ export type ListInputFieldsError =
 
 // Page result structure
 export interface ListInputFieldsPage {
-  data: InputFieldItem[];
+  data: RootFieldItem[];
   nextCursor?: string;
 }
 
 // SDK function interface
 export interface ListInputFieldsSdkFunction {
-  listInputFields: PaginatedSdkFunction<ListInputFieldsOptions, InputFieldItem>;
+  listInputFields: PaginatedSdkFunction<
+    ListInputFieldsOptions,
+    RootFieldItem[]
+  >;
 }

package/src/plugins/registry/index.ts

@@ -55,10 +55,16 @@ export const registryPlugin: Plugin<
   const functions = metaKeys
     .filter((key) => typeof sdk[key as keyof typeof sdk] === "function")
     .map((key) => {
+      const meta = context.meta[key];
       return {
-        ...context.meta[key],
-        categories: context.meta[key].categories || [],
         name: key,
+        type: meta.type,
+        itemType: meta.itemType,
+        returnType: meta.returnType,
+        inputSchema: meta.inputSchema,
+        outputSchema: meta.outputSchema,
+        categories: meta.categories || [],
+        resolvers: meta.resolvers,
       };
     })
     .sort((a, b) => a.name.localeCompare(b.name));

package/src/plugins/request/index.ts

@@ -96,6 +96,7 @@ export const requestPlugin: Plugin<
       meta: {
         request: {
           categories: ["http"],
+          returnType: "Response",
           inputSchema: RelayRequestSchema,
         },
       },

package/src/plugins/runAction/index.ts

@@ -5,6 +5,7 @@ import {
   type RunActionOptions,
   type RunActionPage,
 } from "./schemas";
+import { ActionResultItemSchema } from "../../schemas/Run";
 import {
   ZapierValidationError,
   ZapierConfigurationError,
@@ -13,6 +14,13 @@ import {
 import { createPaginatedFunction } from "../../utils/function-utils";
 import type { GetActionPluginProvides } from "../getAction";
 import type { GetAppPluginProvides } from "../getApp";
+import {
+  appKeyResolver,
+  actionTypeResolver,
+  actionKeyResolver,
+  authenticationIdResolver,
+  inputsResolver,
+} from "../../resolvers";
 import type { GetVersionedImplementationId } from "../manifest/schemas";
 
 export interface RunActionPluginProvides {
@@ -177,7 +185,17 @@ export const runActionPlugin: Plugin<
       meta: {
         runAction: {
           categories: ["action"],
+          type: "list",
+          itemType: "ActionResult",
           inputSchema: RunActionSchema,
+          outputSchema: ActionResultItemSchema,
+          resolvers: {
+            appKey: appKeyResolver,
+            actionType: actionTypeResolver,
+            actionKey: actionKeyResolver,
+            authenticationId: authenticationIdResolver,
+            inputs: inputsResolver,
+          },
         },
       },
     },

package/src/resolvers/actionKey.ts

@@ -1,27 +1,29 @@
-import type { ZapierSdk } from "../types/sdk";
+import type { DynamicResolver } from "../utils/schema-utils";
+import type { ActionTypeProperty } from "../types/properties";
 
-export interface ActionKeyResolver {
-  type: "dynamic";
-  depends: readonly string[];
-  fetch: (
-    sdk: ZapierSdk,
-    resolvedParams: Record<string, any>,
-  ) => Promise<any[]>;
-  prompt: (items: any[], params: Record<string, any>) => any;
+interface ActionItem {
+  key: string;
+  title?: string;
+  name?: string;
+  description?: string;
+  action_type: string;
 }
 
-export const actionKeyResolver: ActionKeyResolver = {
+export const actionKeyResolver: DynamicResolver<
+  ActionItem,
+  { appKey: string; actionType: ActionTypeProperty }
+> = {
   type: "dynamic",
   depends: ["appKey", "actionType"] as const,
-  fetch: async (sdk: ZapierSdk, resolvedParams: Record<string, any>) => {
+  fetch: async (sdk, resolvedParams) => {
     const actionsResponse = await sdk.listActions({
       appKey: resolvedParams.appKey,
     });
     return actionsResponse.data.filter(
-      (action: any) => action.action_type === resolvedParams.actionType,
+      (action: ActionItem) => action.action_type === resolvedParams.actionType,
     );
   },
-  prompt: (actions: any[]) => ({
+  prompt: (actions) => ({
     type: "list",
     name: "actionKey",
     message: "Select action:",