@zapier/zapier-sdk 0.23.2 → 0.24.0

package/dist/plugins/fetch/index.test.js

@@ -0,0 +1,296 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { fetchPlugin } from "./index";
+import { createSdk } from "../../sdk";
+import { eventEmissionPlugin } from "../eventEmission";
+describe("fetch plugin", () => {
+    let mockApiClient;
+    let mockFetch;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mockFetch = vi.fn().mockResolvedValue(new Response('{"success": true}', {
+            status: 200,
+            headers: { "Content-Type": "application/json" },
+        }));
+        mockApiClient = {
+            fetch: mockFetch,
+        };
+    });
+    const apiPlugin = () => ({
+        context: {
+            api: mockApiClient,
+        },
+    });
+    function createTestSdk() {
+        return createSdk()
+            .addPlugin(() => ({
+            context: {
+                options: {},
+            },
+        }))
+            .addPlugin(apiPlugin)
+            .addPlugin(eventEmissionPlugin)
+            .addPlugin(fetchPlugin);
+    }
+    describe("URL transformation", () => {
+        it("should transform full URLs to relay path format", async () => {
+            const sdk = createTestSdk();
+            await sdk.fetch("https://api.github.com/user");
+            expect(mockFetch).toHaveBeenCalledWith("/relay/api.github.com/user", expect.any(Object));
+        });
+        it("should preserve query parameters and fragments", async () => {
+            const sdk = createTestSdk();
+            await sdk.fetch("https://api.example.com/search?q=test&limit=10#section");
+            expect(mockFetch).toHaveBeenCalledWith("/relay/api.example.com/search?q=test&limit=10#section", expect.any(Object));
+        });
+        it("should handle URLs with ports", async () => {
+            const sdk = createTestSdk();
+            await sdk.fetch("https://api.example.com:8443/data");
+            expect(mockFetch).toHaveBeenCalledWith("/relay/api.example.com:8443/data", expect.any(Object));
+        });
+        it("should handle URL objects", async () => {
+            const sdk = createTestSdk();
+            await sdk.fetch(new URL("https://api.example.com/data"));
+            expect(mockFetch).toHaveBeenCalledWith("/relay/api.example.com/data", expect.any(Object));
+        });
+    });
+    describe("headers handling", () => {
+        it("should pass through regular headers", async () => {
+            const sdk = createTestSdk();
+            const headers = {
+                "Content-Type": "application/json",
+                "X-Custom-Header": "test-value",
+            };
+            await sdk.fetch("https://api.example.com/data", {
+                method: "POST",
+                headers,
+            });
+            expect(mockFetch).toHaveBeenCalledWith("/relay/api.example.com/data", {
+                method: "POST",
+                body: undefined,
+                headers: {
+                    "Content-Type": "application/json",
+                    "X-Custom-Header": "test-value",
+                },
+                authRequired: true,
+            });
+        });
+        it("should add relay-specific headers when provided", async () => {
+            const sdk = createTestSdk();
+            await sdk.fetch("https://api.example.com/data", {
+                method: "POST",
+                authenticationId: 123,
+                callbackUrl: "https://webhook.example.com/callback",
+                authenticationTemplate: '{"token": "{{auth.token}}"}',
+            });
+            expect(mockFetch).toHaveBeenCalledWith("/relay/api.example.com/data", {
+                method: "POST",
+                body: undefined,
+                headers: {
+                    "X-Relay-Authentication-Id": "123",
+                    "X-Relay-Callback-Url": "https://webhook.example.com/callback",
+                    "X-Authentication-Template": '{"token": "{{auth.token}}"}',
+                },
+                authRequired: true,
+            });
+        });
+        it("should handle Headers object", async () => {
+            const sdk = createTestSdk();
+            const headers = new Headers();
+            headers.set("Content-Type", "application/json");
+            headers.set("Authorization", "Bearer token");
+            await sdk.fetch("https://api.example.com/data", { headers });
+            expect(mockFetch).toHaveBeenCalledWith("/relay/api.example.com/data", {
+                method: "GET",
+                body: undefined,
+                headers: {
+                    "content-type": "application/json",
+                    authorization: "Bearer token",
+                },
+                authRequired: true,
+            });
+        });
+        it("should handle headers as array of tuples", async () => {
+            const sdk = createTestSdk();
+            const headers = [
+                ["Content-Type", "application/json"],
+                ["X-Api-Key", "secret"],
+            ];
+            await sdk.fetch("https://api.example.com/data", { headers });
+            expect(mockFetch).toHaveBeenCalledWith("/relay/api.example.com/data", {
+                method: "GET",
+                body: undefined,
+                headers: {
+                    "Content-Type": "application/json",
+                    "X-Api-Key": "secret",
+                },
+                authRequired: true,
+            });
+        });
+    });
+    describe("HTTP methods", () => {
+        const methods = [
+            "GET",
+            "POST",
+            "PUT",
+            "DELETE",
+            "PATCH",
+            "HEAD",
+            "OPTIONS",
+        ];
+        methods.forEach((method) => {
+            it(`should support ${method} method`, async () => {
+                const sdk = createTestSdk();
+                await sdk.fetch("https://api.example.com/data", { method });
+                expect(mockFetch).toHaveBeenCalledWith("/relay/api.example.com/data", {
+                    method,
+                    body: undefined,
+                    headers: {},
+                    authRequired: true,
+                });
+            });
+        });
+        it("should default to GET method", async () => {
+            const sdk = createTestSdk();
+            await sdk.fetch("https://api.example.com/data");
+            expect(mockFetch).toHaveBeenCalledWith("/relay/api.example.com/data", {
+                method: "GET",
+                body: undefined,
+                headers: {},
+                authRequired: true,
+            });
+        });
+    });
+    describe("request body", () => {
+        it("should pass through request body", async () => {
+            const sdk = createTestSdk();
+            const body = '{"name": "test", "value": 42}';
+            await sdk.fetch("https://api.example.com/data", {
+                method: "POST",
+                body,
+            });
+            expect(mockFetch).toHaveBeenCalledWith("/relay/api.example.com/data", {
+                method: "POST",
+                body,
+                headers: {
+                    "Content-Type": "application/json; charset=utf-8",
+                },
+                authRequired: true,
+            });
+        });
+        it("should auto-set Content-Type for JSON object bodies", async () => {
+            const sdk = createTestSdk();
+            const body = '{"key": "value"}';
+            await sdk.fetch("https://api.example.com/data", {
+                method: "POST",
+                body,
+            });
+            expect(mockFetch).toHaveBeenCalledWith("/relay/api.example.com/data", {
+                method: "POST",
+                body,
+                headers: {
+                    "Content-Type": "application/json; charset=utf-8",
+                },
+                authRequired: true,
+            });
+        });
+        it("should auto-set Content-Type for JSON array bodies", async () => {
+            const sdk = createTestSdk();
+            const body = '[{"id": 1}, {"id": 2}]';
+            await sdk.fetch("https://api.example.com/data", {
+                method: "POST",
+                body,
+            });
+            expect(mockFetch).toHaveBeenCalledWith("/relay/api.example.com/data", {
+                method: "POST",
+                body,
+                headers: {
+                    "Content-Type": "application/json; charset=utf-8",
+                },
+                authRequired: true,
+            });
+        });
+        it("should not override explicit Content-Type header", async () => {
+            const sdk = createTestSdk();
+            const body = '{"key": "value"}';
+            await sdk.fetch("https://api.example.com/data", {
+                method: "POST",
+                body,
+                headers: {
+                    "Content-Type": "text/plain",
+                },
+            });
+            expect(mockFetch).toHaveBeenCalledWith("/relay/api.example.com/data", {
+                method: "POST",
+                body,
+                headers: {
+                    "Content-Type": "text/plain",
+                },
+                authRequired: true,
+            });
+        });
+        it("should not set Content-Type for non-JSON bodies", async () => {
+            const sdk = createTestSdk();
+            const body = "plain text body";
+            await sdk.fetch("https://api.example.com/data", {
+                method: "POST",
+                body,
+            });
+            expect(mockFetch).toHaveBeenCalledWith("/relay/api.example.com/data", {
+                method: "POST",
+                body,
+                headers: {},
+                authRequired: true,
+            });
+        });
+    });
+    describe("authentication", () => {
+        it("should set authRequired to true in API call options", async () => {
+            const sdk = createTestSdk();
+            await sdk.fetch("https://api.example.com/data");
+            expect(mockFetch).toHaveBeenCalledWith(expect.any(String), expect.objectContaining({
+                authRequired: true,
+            }));
+        });
+    });
+    describe("response handling", () => {
+        it("should return the response from api.fetch", async () => {
+            const mockResponse = new Response('{"result": "success"}', {
+                status: 200,
+                statusText: "OK",
+                headers: { "Content-Type": "application/json" },
+            });
+            mockFetch.mockResolvedValue(mockResponse);
+            const sdk = createTestSdk();
+            const response = await sdk.fetch("https://api.example.com/data");
+            expect(response).toBe(mockResponse);
+            expect(response.status).toBe(200);
+        });
+        it("should handle API errors", async () => {
+            const error = new Error("Network error");
+            mockFetch.mockRejectedValue(error);
+            const sdk = createTestSdk();
+            await expect(sdk.fetch("https://api.example.com/data")).rejects.toThrow("Network error");
+        });
+    });
+    describe("context and metadata", () => {
+        it("should provide context with meta information", () => {
+            const sdk = createTestSdk();
+            const context = sdk.getContext();
+            expect(context.meta.fetch).toBeDefined();
+            expect(context.meta.fetch.inputParameters).toBeDefined();
+            expect(context.meta.fetch.inputParameters).toHaveLength(2);
+        });
+        it("should include cli and mcp in packages", () => {
+            const sdk = createTestSdk();
+            const context = sdk.getContext();
+            expect(context.meta.fetch.packages).toContain("cli");
+            expect(context.meta.fetch.packages).toContain("mcp");
+            expect(context.meta.fetch.packages).toContain("sdk");
+        });
+        it("should be in the http category", () => {
+            const sdk = createTestSdk();
+            const context = sdk.getContext();
+            expect(context.meta.fetch.categories).toContain("http");
+        });
+    });
+});

package/dist/plugins/fetch/schemas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../src/plugins/fetch/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,eAAO,MAAM,cAAc,2DAEI,CAAC;AAEhC,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;kBA0ByB,CAAC"}
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../src/plugins/fetch/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,eAAO,MAAM,cAAc,2DAIxB,CAAC;AAEJ,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;kBAmCzB,CAAC"}

package/dist/plugins/fetch/schemas.js

@@ -3,20 +3,25 @@ import { AuthenticationIdPropertySchema } from "../../types/properties";
 // Schemas for fetch function parameters
 export const FetchUrlSchema = z
     .union([z.string(), z.instanceof(URL)])
-    .describe("The URL to fetch");
+    .describe("The full URL of the API endpoint to call (proxied through Zapier's Relay service)");
 export const FetchInitSchema = z
     .object({
     method: z
         .enum(["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"])
-        .optional(),
-    headers: z.record(z.string(), z.string()).optional(),
+        .optional()
+        .describe("HTTP method for the request (defaults to GET)"),
+    headers: z
+        .record(z.string(), z.string())
+        .optional()
+        .describe("HTTP headers to include in the request"),
     body: z
         .union([
         z.string(),
         z.instanceof(FormData),
         z.instanceof(URLSearchParams),
     ])
-        .optional(),
+        .optional()
+        .describe("Request body — JSON strings are auto-detected and Content-Type is set accordingly"),
     authenticationId: AuthenticationIdPropertySchema.optional(),
     callbackUrl: z
         .string()
@@ -28,4 +33,4 @@ export const FetchInitSchema = z
         .describe("Optional JSON string authentication template to bypass Notary lookup"),
 })
     .optional()
-    .describe("Fetch options including authentication");
+    .describe("Request options including method, headers, body, and authentication");

package/dist/plugins/registry/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/plugins/registry/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AACjD,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,iBAAiB,CAAC;AAE7D,MAAM,WAAW,6BAA6B;CAAG;AAEjD,MAAM,WAAW,sBAAsB;IACrC,WAAW,EAAE,CAAC,OAAO,CAAC,EAAE;QAAE,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE,KAAK;QAC/C,SAAS,EAAE,qBAAqB,EAAE,CAAC;QACnC,UAAU,EAAE;YACV,GAAG,EAAE,MAAM,CAAC;YACZ,KAAK,EAAE,MAAM,CAAC;YACd,WAAW,EAAE,MAAM,CAAC;YACpB,SAAS,EAAE,MAAM,EAAE,CAAC;SACrB,EAAE,CAAC;KACL,CAAC;CACH;AAGD,eAAO,MAAM,cAAc,EAAE,MAAM,CACjC,EAAE,EAAE,wBAAwB;AAC5B,EAAE,EAAE,sBAAsB;AAC1B,sBAAsB,CAiJvB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/plugins/registry/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AACjD,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,iBAAiB,CAAC;AAE7D,MAAM,WAAW,6BAA6B;CAAG;AAEjD,MAAM,WAAW,sBAAsB;IACrC,WAAW,EAAE,CAAC,OAAO,CAAC,EAAE;QAAE,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE,KAAK;QAC/C,SAAS,EAAE,qBAAqB,EAAE,CAAC;QACnC,UAAU,EAAE;YACV,GAAG,EAAE,MAAM,CAAC;YACZ,KAAK,EAAE,MAAM,CAAC;YACd,WAAW,EAAE,MAAM,CAAC;YACpB,SAAS,EAAE,MAAM,EAAE,CAAC;SACrB,EAAE,CAAC;KACL,CAAC;CACH;AAGD,eAAO,MAAM,cAAc,EAAE,MAAM,CACjC,EAAE,EAAE,wBAAwB;AAC5B,EAAE,EAAE,sBAAsB;AAC1B,sBAAsB,CAkJvB,CAAC"}

package/dist/plugins/registry/index.js

@@ -47,6 +47,7 @@ export const registryPlugin = ({ sdk, context }) => {
         const meta = context.meta[key];
         return {
             name: key,
+            description: meta.description,
             type: meta.type,
             itemType: meta.itemType,
             returnType: meta.returnType,

package/dist/plugins/request/index.d.ts

@@ -1,7 +1,7 @@
-import type { Plugin } from "../../types/plugin";
-import type { ApiClient } from "../../api";
+import type { Plugin, GetSdkType } from "../../types/plugin";
 import { RelayRequestSchema, type RelayRequestOptions } from "./schemas";
 import type { EventEmissionContext } from "../eventEmission";
+import type { FetchPluginProvides } from "../fetch";
 export interface RequestPluginProvides {
     request: (options: RelayRequestOptions) => Promise<Response>;
     context: {
@@ -12,10 +12,11 @@ export interface RequestPluginProvides {
         };
     };
 }
-export declare const requestPlugin: Plugin<{}, // no SDK dependencies
-// no SDK dependencies
-{
-    api: ApiClient;
-} & EventEmissionContext, // requires api in context
+/**
+ * @deprecated Use `sdk.fetch(url, init?)` instead. This plugin now delegates to the fetch plugin
+ * and is kept only for backward compatibility. It is hidden from the CLI/MCP registries.
+ */
+export declare const requestPlugin: Plugin<GetSdkType<FetchPluginProvides>, // requires fetch in SDK
+EventEmissionContext, // requires eventEmission context for telemetry
 RequestPluginProvides>;
 //# sourceMappingURL=index.d.ts.map

package/dist/plugins/request/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/plugins/request/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AACjD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAC3C,OAAO,EAAE,kBAAkB,EAAE,KAAK,mBAAmB,EAAE,MAAM,WAAW,CAAC;AAEzE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AAoB7D,MAAM,WAAW,qBAAqB;IACpC,OAAO,EAAE,CAAC,OAAO,EAAE,mBAAmB,KAAK,OAAO,CAAC,QAAQ,CAAC,CAAC;IAC7D,OAAO,EAAE;QACP,IAAI,EAAE;YACJ,OAAO,EAAE;gBACP,WAAW,EAAE,OAAO,kBAAkB,CAAC;aACxC,CAAC;SACH,CAAC;KACH,CAAC;CACH;AAED,eAAO,MAAM,aAAa,EAAE,MAAM,CAChC,EAAE,EAAE,sBAAsB;AAC1B,AADI,sBAAsB;AAC1B;IAAE,GAAG,EAAE,SAAS,CAAA;CAAE,GAAG,oBAAoB,EAAE,0BAA0B;AACrE,qBAAqB,CA4FtB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/plugins/request/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAC7D,OAAO,EAAE,kBAAkB,EAAE,KAAK,mBAAmB,EAAE,MAAM,WAAW,CAAC;AAEzE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AAE7D,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAC;AAGpD,MAAM,WAAW,qBAAqB;IACpC,OAAO,EAAE,CAAC,OAAO,EAAE,mBAAmB,KAAK,OAAO,CAAC,QAAQ,CAAC,CAAC;IAC7D,OAAO,EAAE;QACP,IAAI,EAAE;YACJ,OAAO,EAAE;gBACP,WAAW,EAAE,OAAO,kBAAkB,CAAC;aACxC,CAAC;SACH,CAAC;KACH,CAAC;CACH;AAED;;;GAGG;AACH,eAAO,MAAM,aAAa,EAAE,MAAM,CAChC,UAAU,CAAC,mBAAmB,CAAC,EAAE,wBAAwB;AACzD,oBAAoB,EAAE,+CAA+C;AACrE,qBAAqB,CAgDtB,CAAC"}

package/dist/plugins/request/index.js

@@ -1,64 +1,23 @@
 import { RelayRequestSchema } from "./schemas";
 import { createFunction } from "../../utils/function-utils";
 import { createTelemetryCallback } from "../../utils/telemetry-utils";
-import { coerceToNumericId } from "../../utils/id-utils";
+import { logDeprecation } from "../../utils/logging";
 /**
- * Transforms full URLs into Relay format: /relay/{domain}/{path}
- *
- * @param url - The full URL to transform (e.g., "https://api.github.com/user")
- * @returns The relay path format (e.g., "/relay/api.github.com/user")
+ * @deprecated Use `sdk.fetch(url, init?)` instead. This plugin now delegates to the fetch plugin
+ * and is kept only for backward compatibility. It is hidden from the CLI/MCP registries.
  */
-function transformUrlToRelayPath(url) {
-    const targetUrl = new URL(url);
-    // Build the Relay path: /relay/{host}{pathname}{search}{hash}
-    // Use host instead of hostname to include port if present
-    const relayPath = `/relay/${targetUrl.host}${targetUrl.pathname}${targetUrl.search}${targetUrl.hash}`;
-    return relayPath;
-}
-export const requestPlugin = ({ context }) => {
+export const requestPlugin = ({ sdk, context }) => {
     async function request(options) {
-        const { api } = context;
-        const { url, method = "GET", body, headers: optionsHeaders, authenticationId, callbackUrl, authenticationTemplate, } = options;
-        // Transform full URL to relay path format
-        const relayPath = transformUrlToRelayPath(url);
-        // Build headers for the request
-        const headers = {};
-        // Copy existing headers
-        if (optionsHeaders) {
-            const headerEntries = optionsHeaders instanceof Headers
-                ? Array.from(optionsHeaders.entries())
-                : Array.isArray(optionsHeaders)
-                    ? optionsHeaders
-                    : Object.entries(optionsHeaders);
-            for (const [key, value] of headerEntries) {
-                headers[key] = value;
-            }
-        }
-        // Auto-set Content-Type for JSON bodies if not already specified
-        const hasContentType = Object.keys(headers).some((k) => k.toLowerCase() === "content-type");
-        if (body && !hasContentType) {
-            const bodyStr = typeof body === "string" ? body : JSON.stringify(body);
-            const trimmed = bodyStr.trimStart();
-            if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
-                headers["Content-Type"] = "application/json; charset=utf-8";
-            }
-        }
-        // Add Relay-specific headers
-        if (authenticationId) {
-            headers["X-Relay-Authentication-Id"] = coerceToNumericId("authenticationId", authenticationId).toString();
-        }
-        if (callbackUrl) {
-            headers["X-Relay-Callback-Url"] = callbackUrl;
-        }
-        if (authenticationTemplate) {
-            headers["X-Authentication-Template"] = authenticationTemplate;
-        }
-        // Use the API client's fetch method directly - let it handle auth automatically
-        return await api.fetch(relayPath, {
+        logDeprecation("request() is deprecated. Use fetch() instead.");
+        const { url, method, body, headers, authenticationId, callbackUrl, authenticationTemplate, } = options;
+        return sdk.fetch(url, {
             method,
-            body,
-            headers,
-            authRequired: true,
+            body: body,
+            headers: headers,
+            authenticationId,
+            callbackUrl,
+            authenticationTemplate,
+            _telemetry: { isNested: true },
         });
     }
     const requestDefinition = createFunction(request, RelayRequestSchema, createTelemetryCallback(context.eventEmission.emitMethodCalled, request.name));
@@ -67,7 +26,8 @@ export const requestPlugin = ({ context }) => {
         context: {
             meta: {
                 request: {
-                    categories: ["http"],
+                    packages: ["cli", "mcp"],
+                    categories: ["http", "deprecated"],
                     returnType: "Response",
                     inputSchema: RelayRequestSchema,
                 },

package/dist/plugins/request/index.test.js

@@ -1,8 +1,10 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
 import { ZapierValidationError } from "../../types/errors";
 import { requestPlugin } from "./index";
+import { fetchPlugin } from "../fetch";
 import { createSdk } from "../../sdk";
-import { eventEmissionPlugin } from "../eventEmission";
+import { eventEmissionPlugin, } from "../eventEmission";
+import { resetDeprecationWarnings } from "../../utils/logging";
 describe("request plugin", () => {
     let mockApiClient;
     let mockFetch;
@@ -30,6 +32,7 @@ describe("request plugin", () => {
         }))
             .addPlugin(apiPlugin)
             .addPlugin(eventEmissionPlugin)
+            .addPlugin(fetchPlugin)
             .addPlugin(requestPlugin);
     }
     describe("schema validation", () => {
@@ -353,5 +356,106 @@ describe("request plugin", () => {
             expect(context.meta.request).toBeDefined();
             expect(context.meta.request.inputSchema).toBeDefined();
         });
+        it("should be in both cli and mcp packages for backward compat", () => {
+            const sdk = createTestSdk();
+            const context = sdk.getContext();
+            expect(context.meta.request.packages).toContain("cli");
+            expect(context.meta.request.packages).toContain("mcp");
+        });
+        it("should be marked as deprecated", () => {
+            const sdk = createTestSdk();
+            const context = sdk.getContext();
+            expect(context.meta.request.categories).toContain("deprecated");
+            expect(context.meta.request.categories).toContain("http");
+        });
+    });
+    describe("deprecation warning", () => {
+        let warnSpy;
+        beforeEach(() => {
+            resetDeprecationWarnings();
+            warnSpy = vi.spyOn(console, "warn").mockImplementation(() => { });
+        });
+        afterEach(() => {
+            warnSpy.mockRestore();
+        });
+        it("should log a deprecation warning when called", async () => {
+            const sdk = createTestSdk();
+            await sdk.request({ url: "https://api.example.com/data" });
+            expect(warnSpy).toHaveBeenCalledWith("[zapier-sdk] Deprecation: request() is deprecated. Use fetch() instead.");
+        });
+        it("should only log the deprecation warning once", async () => {
+            const sdk = createTestSdk();
+            await sdk.request({ url: "https://api.example.com/data" });
+            await sdk.request({ url: "https://api.example.com/other" });
+            const deprecationCalls = warnSpy.mock.calls.filter((call) => typeof call[0] === "string" && call[0].includes("Deprecation"));
+            expect(deprecationCalls).toHaveLength(1);
+        });
+    });
+    describe("backward compatibility with fetch", () => {
+        it("should produce the same api.fetch call as sdk.fetch for a simple GET", async () => {
+            const sdk = createTestSdk();
+            await sdk.request({ url: "https://api.example.com/data" });
+            const requestCall = mockFetch.mock.calls[0];
+            mockFetch.mockClear();
+            await sdk.fetch("https://api.example.com/data");
+            const fetchCall = mockFetch.mock.calls[0];
+            expect(requestCall).toEqual(fetchCall);
+        });
+        it("should produce the same api.fetch call as sdk.fetch for a POST with body and auth", async () => {
+            const sdk = createTestSdk();
+            const body = '{"key": "value"}';
+            await sdk.request({
+                url: "https://api.example.com/data",
+                method: "POST",
+                body,
+                headers: { "X-Custom": "header" },
+                authenticationId: 456,
+                callbackUrl: "https://callback.example.com/hook",
+                authenticationTemplate: '{"tok": "{{auth.tok}}"}',
+            });
+            const requestCall = mockFetch.mock.calls[0];
+            mockFetch.mockClear();
+            await sdk.fetch("https://api.example.com/data", {
+                method: "POST",
+                body,
+                headers: { "X-Custom": "header" },
+                authenticationId: 456,
+                callbackUrl: "https://callback.example.com/hook",
+                authenticationTemplate: '{"tok": "{{auth.tok}}"}',
+            });
+            const fetchCall = mockFetch.mock.calls[0];
+            expect(requestCall).toEqual(fetchCall);
+        });
+        it("should propagate errors from fetch through request", async () => {
+            const error = new Error("Network error");
+            mockFetch.mockRejectedValue(error);
+            const sdk = createTestSdk();
+            await expect(sdk.request({ url: "https://api.example.com/data" })).rejects.toThrow("Network error");
+        });
+        it("should not emit double telemetry when request delegates to fetch", async () => {
+            const emitSpy = vi.fn();
+            const mockEventEmissionPlugin = () => ({
+                context: {
+                    eventEmission: {
+                        transport: {},
+                        config: {},
+                        emit: () => { },
+                        createBaseEvent: (() => ({})),
+                        emitMethodCalled: emitSpy,
+                    },
+                },
+            });
+            const sdk = createSdk()
+                .addPlugin(() => ({
+                context: { options: {} },
+            }))
+                .addPlugin(apiPlugin)
+                .addPlugin(mockEventEmissionPlugin)
+                .addPlugin(fetchPlugin)
+                .addPlugin(requestPlugin);
+            await sdk.request({ url: "https://api.example.com/data" });
+            const methodCalledEvents = emitSpy.mock.calls.map((c) => c[0].method_name);
+            expect(methodCalledEvents).toEqual(["request"]);
+        });
     });
 });

package/dist/plugins/request/schemas.d.ts

@@ -16,7 +16,6 @@ export declare const RelayRequestSchema: z.ZodObject<{
     callbackUrl: z.ZodOptional<z.ZodString>;
     authenticationTemplate: z.ZodOptional<z.ZodString>;
     headers: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodString>, z.ZodCustom<Headers, Headers>, z.ZodArray<z.ZodTuple<[z.ZodString, z.ZodString], null>>]>>;
-    relayBaseUrl: z.ZodOptional<z.ZodString>;
     _telemetry: z.ZodOptional<z.ZodObject<{
         isNested: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strip>>;
@@ -42,7 +41,6 @@ export declare const RelayFetchSchema: z.ZodObject<{
     callbackUrl: z.ZodOptional<z.ZodString>;
     authenticationTemplate: z.ZodOptional<z.ZodString>;
     headers: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodString>, z.ZodCustom<Headers, Headers>, z.ZodArray<z.ZodTuple<[z.ZodString, z.ZodString], null>>]>>;
-    relayBaseUrl: z.ZodOptional<z.ZodString>;
     _telemetry: z.ZodOptional<z.ZodObject<{
         isNested: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strip>>;

package/dist/plugins/request/schemas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../src/plugins/request/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EACV,cAAc,EACd,qBAAqB,EACrB,kBAAkB,EACnB,MAAM,oBAAoB,CAAC;AAK5B,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;iBAoC+C,CAAC;AAG/E,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAGrE,MAAM,MAAM,iBAAiB,GACzB,cAAc,GACd,qBAAqB,GACrB,kBAAkB,CAAC;AAGvB,MAAM,WAAW,uBAAuB;IACtC,OAAO,EAAE,CAAC,OAAO,EAAE,mBAAmB,KAAK,OAAO,CAAC,QAAQ,CAAC,CAAC;CAC9D;AAGD,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;iBAAqB,CAAC;AACnD,MAAM,MAAM,iBAAiB,GAAG,mBAAmB,CAAC;AACpD,MAAM,WAAW,qBAAqB;IACpC,KAAK,EAAE,CAAC,OAAO,EAAE,iBAAiB,KAAK,OAAO,CAAC,QAAQ,CAAC,CAAC;CAC1D"}
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../src/plugins/request/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EACV,cAAc,EACd,qBAAqB,EACrB,kBAAkB,EACnB,MAAM,oBAAoB,CAAC;AAK5B,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;iBAiC+C,CAAC;AAG/E,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAGrE,MAAM,MAAM,iBAAiB,GACzB,cAAc,GACd,qBAAqB,GACrB,kBAAkB,CAAC;AAGvB,MAAM,WAAW,uBAAuB;IACtC,OAAO,EAAE,CAAC,OAAO,EAAE,mBAAmB,KAAK,OAAO,CAAC,QAAQ,CAAC,CAAC;CAC9D;AAGD,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;iBAAqB,CAAC;AACnD,MAAM,MAAM,iBAAiB,GAAG,mBAAmB,CAAC;AACpD,MAAM,WAAW,qBAAqB;IACpC,KAAK,EAAE,CAAC,OAAO,EAAE,iBAAiB,KAAK,OAAO,CAAC,QAAQ,CAAC,CAAC;CAC1D"}

package/dist/plugins/request/schemas.js

@@ -31,9 +31,6 @@ export const RelayRequestSchema = z
     ])
         .optional()
         .describe("Request headers"),
-})
-    .extend({
-    relayBaseUrl: z.string().optional().describe("Base URL for Relay service"),
 })
     .merge(TelemetryMarkerSchema)
     .describe("Make authenticated HTTP requests through Zapier's Relay service");

package/dist/schemas/Action.d.ts

@@ -1,8 +1,8 @@
 import { z } from "zod";
 export declare const ActionItemSchema: z.ZodObject<{
     key: z.ZodString;
-    id: z.ZodOptional<z.ZodString>;
     description: z.ZodString;
+    id: z.ZodOptional<z.ZodString>;
     is_important: z.ZodOptional<z.ZodBoolean>;
     is_hidden: z.ZodOptional<z.ZodBoolean>;
     app_key: z.ZodString;