@aws/run-mcp-servers-with-aws-lambda 0.2.1 → 0.2.2

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

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

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

@@ -0,0 +1,26 @@
+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';
+/**
+ * Generic Request Handler for MCP Stdio Server Adapter
+ *
+ * This class provides a reusable implementation of the RequestHandler interface
+ * that delegates JSON-RPC requests to an MCP server via the stdio server adapter.
+ *
+ * Usage:
+ * ```typescript
+ * const serverParams = {
+ *   command: "node",
+ *   args: ["path/to/mcp-server.js", "--option", "value"]
+ * };
+ *
+ * const handler = new StdioServerAdapterRequestHandler(serverParams);
+ * const streamableHandler = new StreamableHttpHandler(handler);
+ * ```
+ */
+export declare class StdioServerAdapterRequestHandler implements RequestHandler {
+    private serverParams;
+    constructor(serverParams: StdioServerParameters);
+    handleRequest(request: JSONRPCRequest, context: Context): Promise<JSONRPCResponse | JSONRPCError>;
+}

package/dist/server-adapter/stdio_server_adapter_request_handler.js

@@ -0,0 +1,66 @@
+import { isJSONRPCResponse, isJSONRPCError, ErrorCode, } from '@modelcontextprotocol/sdk/types.js';
+import { createLogger, format, transports } from 'winston';
+import { stdioServerAdapter } from './stdio_server_adapter.js';
+const logger = createLogger({
+    level: process.env.LOG_LEVEL?.toLowerCase() || 'info',
+    format: format.simple(),
+    transports: [new transports.Console()],
+});
+/**
+ * Generic Request Handler for MCP Stdio Server Adapter
+ *
+ * This class provides a reusable implementation of the RequestHandler interface
+ * that delegates JSON-RPC requests to an MCP server via the stdio server adapter.
+ *
+ * Usage:
+ * ```typescript
+ * const serverParams = {
+ *   command: "node",
+ *   args: ["path/to/mcp-server.js", "--option", "value"]
+ * };
+ *
+ * const handler = new StdioServerAdapterRequestHandler(serverParams);
+ * const streamableHandler = new StreamableHttpHandler(handler);
+ * ```
+ */
+export class StdioServerAdapterRequestHandler {
+    serverParams;
+    constructor(serverParams) {
+        this.serverParams = serverParams;
+    }
+    async handleRequest(request, context) {
+        try {
+            // Call the MCP server adapter with the individual request
+            const mcpResponse = await stdioServerAdapter(this.serverParams, request, context);
+            // The stdioServerAdapter should return JSONRPCResponse or JSONRPCError for requests
+            if (isJSONRPCResponse(mcpResponse) || isJSONRPCError(mcpResponse)) {
+                return mcpResponse;
+            }
+            else {
+                // Unexpected response format - return internal server error
+                logger.error('Unexpected response format from stdioServerAdapter:', mcpResponse);
+                return {
+                    jsonrpc: '2.0',
+                    error: {
+                        code: ErrorCode.InternalError,
+                        message: 'Internal error: Unexpected response format from MCP server',
+                        data: 'Expected JSONRPCResponse or JSONRPCError',
+                    },
+                    id: request.id,
+                };
+            }
+        }
+        catch (error) {
+            // Return JSON-RPC error response
+            return {
+                jsonrpc: '2.0',
+                error: {
+                    code: ErrorCode.InternalError,
+                    message: 'Internal error',
+                    data: error instanceof Error ? error.message : 'Unknown error',
+                },
+                id: request.id,
+            };
+        }
+    }
+}

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

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

package/dist/server-adapter/stdio_server_adapter_request_handler.test.js

@@ -0,0 +1,148 @@
+import { ErrorCode, } from '@modelcontextprotocol/sdk/types.js';
+import { StdioServerAdapterRequestHandler } from './stdio_server_adapter_request_handler.js';
+import * as stdioServerAdapter from './stdio_server_adapter.js';
+// Mock the stdioServerAdapter function
+jest.mock('./stdio_server_adapter.js', () => ({
+    stdioServerAdapter: jest.fn(),
+}));
+const mockStdioServerAdapter = stdioServerAdapter.stdioServerAdapter;
+const mockServerParams = {
+    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',
+    getRemainingTimeInMillis: () => 1000,
+    done: () => { },
+    fail: () => { },
+    succeed: () => { },
+};
+describe('StdioServerAdapterRequestHandler', () => {
+    let handler;
+    beforeEach(() => {
+        handler = new StdioServerAdapterRequestHandler(mockServerParams);
+        jest.clearAllMocks();
+    });
+    describe('handleRequest', () => {
+        test('should return JSONRPCResponse when stdioServerAdapter returns valid response', async () => {
+            const request = {
+                jsonrpc: '2.0',
+                id: 1,
+                method: 'test',
+                params: { arg: 'value' },
+            };
+            const expectedResponse = {
+                jsonrpc: '2.0',
+                id: 1,
+                result: { success: true },
+            };
+            mockStdioServerAdapter.mockResolvedValue(expectedResponse);
+            const result = await handler.handleRequest(request, mockContext);
+            expect(mockStdioServerAdapter).toHaveBeenCalledWith(mockServerParams, request, mockContext);
+            expect(result).toEqual(expectedResponse);
+        });
+        test('should return JSONRPCError when stdioServerAdapter returns error', async () => {
+            const request = {
+                jsonrpc: '2.0',
+                id: 1,
+                method: 'test',
+            };
+            const expectedError = {
+                jsonrpc: '2.0',
+                error: {
+                    code: ErrorCode.MethodNotFound,
+                    message: 'Method not found',
+                },
+                id: 1,
+            };
+            mockStdioServerAdapter.mockResolvedValue(expectedError);
+            const result = await handler.handleRequest(request, mockContext);
+            expect(mockStdioServerAdapter).toHaveBeenCalledWith(mockServerParams, request, mockContext);
+            expect(result).toEqual(expectedError);
+        });
+        test('should return internal error when stdioServerAdapter returns unexpected format', async () => {
+            const request = {
+                jsonrpc: '2.0',
+                id: 1,
+                method: 'test',
+            };
+            const unexpectedResponse = { invalid: 'response' };
+            mockStdioServerAdapter.mockResolvedValue(unexpectedResponse);
+            const result = await handler.handleRequest(request, mockContext);
+            expect(result).toEqual({
+                jsonrpc: '2.0',
+                error: {
+                    code: ErrorCode.InternalError,
+                    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 () => {
+            const request = {
+                jsonrpc: '2.0',
+                id: 1,
+                method: 'test',
+            };
+            const error = new Error('Connection failed');
+            mockStdioServerAdapter.mockRejectedValue(error);
+            const result = await handler.handleRequest(request, mockContext);
+            expect(result).toEqual({
+                jsonrpc: '2.0',
+                error: {
+                    code: ErrorCode.InternalError,
+                    message: 'Internal error',
+                    data: 'Connection failed',
+                },
+                id: 1,
+            });
+        });
+        test('should handle non-Error exceptions', async () => {
+            const request = {
+                jsonrpc: '2.0',
+                id: 1,
+                method: 'test',
+            };
+            mockStdioServerAdapter.mockRejectedValue('String error');
+            const result = await handler.handleRequest(request, mockContext);
+            expect(result).toEqual({
+                jsonrpc: '2.0',
+                error: {
+                    code: ErrorCode.InternalError,
+                    message: 'Internal error',
+                    data: 'Unknown error',
+                },
+                id: 1,
+            });
+        });
+        test('should pass server parameters correctly to stdioServerAdapter', async () => {
+            const customServerParams = {
+                command: 'python',
+                args: ['custom-server.py', '--port', '8080'],
+                env: { NODE_ENV: 'test' },
+            };
+            const customHandler = new StdioServerAdapterRequestHandler(customServerParams);
+            const request = {
+                jsonrpc: '2.0',
+                id: 1,
+                method: 'test',
+            };
+            const response = {
+                jsonrpc: '2.0',
+                id: 1,
+                result: {},
+            };
+            mockStdioServerAdapter.mockResolvedValue(response);
+            await customHandler.handleRequest(request, mockContext);
+            expect(mockStdioServerAdapter).toHaveBeenCalledWith(customServerParams, request, mockContext);
+        });
+    });
+});

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.1",
+  "version": "0.2.2",
   "type": "module",
   "license": "Apache-2.0",
   "author": {
@@ -39,22 +39,22 @@
     "dist"
   ],
   "devDependencies": {
-    "@eslint/js": "^9.27.0",
-    "@tsconfig/recommended": "^1.0.2",
-    "@types/jest": "^29.5.12",
-    "@types/node": "^22.15.24",
+    "@eslint/js": "^9.30.1",
+    "@tsconfig/recommended": "^1.0.10",
+    "@types/jest": "^30.0.0",
+    "@types/node": "^24.0.10",
     "aws-sdk-client-mock": "^4.1.0",
     "aws-sdk-client-mock-jest": "^4.1.0",
-    "eslint": "^9.27.0",
-    "jest": "^29.7.0",
-    "ts-jest": "^29.3.4",
-    "tsx": "^4.19.4",
+    "eslint": "^9.30.1",
+    "jest": "^30.0.4",
+    "ts-jest": "^29.4.0",
+    "tsx": "^4.20.3",
     "typescript": "^5.8.3",
-    "typescript-eslint": "^8.33.0"
+    "typescript-eslint": "^8.35.1"
   },
   "dependencies": {
-    "@aws-sdk/client-lambda": "^3.817.0",
-    "@modelcontextprotocol/sdk": "^1.12.1",
+    "@aws-sdk/client-lambda": "^3.840.0",
+    "@modelcontextprotocol/sdk": "^1.15.0",
     "@types/aws-lambda": "^8.10.149",
     "winston": "^3.17.0"
   }