@zapier/zapier-sdk 0.14.0 → 0.15.1

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @zapier/zapier-sdk
 
+## 0.15.1
+
+### Patch Changes
+
+- 4c78fb0: Added `getInputFieldsSchema` plugin to retrieve JSON Schema for action inputs
+
+## 0.15.0
+
+### Minor Changes
+
+- f92bc07: Route all API requests through new service.
+
 ## 0.14.0
 
 ### Minor Changes

package/README.md

@@ -9,6 +9,7 @@
   - [`getProfile`](#getprofile)
 - [Actions](#actions)
   - [`getAction`](#getaction)
+  - [`getInputFieldsSchema`](#getinputfieldsschema)
   - [`listActions`](#listactions)
   - [`listInputFieldChoices`](#listinputfieldchoices)
   - [`listInputFields`](#listinputfields)
@@ -256,6 +257,33 @@ const { data: action } = await sdk.getAction({
 });
 ```
 
+#### `getInputFieldsSchema`
+
+Get the JSON Schema representation of input fields for an action. Returns a JSON Schema object describing the structure, types, and validation rules for the action's input parameters.
+
+**Parameters:**
+
+| Name                 | Type     | Required | Default | Possible Values                                                                                | Description                                                                                                                   |
+| -------------------- | -------- | -------- | ------- | ---------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------- |
+| `options`            | `object` | ✅       | —       | —                                                                                              |                                                                                                                               |
+| ↳ `appKey`           | `string` | ✅       | —       | —                                                                                              | App key (e.g., 'SlackCLIAPI' or slug like 'github') to get the input schema for                                               |
+| ↳ `actionType`       | `string` | ✅       | —       | `read`, `read_bulk`, `write`, `run`, `search`, `search_or_write`, `search_and_write`, `filter` | Action type that matches the action's defined type                                                                            |
+| ↳ `actionKey`        | `string` | ✅       | —       | —                                                                                              | Action key to get the input schema for                                                                                        |
+| ↳ `authenticationId` | `string` | ❌       | —       | —                                                                                              | Authentication ID to use when fetching the schema. Required if the action needs authentication to determine available fields. |
+| ↳ `inputs`           | `object` | ❌       | —       | —                                                                                              | Current input values that may affect the schema (e.g., when fields depend on other field values)                              |
+
+**Returns:** `Promise<InputSchemaItem>`
+
+**Example:**
+
+```typescript
+const { data: inputSchema } = await sdk.getInputFieldsSchema({
+  appKey: "example-key",
+  actionType: "read",
+  actionKey: "example-key",
+});
+```
+
 #### `listActions`
 
 List all actions for a specific app

package/dist/api/client.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../src/api/client.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EACV,SAAS,EACT,gBAAgB,EAGjB,MAAM,SAAS,CAAC;AA4cjB,eAAO,MAAM,eAAe,GAAI,SAAS,gBAAgB,KAAG,SAW3D,CAAC"}
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../src/api/client.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EACV,SAAS,EACT,gBAAgB,EAGjB,MAAM,SAAS,CAAC;AAwejB,eAAO,MAAM,eAAe,GAAI,SAAS,gBAAgB,KAAG,SAW3D,CAAC"}

package/dist/api/client.js

@@ -8,11 +8,18 @@ import { getAuthorizationHeader } from "./auth";
 import { createDebugLogger, createDebugFetch } from "./debug";
 import { pollUntilComplete } from "./polling";
 import { getTokenFromEnvOrConfig } from "../auth";
+import { getZapierBaseUrl } from "../utils/url-utils";
 import { ZapierApiError, ZapierAuthenticationError, ZapierValidationError, ZapierNotFoundError, } from "../types/errors";
-const SubdomainConfigMap = {
-    // e.g. https://relay.zapier.com
-    relay: {
+const pathConfig = {
+    // e.g. /relay -> https://sdkapi.zapier.com/api/v0/sdk/relay/...
+    "/relay": {
         authHeader: "X-Relay-Authorization",
+        pathPrefix: "/api/v0/sdk/relay",
+    },
+    // e.g. /zapier -> https://sdkapi.zapier.com/api/v0/sdk/zapier/...
+    "/zapier": {
+        authHeader: "Authorization",
+        pathPrefix: "/api/v0/sdk/zapier",
     },
 };
 class ZapierApiClient {
@@ -223,37 +230,53 @@ class ZapierApiClient {
             return { message: fallbackMessage };
         }
     }
-    // Check if this is a path that needs subdomain routing
-    // e.g. /relay/workflows -> relay.zapier.com/workflows
-    applySubdomainBehavior(path) {
-        const pathSegments = path.split("/").filter(Boolean);
-        if (pathSegments.length > 0 && pathSegments[0] in SubdomainConfigMap) {
-            // Transform paths to use subdomain routing
-            // /prefix/domain/path -> prefix.zapier.com/domain/path
-            const domainPrefix = pathSegments[0];
-            const subdomainConfig = SubdomainConfigMap[domainPrefix];
+    // Apply any special routing logic for configured paths.
+    applyPathConfiguration(path) {
+        // Find matching path configuration.
+        const matchingPathKey = Object.keys(pathConfig).find((configPath) => path === configPath || path.startsWith(configPath + "/"));
+        const config = matchingPathKey ? pathConfig[matchingPathKey] : undefined;
+        // Check if baseUrl is a Zapier-inferred base URL.
+        const zapierBaseUrl = getZapierBaseUrl(this.options.baseUrl);
+        // Let's remain compatible with a base URL that is set to a Zapier-inferred
+        // domain, rather than requiring the base URL to go to our proxy. Later, the
+        // proxy will be removed, so this should make that transition easier.
+        if (zapierBaseUrl === this.options.baseUrl) {
+            // If baseUrl is already the Zapier base URL, use sdkapi subdomain.
             const originalBaseUrl = new URL(this.options.baseUrl);
-            const finalBaseUrl = `https://${domainPrefix}.${originalBaseUrl.hostname}`;
-            const pathWithoutPrefix = "/" + pathSegments.slice(1).join("/");
-            return { url: new URL(pathWithoutPrefix, finalBaseUrl), subdomainConfig };
+            const finalBaseUrl = `https://sdkapi.${originalBaseUrl.hostname}`;
+            // Only prepend pathPrefix if there's a matching config with pathPrefix.
+            let finalPath = path;
+            if (config &&
+                "pathPrefix" in config &&
+                config.pathPrefix &&
+                matchingPathKey) {
+                // Strip the matching path key, and use the pathPrefix instead.
+                const pathWithoutPrefix = path.slice(matchingPathKey.length) || "/";
+                finalPath = `${config.pathPrefix}${pathWithoutPrefix}`;
+            }
+            return {
+                url: new URL(finalPath, finalBaseUrl),
+                pathConfig: config,
+            };
         }
+        // For a base URL that isn't a Zapier-inferred domain, use the whole base URL.
         return {
             url: new URL(path, this.options.baseUrl),
-            subdomainConfig: undefined,
+            pathConfig: config,
         };
     }
     // Helper to build full URLs and return routing info
     buildUrl(path, searchParams) {
-        const { url, subdomainConfig } = this.applySubdomainBehavior(path);
+        const { url, pathConfig: config } = this.applyPathConfiguration(path);
         if (searchParams) {
             Object.entries(searchParams).forEach(([key, value]) => {
                 url.searchParams.set(key, value);
             });
         }
-        return { url: url.toString(), subdomainConfig };
+        return { url: url.toString(), pathConfig: config };
     }
     // Helper to build headers
-    async buildHeaders(options = {}, subdomainConfig) {
+    async buildHeaders(options = {}, pathConfig) {
         const headers = new Headers(options.headers ?? {});
         // Even if auth is not required, we still want to add it in case it adds
         // useful context to the API. The session is a good example of this. Auth
@@ -261,7 +284,7 @@ class ZapierApiClient {
         // session!
         const authToken = await this.getAuthToken();
         if (authToken) {
-            const authHeaderName = subdomainConfig?.authHeader || "Authorization";
+            const authHeaderName = pathConfig?.authHeader || "Authorization";
             headers.set(authHeaderName, getAuthorizationHeader(authToken));
         }
         // If we know auth is required, and we don't have a token, throw an error
@@ -307,8 +330,8 @@ class ZapierApiClient {
         if (fetchOptions?.body && typeof fetchOptions.body === "object") {
             fetchOptions.body = JSON.stringify(fetchOptions.body);
         }
-        const { url, subdomainConfig } = this.buildUrl(path, fetchOptions?.searchParams);
-        const builtHeaders = await this.buildHeaders(fetchOptions, subdomainConfig);
+        const { url, pathConfig } = this.buildUrl(path, fetchOptions?.searchParams);
+        const builtHeaders = await this.buildHeaders(fetchOptions, pathConfig);
         const inputHeaders = new Headers(fetchOptions?.headers ?? {});
         const mergedHeaders = new Headers();
         builtHeaders.forEach((value, key) => {

package/dist/api/schemas.d.ts

@@ -972,6 +972,7 @@ export declare const NeedsResponseSchema: z.ZodObject<{
     }>, "many">>;
     errors: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
     last_fetched_at: z.ZodOptional<z.ZodString>;
+    schema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
 }, "strip", z.ZodTypeAny, {
     success: boolean;
     needs?: {
@@ -1008,6 +1009,7 @@ export declare const NeedsResponseSchema: z.ZodObject<{
     }[] | undefined;
     errors?: string[] | undefined;
     last_fetched_at?: string | undefined;
+    schema?: Record<string, unknown> | undefined;
 }, {
     success: boolean;
     needs?: {
@@ -1044,6 +1046,7 @@ export declare const NeedsResponseSchema: z.ZodObject<{
     }[] | undefined;
     errors?: string[] | undefined;
     last_fetched_at?: string | undefined;
+    schema?: Record<string, unknown> | undefined;
 }>;
 export declare const ImplementationSchema: z.ZodObject<{
     selected_api: z.ZodString;

package/dist/api/schemas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../src/api/schemas.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../src/api/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;;GAIG;AAMH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;EAK5B,CAAC;AAEH,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA0CrB,CAAC;AAEH,eAAO,MAAM,iBAAiB;;;;;;EAE5B,CAAC;AAEH,eAAO,MAAM,uBAAuB;;;;;;EAElC,CAAC;AAEH,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkBvB,CAAC;AAEH,eAAO,MAAM,YAAY;;;;;;;;;EAGvB,CAAC;AAEH,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAetB,CAAC;AAEH,eAAO,MAAM,2BAA2B;;;;;;EAEtC,CAAC;AAEH,eAAO,MAAM,uBAAuB;;;;;;;;;EAGlC,CAAC;AAEH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAe5B,CAAC;AAMH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqB/B,CAAC;AAEH,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAKxC,CAAC;AAEH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAoD5B,CAAC;AAEH,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA+BpB,CAAC;AAEH,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAaxB,CAAC;AAEH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAIjC,CAAC;AAMH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;EAM7B,CAAC;AAEH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAM9B,CAAC;AAMH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmB/B,CAAC;AAEH,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAKxC,CAAC;AAMH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2DnC,CAAC;AAEH,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAK5C,CAAC;AAMH,eAAO,MAAM,6BAA6B;;;;;;EAExC,CAAC;AAEH,eAAO,MAAM,8BAA8B;;;;;;;;;EAGzC,CAAC;AAEH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;EAsCnC,CAAC;AAEH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAOpC,CAAC"}

package/dist/api/schemas.js

@@ -272,6 +272,7 @@ export const NeedsResponseSchema = z.object({
     needs: z.array(NeedSchema).optional(),
     errors: z.array(z.string()).optional(),
     last_fetched_at: z.string().optional(),
+    schema: z.record(z.unknown()).optional(),
 });
 // ============================================================================
 // Implementation Schema

package/dist/index.cjs

@@ -978,7 +978,8 @@ zod.z.object({
   success: zod.z.boolean(),
   needs: zod.z.array(NeedSchema).optional(),
   errors: zod.z.array(zod.z.string()).optional(),
-  last_fetched_at: zod.z.string().optional()
+  last_fetched_at: zod.z.string().optional(),
+  schema: zod.z.record(zod.z.unknown()).optional()
 });
 var ImplementationSchema = zod.z.object({
   selected_api: zod.z.string(),
@@ -1295,7 +1296,7 @@ var listAppsPlugin = ({ context }) => {
       const searchParams2 = {};
       searchParams2.term = options.search;
       const searchEnvelope = await api.get(
-        "/api/v4/implementations-meta/search/",
+        "/zapier/api/v4/implementations-meta/search/",
         {
           searchParams: searchParams2
         }
@@ -1335,7 +1336,7 @@ var listAppsPlugin = ({ context }) => {
       };
     }
     const implementationsEnvelope = await api.get(
-      "/api/v4/implementations-meta/lookup/",
+      "/zapier/api/v4/implementations-meta/lookup/",
       {
         searchParams
       }
@@ -1621,7 +1622,7 @@ var listActionsPlugin = ({ context }) => {
       selected_apis: selectedApi
     };
     const data = await api.get(
-      "/api/v4/implementations/",
+      "/zapier/api/v4/implementations/",
       {
         searchParams,
         customErrorHandler: ({ status }) => {
@@ -1831,7 +1832,7 @@ async function fetchImplementationNeeds({
     request.authentication_id = authenticationId;
   }
   const response = await api.post(
-    "/api/v4/implementations/needs/",
+    "/zapier/api/v4/implementations/needs/",
     request
   );
   if (!response.success) {
@@ -1859,7 +1860,7 @@ async function fetchImplementationChoices({
     request.authentication_id = authenticationId;
   }
   const response = await api.post(
-    "/api/v4/implementations/choices/",
+    "/zapier/api/v4/implementations/choices/",
     request
   );
   if (!response.success) {
@@ -2124,7 +2125,7 @@ var listAuthenticationsPlugin = ({ context }) => {
         searchParams.offset = options.cursor;
       }
       const data = await api.get(
-        "/api/v4/authentications/",
+        "/zapier/api/v4/authentications/",
         {
           searchParams,
           customErrorHandler: ({ status }) => {
@@ -2264,7 +2265,7 @@ var getAuthenticationPlugin = ({ context }) => {
     const { api } = context;
     const { authenticationId } = options;
     const data = await api.get(
-      `/api/v4/authentications/${authenticationId}/`,
+      `/zapier/api/v4/authentications/${authenticationId}/`,
       {
         customErrorHandler: ({ status }) => {
           if (status === 401) {
@@ -2457,11 +2458,11 @@ async function executeAction(actionOptions) {
     data: runRequestData
   };
   const runData = await api.post(
-    "/api/actions/v1/runs",
+    "/zapier/api/actions/v1/runs",
     runRequest
   );
   const runId = runData.data.id;
-  return await api.poll(`/api/actions/v1/runs/${runId}`, {
+  return await api.poll(`/zapier/api/actions/v1/runs/${runId}`, {
     successStatus: 200,
     pendingStatus: 202,
     resultExtractor: (result) => result.data
@@ -2742,7 +2743,7 @@ async function getPreferredManifestEntryKey({
   }
   if (locator.implementationName) {
     try {
-      const implementationsEnvelope = await api.get(`/api/v4/implementations-meta/lookup/`, {
+      const implementationsEnvelope = await api.get(`/zapier/api/v4/implementations-meta/lookup/`, {
         searchParams: {
           selected_apis: locator.implementationName
         }
@@ -2769,7 +2770,7 @@ async function listAppsForSlugsPage({
     searchParams.offset = cursor;
   }
   const implementationsEnvelope = await api.get(
-    "/api/v4/implementations-meta/lookup/",
+    "/zapier/api/v4/implementations-meta/lookup/",
     {
       searchParams
     }
@@ -3008,9 +3009,12 @@ var UserProfileItemSchema = withFormatter(
 // src/plugins/getProfile/index.ts
 var getProfilePlugin = ({ context }) => {
   const getProfile = createFunction(async function getProfile2() {
-    const profile = await context.api.get("/api/v4/profile/", {
-      authRequired: true
-    });
+    const profile = await context.api.get(
+      "/zapier/api/v4/profile/",
+      {
+        authRequired: true
+      }
+    );
     const { user_id: _unusedUserId, ...data } = profile;
     return {
       data: {
@@ -3337,11 +3341,63 @@ async function getTokenFromEnvOrConfig(options = {}) {
   return getTokenFromCliLogin(options);
 }
 
+// src/utils/url-utils.ts
+function getZapierBaseUrl(baseUrl) {
+  if (!baseUrl) {
+    return void 0;
+  }
+  try {
+    const url = new URL(baseUrl);
+    const hostname = url.hostname;
+    const hostParts = hostname.split(".");
+    if (hostParts.length < 2) {
+      return void 0;
+    }
+    const hasZapierPart = hostParts.some(
+      (part) => part === "zapier" || part.startsWith("zapier-")
+    );
+    if (!hasZapierPart) {
+      return void 0;
+    }
+    const rootDomain = hostParts.slice(-2).join(".");
+    return `${url.protocol}//${rootDomain}`;
+  } catch {
+    return void 0;
+  }
+}
+function getTrackingBaseUrl({
+  trackingBaseUrl,
+  baseUrl
+}) {
+  if (trackingBaseUrl) {
+    return trackingBaseUrl;
+  }
+  if (process.env.ZAPIER_TRACKING_BASE_URL) {
+    return process.env.ZAPIER_TRACKING_BASE_URL;
+  }
+  if (baseUrl) {
+    const zapierBaseUrl = getZapierBaseUrl(baseUrl);
+    if (zapierBaseUrl) {
+      return zapierBaseUrl;
+    }
+  }
+  if (baseUrl) {
+    return baseUrl;
+  }
+  return ZAPIER_BASE_URL;
+}
+
 // src/api/client.ts
-var SubdomainConfigMap = {
-  // e.g. https://relay.zapier.com
-  relay: {
-    authHeader: "X-Relay-Authorization"
+var pathConfig = {
+  // e.g. /relay -> https://sdkapi.zapier.com/api/v0/sdk/relay/...
+  "/relay": {
+    authHeader: "X-Relay-Authorization",
+    pathPrefix: "/api/v0/sdk/relay"
+  },
+  // e.g. /zapier -> https://sdkapi.zapier.com/api/v0/sdk/zapier/...
+  "/zapier": {
+    authHeader: "Authorization",
+    pathPrefix: "/api/v0/sdk/zapier"
   }
 };
 var ZapierApiClient = class {
@@ -3530,39 +3586,47 @@ var ZapierApiClient = class {
       return { message: fallbackMessage };
     }
   }
-  // Check if this is a path that needs subdomain routing
-  // e.g. /relay/workflows -> relay.zapier.com/workflows
-  applySubdomainBehavior(path) {
-    const pathSegments = path.split("/").filter(Boolean);
-    if (pathSegments.length > 0 && pathSegments[0] in SubdomainConfigMap) {
-      const domainPrefix = pathSegments[0];
-      const subdomainConfig = SubdomainConfigMap[domainPrefix];
+  // Apply any special routing logic for configured paths.
+  applyPathConfiguration(path) {
+    const matchingPathKey = Object.keys(pathConfig).find(
+      (configPath) => path === configPath || path.startsWith(configPath + "/")
+    );
+    const config = matchingPathKey ? pathConfig[matchingPathKey] : void 0;
+    const zapierBaseUrl = getZapierBaseUrl(this.options.baseUrl);
+    if (zapierBaseUrl === this.options.baseUrl) {
       const originalBaseUrl = new URL(this.options.baseUrl);
-      const finalBaseUrl = `https://${domainPrefix}.${originalBaseUrl.hostname}`;
-      const pathWithoutPrefix = "/" + pathSegments.slice(1).join("/");
-      return { url: new URL(pathWithoutPrefix, finalBaseUrl), subdomainConfig };
+      const finalBaseUrl = `https://sdkapi.${originalBaseUrl.hostname}`;
+      let finalPath = path;
+      if (config && "pathPrefix" in config && config.pathPrefix && matchingPathKey) {
+        const pathWithoutPrefix = path.slice(matchingPathKey.length) || "/";
+        finalPath = `${config.pathPrefix}${pathWithoutPrefix}`;
+      }
+      return {
+        url: new URL(finalPath, finalBaseUrl),
+        pathConfig: config
+      };
     }
     return {
       url: new URL(path, this.options.baseUrl),
-      subdomainConfig: void 0
+      pathConfig: config
     };
   }
   // Helper to build full URLs and return routing info
   buildUrl(path, searchParams) {
-    const { url, subdomainConfig } = this.applySubdomainBehavior(path);
+    const { url, pathConfig: config } = this.applyPathConfiguration(path);
     if (searchParams) {
       Object.entries(searchParams).forEach(([key, value]) => {
         url.searchParams.set(key, value);
       });
     }
-    return { url: url.toString(), subdomainConfig };
+    return { url: url.toString(), pathConfig: config };
   }
   // Helper to build headers
-  async buildHeaders(options = {}, subdomainConfig) {
+  async buildHeaders(options = {}, pathConfig2) {
     const headers = new Headers(options.headers ?? {});
     const authToken = await this.getAuthToken();
     if (authToken) {
-      const authHeaderName = subdomainConfig?.authHeader || "Authorization";
+      const authHeaderName = pathConfig2?.authHeader || "Authorization";
       headers.set(authHeaderName, getAuthorizationHeader(authToken));
     }
     if (options.authRequired) {
@@ -3609,13 +3673,10 @@ var ZapierApiClient = class {
     if (fetchOptions?.body && typeof fetchOptions.body === "object") {
       fetchOptions.body = JSON.stringify(fetchOptions.body);
     }
-    const { url, subdomainConfig } = this.buildUrl(
-      path,
-      fetchOptions?.searchParams
-    );
+    const { url, pathConfig: pathConfig2 } = this.buildUrl(path, fetchOptions?.searchParams);
     const builtHeaders = await this.buildHeaders(
       fetchOptions,
-      subdomainConfig
+      pathConfig2
     );
     const inputHeaders = new Headers(fetchOptions?.headers ?? {});
     const mergedHeaders = new Headers();
@@ -3859,6 +3920,85 @@ var registryPlugin = ({ sdk, context }) => {
     getRegistry
   };
 };
+var GetInputFieldsSchemaSchema = zod.z.object({
+  appKey: AppKeyPropertySchema.describe(
+    "App key (e.g., 'SlackCLIAPI' or slug like 'github') to get the input schema for"
+  ),
+  actionType: ActionTypePropertySchema.describe(
+    "Action type that matches the action's defined type"
+  ),
+  actionKey: ActionKeyPropertySchema.describe(
+    "Action key to get the input schema for"
+  ),
+  authenticationId: AuthenticationIdPropertySchema.nullable().optional().describe(
+    "Authentication ID to use when fetching the schema. Required if the action needs authentication to determine available fields."
+  ),
+  inputs: InputsPropertySchema.optional().describe(
+    "Current input values that may affect the schema (e.g., when fields depend on other field values)"
+  )
+}).describe(
+  "Get the JSON Schema representation of input fields for an action. Returns a JSON Schema object describing the structure, types, and validation rules for the action's input parameters."
+);
+
+// src/plugins/getInputFieldsSchema/index.ts
+var getInputFieldsSchemaPlugin = ({ sdk, context }) => {
+  const getInputFieldsSchema = createFunction(
+    async function getInputFieldsSchema2(options) {
+      const { api, getVersionedImplementationId } = context;
+      const {
+        appKey,
+        actionKey,
+        actionType,
+        authenticationId = null,
+        inputs
+      } = options;
+      const selectedApi = await getVersionedImplementationId(appKey);
+      if (!selectedApi) {
+        throw new ZapierConfigurationError(
+          "No current_implementation_id found for app",
+          { configType: "current_implementation_id" }
+        );
+      }
+      const { data: action } = await sdk.getAction({
+        appKey,
+        actionType,
+        actionKey
+      });
+      const needsData = await fetchImplementationNeeds({
+        api,
+        selectedApi,
+        action: action.key,
+        actionType,
+        authenticationId,
+        inputs
+      });
+      return {
+        data: needsData.schema || {}
+      };
+    },
+    GetInputFieldsSchemaSchema
+  );
+  return {
+    getInputFieldsSchema,
+    context: {
+      meta: {
+        getInputFieldsSchema: {
+          categories: ["action"],
+          type: "item",
+          itemType: "InputSchema",
+          inputSchema: GetInputFieldsSchemaSchema,
+          resolvers: {
+            appKey: appKeyResolver,
+            actionType: actionTypeResolver,
+            actionKey: actionKeyResolver,
+            authenticationId: authenticationIdResolver,
+            inputs: inputsAllOptionalResolver
+          }
+        }
+      }
+    }
+  };
+};
 var InputFieldChoiceItemSchema = withFormatter(NeedChoicesSchema, {
   format: (item) => {
     const title = item.label || item.key || "Choice";
@@ -4162,7 +4302,7 @@ function getCpuTime() {
 
 // package.json
 var package_default = {
-  version: "0.14.0"};
+  version: "0.15.1"};
 
 // src/plugins/eventEmission/builders.ts
 function createBaseEvent(context = {}) {
@@ -4232,52 +4372,6 @@ function buildErrorEventWithContext(data, context = {}) {
   };
 }
 
-// src/utils/url-utils.ts
-function getZapierBaseUrl(baseUrl) {
-  if (!baseUrl) {
-    return void 0;
-  }
-  try {
-    const url = new URL(baseUrl);
-    const hostname = url.hostname;
-    const hostParts = hostname.split(".");
-    if (hostParts.length < 2) {
-      return void 0;
-    }
-    const hasZapierPart = hostParts.some(
-      (part) => part === "zapier" || part.startsWith("zapier-")
-    );
-    if (!hasZapierPart) {
-      return void 0;
-    }
-    const rootDomain = hostParts.slice(-2).join(".");
-    return `${url.protocol}//${rootDomain}`;
-  } catch {
-    return void 0;
-  }
-}
-function getTrackingBaseUrl({
-  trackingBaseUrl,
-  baseUrl
-}) {
-  if (trackingBaseUrl) {
-    return trackingBaseUrl;
-  }
-  if (process.env.ZAPIER_TRACKING_BASE_URL) {
-    return process.env.ZAPIER_TRACKING_BASE_URL;
-  }
-  if (baseUrl) {
-    const zapierBaseUrl = getZapierBaseUrl(baseUrl);
-    if (zapierBaseUrl) {
-      return zapierBaseUrl;
-    }
-  }
-  if (baseUrl) {
-    return baseUrl;
-  }
-  return ZAPIER_BASE_URL;
-}
-
 // src/plugins/eventEmission/index.ts
 var APPLICATION_LIFECYCLE_EVENT_SUBJECT = "platform.sdk.ApplicationLifecycleEvent";
 var ERROR_OCCURRED_EVENT_SUBJECT = "platform.sdk.ErrorOccurredEvent";
@@ -4524,7 +4618,7 @@ function createSdk(options = {}, initialSdk = {}, initialContext = { meta: {} })
   };
 }
 function createZapierSdkWithoutRegistry(options = {}) {
-  return createSdk(options).addPlugin(eventEmissionPlugin).addPlugin(apiPlugin).addPlugin(manifestPlugin).addPlugin(listAppsPlugin).addPlugin(getAppPlugin).addPlugin(listActionsPlugin).addPlugin(getActionPlugin).addPlugin(listInputFieldsPlugin).addPlugin(listInputFieldChoicesPlugin).addPlugin(runActionPlugin).addPlugin(listAuthenticationsPlugin).addPlugin(getAuthenticationPlugin).addPlugin(findFirstAuthenticationPlugin).addPlugin(findUniqueAuthenticationPlugin).addPlugin(requestPlugin).addPlugin(fetchPlugin).addPlugin(appsPlugin).addPlugin(getProfilePlugin);
+  return createSdk(options).addPlugin(eventEmissionPlugin).addPlugin(apiPlugin).addPlugin(manifestPlugin).addPlugin(listAppsPlugin).addPlugin(getAppPlugin).addPlugin(listActionsPlugin).addPlugin(getActionPlugin).addPlugin(listInputFieldsPlugin).addPlugin(getInputFieldsSchemaPlugin).addPlugin(listInputFieldChoicesPlugin).addPlugin(runActionPlugin).addPlugin(listAuthenticationsPlugin).addPlugin(getAuthenticationPlugin).addPlugin(findFirstAuthenticationPlugin).addPlugin(findUniqueAuthenticationPlugin).addPlugin(requestPlugin).addPlugin(fetchPlugin).addPlugin(appsPlugin).addPlugin(getProfilePlugin);
 }
 function createZapierSdk(options = {}) {
   return createZapierSdkWithoutRegistry(options).addPlugin(registryPlugin);