@zapier/zapier-sdk 0.23.2 → 0.25.0

package/dist/plugins/fetch/index.js

@@ -1,54 +1,106 @@
 import { FetchUrlSchema, FetchInitSchema } from "./schemas";
+import { coerceToNumericId } from "../../utils/id-utils";
 /**
- * Direct plugin function - takes options + sdk + context in one object
+ * Transforms full URLs into Relay format: /relay/{domain}/{path}
  */
-export const fetchPlugin = ({ sdk, context }) => {
-    // Return flat structure - fetch goes directly to SDK
+function transformUrlToRelayPath(url) {
+    const targetUrl = new URL(url);
+    return `/relay/${targetUrl.host}${targetUrl.pathname}${targetUrl.search}${targetUrl.hash}`;
+}
+/**
+ * Normalizes various header formats into a plain Record<string, string>.
+ */
+function normalizeHeaders(optionsHeaders) {
+    const headers = {};
+    if (!optionsHeaders) {
+        return headers;
+    }
+    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;
+    }
+    return headers;
+}
+/**
+ * Fetch plugin — the primary way to make authenticated HTTP requests through Zapier's Relay service.
+ * Mirrors the native fetch(url, init?) signature with additional Zapier-specific options.
+ */
+export const fetchPlugin = ({ context }) => {
     return {
         fetch: async function fetch(url, init) {
+            const { api } = context;
             const startTime = Date.now();
+            const isNested = init?._telemetry?.isNested === true;
             try {
-                const { authenticationId, callbackUrl, authenticationTemplate, ...fetchInit } = init || {};
-                const result = await sdk.request({
-                    url: url.toString(),
-                    method: fetchInit.method,
+                const { authenticationId, callbackUrl, authenticationTemplate, _telemetry, ...fetchInit } = init || {};
+                const relayPath = transformUrlToRelayPath(url);
+                const headers = normalizeHeaders(fetchInit.headers);
+                // Auto-set Content-Type for JSON bodies if not already specified
+                const hasContentType = Object.keys(headers).some((k) => k.toLowerCase() === "content-type");
+                if (fetchInit.body && !hasContentType) {
+                    const bodyStr = typeof fetchInit.body === "string"
+                        ? fetchInit.body
+                        : JSON.stringify(fetchInit.body);
+                    const trimmed = bodyStr.trimStart();
+                    if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+                        headers["Content-Type"] = "application/json; charset=utf-8";
+                    }
+                }
+                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;
+                }
+                const result = await api.fetch(relayPath, {
+                    method: fetchInit.method ?? "GET",
                     body: fetchInit.body,
-                    headers: fetchInit.headers,
-                    authenticationId,
-                    callbackUrl,
-                    authenticationTemplate,
-                    _telemetry: { isNested: true },
-                });
-                // Emit success telemetry
-                context.eventEmission.emitMethodCalled({
-                    method_name: "fetch",
-                    execution_duration_ms: Date.now() - startTime,
-                    success_flag: true,
-                    error_message: null,
-                    error_type: null,
-                    argument_count: init ? 2 : 1,
-                    is_paginated: false,
+                    headers,
+                    authRequired: true,
                 });
+                if (!isNested) {
+                    context.eventEmission.emitMethodCalled({
+                        method_name: "fetch",
+                        execution_duration_ms: Date.now() - startTime,
+                        success_flag: true,
+                        error_message: null,
+                        error_type: null,
+                        argument_count: init ? 2 : 1,
+                        is_paginated: false,
+                    });
+                }
                 return result;
             }
             catch (error) {
-                // Emit failure telemetry
-                context.eventEmission.emitMethodCalled({
-                    method_name: "fetch",
-                    execution_duration_ms: Date.now() - startTime,
-                    success_flag: false,
-                    error_message: error instanceof Error ? error.message : String(error),
-                    error_type: error instanceof Error ? error.constructor.name : "Unknown",
-                    argument_count: init ? 2 : 1,
-                    is_paginated: false,
-                });
+                if (!isNested) {
+                    context.eventEmission.emitMethodCalled({
+                        method_name: "fetch",
+                        execution_duration_ms: Date.now() - startTime,
+                        success_flag: false,
+                        error_message: error instanceof Error ? error.message : String(error),
+                        error_type: error instanceof Error ? error.constructor.name : "Unknown",
+                        argument_count: init ? 2 : 1,
+                        is_paginated: false,
+                    });
+                }
                 throw error;
             }
         },
         context: {
             meta: {
                 fetch: {
-                    packages: ["sdk"],
+                    description: "Make authenticated HTTP requests to any API through Zapier's Relay service. " +
+                        "Pass an authenticationId to automatically inject the user's stored credentials " +
+                        "(OAuth tokens, API keys, etc.) into the outgoing request. " +
+                        "Mirrors the native fetch(url, init?) signature with additional Zapier-specific options.",
+                    packages: ["sdk", "cli", "mcp"],
                     categories: ["http"],
                     returnType: "Response",
                     inputParameters: [

package/dist/plugins/fetch/index.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.test.d.ts.map

package/dist/plugins/fetch/index.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.test.d.ts","sourceRoot":"","sources":["../../../src/plugins/fetch/index.test.ts"],"names":[],"mappings":""}

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