@aws/run-mcp-servers-with-aws-lambda 0.2.3 → 0.2.4

package/dist/client/index.d.ts

@@ -1,27 +1,2 @@
-import { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
-import { JSONRPCMessage } from "@modelcontextprotocol/sdk/types.js";
-export type LambdaFunctionParameters = {
-    /**
-     * The name or ARN of the Lambda function, version, or alias.
-     */
-    functionName: string;
-    /**
-     * The AWS region of the Lambda function.
-     */
-    regionName?: string;
-};
-/**
- * Client transport for Lambda functions:
- * this will connect to a server by calling the Lambda Invoke API.
- */
-export declare class LambdaFunctionClientTransport implements Transport {
-    private _serverParams;
-    private _lambdaClient;
-    onclose?: () => void;
-    onerror?: (error: Error) => void;
-    onmessage?: (message: JSONRPCMessage) => void;
-    constructor(server: LambdaFunctionParameters);
-    start(): Promise<void>;
-    close(): Promise<void>;
-    send(message: JSONRPCMessage): Promise<void>;
-}
+export * from "./lambdaFunction.js";
+export * from "./streamableHttpWithSigV4.js";

package/dist/client/index.js

@@ -1,51 +1,4 @@
-import { LambdaClient, InvokeCommand } from "@aws-sdk/client-lambda";
-/**
- * Client transport for Lambda functions:
- * this will connect to a server by calling the Lambda Invoke API.
- */
-export class LambdaFunctionClientTransport {
-    _serverParams;
-    _lambdaClient;
-    onclose;
-    onerror;
-    onmessage;
-    constructor(server) {
-        this._serverParams = server;
-        this._lambdaClient = new LambdaClient({
-            region: this._serverParams.regionName,
-        });
-    }
-    async start() {
-        // no-op
-    }
-    async close() {
-        // no-op
-    }
-    async send(message) {
-        try {
-            const invokeCommand = new InvokeCommand({
-                FunctionName: this._serverParams.functionName,
-                InvocationType: "RequestResponse",
-                Payload: JSON.stringify(message),
-            });
-            const invokeCommandOutput = await this._lambdaClient.send(invokeCommand);
-            if (invokeCommandOutput.Payload) {
-                const responseMessage = Buffer.from(invokeCommandOutput.Payload).toString("utf-8");
-                if (invokeCommandOutput.FunctionError) {
-                    throw new Error(`${invokeCommandOutput.FunctionError} ${responseMessage}`);
-                }
-                if (responseMessage === "{}") {
-                    // Assume we sent a notification and do not expect a response
-                    return;
-                }
-                this.onmessage?.(JSON.parse(responseMessage));
-            }
-            else {
-                throw new Error("No payload returned from Lambda function");
-            }
-        }
-        catch (error) {
-            this.onerror?.(error);
-        }
-    }
-}
+// Export Lambda function client transport
+export * from "./lambdaFunction.js";
+// Export SigV4 HTTP client transport
+export * from "./streamableHttpWithSigV4.js";

package/dist/client/lambdaFunction.d.ts

@@ -0,0 +1,27 @@
+import { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
+import { JSONRPCMessage } from "@modelcontextprotocol/sdk/types.js";
+export type LambdaFunctionParameters = {
+    /**
+     * The name or ARN of the Lambda function, version, or alias.
+     */
+    functionName: string;
+    /**
+     * The AWS region of the Lambda function.
+     */
+    regionName?: string;
+};
+/**
+ * Client transport for Lambda functions:
+ * this will connect to a server by calling the Lambda Invoke API.
+ */
+export declare class LambdaFunctionClientTransport implements Transport {
+    private _serverParams;
+    private _lambdaClient;
+    onclose?: () => void;
+    onerror?: (error: Error) => void;
+    onmessage?: (message: JSONRPCMessage) => void;
+    constructor(server: LambdaFunctionParameters);
+    start(): Promise<void>;
+    close(): Promise<void>;
+    send(message: JSONRPCMessage): Promise<void>;
+}

package/dist/client/lambdaFunction.js

@@ -0,0 +1,51 @@
+import { LambdaClient, InvokeCommand } from "@aws-sdk/client-lambda";
+/**
+ * Client transport for Lambda functions:
+ * this will connect to a server by calling the Lambda Invoke API.
+ */
+export class LambdaFunctionClientTransport {
+    _serverParams;
+    _lambdaClient;
+    onclose;
+    onerror;
+    onmessage;
+    constructor(server) {
+        this._serverParams = server;
+        this._lambdaClient = new LambdaClient({
+            region: this._serverParams.regionName,
+        });
+    }
+    async start() {
+        // no-op
+    }
+    async close() {
+        // no-op
+    }
+    async send(message) {
+        try {
+            const invokeCommand = new InvokeCommand({
+                FunctionName: this._serverParams.functionName,
+                InvocationType: "RequestResponse",
+                Payload: JSON.stringify(message),
+            });
+            const invokeCommandOutput = await this._lambdaClient.send(invokeCommand);
+            if (invokeCommandOutput.Payload) {
+                const responseMessage = Buffer.from(invokeCommandOutput.Payload).toString("utf-8");
+                if (invokeCommandOutput.FunctionError) {
+                    throw new Error(`${invokeCommandOutput.FunctionError} ${responseMessage}`);
+                }
+                if (responseMessage === "{}") {
+                    // Assume we sent a notification and do not expect a response
+                    return;
+                }
+                this.onmessage?.(JSON.parse(responseMessage));
+            }
+            else {
+                throw new Error("No payload returned from Lambda function");
+            }
+        }
+        catch (error) {
+            this.onerror?.(error);
+        }
+    }
+}

package/dist/client/streamableHttpWithSigV4.d.ts

@@ -0,0 +1,88 @@
+import { StreamableHTTPClientTransport, StreamableHTTPClientTransportOptions } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { FetchLike } from "@modelcontextprotocol/sdk/shared/transport.js";
+import { AwsCredentialIdentity, Provider } from "@aws-sdk/types";
+/**
+ * Configuration options for SigV4FetchLike
+ */
+export interface SigV4FetchLikeOptions {
+    /**
+     * AWS credentials (provider), if not provided, default provider will be used
+     */
+    credentials?: AwsCredentialIdentity | Provider<AwsCredentialIdentity>;
+    /**
+     * AWS region for signing requests
+     */
+    region: string;
+    /**
+     * AWS service name for signing requests (e.g., 'lambda', 'execute-api')
+     */
+    service: string;
+    /**
+     * Base fetch implementation to use for actual HTTP requests
+     * If not provided, the global fetch will be used
+     */
+    baseFetch?: FetchLike;
+}
+/**
+ * A FetchLike implementation that signs HTTP requests using AWS Signature Version 4.
+ *
+ * This class can be passed to any transport that accepts a FetchLike parameter.
+ * It wraps a base fetch implementation and automatically signs all requests with AWS SigV4.
+ */
+export declare class SigV4FetchLike {
+    private _signer;
+    private _baseFetch;
+    constructor(options: SigV4FetchLikeOptions);
+    /**
+     * Fetch implementation that signs requests with AWS SigV4
+     */
+    fetch(url: string | URL, init?: RequestInit): Promise<Response>;
+}
+/**
+ * Creates a FetchLike function that signs HTTP requests using AWS Signature Version 4.
+ *
+ * This function can be passed to any transport that accepts a FetchLike parameter,
+ * such as StreamableHTTPClientTransport.
+ *
+ * @param options Configuration options for AWS SigV4 signing
+ * @returns A FetchLike function that automatically signs requests
+ *
+ * @example
+ * ```typescript
+ * const sigV4Fetch = createSigV4Fetch({
+ *   region: 'us-east-1',
+ *   service: 'lambda'
+ * });
+ *
+ * const transport = new StreamableHTTPClientTransport(url, {
+ *   fetch: sigV4Fetch
+ * });
+ * ```
+ */
+export declare function createSigV4Fetch(options: SigV4FetchLikeOptions): FetchLike;
+/**
+ * Extended options for StreamableHTTPClientWithSigV4Transport
+ */
+export interface StreamableHTTPClientWithSigV4TransportOptions extends StreamableHTTPClientTransportOptions {
+    /**
+     * AWS credentials (provider), if not provided, default provider will be used
+     */
+    credentials?: AwsCredentialIdentity | Provider<AwsCredentialIdentity>;
+    /**
+     * AWS region for signing requests
+     */
+    region: string;
+    /**
+     * AWS service name for signing requests (e.g., 'lambda', 'execute-api')
+     */
+    service: string;
+}
+/**
+ * Streamable HTTP client transport with AWS SigV4 signing support.
+ *
+ * This transport enables communication with MCP servers that authenticate using AWS IAM,
+ * such as servers behind a Lambda function URL or API Gateway.
+ */
+export declare class StreamableHTTPClientWithSigV4Transport extends StreamableHTTPClientTransport {
+    constructor(url: URL, options: StreamableHTTPClientWithSigV4TransportOptions);
+}

package/dist/client/streamableHttpWithSigV4.js

@@ -0,0 +1,116 @@
+import { StreamableHTTPClientTransport, } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { SignatureV4 } from "@smithy/signature-v4";
+import { defaultProvider } from "@aws-sdk/credential-provider-node";
+import { Sha256 } from "@aws-crypto/sha256-js";
+import { HttpRequest } from "@aws-sdk/protocol-http";
+/**
+ * A FetchLike implementation that signs HTTP requests using AWS Signature Version 4.
+ *
+ * This class can be passed to any transport that accepts a FetchLike parameter.
+ * It wraps a base fetch implementation and automatically signs all requests with AWS SigV4.
+ */
+export class SigV4FetchLike {
+    _signer;
+    _baseFetch;
+    constructor(options) {
+        this._baseFetch = options.baseFetch ?? fetch;
+        this._signer = new SignatureV4({
+            service: options.service,
+            region: options.region,
+            credentials: options.credentials ?? defaultProvider(),
+            sha256: Sha256,
+        });
+    }
+    /**
+     * Fetch implementation that signs requests with AWS SigV4
+     */
+    async fetch(url, init) {
+        const urlObj = typeof url === "string" ? new URL(url) : url;
+        const requestInit = init || {};
+        // Convert fetch RequestInit to HttpRequest for signing
+        const headers = {
+            host: urlObj.hostname,
+        };
+        if (requestInit.headers) {
+            if (requestInit.headers instanceof Headers) {
+                requestInit.headers.forEach((value, key) => {
+                    headers[key.toLowerCase()] = value;
+                });
+            }
+            else if (Array.isArray(requestInit.headers)) {
+                requestInit.headers.forEach(([key, value]) => {
+                    headers[key.toLowerCase()] = value;
+                });
+            }
+            else {
+                Object.entries(requestInit.headers).forEach(([key, value]) => {
+                    headers[key.toLowerCase()] = value;
+                });
+            }
+        }
+        const unsignedRequest = new HttpRequest({
+            method: requestInit.method || "GET",
+            protocol: urlObj.protocol,
+            hostname: urlObj.hostname,
+            port: urlObj.port ? parseInt(urlObj.port) : undefined,
+            path: urlObj.pathname + urlObj.search,
+            headers,
+            body: requestInit.body,
+        });
+        // Sign the request
+        const signedRequest = await this._signer.sign(unsignedRequest);
+        // Convert signed request back to fetch format
+        const signedInit = {
+            ...requestInit,
+            method: signedRequest.method,
+            headers: signedRequest.headers,
+            body: signedRequest.body,
+        };
+        return this._baseFetch(urlObj, signedInit);
+    }
+}
+/**
+ * Creates a FetchLike function that signs HTTP requests using AWS Signature Version 4.
+ *
+ * This function can be passed to any transport that accepts a FetchLike parameter,
+ * such as StreamableHTTPClientTransport.
+ *
+ * @param options Configuration options for AWS SigV4 signing
+ * @returns A FetchLike function that automatically signs requests
+ *
+ * @example
+ * ```typescript
+ * const sigV4Fetch = createSigV4Fetch({
+ *   region: 'us-east-1',
+ *   service: 'lambda'
+ * });
+ *
+ * const transport = new StreamableHTTPClientTransport(url, {
+ *   fetch: sigV4Fetch
+ * });
+ * ```
+ */
+export function createSigV4Fetch(options) {
+    const sigV4Fetch = new SigV4FetchLike(options);
+    return sigV4Fetch.fetch.bind(sigV4Fetch);
+}
+/**
+ * Streamable HTTP client transport with AWS SigV4 signing support.
+ *
+ * This transport enables communication with MCP servers that authenticate using AWS IAM,
+ * such as servers behind a Lambda function URL or API Gateway.
+ */
+export class StreamableHTTPClientWithSigV4Transport extends StreamableHTTPClientTransport {
+    constructor(url, options) {
+        const sigV4Fetch = createSigV4Fetch({
+            credentials: options.credentials,
+            region: options.region,
+            service: options.service,
+            baseFetch: options.fetch,
+        });
+        super(url, {
+            ...options,
+            fetch: sigV4Fetch,
+        });
+    }
+}

package/dist/client/streamableHttpWithSigV4.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/client/streamableHttpWithSigV4.test.js

@@ -0,0 +1,442 @@
+import { SignatureV4 } from "@smithy/signature-v4";
+import { defaultProvider } from "@aws-sdk/credential-provider-node";
+import { HttpRequest } from "@aws-sdk/protocol-http";
+import { StreamableHTTPClientWithSigV4Transport, SigV4FetchLike, createSigV4Fetch, } from "./streamableHttpWithSigV4.js";
+// Mock dependencies
+jest.mock("@smithy/signature-v4");
+jest.mock("@aws-sdk/credential-provider-node");
+jest.mock("@aws-sdk/protocol-http");
+jest.mock("@modelcontextprotocol/sdk/client/streamableHttp.js");
+describe("StreamableHTTPClientWithSigV4Transport", () => {
+    const mockSign = jest.fn();
+    const mockDefaultProvider = jest.fn();
+    const mockCredentials = {
+        accessKeyId: "test-access-key",
+        secretAccessKey: "test-secret-key",
+    };
+    beforeEach(() => {
+        jest.clearAllMocks();
+        // Mock SignatureV4
+        SignatureV4.mockImplementation(() => ({
+            sign: mockSign,
+        }));
+        // Mock defaultProvider
+        defaultProvider.mockReturnValue(mockDefaultProvider);
+        mockDefaultProvider.mockResolvedValue(mockCredentials);
+    });
+    describe("constructor", () => {
+        test("should initialize with required options", () => {
+            const url = new URL("https://example.com/mcp");
+            const options = {
+                region: "us-east-1",
+                service: "lambda",
+            };
+            new StreamableHTTPClientWithSigV4Transport(url, options);
+            expect(SignatureV4).toHaveBeenCalledWith({
+                service: "lambda",
+                region: "us-east-1",
+                credentials: mockDefaultProvider,
+                sha256: expect.any(Function),
+            });
+        });
+        test("should use provided credentials instead of default provider", () => {
+            const url = new URL("https://example.com/mcp");
+            const customCredentials = {
+                accessKeyId: "custom-access-key",
+                secretAccessKey: "custom-secret-key",
+            };
+            const options = {
+                region: "us-west-2",
+                service: "execute-api",
+                credentials: customCredentials,
+            };
+            new StreamableHTTPClientWithSigV4Transport(url, options);
+            expect(SignatureV4).toHaveBeenCalledWith({
+                service: "execute-api",
+                region: "us-west-2",
+                credentials: customCredentials,
+                sha256: expect.any(Function),
+            });
+            expect(defaultProvider).not.toHaveBeenCalled();
+        });
+        test("should use provided fetch function", () => {
+            const url = new URL("https://example.com/mcp");
+            const customFetch = jest.fn();
+            const options = {
+                region: "us-east-1",
+                service: "lambda",
+                fetch: customFetch,
+            };
+            new StreamableHTTPClientWithSigV4Transport(url, options);
+            // The custom fetch should be passed to the SigV4FetchLike as baseFetch
+            expect(customFetch).not.toHaveBeenCalled();
+        });
+    });
+    describe("SigV4FetchLike", () => {
+        let mockFetch;
+        beforeEach(() => {
+            mockFetch = jest.fn();
+        });
+        it("should sign and execute GET request", async () => {
+            const testUrl = "https://example.com/test";
+            const signedHeaders = {
+                authorization: "AWS4-HMAC-SHA256 ...",
+                "x-amz-date": "20231201T120000Z",
+            };
+            mockSign.mockResolvedValue({
+                method: "GET",
+                headers: signedHeaders,
+                body: undefined,
+            });
+            const mockResponse = new Response("test response");
+            mockFetch.mockResolvedValue(mockResponse);
+            const options = {
+                region: "us-east-1",
+                service: "lambda",
+                baseFetch: mockFetch,
+            };
+            const sigV4Fetch = new SigV4FetchLike(options);
+            const result = await sigV4Fetch.fetch(testUrl, undefined);
+            expect(HttpRequest).toHaveBeenCalledWith({
+                method: "GET",
+                protocol: "https:",
+                hostname: "example.com",
+                path: "/test",
+                headers: {
+                    host: "example.com",
+                },
+                body: undefined,
+            });
+            expect(mockSign).toHaveBeenCalledWith(expect.any(HttpRequest));
+            expect(mockFetch).toHaveBeenCalledWith(new URL(testUrl), {
+                method: "GET",
+                headers: signedHeaders,
+                body: undefined,
+            });
+            expect(result).toBe(mockResponse);
+        });
+        it("should sign and execute POST request with body", async () => {
+            const testUrl = "https://example.com/api";
+            const requestInit = {
+                method: "POST",
+                headers: {
+                    "content-type": "application/json",
+                },
+                body: JSON.stringify({ test: "data" }),
+            };
+            const signedHeaders = {
+                authorization: "AWS4-HMAC-SHA256 ...",
+                "x-amz-date": "20231201T120000Z",
+                "content-type": "application/json",
+            };
+            mockSign.mockResolvedValue({
+                method: "POST",
+                headers: signedHeaders,
+                body: requestInit.body,
+            });
+            const mockResponse = new Response("success");
+            mockFetch.mockResolvedValue(mockResponse);
+            const options = {
+                region: "us-east-1",
+                service: "lambda",
+                baseFetch: mockFetch,
+            };
+            const sigV4Fetch = new SigV4FetchLike(options);
+            const result = await sigV4Fetch.fetch(testUrl, requestInit);
+            expect(HttpRequest).toHaveBeenCalledWith({
+                method: "POST",
+                protocol: "https:",
+                hostname: "example.com",
+                path: "/api",
+                headers: {
+                    host: "example.com",
+                    "content-type": "application/json",
+                },
+                body: requestInit.body,
+            });
+            expect(mockSign).toHaveBeenCalledWith(expect.any(HttpRequest));
+            expect(mockFetch).toHaveBeenCalledWith(new URL(testUrl), {
+                method: "POST",
+                headers: signedHeaders,
+                body: requestInit.body,
+            });
+            expect(result).toBe(mockResponse);
+        });
+        it("should handle URL with port and query parameters", async () => {
+            const testUrl = "https://example.com:8443/path?param=value";
+            mockSign.mockResolvedValue({
+                method: "GET",
+                headers: { authorization: "AWS4-HMAC-SHA256 ..." },
+                body: undefined,
+            });
+            mockFetch.mockResolvedValue(new Response("test"));
+            const options = {
+                region: "us-east-1",
+                service: "lambda",
+                baseFetch: mockFetch,
+            };
+            const sigV4Fetch = new SigV4FetchLike(options);
+            await sigV4Fetch.fetch(testUrl, undefined);
+            expect(HttpRequest).toHaveBeenCalledWith({
+                method: "GET",
+                protocol: "https:",
+                hostname: "example.com",
+                port: 8443,
+                path: "/path?param=value",
+                headers: {
+                    host: "example.com",
+                },
+                body: undefined,
+            });
+        });
+        it("should handle Headers object in request init", async () => {
+            const testUrl = "https://example.com/test";
+            const headers = new Headers();
+            headers.set("Content-Type", "application/json");
+            headers.set("X-Custom-Header", "custom-value");
+            const requestInit = {
+                method: "POST",
+                headers,
+                body: "test body",
+            };
+            mockSign.mockResolvedValue({
+                method: "POST",
+                headers: { authorization: "AWS4-HMAC-SHA256 ..." },
+                body: "test body",
+            });
+            mockFetch.mockResolvedValue(new Response("test"));
+            const options = {
+                region: "us-east-1",
+                service: "lambda",
+                baseFetch: mockFetch,
+            };
+            const sigV4Fetch = new SigV4FetchLike(options);
+            await sigV4Fetch.fetch(testUrl, requestInit);
+            expect(HttpRequest).toHaveBeenCalledWith({
+                method: "POST",
+                protocol: "https:",
+                hostname: "example.com",
+                path: "/test",
+                headers: {
+                    host: "example.com",
+                    "content-type": "application/json",
+                    "x-custom-header": "custom-value",
+                },
+                body: "test body",
+            });
+        });
+        it("should handle array headers in request init", async () => {
+            const testUrl = "https://example.com/test";
+            const requestInit = {
+                method: "POST",
+                headers: [
+                    ["Content-Type", "application/json"],
+                    ["X-Custom-Header", "custom-value"],
+                ],
+                body: "test body",
+            };
+            mockSign.mockResolvedValue({
+                method: "POST",
+                headers: { authorization: "AWS4-HMAC-SHA256 ..." },
+                body: "test body",
+            });
+            mockFetch.mockResolvedValue(new Response("test"));
+            const options = {
+                region: "us-east-1",
+                service: "lambda",
+                baseFetch: mockFetch,
+            };
+            const sigV4Fetch = new SigV4FetchLike(options);
+            await sigV4Fetch.fetch(testUrl, requestInit);
+            expect(HttpRequest).toHaveBeenCalledWith({
+                method: "POST",
+                protocol: "https:",
+                hostname: "example.com",
+                path: "/test",
+                headers: {
+                    host: "example.com",
+                    "content-type": "application/json",
+                    "x-custom-header": "custom-value",
+                },
+                body: "test body",
+            });
+        });
+        it("should handle URL object as input", async () => {
+            const testUrl = new URL("https://example.com/test");
+            mockSign.mockResolvedValue({
+                method: "GET",
+                headers: { authorization: "AWS4-HMAC-SHA256 ..." },
+                body: undefined,
+            });
+            mockFetch.mockResolvedValue(new Response("test"));
+            const options = {
+                region: "us-east-1",
+                service: "lambda",
+                baseFetch: mockFetch,
+            };
+            const sigV4Fetch = new SigV4FetchLike(options);
+            await sigV4Fetch.fetch(testUrl, undefined);
+            expect(HttpRequest).toHaveBeenCalledWith({
+                method: "GET",
+                protocol: "https:",
+                hostname: "example.com",
+                path: "/test",
+                headers: {
+                    host: "example.com",
+                },
+                body: undefined,
+            });
+        });
+        it("should propagate signing errors", async () => {
+            const testUrl = "https://example.com/test";
+            mockSign.mockRejectedValue(new Error("Signing failed"));
+            const options = {
+                region: "us-east-1",
+                service: "lambda",
+                baseFetch: mockFetch,
+            };
+            const sigV4Fetch = new SigV4FetchLike(options);
+            await expect(sigV4Fetch.fetch(testUrl, undefined)).rejects.toThrow("Signing failed");
+            expect(mockFetch).not.toHaveBeenCalled();
+        });
+        it("should propagate fetch errors", async () => {
+            const testUrl = "https://example.com/test";
+            mockSign.mockResolvedValue({
+                method: "GET",
+                headers: { authorization: "AWS4-HMAC-SHA256 ..." },
+                body: undefined,
+            });
+            mockFetch.mockRejectedValue(new Error("Network error"));
+            const options = {
+                region: "us-east-1",
+                service: "lambda",
+                baseFetch: mockFetch,
+            };
+            const sigV4Fetch = new SigV4FetchLike(options);
+            await expect(sigV4Fetch.fetch(testUrl, undefined)).rejects.toThrow("Network error");
+        });
+    });
+    describe("createSigV4Fetch", () => {
+        let mockFetch;
+        beforeEach(() => {
+            mockFetch = jest.fn();
+        });
+        it("should create a FetchLike function that signs requests", async () => {
+            const testUrl = "https://example.com/test";
+            const signedHeaders = {
+                authorization: "AWS4-HMAC-SHA256 ...",
+                "x-amz-date": "20231201T120000Z",
+            };
+            mockSign.mockResolvedValue({
+                method: "GET",
+                headers: signedHeaders,
+                body: undefined,
+            });
+            const mockResponse = new Response("test response");
+            mockFetch.mockResolvedValue(mockResponse);
+            const options = {
+                region: "us-east-1",
+                service: "lambda",
+                baseFetch: mockFetch,
+            };
+            const sigV4Fetch = createSigV4Fetch(options);
+            const result = await sigV4Fetch(testUrl, undefined);
+            expect(HttpRequest).toHaveBeenCalledWith({
+                method: "GET",
+                protocol: "https:",
+                hostname: "example.com",
+                path: "/test",
+                headers: {
+                    host: "example.com",
+                },
+                body: undefined,
+            });
+            expect(mockSign).toHaveBeenCalledWith(expect.any(HttpRequest));
+            expect(mockFetch).toHaveBeenCalledWith(new URL(testUrl), {
+                method: "GET",
+                headers: signedHeaders,
+                body: undefined,
+            });
+            expect(result).toBe(mockResponse);
+        });
+        it("should work with StreamableHTTPClientTransport", async () => {
+            const testUrl = "https://example.com/test";
+            const signedHeaders = {
+                authorization: "AWS4-HMAC-SHA256 ...",
+                "x-amz-date": "20231201T120000Z",
+            };
+            mockSign.mockResolvedValue({
+                method: "GET",
+                headers: signedHeaders,
+                body: undefined,
+            });
+            const mockResponse = new Response("test response");
+            mockFetch.mockResolvedValue(mockResponse);
+            const options = {
+                region: "us-east-1",
+                service: "lambda",
+                baseFetch: mockFetch,
+            };
+            const sigV4Fetch = createSigV4Fetch(options);
+            // This demonstrates how users can now use the SigV4 fetch with any transport
+            const result = await sigV4Fetch(testUrl, { method: "GET" });
+            expect(result).toBe(mockResponse);
+            expect(mockSign).toHaveBeenCalled();
+            expect(mockFetch).toHaveBeenCalled();
+        });
+    });
+    describe("credential provider integration", () => {
+        test("should use default provider when no credentials provided", () => {
+            const url = new URL("https://example.com/mcp");
+            const options = {
+                region: "us-east-1",
+                service: "lambda",
+            };
+            new StreamableHTTPClientWithSigV4Transport(url, options);
+            expect(defaultProvider).toHaveBeenCalled();
+            expect(SignatureV4).toHaveBeenCalledWith({
+                service: "lambda",
+                region: "us-east-1",
+                credentials: mockDefaultProvider,
+                sha256: expect.any(Function),
+            });
+        });
+        test("should use provided credential provider function", () => {
+            const url = new URL("https://example.com/mcp");
+            const customProvider = jest.fn().mockResolvedValue(mockCredentials);
+            const options = {
+                region: "us-east-1",
+                service: "lambda",
+                credentials: customProvider,
+            };
+            new StreamableHTTPClientWithSigV4Transport(url, options);
+            expect(SignatureV4).toHaveBeenCalledWith({
+                service: "lambda",
+                region: "us-east-1",
+                credentials: customProvider,
+                sha256: expect.any(Function),
+            });
+            expect(defaultProvider).not.toHaveBeenCalled();
+        });
+        test("should use provided static credentials", () => {
+            const url = new URL("https://example.com/mcp");
+            const staticCredentials = {
+                accessKeyId: "static-key",
+                secretAccessKey: "static-secret",
+            };
+            const options = {
+                region: "us-east-1",
+                service: "lambda",
+                credentials: staticCredentials,
+            };
+            new StreamableHTTPClientWithSigV4Transport(url, options);
+            expect(SignatureV4).toHaveBeenCalledWith({
+                service: "lambda",
+                region: "us-east-1",
+                credentials: staticCredentials,
+                sha256: expect.any(Function),
+            });
+            expect(defaultProvider).not.toHaveBeenCalled();
+        });
+    });
+});

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@aws/run-mcp-servers-with-aws-lambda",
   "description": "Run Model Context Protocol (MCP) servers with AWS Lambda",
-  "version": "0.2.3",
+  "version": "0.2.4",
   "type": "module",
   "license": "Apache-2.0",
   "author": {
@@ -53,8 +53,13 @@
     "typescript-eslint": "^8.35.1"
   },
   "dependencies": {
+    "@aws-crypto/sha256-js": "^5.2.0",
     "@aws-sdk/client-lambda": "^3.840.0",
+    "@aws-sdk/credential-provider-node": "^3.840.0",
+    "@aws-sdk/protocol-http": "^3.370.0",
+    "@aws-sdk/types": "^3.840.0",
     "@modelcontextprotocol/sdk": "^1.15.0",
+    "@smithy/signature-v4": "^5.1.2",
     "@types/aws-lambda": "^8.10.149",
     "winston": "^3.17.0"
   }