@zapier/zapier-sdk 0.9.0 → 0.10.0

package/dist/utils/domain-utils.js

@@ -20,42 +20,6 @@ export function splitVersionedKey(versionedKey) {
     }
     return [versionedKey, undefined];
 }
-/**
- * Converts an API App to an AppItem with normalized field names
- *
- * @param app - Raw App from API
- * @returns Normalized AppItem
- */
-export function normalizeAppItem(app) {
-    // Extract API name and version from current_implementation_id
-    const [apiName, appVersion] = app.current_implementation_id
-        ? splitVersionedKey(app.current_implementation_id)
-        : [app.current_implementation_id || "", undefined];
-    return {
-        title: app.name,
-        key: app.slug || apiName,
-        current_implementation_id: app.current_implementation_id || "",
-        version: appVersion, // Extract version separately
-    };
-}
-/**
- * Converts an Implementation to an AppItem with normalized field names
- *
- * @param implementation - Raw Implementation from API
- * @returns Normalized AppItem
- */
-export function normalizeImplementationToAppItem(implementation) {
-    // Extract API name and version from selected_api
-    const [selectedApi, appVersion] = implementation.selected_api
-        ? splitVersionedKey(implementation.selected_api)
-        : [implementation.selected_api || "", undefined];
-    return {
-        title: implementation.name || selectedApi,
-        key: selectedApi,
-        current_implementation_id: implementation.selected_api || "",
-        version: appVersion, // Extract version separately
-    };
-}
 /**
  * Converts a lightweight ImplementationMeta to a slimmed AppItem
  *
@@ -65,24 +29,16 @@ export function normalizeImplementationToAppItem(implementation) {
 export function normalizeImplementationMetaToAppItem(implementationMeta) {
     // Extract API name and version from the implementation ID
     const [selectedApi, appVersion] = splitVersionedKey(implementationMeta.id);
+    // Destructure to exclude id and name before spreading
+    const { id, name, ...restOfImplementationMeta } = implementationMeta;
     return {
-        title: implementationMeta.name,
+        // Pass through all ImplementationMeta fields except id and name
+        ...restOfImplementationMeta,
+        // Transform key fields
+        title: name,
         key: selectedApi,
-        current_implementation_id: implementationMeta.id, // Keep the full versioned ID
+        implementation_id: id, // Keep the full versioned ID
         version: appVersion, // Extract version separately
-        slug: implementationMeta.slug,
-    };
-}
-export function normalizeServiceToAppItem(service) {
-    const [selectedApi, appVersion] = service.current_implementation_id
-        ? splitVersionedKey(service.current_implementation_id)
-        : ["", undefined];
-    return {
-        title: service.name,
-        key: selectedApi,
-        current_implementation_id: service.current_implementation_id,
-        version: appVersion,
-        description: service.description,
     };
 }
 /**

package/dist/utils/schema-utils.d.ts

@@ -1,45 +1,68 @@
 import { z } from "zod";
+import type { ZapierSdk } from "../types/sdk";
+import type { InputFieldItem } from "../schemas/Field";
 export interface FormattedItem {
     title: string;
-    subtitle?: string;
+    id?: string;
+    key?: string;
+    description?: string;
+    data?: unknown;
     details: Array<{
         text: string;
         style: "normal" | "dim" | "accent" | "warning" | "success";
     }>;
 }
-export interface FormatMetadata {
-    format: (item: any) => FormattedItem;
+export interface FormatMetadata<TItem = unknown> {
+    format: (item: TItem) => FormattedItem;
 }
-export declare function withFormatter<T extends z.ZodType>(schema: T, formatMeta: FormatMetadata): T;
-export declare function getFormatMetadata(schema: z.ZodType): FormatMetadata | undefined;
-export declare function withOutputSchema<T extends z.ZodType>(inputSchema: T, outputSchema: z.ZodType): T;
+export declare function withFormatter<T extends z.ZodType>(schema: T, formatMeta: FormatMetadata<z.infer<T>>): T;
 export declare function getOutputSchema(inputSchema: z.ZodType): z.ZodType | undefined;
-export interface StaticResolver {
+export declare function withOutputSchema<T extends z.ZodType>(inputSchema: T, outputSchema: z.ZodType): T & {
+    _def: T["_def"] & {
+        outputSchema: z.ZodType;
+    };
+};
+export interface PromptConfig {
+    type: "list";
+    name: string;
+    message: string;
+    choices: Array<{
+        name: string;
+        value: unknown;
+    }>;
+}
+export interface Resolver {
+    type: string;
+    depends?: readonly string[] | string[];
+}
+export interface StaticResolver extends Resolver {
     type: "static";
     inputType?: "text" | "password" | "email";
     placeholder?: string;
 }
-export interface DynamicResolver {
+export interface DynamicResolver<TItem = unknown, TParams = Record<string, unknown>> extends Resolver {
     type: "dynamic";
-    fetch: (sdk: any, resolvedParams: any) => Promise<any[]>;
-    prompt: (items: any[], params: any) => any;
-    depends?: string[];
+    fetch: (sdk: ZapierSdk, resolvedParams: TParams) => Promise<TItem[]>;
+    prompt: (items: TItem[], params: TParams) => PromptConfig;
 }
-export interface FieldsResolver {
+export interface FieldsResolver<TParams = Record<string, unknown>> extends Resolver {
     type: "fields";
-    fetch: (sdk: any, resolvedParams: any) => Promise<any[]>;
-    depends?: string[];
+    fetch: (sdk: ZapierSdk, resolvedParams: TParams) => Promise<InputFieldItem[]>;
 }
-export type ResolverMetadata = StaticResolver | DynamicResolver | FieldsResolver;
-export interface ResolverConfig {
-    resolver: ResolverMetadata;
+export type ResolverMetadata<TItem = unknown, TParams = Record<string, unknown>> = StaticResolver | DynamicResolver<TItem, TParams> | FieldsResolver<TParams>;
+export interface ResolverConfig<TItem = unknown, TParams = Record<string, unknown>> {
+    resolver: ResolverMetadata<TItem, TParams>;
 }
-export declare function withResolver<T extends z.ZodType>(schema: T, config: ResolverConfig): T;
+export declare function withResolver<T extends z.ZodType, TItem = unknown, TParams = Record<string, unknown>>(schema: T, config: ResolverConfig<TItem, TParams>): T;
 export declare function getSchemaDescription(schema: z.ZodSchema): string | undefined;
-export declare function getFieldDescriptions(schema: z.ZodObject<any>): Record<string, string>;
+export declare function getFieldDescriptions(schema: z.ZodObject<z.ZodRawShape>): Record<string, string>;
 export interface PositionalMetadata {
-    positional: true;
+    positionalMeta: {
+        positional: true;
+    };
 }
-export declare function withPositional<T extends z.ZodType>(schema: T): T;
+export declare function withPositional<T extends z.ZodType>(schema: T): T & {
+    _def: T["_def"] & PositionalMetadata;
+};
 export declare function isPositional(schema: z.ZodType): boolean;
 //# sourceMappingURL=schema-utils.d.ts.map

package/dist/utils/schema-utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schema-utils.d.ts","sourceRoot":"","sources":["../../src/utils/schema-utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,MAAM,WAAW,aAAa;IAC5B,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,KAAK,CAAC;QACb,IAAI,EAAE,MAAM,CAAC;QACb,KAAK,EAAE,QAAQ,GAAG,KAAK,GAAG,QAAQ,GAAG,SAAS,GAAG,SAAS,CAAC;KAC5D,CAAC,CAAC;CACJ;AAED,MAAM,WAAW,cAAc;IAC7B,MAAM,EAAE,CAAC,IAAI,EAAE,GAAG,KAAK,aAAa,CAAC;CACtC;AAGD,wBAAgB,aAAa,CAAC,CAAC,SAAS,CAAC,CAAC,OAAO,EAC/C,MAAM,EAAE,CAAC,EACT,UAAU,EAAE,cAAc,GACzB,CAAC,CAIH;AAGD,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,CAAC,CAAC,OAAO,GAChB,cAAc,GAAG,SAAS,CAE5B;AAGD,wBAAgB,gBAAgB,CAAC,CAAC,SAAS,CAAC,CAAC,OAAO,EAClD,WAAW,EAAE,CAAC,EACd,YAAY,EAAE,CAAC,CAAC,OAAO,GACtB,CAAC,CAIH;AAGD,wBAAgB,eAAe,CAAC,WAAW,EAAE,CAAC,CAAC,OAAO,GAAG,CAAC,CAAC,OAAO,GAAG,SAAS,CAE7E;AAMD,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,QAAQ,CAAC;IACf,SAAS,CAAC,EAAE,MAAM,GAAG,UAAU,GAAG,OAAO,CAAC;IAC1C,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,SAAS,CAAC;IAChB,KAAK,EAAE,CAAC,GAAG,EAAE,GAAG,EAAE,cAAc,EAAE,GAAG,KAAK,OAAO,CAAC,GAAG,EAAE,CAAC,CAAC;IACzD,MAAM,EAAE,CAAC,KAAK,EAAE,GAAG,EAAE,EAAE,MAAM,EAAE,GAAG,KAAK,GAAG,CAAC;IAC3C,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;CACpB;AAED,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,QAAQ,CAAC;IACf,KAAK,EAAE,CAAC,GAAG,EAAE,GAAG,EAAE,cAAc,EAAE,GAAG,KAAK,OAAO,CAAC,GAAG,EAAE,CAAC,CAAC;IACzD,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;CACpB;AAED,MAAM,MAAM,gBAAgB,GACxB,cAAc,GACd,eAAe,GACf,cAAc,CAAC;AAGnB,MAAM,WAAW,cAAc;IAC7B,QAAQ,EAAE,gBAAgB,CAAC;CAI5B;AAGD,wBAAgB,YAAY,CAAC,CAAC,SAAS,CAAC,CAAC,OAAO,EAC9C,MAAM,EAAE,CAAC,EACT,MAAM,EAAE,cAAc,GACrB,CAAC,CAIH;AAMD,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,CAAC,CAAC,SAAS,GAAG,MAAM,GAAG,SAAS,CAE5E;AAED,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,CAAC,CAAC,SAAS,CAAC,GAAG,CAAC,GACvB,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAWxB;AAMD,MAAM,WAAW,kBAAkB;IACjC,UAAU,EAAE,IAAI,CAAC;CAClB;AAGD,wBAAgB,cAAc,CAAC,CAAC,SAAS,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,CAAC,GAAG,CAAC,CAIhE;AAGD,wBAAgB,YAAY,CAAC,MAAM,EAAE,CAAC,CAAC,OAAO,GAAG,OAAO,CAiBvD"}
+{"version":3,"file":"schema-utils.d.ts","sourceRoot":"","sources":["../../src/utils/schema-utils.ts"],"names":[],"mappings":"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"}

package/dist/utils/schema-utils.js

@@ -2,23 +2,23 @@ import { z } from "zod";
 // Helper function to add format metadata to schemas
 export function withFormatter(schema, formatMeta) {
     // Store format metadata on the schema definition
-    schema._def.formatMeta = formatMeta;
+    Object.assign(schema._def, {
+        formatMeta: formatMeta,
+    });
     return schema;
 }
-// Helper function to get format metadata from a schema
-export function getFormatMetadata(schema) {
-    return schema._def.formatMeta;
+// Helper function to get output schema from an input schema
+export function getOutputSchema(inputSchema) {
+    return inputSchema._def.outputSchema;
 }
 // Helper function to link input schemas to output schemas
 export function withOutputSchema(inputSchema, outputSchema) {
     // Store output schema reference on the input schema
-    inputSchema._def.outputSchema = outputSchema;
+    Object.assign(inputSchema._def, {
+        outputSchema,
+    });
     return inputSchema;
 }
-// Helper function to get output schema from an input schema
-export function getOutputSchema(inputSchema) {
-    return inputSchema._def.outputSchema;
-}
 // Helper function to add resolver metadata to schemas
 export function withResolver(schema, config) {
     // Store resolver metadata on the schema definition
@@ -44,13 +44,19 @@ export function getFieldDescriptions(schema) {
 // Helper function to mark a parameter as positional for CLI
 export function withPositional(schema) {
     // Store positional metadata on the schema definition
-    schema._def.positionalMeta = { positional: true };
+    Object.assign(schema._def, {
+        positionalMeta: { positional: true },
+    });
     return schema;
 }
+function schemaHasPositionalMeta(schema) {
+    return "positionalMeta" in schema._def;
+}
 // Helper function to check if a parameter should be positional
 export function isPositional(schema) {
     // Check the current schema first
-    if (schema._def.positionalMeta?.positional) {
+    if (schemaHasPositionalMeta(schema) &&
+        schema._def.positionalMeta?.positional) {
         return true;
     }
     // If this is a ZodOptional, check the inner type

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zapier/zapier-sdk",
-  "version": "0.9.0",
+  "version": "0.10.0",
   "description": "Complete Zapier SDK - combines all Zapier SDK packages",
   "main": "dist/index.cjs",
   "module": "dist/index.mjs",

package/src/api/client.ts

@@ -188,6 +188,18 @@ class ZapierApiClient implements ApiClient {
       if ("errors" in data && Array.isArray(data.errors)) {
         if (this.isApiErrorArray(data.errors)) {
           return data.errors[0].detail || data.errors[0].title;
+        } else if (data.errors.length > 0) {
+          // Handle simple string errors array
+          const firstError = data.errors[0];
+          if (typeof firstError === "string") {
+            return firstError;
+          }
+          // For non-string errors, stringify them
+          try {
+            return JSON.stringify(firstError);
+          } catch {
+            return String(firstError);
+          }
         }
       }
     }

package/src/api/debug.test.ts

@@ -0,0 +1,76 @@
+import { describe, it, expect } from "vitest";
+import { censorHeaders } from "./debug";
+
+describe("censorHeaders", () => {
+  it("should return undefined for undefined headers", () => {
+    expect(censorHeaders(undefined)).toBeUndefined();
+  });
+
+  it("should return headers unchanged for non-auth headers", () => {
+    const headers = {
+      "Content-Type": "application/json",
+      "User-Agent": "test",
+    };
+    const result = censorHeaders(headers);
+    // Headers API normalizes header names to lowercase
+    expect(result!["content-type"]).toBe("application/json");
+    expect(result!["user-agent"]).toBe("test");
+  });
+
+  it("should censor authorization header with Bearer prefix - long token", () => {
+    const headers = { authorization: "Bearer abcdef1234567890xyz" };
+    const result = censorHeaders(headers);
+
+    expect(result!.authorization).toBe("Bearer abcd...0xyz");
+  });
+
+  it("should censor authorization header with Bearer prefix - short token", () => {
+    const headers = { authorization: "Bearer short123" };
+    const result = censorHeaders(headers);
+
+    expect(result!.authorization).toBe("Bearer s...");
+  });
+
+  it("should censor x-api-key header - long token", () => {
+    const headers = { "x-api-key": "sk-1234567890abcdefghij" };
+    const result = censorHeaders(headers);
+
+    expect(result!["x-api-key"]).toBe("sk-1...ghij");
+  });
+
+  it("should censor x-api-key header - short token", () => {
+    const headers = { "x-api-key": "short" };
+    const result = censorHeaders(headers);
+
+    expect(result!["x-api-key"]).toBe("s...");
+  });
+
+  it("should handle Headers object input", () => {
+    const headers = new Headers();
+    headers.set("authorization", "Bearer verylongtoken123456789");
+
+    const result = censorHeaders(headers);
+    expect(result!.authorization).toBe("Bearer very...6789");
+  });
+
+  it("should handle mixed case authorization headers", () => {
+    const headers = { Authorization: "Bearer mixedcasetoken123" };
+    const result = censorHeaders(headers);
+
+    expect(result!.authorization).toBe("Bearer mixe...n123");
+  });
+
+  it("should preserve non-auth headers while censoring auth headers", () => {
+    const headers = {
+      "Content-Type": "application/json",
+      authorization: "Bearer shouldbecensored123456789",
+      "User-Agent": "test-agent",
+    };
+
+    const result = censorHeaders(headers);
+
+    expect(result!["content-type"]).toBe("application/json");
+    expect(result!["user-agent"]).toBe("test-agent");
+    expect(result!.authorization).toBe("Bearer shou...6789");
+  });
+});

package/src/api/debug.ts

@@ -12,11 +12,55 @@ export function createDebugLogger(enabled: boolean): DebugLogger {
     return () => {}; // No-op function when debug is disabled
   }
 
-  return (message: string, data?: any) => {
+  return (message: string, data?: unknown) => {
     console.log(`[Zapier SDK] ${message}`, data || "");
   };
 }
 
+export function censorHeaders(
+  headers?: HeadersInit,
+): Record<string, string> | undefined {
+  if (!headers) return headers;
+
+  const headersObj = new Headers(headers);
+  const authKeys = ["authorization", "x-api-key"];
+
+  for (const [key, value] of headersObj.entries()) {
+    if (authKeys.some((authKey) => key.toLowerCase() === authKey)) {
+      // Find space after prefix (like "Bearer ")
+      const spaceIndex = value.indexOf(" ");
+      if (spaceIndex > 0 && spaceIndex < value.length - 1) {
+        const prefix = value.substring(0, spaceIndex + 1); // Include the space
+        const token = value.substring(spaceIndex + 1);
+
+        if (token.length > 12) {
+          // Show first 4 and last 4 chars, truncate middle
+          const start = token.substring(0, 4);
+          const end = token.substring(token.length - 4);
+          headersObj.set(key, `${prefix}${start}...${end}`);
+        } else {
+          // Short token, use first character + three dots
+          const firstChar = token.charAt(0);
+          headersObj.set(key, `${prefix}${firstChar}...`);
+        }
+      } else {
+        // No prefix found, truncate the whole value
+        if (value.length > 12) {
+          const start = value.substring(0, 4);
+          const end = value.substring(value.length - 4);
+          headersObj.set(key, `${start}...${end}`);
+        } else {
+          // Short token, use first character + three dots
+          const firstChar = value.charAt(0);
+          headersObj.set(key, `${firstChar}...`);
+        }
+      }
+    }
+  }
+
+  return Object.fromEntries(headersObj);
+}
+
 export function createDebugFetch(options: {
   originalFetch: typeof globalThis.fetch;
   debugLog: DebugLogger;
@@ -30,7 +74,7 @@ export function createDebugFetch(options: {
     const method = options?.method || "GET";
 
     debugLog(`→ ${method} ${url}`, {
-      headers: options?.headers,
+      headers: censorHeaders(options?.headers),
       body:
         options?.body && typeof options.body === "string"
           ? (() => {

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

@@ -38,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 {

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,
         },
       },
     },