@zapier/zapier-sdk 0.8.3 → 0.10.0

package/src/api/schemas.ts

@@ -118,7 +118,7 @@ export const FieldSchema = z.object({
 });
 
 export const ActionExecutionResultSchema = z.object({
-  data: z.array(z.any()),
+  data: z.array(z.unknown()),
 });
 
 export const ActionFieldChoiceSchema = z.object({
@@ -217,9 +217,9 @@ export const UserProfileSchema = z.object({
   enable_totp_2fa: z.boolean(),
   viewed_help: z.record(z.boolean()),
   show_editor_migration_mesaging: z.boolean(),
-  switches: z.record(z.any()),
-  organizations: z.array(z.any().nullable()),
-  primary_organization: z.any().nullable(),
+  switches: z.record(z.unknown()),
+  organizations: z.array(z.record(z.unknown()).nullable()),
+  primary_organization: z.record(z.unknown()).nullable(),
   has_active_zaps: z.boolean(),
   has_google_sso: z.boolean(),
   auth_realm: z.string(),
@@ -236,7 +236,7 @@ export const AppSchema = z.object({
   api_docs_url: z.string().nullable().optional(),
   app_profile_url: z.string(),
   banner: z.string().optional(),
-  categories: z.array(z.any()).optional(), // TODO: Define proper service_category type
+  categories: z.array(z.string()).optional(), // Service category names
   canonical_id: z.string().optional(),
   current_implementation_id: z.string(),
   days_since_last_update: z.string().optional(),
@@ -294,7 +294,7 @@ export const NeedsRequestSchema = z.object({
   action: z.string(),
   type_of: z.string(),
   authentication_id: z.number().optional(),
-  params: z.record(z.any()).optional(),
+  params: z.record(z.unknown()).optional(),
 });
 
 export const NeedsResponseSchema = z.object({
@@ -341,20 +341,11 @@ export const ImplementationsResponseSchema = z.object({
 // ============================================================================
 
 export const ImplementationMetaSchema = z.object({
-  id: z.string(), // e.g. "ZapierFormatterCLIAPI@1.0.7"
+  id: z.string(), // e.g. "100HiresCLIAPI@1.2.1"
   name: z.string(),
   slug: z.string(),
-  images: z
-    .object({
-      url_16x16: z.string().optional(),
-      url_32x32: z.string().optional(),
-      url_64x64: z.string().optional(),
-      url_128x128: z.string().optional(),
-    })
-    .optional(),
-  // Include other fields for completeness but we'll only use what we need
-  ageInDays: z.union([z.string(), z.number()]).optional(),
-  authType: z.string().nullable().optional(),
+  age_in_days: z.number().optional(),
+  auth_type: z.string().optional(),
   banner: z.string().optional(),
   categories: z
     .array(
@@ -365,18 +356,49 @@ export const ImplementationMetaSchema = z.object({
       }),
     )
     .optional(),
-  isBeta: z.boolean().optional(),
-  isBuiltIn: z.boolean().optional(),
-  isDeprecated: z.boolean().optional(),
-  isFeatured: z.boolean().optional(),
-  isHidden: z.boolean().optional(),
-  isInvite: z.boolean().optional(),
-  isPremium: z.boolean().optional(),
-  isPublic: z.boolean().optional(),
-  isUpcoming: z.boolean().optional(),
+  images: z
+    .object({
+      url_16x16: z.string().optional(),
+      url_32x32: z.string().optional(),
+      url_64x64: z.string().optional(),
+      url_128x128: z.string().optional(),
+    })
+    .optional(),
   popularity: z.number().optional(),
-  apiDocsUrl: z.string().optional(),
+  has_filters: z.boolean().optional(),
+  has_reads: z.boolean().optional(),
+  has_searches: z.boolean().optional(),
+  has_searches_or_writes: z.boolean().optional(),
+  has_upfront_fields: z.boolean().optional(),
+  has_writes: z.boolean().optional(),
+  is_beta: z.boolean().optional(),
+  is_built_in: z.boolean().optional(),
+  is_deprecated: z.boolean().optional(),
+  is_featured: z.boolean().optional(),
+  is_hidden: z.boolean().optional(),
+  is_invite: z.boolean().optional(),
+  is_premium: z.boolean().optional(),
+  is_public: z.boolean().optional(),
+  is_upcoming: z.boolean().optional(),
+  version: z.string().optional(),
+  visibility: z.string().optional(),
+  actions: z
+    .object({
+      read: z.number().optional(),
+      read_bulk: z.number().optional(),
+      write: z.number().optional(),
+      search: z.number().optional(),
+      search_or_write: z.number().optional(),
+      search_and_write: z.number().optional(),
+      filter: z.number().optional(),
+    })
+    .optional(),
+  description: z.string().optional(),
+  primary_color: z.string().optional(),
+  secondary_color: z.string().optional(),
   classification: z.string().optional(),
+  api_docs_url: z.string().optional(),
+  image: z.string().optional(),
 });
 
 export const ImplementationsMetaResponseSchema = z.object({
@@ -413,7 +435,7 @@ export const NeedChoicesRequestSchema = z.object({
       "If the app needs auth, provide an `authentication_id` that has the `selected_api` of the app you want to run. Can be any auth visible to the user (including shared).",
     ),
   params: z
-    .record(z.any())
+    .record(z.unknown())
     .optional()
     .describe(
       "Object that matches the input the node would normally get. Has all the same keys/types as the `needs` of the action.",

package/src/index.ts

@@ -17,7 +17,6 @@ export * from "./plugins/findUniqueAuthentication";
 export * from "./plugins/runAction";
 export * from "./plugins/request";
 export * from "./plugins/manifest";
-export * from "./plugins/lockVersion";
 export * from "./plugins/getProfile";
 export * from "./plugins/api";
 
@@ -39,16 +38,15 @@ export type {
 } from "./api/types";
 
 // Export schema utilities for CLI
-export { isPositional } from "./utils/schema-utils";
-export { hasResolver } from "./resolvers";
+export { isPositional, PositionalMetadata } from "./utils/schema-utils";
 export { createFunction } from "./utils/function-utils";
 
+// Export resolver utilities for CLI
+export * from "./resolvers";
+
 // Export auth utilities for CLI use
 export * from "./auth";
 
-// Export resolvers for CLI use
-export * from "./resolvers";
-
 // All functions now available through the plugin system via createZapierSdk()
 // Export plugin schemas for external use
 export {
@@ -74,6 +72,7 @@ export type {
   PluginDependencies,
   PluginOptions,
   GetSdkType,
+  GetContextType,
   Sdk,
 } from "./types/plugin";
 

package/src/plugins/apps/index.ts

@@ -1,5 +1,4 @@
-import type { ActionExecutionOptions } from "./types";
-import type { ActionProxy } from "./types";
+import type { ActionExecutionOptions, ActionProxy } from "./types";
 import { ZapierValidationError } from "../../types/errors";
 import type { Plugin, GetSdkType } from "../../types/plugin";
 import type { FetchPluginProvides } from "../fetch/index";
@@ -173,3 +172,11 @@ export const appsPlugin: Plugin<
     apps: createAppsProxy({ sdk }),
   };
 };
+
+// Export types for use in generated code
+export type { ActionExecutionOptions } from "./types";
+export type { ActionExecutionResult } from "../../api/types";
+
+// Interface for generated apps - will be augmented by generated .d.ts files
+// This interface will contain only the specifically typed apps
+export interface ZapierSdkApps {}

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

@@ -132,17 +132,20 @@ describe("findFirstAuthentication plugin", () => {
       expect(result.data).toEqual(mockAuth);
     });
 
-    it("should return null when no authentications found", async () => {
+    it("should throw error when no authentications found", async () => {
       mockListAuthentications.mockResolvedValue({
         data: [],
       });
 
       const sdk = createTestSdk();
-      const result = await sdk.findFirstAuthentication({
-        appKey: "nonexistent",
-      });
 
-      expect(result.data).toBeNull();
+      await expect(
+        sdk.findFirstAuthentication({
+          appKey: "nonexistent",
+        }),
+      ).rejects.toThrow(
+        "No authentication found matching the specified criteria",
+      );
     });
 
     it("should return first authentication when multiple found", async () => {

package/src/plugins/findFirstAuthentication/index.ts

@@ -6,11 +6,13 @@ import {
 } from "./schemas";
 import { createFunction } from "../../utils/function-utils";
 import type { ListAuthenticationsPluginProvides } from "../listAuthentications";
+import { AuthenticationItemSchema } from "../../schemas/Auth";
+import { ZapierResourceNotFoundError } from "../../types/errors";
 
 export interface FindFirstAuthenticationPluginProvides {
   findFirstAuthentication: (
     options?: FindFirstAuthenticationOptions,
-  ) => Promise<{ data: AuthenticationItem | null }>;
+  ) => Promise<{ data: AuthenticationItem }>;
   context: {
     meta: {
       findFirstAuthentication: {
@@ -35,8 +37,15 @@ export const findFirstAuthenticationPlugin: Plugin<
         maxItems: 1,
       });
 
+      if (authsResponse.data.length === 0) {
+        throw new ZapierResourceNotFoundError(
+          "No authentication found matching the specified criteria",
+          { resourceType: "Authentication" },
+        );
+      }
+
       return {
-        data: authsResponse.data.length > 0 ? authsResponse.data[0] : null,
+        data: authsResponse.data[0],
       };
     },
     FindFirstAuthenticationSchema,
@@ -48,7 +57,10 @@ export const findFirstAuthenticationPlugin: Plugin<
       meta: {
         findFirstAuthentication: {
           categories: ["authentication"],
+          type: "item",
+          itemType: "Authentication",
           inputSchema: FindFirstAuthenticationSchema,
+          outputSchema: AuthenticationItemSchema,
         },
       },
     },

package/src/plugins/findUniqueAuthentication/index.ts

@@ -10,6 +10,7 @@ import {
 } from "../../types/errors";
 import { createFunction } from "../../utils/function-utils";
 import type { ListAuthenticationsPluginProvides } from "../listAuthentications";
+import { AuthenticationItemSchema } from "../../schemas/Auth";
 
 export interface FindUniqueAuthenticationPluginProvides {
   findUniqueAuthentication: (
@@ -65,7 +66,10 @@ export const findUniqueAuthenticationPlugin: Plugin<
       meta: {
         findUniqueAuthentication: {
           categories: ["authentication"],
+          type: "item",
+          itemType: "Authentication",
           inputSchema: FindUniqueAuthenticationSchema,
+          outputSchema: AuthenticationItemSchema,
         },
       },
     },

package/src/plugins/getAction/index.ts

@@ -5,6 +5,12 @@ import { GetActionSchema, type GetActionOptions } from "./schemas";
 import { ZapierResourceNotFoundError } from "../../types/errors";
 import { createFunction } from "../../utils/function-utils";
 import type { ListActionsPluginProvides } from "../listActions";
+import {
+  appKeyResolver,
+  actionTypeResolver,
+  actionKeyResolver,
+} from "../../resolvers";
+import { ActionItemSchema } from "../../schemas/Action";
 
 export interface GetActionPluginProvides {
   getAction: (options: GetActionOptions) => Promise<{ data: ActionItem }>;
@@ -50,7 +56,15 @@ export const getActionPlugin: Plugin<
       meta: {
         getAction: {
           categories: ["action"],
+          type: "item",
+          itemType: "Action",
           inputSchema: GetActionSchema,
+          outputSchema: ActionItemSchema,
+          resolvers: {
+            appKey: appKeyResolver,
+            actionType: actionTypeResolver,
+            actionKey: actionKeyResolver,
+          },
         },
       },
     },

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

@@ -12,8 +12,8 @@ import { manifestPlugin } from "../manifest";
 function createTestSdk() {
   return createSdk()
     .addPlugin(apiPlugin, { fetch: global.fetch })
-    .addPlugin(listAppsPlugin)
     .addPlugin(manifestPlugin)
+    .addPlugin(listAppsPlugin)
     .addPlugin(getAppPlugin);
 }
 
@@ -72,7 +72,7 @@ describe("getApp plugin", () => {
 
       expect(result.data.title).toBe("Slack");
       expect(result.data.key).toBe("SlackCLIAPI");
-      expect(result.data.current_implementation_id).toBe("SlackCLIAPI@1.0.0");
+      expect(result.data.implementation_id).toBe("SlackCLIAPI@1.0.0");
       expect(result.data.version).toBe("1.0.0");
     });
   });
@@ -121,7 +121,7 @@ describe("getApp plugin", () => {
 
       expect(result.data.title).toBeDefined();
       expect(result.data.key).toBeDefined();
-      expect(result.data.current_implementation_id).toBeDefined();
+      expect(result.data.implementation_id).toBeDefined();
       expect(result.data.title).toBe("Test App");
       expect(result.data.key).toBe("TestCLIAPI");
     });

package/src/plugins/getApp/index.ts

@@ -3,10 +3,11 @@ import { createFunction } from "../../utils/function-utils";
 import { GetAppSchema } from "./schemas";
 import type { GetAppOptions } from "./schemas";
 import type { AppItem } from "../../types/domain";
+import { AppItemSchema } from "../../schemas/App";
 import { ZapierAppNotFoundError } from "../../types/errors";
 import type { GetSdkType } from "../../types/plugin";
-import type { GetImplementation } from "../manifest/schemas";
-import type { ManifestPluginProvides } from "../manifest";
+import type { ListAppsPluginProvides } from "../listApps";
+import { appKeyResolver } from "../../resolvers";
 
 // GetApp plugin provides interface - getApp goes directly to SDK root
 export interface GetAppPluginProvides {
@@ -22,21 +23,20 @@ export interface GetAppPluginProvides {
 
 // GetApp plugin depends on listApps SDK function
 export const getAppPlugin: Plugin<
-  GetSdkType<ManifestPluginProvides>, // depends on manifest plugin with getImplementation in context
-  { getImplementation: GetImplementation }, //
+  GetSdkType<ListAppsPluginProvides>,
+  {},
   GetAppPluginProvides
-> = ({ context }) => {
+> = ({ sdk }) => {
   const getApp = createFunction(async function getApp(options: GetAppOptions) {
-    const app = await context.getImplementation(options.appKey);
-    if (!app) {
-      throw new ZapierAppNotFoundError("App not found", {
-        appKey: options.appKey,
-      });
+    const appsIterator = sdk.listApps({ appKeys: [options.appKey] }).items();
+    for await (const app of appsIterator) {
+      return {
+        data: app,
+      };
     }
-
-    return {
-      data: app,
-    };
+    throw new ZapierAppNotFoundError("App not found", {
+      appKey: options.appKey,
+    });
   }, GetAppSchema);
 
   // Return flat structure - getApp goes directly to SDK
@@ -46,7 +46,13 @@ export const getAppPlugin: Plugin<
       meta: {
         getApp: {
           categories: ["app"],
+          type: "item",
+          itemType: "App",
           inputSchema: GetAppSchema,
+          outputSchema: AppItemSchema,
+          resolvers: {
+            appKey: appKeyResolver,
+          },
         },
       },
     },

package/src/plugins/getApp/schemas.ts

@@ -1,7 +1,5 @@
 import { z } from "zod";
 import { AppKeyPropertySchema } from "../../types/properties";
-import { withOutputSchema } from "../../utils/schema-utils";
-import { AppItemSchema } from "../../schemas/App";
 import type { AppItem } from "../../types/domain";
 import type {
   ZapierApiError,
@@ -18,16 +16,13 @@ export type GetAppError =
   | ZapierValidationError;
 
 // Pure Zod schema - no resolver metadata!
-export const GetAppSchema = withOutputSchema(
-  z
-    .object({
-      appKey: AppKeyPropertySchema.describe(
-        "App key of app to fetch (e.g., 'SlackCLIAPI')",
-      ),
-    })
-    .describe("Get detailed information about a specific app"),
-  AppItemSchema,
-);
+export const GetAppSchema = z
+  .object({
+    appKey: AppKeyPropertySchema.describe(
+      "App key of app to fetch (e.g., 'SlackCLIAPI')",
+    ),
+  })
+  .describe("Get detailed information about a specific app");
 
 // Type inferred from schema
 export type GetAppOptions = z.infer<typeof GetAppSchema>;

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

@@ -45,8 +45,8 @@ describe("getAuthentication plugin", () => {
   function createTestSdk() {
     return createSdk()
       .addPlugin(apiPlugin)
-      .addPlugin(listAppsPlugin)
       .addPlugin(manifestPlugin)
+      .addPlugin(listAppsPlugin)
       .addPlugin(getAuthenticationPlugin);
   }
 

package/src/plugins/getAuthentication/index.ts

@@ -12,6 +12,8 @@ import {
 } from "../../types/errors";
 import { createFunction } from "../../utils/function-utils";
 import { normalizeAuthenticationItem } from "../../utils/domain-utils";
+import { authenticationIdGenericResolver } from "../../resolvers";
+import { AuthenticationItemSchema } from "../../schemas/Auth";
 
 export interface GetAuthenticationPluginProvides {
   getAuthentication: (
@@ -79,7 +81,13 @@ export const getAuthenticationPlugin: Plugin<
       meta: {
         getAuthentication: {
           categories: ["authentication"],
+          type: "item",
+          itemType: "Authentication",
           inputSchema: GetAuthenticationSchema,
+          outputSchema: AuthenticationItemSchema,
+          resolvers: {
+            authenticationId: authenticationIdGenericResolver,
+          },
         },
       },
     },

package/src/plugins/getProfile/index.ts

@@ -4,6 +4,7 @@ import { createFunction } from "../../utils/function-utils";
 import type { Plugin } from "../../types/plugin";
 import type { UserProfileItem } from "../../types/domain";
 import { GetProfileSchema } from "./schemas";
+import { UserProfileItemSchema } from "../../schemas/UserProfile";
 
 // GetProfile plugin provides interface - getProfile goes directly to SDK root
 export interface GetProfilePluginProvides {
@@ -48,7 +49,10 @@ export const getProfilePlugin: Plugin<
       meta: {
         getProfile: {
           categories: ["account"],
+          type: "item",
+          itemType: "Profile",
           inputSchema: GetProfileSchema,
+          outputSchema: UserProfileItemSchema,
         },
       },
     },

package/src/plugins/getProfile/schemas.ts

@@ -1,6 +1,4 @@
 import { z } from "zod";
-import { withOutputSchema } from "../../utils/schema-utils";
-import { UserProfileItemSchema } from "../../schemas/UserProfile";
 import type { FunctionOptions } from "../../types/functions";
 import type { UserProfileItem } from "../../types/domain";
 import type { ZapierApiError, ZapierValidationError } from "../../types/errors";
@@ -9,10 +7,10 @@ import type { ZapierApiError, ZapierValidationError } from "../../types/errors";
 export type GetProfileError = ZapierApiError | ZapierValidationError;
 
 // Pure Zod schema - no resolver metadata!
-export const GetProfileSchema = withOutputSchema(
-  z.object({}).optional().describe("Get current user's profile information"),
-  UserProfileItemSchema,
-);
+export const GetProfileSchema = z
+  .object({})
+  .optional()
+  .describe("Get current user's profile information");
 
 // Type inferred from schema + function config
 export type GetProfileOptions = z.infer<typeof GetProfileSchema> &

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

@@ -68,6 +68,8 @@ describe("listActions plugin", () => {
       .mockResolvedValue("SlackCLIAPI@1.21.1");
   });
 
+  const mockResolveAppKeys = vi.fn().mockResolvedValue([]);
+
   function createTestSdk() {
     // Create a proper plugin chain with context dependencies
 
@@ -76,18 +78,17 @@ describe("listActions plugin", () => {
       .addPlugin(() => ({
         context: {
           api: mockApiClient,
-          getVersionedImplementationId: mockGetVersionedImplementationId,
         },
       }))
-      .addPlugin(listAppsPlugin)
       .addPlugin(() => ({
         context: {
           manifest: null,
-          getManifestEntry: () => null,
           getVersionedImplementationId: mockGetVersionedImplementationId,
-          getImplementation: () => Promise.resolve(null),
+          resolveAppKeys: mockResolveAppKeys,
+          updateManifestEntry: vi.fn().mockResolvedValue(["test-key", {}]),
         },
       }))
+      .addPlugin(listAppsPlugin)
       .addPlugin(listActionsPlugin);
   }
 
@@ -166,7 +167,7 @@ describe("listActions plugin", () => {
 
       expect(result.data).toHaveLength(2); // Only write actions
       expect(
-        result.data.every((action) => action.action_type === "write"),
+        result.data.every((action: any) => action.action_type === "write"),
       ).toBe(true);
     });
   });
@@ -309,9 +310,9 @@ describe("listActions plugin", () => {
 
       expect(result.data).toHaveLength(2);
       expect(
-        result.data.every((action) => action.action_type === "write"),
+        result.data.every((action: any) => action.action_type === "write"),
       ).toBe(true);
-      expect(result.data.map((action) => action.key)).toEqual([
+      expect(result.data.map((action: any) => action.key)).toEqual([
         "send_message",
         "create_channel",
       ]);

package/src/plugins/listActions/index.ts

@@ -7,6 +7,7 @@ import {
   type ListActionsOptions,
   type ListActionsPage,
 } from "./schemas";
+import { ActionItemSchema } from "../../schemas/Action";
 import {
   ZapierConfigurationError,
   ZapierAuthenticationError,
@@ -14,6 +15,7 @@ import {
 import { createPaginatedFunction } from "../../utils/function-utils";
 import type { ManifestPluginProvides } from "../manifest";
 import type { GetVersionedImplementationId } from "../manifest/schemas";
+import { appKeyResolver, actionTypeResolver } from "../../resolvers";
 
 export interface ListActionsPluginProvides {
   listActions: (options?: ListActionsOptions) => Promise<{
@@ -32,11 +34,11 @@ export interface ListActionsPluginProvides {
 }
 
 export const listActionsPlugin: Plugin<
-  GetSdkType<ManifestPluginProvides>, // requires getApp in SDK
+  GetSdkType<ManifestPluginProvides>,
   {
     api: ApiClient;
     getVersionedImplementationId: GetVersionedImplementationId;
-  }, // requires api and getVersionedImplementationId in context
+  },
   ListActionsPluginProvides
 > = ({ context }) => {
   const listActions = createPaginatedFunction(async function listActionsPage(
@@ -44,7 +46,7 @@ export const listActionsPlugin: Plugin<
   ): Promise<ListActionsPage> {
     const { api, getVersionedImplementationId } = context;
 
-    // Use the getApp function from the SDK (dependency injection)
+    // Use getVersionedImplementationId (optimized to check manifest first)
     const selectedApi = await getVersionedImplementationId(options.appKey);
 
     if (!selectedApi) {
@@ -114,7 +116,14 @@ export const listActionsPlugin: Plugin<
       meta: {
         listActions: {
           categories: ["action"],
+          type: "list",
+          itemType: "Action",
           inputSchema: ListActionsSchema,
+          outputSchema: ActionItemSchema,
+          resolvers: {
+            appKey: appKeyResolver,
+            actionType: actionTypeResolver,
+          },
         },
       },
     },

package/src/plugins/listActions/schemas.ts

@@ -3,8 +3,6 @@ import {
   AppKeyPropertySchema,
   ActionTypePropertySchema,
 } from "../../types/properties";
-import { withOutputSchema } from "../../utils/schema-utils";
-import { ActionItemSchema } from "../../schemas/Action";
 import type { ActionItem } from "../../types/domain";
 import type { PaginatedSdkFunction } from "../../types/functions";
 import type {
@@ -14,29 +12,26 @@ import type {
 } from "../../types/errors";
 
 // Pure Zod schema - no resolver metadata!
-export const ListActionsSchema = withOutputSchema(
-  z
-    .object({
-      appKey: AppKeyPropertySchema.describe(
-        "App key of actions to list (e.g., 'SlackCLIAPI')",
-      ),
-      actionType: ActionTypePropertySchema.optional().describe(
-        "Filter actions by type",
-      ),
-      pageSize: z
-        .number()
-        .min(1)
-        .optional()
-        .describe("Number of actions per page"),
-      maxItems: z
-        .number()
-        .min(1)
-        .optional()
-        .describe("Maximum total items to return across all pages"),
-    })
-    .describe("List all actions for a specific app"),
-  ActionItemSchema,
-);
+export const ListActionsSchema = z
+  .object({
+    appKey: AppKeyPropertySchema.describe(
+      "App key of actions to list (e.g., 'SlackCLIAPI')",
+    ),
+    actionType: ActionTypePropertySchema.optional().describe(
+      "Filter actions by type",
+    ),
+    pageSize: z
+      .number()
+      .min(1)
+      .optional()
+      .describe("Number of actions per page"),
+    maxItems: z
+      .number()
+      .min(1)
+      .optional()
+      .describe("Maximum total items to return across all pages"),
+  })
+  .describe("List all actions for a specific app");
 
 // Type inferred from schema
 export type ListActionsOptions = z.infer<typeof ListActionsSchema>;