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

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.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/dist/handlers/{api_gateway_proxy_event_handler.d.ts → apiGatewayProxyEventHandler.d.ts}

@@ -1,6 +1,6 @@
 import { APIGatewayProxyEvent, APIGatewayProxyResult } from "aws-lambda";
-import { StreamableHttpHandler, ParsedHttpRequest, HttpResponse } from "./streamable_http_handler.js";
-import { RequestHandler } from "./request_handler.js";
+import { StreamableHttpHandler, ParsedHttpRequest, HttpResponse } from "./streamableHttpHandler.js";
+import { RequestHandler } from "./requestHandler.js";
 /**
  * Handler for API Gateway V1 events (REST APIs)
  *

package/dist/handlers/{api_gateway_proxy_event_handler.js → apiGatewayProxyEventHandler.js}

@@ -1,4 +1,4 @@
-import { StreamableHttpHandler, } from "./streamable_http_handler.js";
+import { StreamableHttpHandler, } from "./streamableHttpHandler.js";
 /**
  * Handler for API Gateway V1 events (REST APIs)
  *

package/dist/handlers/{api_gateway_proxy_event_v2_handler.d.ts → apiGatewayProxyEventV2Handler.d.ts}

@@ -1,6 +1,6 @@
 import { APIGatewayProxyEventV2, APIGatewayProxyResultV2 } from "aws-lambda";
-import { StreamableHttpHandler, ParsedHttpRequest, HttpResponse } from "./streamable_http_handler.js";
-import { RequestHandler } from "./request_handler.js";
+import { StreamableHttpHandler, ParsedHttpRequest, HttpResponse } from "./streamableHttpHandler.js";
+import { RequestHandler } from "./requestHandler.js";
 /**
  * Handler for API Gateway V2 events (HTTP APIs)
  *

package/dist/handlers/{api_gateway_proxy_event_v2_handler.js → apiGatewayProxyEventV2Handler.js}

@@ -1,4 +1,4 @@
-import { StreamableHttpHandler, } from "./streamable_http_handler.js";
+import { StreamableHttpHandler, } from "./streamableHttpHandler.js";
 /**
  * Handler for API Gateway V2 events (HTTP APIs)
  *

package/dist/handlers/index.d.ts

@@ -1,4 +1,4 @@
-export { RequestHandler } from "./request_handler.js";
-export { APIGatewayProxyEventHandler } from "./api_gateway_proxy_event_handler.js";
-export { APIGatewayProxyEventV2Handler } from "./api_gateway_proxy_event_v2_handler.js";
-export { LambdaFunctionURLEventHandler } from "./lambda_function_url_event_handler.js";
+export { RequestHandler } from "./requestHandler.js";
+export { APIGatewayProxyEventHandler } from "./apiGatewayProxyEventHandler.js";
+export { APIGatewayProxyEventV2Handler } from "./apiGatewayProxyEventV2Handler.js";
+export { LambdaFunctionURLEventHandler } from "./lambdaFunctionUrlEventHandler.js";

package/dist/handlers/index.js

@@ -1,3 +1,3 @@
-export { APIGatewayProxyEventHandler } from "./api_gateway_proxy_event_handler.js";
-export { APIGatewayProxyEventV2Handler } from "./api_gateway_proxy_event_v2_handler.js";
-export { LambdaFunctionURLEventHandler } from "./lambda_function_url_event_handler.js";
+export { APIGatewayProxyEventHandler } from "./apiGatewayProxyEventHandler.js";
+export { APIGatewayProxyEventV2Handler } from "./apiGatewayProxyEventV2Handler.js";
+export { LambdaFunctionURLEventHandler } from "./lambdaFunctionUrlEventHandler.js";

package/dist/handlers/{lambda_function_url_event_handler.d.ts → lambdaFunctionUrlEventHandler.d.ts}

@@ -1,6 +1,6 @@
 import { APIGatewayProxyEventV2, APIGatewayProxyResultV2 } from "aws-lambda";
-import { StreamableHttpHandler, ParsedHttpRequest, HttpResponse } from "./streamable_http_handler.js";
-import { RequestHandler } from "./request_handler.js";
+import { StreamableHttpHandler, ParsedHttpRequest, HttpResponse } from "./streamableHttpHandler.js";
+import { RequestHandler } from "./requestHandler.js";
 /**
  * Handler for Lambda Function URL requests
  *

package/dist/handlers/{lambda_function_url_event_handler.js → lambdaFunctionUrlEventHandler.js}

@@ -1,4 +1,4 @@
-import { StreamableHttpHandler, } from "./streamable_http_handler.js";
+import { StreamableHttpHandler, } from "./streamableHttpHandler.js";
 /**
  * Handler for Lambda Function URL requests
  *

package/dist/handlers/{streamable_http_handler.d.ts → streamableHttpHandler.d.ts}

@@ -1,6 +1,6 @@
 import { Context } from "aws-lambda";
 import { ErrorCode } from "@modelcontextprotocol/sdk/types.js";
-import { RequestHandler } from "./request_handler.js";
+import { RequestHandler } from "./requestHandler.js";
 /**
  * Parsed HTTP request data extracted from various Lambda event types
  */

package/dist/server-adapter/index.d.ts

@@ -1,2 +1,2 @@
-export { stdioServerAdapter } from "./stdio_server_adapter.js";
-export { StdioServerAdapterRequestHandler } from "./stdio_server_adapter_request_handler.js";
+export { stdioServerAdapter } from "./stdioServerAdapter.js";
+export { StdioServerAdapterRequestHandler } from "./stdioServerAdapterRequestHandler.js";

package/dist/server-adapter/index.js

@@ -1,2 +1,2 @@
-export { stdioServerAdapter } from "./stdio_server_adapter.js";
-export { StdioServerAdapterRequestHandler } from "./stdio_server_adapter_request_handler.js";
+export { stdioServerAdapter } from "./stdioServerAdapter.js";
+export { StdioServerAdapterRequestHandler } from "./stdioServerAdapterRequestHandler.js";

package/dist/server-adapter/{stdio_server_adapter.test.js → stdioServerAdapter.test.js}

@@ -1,8 +1,8 @@
 import { ErrorCode, } from '@modelcontextprotocol/sdk/types.js';
-import { stdioServerAdapter } from './stdio_server_adapter.js';
+import { stdioServerAdapter } from './stdioServerAdapter.js';
 const serverParameters = {
     command: 'npx',
-    args: ['tsx', 'test-stdio-server/echo_server.ts'],
+    args: ['tsx', 'test-stdio-server/echoServer.ts'],
 };
 const mockContext = {
     callbackWaitsForEmptyEventLoop: true,

package/dist/server-adapter/{stdio_server_adapter_request_handler.d.ts → stdioServerAdapterRequestHandler.d.ts}

@@ -1,7 +1,7 @@
 import { Context } from 'aws-lambda';
 import { StdioServerParameters } from '@modelcontextprotocol/sdk/client/stdio.js';
 import { JSONRPCRequest, JSONRPCResponse, JSONRPCError } from '@modelcontextprotocol/sdk/types.js';
-import { RequestHandler } from '../handlers/request_handler.js';
+import { RequestHandler } from '../handlers/requestHandler.js';
 /**
  * Generic Request Handler for MCP Stdio Server Adapter
  *

package/dist/server-adapter/{stdio_server_adapter_request_handler.js → stdioServerAdapterRequestHandler.js}

@@ -1,6 +1,6 @@
 import { isJSONRPCResponse, isJSONRPCError, ErrorCode, } from '@modelcontextprotocol/sdk/types.js';
 import { createLogger, format, transports } from 'winston';
-import { stdioServerAdapter } from './stdio_server_adapter.js';
+import { stdioServerAdapter } from './stdioServerAdapter.js';
 const logger = createLogger({
     level: process.env.LOG_LEVEL?.toLowerCase() || 'info',
     format: format.simple(),

package/dist/server-adapter/stdioServerAdapterRequestHandler.test.d.ts

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

package/dist/server-adapter/{stdio_server_adapter_request_handler.test.js → stdioServerAdapterRequestHandler.test.js}

@@ -1,45 +1,45 @@
-import { ErrorCode, } from '@modelcontextprotocol/sdk/types.js';
-import { StdioServerAdapterRequestHandler } from './stdio_server_adapter_request_handler.js';
-import * as stdioServerAdapter from './stdio_server_adapter.js';
+import { ErrorCode, } from "@modelcontextprotocol/sdk/types.js";
+import { StdioServerAdapterRequestHandler } from "./stdioServerAdapterRequestHandler.js";
+import * as stdioServerAdapter from "./stdioServerAdapter.js";
 // Mock the stdioServerAdapter function
-jest.mock('./stdio_server_adapter.js', () => ({
+jest.mock("./stdioServerAdapter.js", () => ({
     stdioServerAdapter: jest.fn(),
 }));
 const mockStdioServerAdapter = stdioServerAdapter.stdioServerAdapter;
 const mockServerParams = {
-    command: 'node',
-    args: ['test-server.js'],
+    command: "node",
+    args: ["test-server.js"],
 };
 const mockContext = {
     callbackWaitsForEmptyEventLoop: true,
-    functionName: 'test-function',
-    functionVersion: '1',
-    invokedFunctionArn: 'test-arn',
-    memoryLimitInMB: '128',
-    awsRequestId: 'test-id',
-    logGroupName: 'test-group',
-    logStreamName: 'test-stream',
+    functionName: "test-function",
+    functionVersion: "1",
+    invokedFunctionArn: "test-arn",
+    memoryLimitInMB: "128",
+    awsRequestId: "test-id",
+    logGroupName: "test-group",
+    logStreamName: "test-stream",
     getRemainingTimeInMillis: () => 1000,
     done: () => { },
     fail: () => { },
     succeed: () => { },
 };
-describe('StdioServerAdapterRequestHandler', () => {
+describe("StdioServerAdapterRequestHandler", () => {
     let handler;
     beforeEach(() => {
         handler = new StdioServerAdapterRequestHandler(mockServerParams);
         jest.clearAllMocks();
     });
-    describe('handleRequest', () => {
-        test('should return JSONRPCResponse when stdioServerAdapter returns valid response', async () => {
+    describe("handleRequest", () => {
+        test("should return JSONRPCResponse when stdioServerAdapter returns valid response", async () => {
             const request = {
-                jsonrpc: '2.0',
+                jsonrpc: "2.0",
                 id: 1,
-                method: 'test',
-                params: { arg: 'value' },
+                method: "test",
+                params: { arg: "value" },
             };
             const expectedResponse = {
-                jsonrpc: '2.0',
+                jsonrpc: "2.0",
                 id: 1,
                 result: { success: true },
             };
@@ -48,17 +48,17 @@ describe('StdioServerAdapterRequestHandler', () => {
             expect(mockStdioServerAdapter).toHaveBeenCalledWith(mockServerParams, request, mockContext);
             expect(result).toEqual(expectedResponse);
         });
-        test('should return JSONRPCError when stdioServerAdapter returns error', async () => {
+        test("should return JSONRPCError when stdioServerAdapter returns error", async () => {
             const request = {
-                jsonrpc: '2.0',
+                jsonrpc: "2.0",
                 id: 1,
-                method: 'test',
+                method: "test",
             };
             const expectedError = {
-                jsonrpc: '2.0',
+                jsonrpc: "2.0",
                 error: {
                     code: ErrorCode.MethodNotFound,
-                    message: 'Method not found',
+                    message: "Method not found",
                 },
                 id: 1,
             };
@@ -67,76 +67,76 @@ describe('StdioServerAdapterRequestHandler', () => {
             expect(mockStdioServerAdapter).toHaveBeenCalledWith(mockServerParams, request, mockContext);
             expect(result).toEqual(expectedError);
         });
-        test('should return internal error when stdioServerAdapter returns unexpected format', async () => {
+        test("should return internal error when stdioServerAdapter returns unexpected format", async () => {
             const request = {
-                jsonrpc: '2.0',
+                jsonrpc: "2.0",
                 id: 1,
-                method: 'test',
+                method: "test",
             };
-            const unexpectedResponse = { invalid: 'response' };
+            const unexpectedResponse = { invalid: "response" };
             mockStdioServerAdapter.mockResolvedValue(unexpectedResponse);
             const result = await handler.handleRequest(request, mockContext);
             expect(result).toEqual({
-                jsonrpc: '2.0',
+                jsonrpc: "2.0",
                 error: {
                     code: ErrorCode.InternalError,
-                    message: 'Internal error: Unexpected response format from MCP server',
-                    data: 'Expected JSONRPCResponse or JSONRPCError',
+                    message: "Internal error: Unexpected response format from MCP server",
+                    data: "Expected JSONRPCResponse or JSONRPCError",
                 },
                 id: 1,
             });
         });
-        test('should return internal error when stdioServerAdapter throws exception', async () => {
+        test("should return internal error when stdioServerAdapter throws exception", async () => {
             const request = {
-                jsonrpc: '2.0',
+                jsonrpc: "2.0",
                 id: 1,
-                method: 'test',
+                method: "test",
             };
-            const error = new Error('Connection failed');
+            const error = new Error("Connection failed");
             mockStdioServerAdapter.mockRejectedValue(error);
             const result = await handler.handleRequest(request, mockContext);
             expect(result).toEqual({
-                jsonrpc: '2.0',
+                jsonrpc: "2.0",
                 error: {
                     code: ErrorCode.InternalError,
-                    message: 'Internal error',
-                    data: 'Connection failed',
+                    message: "Internal error",
+                    data: "Connection failed",
                 },
                 id: 1,
             });
         });
-        test('should handle non-Error exceptions', async () => {
+        test("should handle non-Error exceptions", async () => {
             const request = {
-                jsonrpc: '2.0',
+                jsonrpc: "2.0",
                 id: 1,
-                method: 'test',
+                method: "test",
             };
-            mockStdioServerAdapter.mockRejectedValue('String error');
+            mockStdioServerAdapter.mockRejectedValue("String error");
             const result = await handler.handleRequest(request, mockContext);
             expect(result).toEqual({
-                jsonrpc: '2.0',
+                jsonrpc: "2.0",
                 error: {
                     code: ErrorCode.InternalError,
-                    message: 'Internal error',
-                    data: 'Unknown error',
+                    message: "Internal error",
+                    data: "Unknown error",
                 },
                 id: 1,
             });
         });
-        test('should pass server parameters correctly to stdioServerAdapter', async () => {
+        test("should pass server parameters correctly to stdioServerAdapter", async () => {
             const customServerParams = {
-                command: 'python',
-                args: ['custom-server.py', '--port', '8080'],
-                env: { NODE_ENV: 'test' },
+                command: "python",
+                args: ["custom-server.py", "--port", "8080"],
+                env: { hello: "world" },
             };
             const customHandler = new StdioServerAdapterRequestHandler(customServerParams);
             const request = {
-                jsonrpc: '2.0',
+                jsonrpc: "2.0",
                 id: 1,
-                method: 'test',
+                method: "test",
             };
             const response = {
-                jsonrpc: '2.0',
+                jsonrpc: "2.0",
                 id: 1,
                 result: {},
             };

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.3.0",
   "type": "module",
   "license": "Apache-2.0",
   "author": {
@@ -46,6 +46,7 @@
     "aws-sdk-client-mock": "^4.1.0",
     "aws-sdk-client-mock-jest": "^4.1.0",
     "eslint": "^9.30.1",
+    "eslint-plugin-check-file": "^3.3.0",
     "jest": "^30.0.4",
     "ts-jest": "^29.4.0",
     "tsx": "^4.20.3",
@@ -53,8 +54,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"
   }