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

package/README.md

@@ -17,13 +17,11 @@ flowchart LR
     end
 ```
 
-This MCP server adapter for AWS Lambda helps you to wrap existing stdio MCP servers into Lambda functions.
+This library helps you to wrap existing stdio MCP servers into Lambda functions.
 You can invoke these function-based MCP servers from your application using the MCP protocol
-over short-lived connections.
+over short-lived HTTPS connections.
 Your application can then be a desktop-based app, a distributed system running in the cloud,
 or any other architecture.
-Your application must have access to invoke your Lambda functions,
-and use the custom MCP client transport that invokes the Lambda functions.
 
 ```mermaid
 flowchart LR
@@ -31,62 +29,356 @@ flowchart LR
         App["Your Application<br>with MCP Clients"]
         S3["MCP Server A<br>(Lambda function)"]
         S4["MCP Server B<br>(Lambda function)"]
-        App <-->|"MCP Protocol<br>with custom transport<br>(invoke function)"| S3
-        App <-->|"MCP Protocol<br>with custom transport<br>(invoke function)"| S4
+        App <-->|"MCP Protocol<br>(over HTTPS connection)"| S3
+        App <-->|"MCP Protocol<br>(over HTTPS connection)"| S4
     end
 ```
 
-## Considerations
+Using this library, the Lambda function will manage the lifecycle of your stdio MCP server.
+Each Lambda function invocation will:
 
-- If you are looking for a way to invoke existing Lambda functions as tools through MCP,
-  see the [AWS Lambda MCP Server project](https://awslabs.github.io/mcp/servers/lambda-mcp-server/).
-- This package currently requires using a custom MCP client transport to communicate with the MCP
-  server by invoking the Lambda function. Existing applications with MCP support such as
-  Amazon Q Developer CLI, Cline, etc do not have this custom transport, and cannot communicate with
-  MCP servers adapted into Lambda functions.
-  Note: with [upcoming changes to the MCP protocol](https://github.com/modelcontextprotocol/specification/pull/206),
-  we expect that this limitation will be removed in the future.
-- This package currently supports MCP servers and clients written in Python and Typescript.
-  Other languages such as Kotlin are not supported.
-- The server adapters only adapt stdio MCP servers, not servers written for other protocols such as SSE.
-- The server adapters do not maintain any MCP server state across Lambda function invocations.
-  Only stateless MCP servers are a good fit for using this adapter. For example, MCP servers
-  that invoke stateless tools like the [time MCP server](https://github.com/modelcontextprotocol/servers/tree/main/src/time)
-  or make stateless web requests like the [fetch MCP server](https://github.com/modelcontextprotocol/servers/tree/main/src/fetch).
-  Stateful MCP servers are not a good fit, because they will lose their state on every request.
-  For example, MCP servers that manage data on disk or in memory such as
-  the [sqlite MCP server](https://github.com/modelcontextprotocol/servers/tree/main/src/sqlite),
-  the [filesystem MCP server](https://github.com/modelcontextprotocol/servers/tree/main/src/filesystem),
-  and the [git MCP server](https://github.com/modelcontextprotocol/servers/tree/main/src/git).
-- The server adapters ignore any MCP protocol notifications from the client to the server.
-- The server adapters do not provide mechanisms for managing any secrets needed by the wrapped
-  MCP server. For example, the [GitHub MCP server](https://github.com/modelcontextprotocol/servers/tree/main/src/github)
-  and the [Brave search MCP server](https://github.com/modelcontextprotocol/servers/tree/main/src/brave-search)
-  require API keys to make requests to third-party APIs.
-  You can configure these API keys as
-  [encrypted environment variables](https://docs.aws.amazon.com/lambda/latest/dg/configuration-envvars-encryption.html)
-  in the Lambda function's configuration. However, note that anyone with access to invoke the Lambda function
-  will then have access to use your API key to call the third-party APIs by invoking the function.
-  We recommend limiting access to the Lambda function using
-  [least-privilege IAM policies](https://docs.aws.amazon.com/lambda/latest/dg/security-iam.html).
+1. Start the stdio MCP server as a child process
+1. Initialize the MCP server
+1. Forward the incoming request to the local server
+1. Return the server's response to the function caller
+1. Shut down the MCP server child process
+
+This library supports connecting to Lambda-based MCP servers in three ways:
+
+1. The [MCP Streamable HTTP transport](https://modelcontextprotocol.io/specification/2025-06-18/basic/transports#streamable-http), using Amazon API Gateway. Typically authenticated using OAuth.
+2. A custom Streamable HTTP transport with support for SigV4, using a Lambda function URL. Authenticated with AWS IAM.
+3. A custom Lambda invocation transport, using the Lambda Invoke API directly. Authenticated with AWS IAM.
+
+## Using API Gateway
+
+```mermaid
+flowchart LR
+    App["MCP Client"]
+    T1["MCP Server<br>(Lambda function)"]
+    T2["API Gateway"]
+    T3["OAuth Server<br>(Cognito or similar)"]
+    App -->|"MCP Streamable<br>HTTP Transport"| T2
+    T2 -->|"Invoke"| T1
+    T2 -->|"Authorize"| T3
+```
+
+This solution is compatible with most MCP clients that support the streamable HTTP transport.
+MCP servers deployed with this architecture can typically be used with off-the-shelf
+MCP-compatible applications such as Cursor, Cline, Claude Desktop, etc.
+
+You can choose your desired OAuth server provider for this solution. The examples in this
+repository use Amazon Cognito, or you can use third-party providers such as Okta or Auth0
+with API Gateway custom authorization.
+
+<details>
+
+<summary><b>Python server example</b></summary>
+
+```python
+import sys
+from mcp.client.stdio import StdioServerParameters
+from mcp_lambda import APIGatewayProxyEventHandler, StdioServerAdapterRequestHandler
+
+server_params = StdioServerParameters(
+    command=sys.executable,
+    args=[
+        "-m",
+        "my_mcp_server_python_module",
+        "--my-server-command-line-parameter",
+        "some_value",
+    ],
+)
+
+
+request_handler = StdioServerAdapterRequestHandler(server_params)
+event_handler = APIGatewayProxyEventHandler(request_handler)
+
+
+def handler(event, context):
+    return event_handler.handle(event, context)
+```
+
+See a full, deployable example [here](examples/servers/dad-jokes/).
+
+</details>
+
+<details>
+
+<summary><b>Typescript server example</b></summary>
+
+```typescript
+import {
+  Handler,
+  Context,
+  APIGatewayProxyWithCognitoAuthorizerEvent,
+  APIGatewayProxyResult,
+} from "aws-lambda";
+import {
+  APIGatewayProxyEventHandler,
+  StdioServerAdapterRequestHandler,
+} from "@aws/run-mcp-servers-with-aws-lambda";
+
+const serverParams = {
+  command: "npx",
+  args: [
+    "--offline",
+    "my-mcp-server-typescript-module",
+    "--my-server-command-line-parameter",
+    "some_value",
+  ],
+};
+
+const requestHandler = new APIGatewayProxyEventHandler(
+  new StdioServerAdapterRequestHandler(serverParams)
+);
+
+export const handler: Handler = async (
+  event: APIGatewayProxyWithCognitoAuthorizerEvent,
+  context: Context
+): Promise<APIGatewayProxyResult> => {
+  return requestHandler.handle(event, context);
+};
+```
+
+See a full, deployable example [here](examples/servers/dog-facts/).
+
+</details>
+
+<details>
+
+<summary><b>Python client example</b></summary>
+
+```python
+from mcp import ClientSession
+from mcp.client.streamable_http import streamablehttp_client
+
+# Create OAuth client provider here
+
+async with streamablehttp_client(
+    url="https://abc123.execute-api.us-east-2.amazonaws.com/prod/mcp",
+    auth=oauth_client_provider,
+) as (
+    read_stream,
+    write_stream,
+    _,
+):
+    async with ClientSession(read_stream, write_stream) as session:
+        await session.initialize()
+        tool_result = await session.call_tool("echo", {"message": "hello"})
+```
+
+See a full example as part of the sample chatbot [here](examples/chatbots/python/server_clients/interactive_oauth.py).
+
+</details>
+
+<details>
+
+<summary><b>Typescript client example</b></summary>
+
+```typescript
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+
+const client = new Client(
+  {
+    name: "my-client",
+    version: "0.0.1",
+  },
+  {
+    capabilities: {
+      sampling: {},
+    },
+  }
+);
+
+// Create OAuth client provider here
+
+const transport = new StreamableHTTPClientTransport(
+  "https://abc123.execute-api.us-east-2.amazonaws.com/prod/mcp",
+  {
+    authProvider: oauthProvider,
+  }
+);
+await client.connect(transport);
+```
+
+See a full example as part of the sample chatbot [here](examples/chatbots/typescript/src/server_clients/interactive_oauth.ts).
+
+</details>
+
+## Using a Lambda function URL
+
+```mermaid
+flowchart LR
+    App["MCP Client"]
+    T1["MCP Server<br>(Lambda function)"]
+    T2["Lambda function URL"]
+    App -->|"Custom Streamable HTTP<br>Transport with AWS Auth"| T2
+    T2 -->|"Invoke"| T1
+```
+
+This solution uses AWS IAM for authentication, and relies on granting
+[Lambda InvokeFunctionUrl permission](https://docs.aws.amazon.com/lambda/latest/dg/urls-auth.html#urls-auth-iam) to your
+IAM users and roles to enable access to the MCP server. Clients must use an extension to the MCP Streamable
+HTTP transport that signs requests with [AWS SigV4](https://docs.aws.amazon.com/AmazonS3/latest/API/sig-v4-authenticating-requests.html).
+Off-the-shelf MCP-compatible applications are unlikely to have support for this custom transport,
+so this solution is more appropriate for service-to-service communication rather than for end users.
 
-## Examples
+<details>
 
-### Python server example
+<summary><b>Python server example</b></summary>
 
-This project includes an
-[example Python Lambda function](examples/servers/time/function/index.py)
-that runs the simple
-[MCP 'time' reference server](https://github.com/modelcontextprotocol/servers/tree/main/src/time).
-The Lambda function bundles the [mcp-server-time package](https://pypi.org/project/mcp-server-time/).
-On each function invocation, the Lambda function will manage the lifecycle of the bundled MCP server.
-It will:
+```python
+import sys
+from mcp.client.stdio import StdioServerParameters
+from mcp_lambda import LambdaFunctionURLEventHandler, StdioServerAdapterRequestHandler
+
+server_params = StdioServerParameters(
+    command=sys.executable,
+    args=[
+        "-m",
+        "my_mcp_server_python_module",
+        "--my-server-command-line-parameter",
+        "some_value",
+    ],
+)
+
+
+request_handler = StdioServerAdapterRequestHandler(server_params)
+event_handler = LambdaFunctionURLEventHandler(request_handler)
+
+
+def handler(event, context):
+    return event_handler.handle(event, context)
+```
+
+See a full, deployable example [here](examples/servers/mcpdoc/).
+
+</details>
+
+<details>
+
+<summary><b>Typescript server example</b></summary>
+
+```typescript
+import {
+  Handler,
+  Context,
+  APIGatewayProxyEventV2WithIAMAuthorizer,
+  APIGatewayProxyResultV2,
+} from "aws-lambda";
+import {
+  LambdaFunctionURLEventHandler,
+  StdioServerAdapterRequestHandler,
+} from "@aws/run-mcp-servers-with-aws-lambda";
+
+const serverParams = {
+  command: "npx",
+  args: [
+    "--offline",
+    "my-mcp-server-typescript-module",
+    "--my-server-command-line-parameter",
+    "some_value",
+  ],
+};
+
+const requestHandler = new LambdaFunctionURLEventHandler(
+  new StdioServerAdapterRequestHandler(serverParams)
+);
+
+export const handler: Handler = async (
+  event: APIGatewayProxyEventV2WithIAMAuthorizer,
+  context: Context
+): Promise<APIGatewayProxyResultV2> => {
+  return requestHandler.handle(event, context);
+};
+```
+
+See a full, deployable example [here](examples/servers/cat-facts/).
+
+</details>
+
+<details>
+
+<summary><b>Python client example</b></summary>
+
+```python
+from mcp import ClientSession
+from mcp_lambda.client.streamable_http_sigv4 import streamablehttp_client_with_sigv4
+
+async with streamablehttp_client_with_sigv4(
+    url="https://url-id-12345.lambda-url.us-east-2.on.aws",
+    service="lambda",
+    region="us-east-2",
+) as (
+    read_stream,
+    write_stream,
+    _,
+):
+    async with ClientSession(read_stream, write_stream) as session:
+        await session.initialize()
+        tool_result = await session.call_tool("echo", {"message": "hello"})
+```
+
+See a full example as part of the sample chatbot [here](examples/chatbots/python/server_clients/lambda_function_url.py).
+
+</details>
+
+<details>
+
+<summary><b>Typescript client example</b></summary>
+
+```typescript
+import { StreamableHTTPClientWithSigV4Transport } from "@aws/run-mcp-servers-with-aws-lambda";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+
+const client = new Client(
+  {
+    name: "my-client",
+    version: "0.0.1",
+  },
+  {
+    capabilities: {
+      sampling: {},
+    },
+  }
+);
+
+const transport = new StreamableHTTPClientWithSigV4Transport(
+  new URL("https://url-id-12345.lambda-url.us-east-2.on.aws"),
+  {
+    service: "lambda",
+    region: "us-east-2",
+  }
+);
+await client.connect(transport);
+```
 
-1. start the 'time' MCP server as a child process
-1. initialize the MCP server
-1. forward the incoming request to the local server
-1. return the server's response to the function caller
-1. shut down the MCP server child process
+See a full example as part of the sample chatbot [here](examples/chatbots/typescript/src/server_clients/lambda_function_url.ts).
+
+</details>
+
+## Using the Lambda Invoke API
+
+```mermaid
+flowchart LR
+    App["MCP Client"]
+    T1["MCP Server<br>(Lambda function)"]
+    App -->|"Custom MCP Transport<br>(Lambda Invoke API)"| T1
+```
+
+Like the Lambda function URL approach, this solution uses AWS IAM for authentication.
+It relies on granting
+[Lambda InvokeFunction permission](https://docs.aws.amazon.com/lambda/latest/dg/lambda-api-permissions-ref.html)
+to your IAM users and roles to enable access to the MCP server.
+Clients must use a custom MCP transport that directly calls the
+[Lambda Invoke API](https://docs.aws.amazon.com/lambda/latest/api/API_Invoke.html).
+Off-the-shelf MCP-compatible applications are unlikely to have support for this custom transport,
+so this solution is more appropriate for service-to-service communication rather than for end users.
+
+<details>
+
+<summary><b>Python server example</b></summary>
 
 ```python
 import sys
@@ -97,9 +389,9 @@ server_params = StdioServerParameters(
     command=sys.executable,
     args=[
         "-m",
-        "mcp_server_time",
-        "--local-timezone",
-        "America/New_York",
+        "my_mcp_server_python_module",
+        "--my-server-command-line-parameter",
+        "some_value",
     ],
 )
 
@@ -108,69 +400,66 @@ def handler(event, context):
     return stdio_server_adapter(server_params, event, context)
 ```
 
-### Typescript server example
+See a full, deployable example [here](examples/servers/time/).
+
+</details>
 
-This project includes an
-[example Node.js Lambda function](examples/servers/weather-alerts/lib/weather-alerts-mcp-server.function.ts)
-that runs an [OpenAPI MCP server](https://github.com/snaggle-ai/openapi-mcp-server/)
-to provide a single API from [weather.gov](https://www.weather.gov/documentation/services-web-api) as a tool.
-The Lambda function bundles the [openapi-mcp-server package](https://www.npmjs.com/package/openapi-mcp-server).
-On each function invocation, the Lambda function will manage the lifecycle of the bundled MCP server.
-It will:
+<details>
 
-1. start the 'openapi-mcp-server' MCP server as a child process
-1. initialize the MCP server
-1. forward the incoming request to the local server
-1. return the server's response to the function caller
-1. shut down the MCP server child process
+<summary><b>Typescript server example</b></summary>
 
 ```typescript
 import { Handler, Context } from "aws-lambda";
+import { stdioServerAdapter } from "@aws/run-mcp-servers-with-aws-lambda";
 
 const serverParams = {
   command: "npx",
-  args: ["--offline", "openapi-mcp-server", "./weather-alerts-openapi.json"],
+  args: [
+    "--offline",
+    "my-mcp-server-typescript-module",
+    "--my-server-command-line-parameter",
+    "some_value",
+  ],
 };
 
 export const handler: Handler = async (event, context: Context) => {
-  // Dynamically import ES module into CommonJS Lambda function
-  const { stdioServerAdapter } = await import(
-    "@aws/run-mcp-servers-with-aws-lambda"
-  );
-
   return await stdioServerAdapter(serverParams, event, context);
 };
 ```
 
-### Python client example
+See a full, deployable example [here](examples/servers/weather-alerts/).
+
+</details>
+
+<details>
 
-This project includes an
-[example Python MCP client](examples/chatbots/python/server_clients/lambda_function.py)
-that invokes the 'time' MCP server function from above.
-The client invokes a Lambda function named "mcp-server-time" with a payload that is compliant
-with the MCP protocol and returns the function's response to the caller.
+<summary><b>Python client example</b></summary>
 
 ```python
 from mcp import ClientSession
 from mcp_lambda import LambdaFunctionParameters, lambda_function_client
 
 server_params = LambdaFunctionParameters(
-    function_name="mcp-server-time",
+    function_name="my-mcp-server-function",
     region_name="us-east-2",
 )
 
-read, write = await lambda_function_client(server_params)
-session = ClientSession(read, write)
-await session.initialize()
+async with lambda_function_client(server_params) as (
+    read_stream,
+    write_stream,
+):
+    async with ClientSession(read_stream, write_stream) as session:
+        await session.initialize()
+        tool_result = await session.call_tool("echo", {"message": "hello"})
 ```
 
-### Typescript client example
+See a full example as part of the sample chatbot [here](examples/chatbots/python/server_clients/lambda_function.py).
 
-This project includes an
-[example Typescript MCP client](examples/chatbots/typescript/src/server_clients/lambda_function.ts)
-that invokes the 'time' MCP server function from above.
-The client invokes a Lambda function named "mcp-server-time" with a payload that is compliant
-with the MCP protocol and returns the function's response to the caller.
+</details>
+
+<details>
+
+<summary><b>Typescript client example</b></summary>
 
 ```typescript
 import {
@@ -180,7 +469,7 @@ import {
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 
 const serverParams: LambdaFunctionParameters = {
-  functionName: "mcp-server-time",
+  functionName: "my-mcp-server-function",
   regionName: "us-east-2",
 };
 
@@ -200,7 +489,44 @@ const transport = new LambdaFunctionClientTransport(serverParams);
 await client.connect(transport);
 ```
 
-### Deploy and run the examples
+See a full example as part of the sample chatbot [here](examples/chatbots/typescript/src/server_clients/lambda_function.ts).
+
+</details>
+
+## Related projects
+
+- To write custom MCP servers in Lambda functions,
+  see the [MCP Lambda Handler](https://github.com/awslabs/mcp/tree/main/src/mcp-lambda-handler) project.
+- To invoke existing Lambda functions as tools through a stdio MCP server,
+  see the [AWS Lambda Tool MCP Server](https://awslabs.github.io/mcp/servers/lambda-tool-mcp-server/) project.
+
+## Considerations
+
+- This library currently supports MCP servers and clients written in Python and Typescript.
+  Other languages such as Kotlin are not supported.
+- This library only adapts stdio MCP servers for Lambda, not servers written for other protocols such as SSE.
+- This library does not maintain any MCP server state or sessions across Lambda function invocations.
+  Only stateless MCP servers are a good fit for using this adapter. For example, MCP servers
+  that invoke stateless tools like the [time MCP server](https://github.com/modelcontextprotocol/servers/tree/main/src/time)
+  or make stateless web requests like the [fetch MCP server](https://github.com/modelcontextprotocol/servers/tree/main/src/fetch).
+  Stateful MCP servers are not a good fit, because they will lose their state on every request.
+  For example, MCP servers that manage data on disk or in memory such as
+  the [sqlite MCP server](https://github.com/modelcontextprotocol/servers/tree/main/src/sqlite),
+  the [filesystem MCP server](https://github.com/modelcontextprotocol/servers/tree/main/src/filesystem),
+  and the [git MCP server](https://github.com/modelcontextprotocol/servers/tree/main/src/git).
+- This library does not provide mechanisms for managing any secrets needed by the wrapped
+  MCP server. For example, the [GitHub MCP server](https://github.com/modelcontextprotocol/servers/tree/main/src/github)
+  and the [Brave search MCP server](https://github.com/modelcontextprotocol/servers/tree/main/src/brave-search)
+  require API keys to make requests to third-party APIs.
+  You may configure these API keys as
+  [encrypted environment variables](https://docs.aws.amazon.com/lambda/latest/dg/configuration-envvars-encryption.html)
+  in the Lambda function's configuration. However, note that anyone with access to invoke the Lambda function
+  will then have access to use your API key to call the third-party APIs by invoking the function.
+  We recommend limiting access to the Lambda function using
+  [least-privilege IAM policies](https://docs.aws.amazon.com/lambda/latest/dg/security-iam.html).
+  If you use an identity-based authentication mechanism such as OAuth, you could also store and retrieve API keys per user but there are no implementation examples in this repository.
+
+## Deploy and run the examples
 
 See the [development guide](DEVELOP.md) for instructions to deploy and run the examples in this repository.
 

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/{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.4",
+  "version": "0.3.1",
   "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",