aws-lambda-mcp-server 0.0.2 → 0.0.3

package/README.md

@@ -1,5 +1,7 @@
 # aws-lambda-mcp-server
 
+[![npm version](https://badge.fury.io/js/aws-lambda-mcp-server.svg)](https://badge.fury.io/js/aws-lambda-mcp-server)
+
 AWS Lambda上でMCP（Model Context Protocol）サーバー機能を提供するためのライブラリです。
 APIエンドポイントの実装や、各種AWSサービスとの連携を簡易化することを目的としています。
 
@@ -19,29 +21,33 @@ TypeScriptでの利用例です。
 
 ```typescript
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import { handler } from 'aws-lambda-mcp-server';
+import { createHonoApp } from 'aws-lambda-mcp-server';
 import { handle } from 'hono/aws-lambda';
-
-// MCPサーバーのインスタンスを作成
-const server = new McpServer({
-  name: 'my-mcp-server',
-  version: '1.0.0',
-});
-
-// MCPサーバーのインスタンスにToolsやResourcesなどを設定する
-server.tool(
-  "say_hello",
-  { who: z.string() },
-  async ({ who }) => ({
-    content: [{
-      type: "text",
-      text: `${who} さん、こんにちは！`
-    }]
-  })
-);
+import { z } from 'zod';
+
+// MCPサーバーのファクトリ関数を用意
+const createMcpServer = () => {
+  const server = new McpServer({
+    name: 'my-mcp-server',
+    version: '1.0.0',
+  });
+
+  // MCPサーバーのインスタンスにToolsやResourcesなどを設定する
+  server.tool(
+    'say_hello',
+    { who: z.string() },
+    async ({ who }) => ({
+      content: [{
+        type: 'text',
+        text: `${who} さん、こんにちは！`
+      }]
+    })
+  );
+  return server;
+};
 
 // Hono アプリケーションを作成
-const app = createHonoApp(server);
+const app = createHonoApp(createMcpServer);
 
 // AWS Lambdaのエントリポイントとして利用
 export const handler = handle(app);

package/dist/index.d.ts

@@ -1,5 +1,31 @@
+/**
+ * Model Context Protocol (MCP) サーバーを Hono フレームワーク上で動作させるエントリーポイント。
+ *
+ * @remarks
+ * `createHonoApp` 関数を通じて、/mcp エンドポイントでMCPサーバーを提供します。
+ * - POST/GET /mcp: MCPリクエストの受信・処理
+ * - その他のHTTPメソッド: 405 Method Not Allowed
+ *
+ * 内部的にエラーハンドリングやリソースクローズ処理も行います。
+ */
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { Hono } from 'hono';
 import { BlankEnv } from 'hono/types';
-export declare const createHonoApp: (server: McpServer) => Hono<BlankEnv, import("hono/types").BlankSchema, "/">;
+/**
+ * Honoアプリケーションを生成し、/mcpエンドポイントでMCPサーバーを提供します。
+ *
+ * @remarks
+ * POST/GET /mcp でMCPリクエストを受け付け、他のHTTPメソッドは405を返します。
+ *
+ * @param createMcpServer MCPサーバーインスタンスを生成するファクトリ関数
+ * @returns Honoアプリケーションインスタンス
+ *
+ * @example
+ * ```ts
+ * import { createHonoApp } from '...';
+ * import { createMcpServer } from './your-mcp-server';
+ * const app = createHonoApp(createMcpServer);
+ * ```
+ */
+export declare const createHonoApp: (createMcpServer: () => McpServer) => Hono<BlankEnv, import("hono/types").BlankSchema, "/">;
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AACpE,OAAO,EAAW,IAAI,EAAE,MAAM,MAAM,CAAC;AACrC,OAAO,EAAE,QAAQ,EAAc,MAAM,YAAY,CAAC;AAqFlD,eAAO,MAAM,aAAa,GAAI,QAAQ,SAAS,0DAiB9C,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAIH,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AACpE,OAAO,EAAW,IAAI,EAAE,MAAM,MAAM,CAAC;AACrC,OAAO,EAAE,QAAQ,EAAc,MAAM,YAAY,CAAC;AA0IlD;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,aAAa,GAAI,iBAAiB,MAAM,SAAS,0DAiB7D,CAAC"}

package/dist/index.js

@@ -1,7 +1,32 @@
+/**
+ * Model Context Protocol (MCP) サーバーを Hono フレームワーク上で動作させるエントリーポイント。
+ *
+ * @remarks
+ * `createHonoApp` 関数を通じて、/mcp エンドポイントでMCPサーバーを提供します。
+ * - POST/GET /mcp: MCPリクエストの受信・処理
+ * - その他のHTTPメソッド: 405 Method Not Allowed
+ *
+ * 内部的にエラーハンドリングやリソースクローズ処理も行います。
+ */
 import { Logger } from '@aws-lambda-powertools/logger';
 import { StreamableHTTPTransport } from '@hono/mcp';
 import { Hono } from 'hono';
+/**
+ * ロガーインスタンス（AWS Lambda Powertools）。
+ *
+ * @private
+ */
 const logger = new Logger();
+/**
+ * 許可されていないHTTPメソッドに対するハンドラーです。
+ *
+ * @remarks
+ * 405エラーのJSONレスポンスを返します。
+ *
+ * @param c Honoのコンテキスト
+ * @returns 405エラーのJSONレスポンス
+ * @private
+ */
 const methodNotAllowedHandler = async (c) => {
     return c.json({
         jsonrpc: '2.0',
@@ -12,6 +37,18 @@ const methodNotAllowedHandler = async (c) => {
         id: null,
     }, { status: 405 });
 };
+/**
+ * サーバーエラー発生時の共通エラーハンドラーです。
+ *
+ * @remarks
+ * エラー内容をロギングし、500エラーのJSONレスポンスを返します。
+ *
+ * @param c Honoのコンテキスト
+ * @param reason エラー理由
+ * @param logMessage ログ出力用メッセージ
+ * @returns 500エラーのJSONレスポンス
+ * @private
+ */
 const handleError = (c, reason, logMessage) => {
     const errorDetails = reason instanceof Error
         ? { message: reason.message, stack: reason.stack, name: reason.name }
@@ -26,6 +63,17 @@ const handleError = (c, reason, logMessage) => {
         id: null,
     }, { status: 500 });
 };
+/**
+ * MCPサーバーおよびトランスポートのリソースをクローズします。
+ *
+ * @remarks
+ * どちらか一方のクローズに失敗しても、もう一方は必ず実行されます。
+ *
+ * @param server MCPサーバーインスタンス
+ * @param transport トランスポートインスタンス
+ * @returns void
+ * @private
+ */
 const closeResources = async (server, transport) => {
     // 両方のクローズを確実に実行（片方が失敗してももう片方を実行）
     const closeResults = await Promise.allSettled([
@@ -44,36 +92,69 @@ const closeResources = async (server, transport) => {
         }
     });
 };
-const handleRequest = async (server, c) => {
+/**
+ * MCPリクエストを処理します。
+ *
+ * @remarks
+ * サーバーとトランスポートの接続・リクエスト処理・エラーハンドリングを行います。
+ *
+ * @param createMcpServer MCPサーバーインスタンスを生成するファクトリ関数
+ * @param c Honoのコンテキスト
+ * @returns MCPレスポンス
+ * @private
+ */
+const handleRequest = async (createMcpServer, c) => {
     const transport = new StreamableHTTPTransport({
         sessionIdGenerator: undefined, // セッションIDを生成しない（ステートレスモード）
         enableJsonResponse: true,
     });
+    const server = createMcpServer();
     try {
         await server.connect(transport);
         logger.trace('MCP リクエストを受信');
         return await transport.handleRequest(c);
     }
     catch (error) {
+        return handleError(c, error, 'MCP 接続中のエラー:');
+    }
+    finally {
+        // エラーの有無に関わらず必ずリソースをクローズ
         try {
             await closeResources(server, transport);
         }
         catch (closeError) {
+            // クローズエラーは既にcloseResources内でログ出力されているため、
+            // ここでは追加のエラーハンドリングは不要だが、エラーの詳細を記録
             const errorDetails = closeError instanceof Error
                 ? { message: closeError.message, stack: closeError.stack }
                 : closeError;
-            logger.error('Transport close failed after connection error:', { closeError: errorDetails });
+            logger.error('リソースクローズ中に追加エラーが発生しましたが、処理を継続します', { closeError: errorDetails });
         }
-        return handleError(c, error, 'MCP 接続中のエラー:');
     }
 };
-export const createHonoApp = (server) => {
+/**
+ * Honoアプリケーションを生成し、/mcpエンドポイントでMCPサーバーを提供します。
+ *
+ * @remarks
+ * POST/GET /mcp でMCPリクエストを受け付け、他のHTTPメソッドは405を返します。
+ *
+ * @param createMcpServer MCPサーバーインスタンスを生成するファクトリ関数
+ * @returns Honoアプリケーションインスタンス
+ *
+ * @example
+ * ```ts
+ * import { createHonoApp } from '...';
+ * import { createMcpServer } from './your-mcp-server';
+ * const app = createHonoApp(createMcpServer);
+ * ```
+ */
+export const createHonoApp = (createMcpServer) => {
     const app = new Hono();
     app.post('/mcp', async (c) => {
-        return await handleRequest(server, c);
+        return await handleRequest(createMcpServer, c);
     });
     app.get('/mcp', async (c) => {
-        return await handleRequest(server, c);
+        return await handleRequest(createMcpServer, c);
     });
     app.put('/mcp', methodNotAllowedHandler);
     app.delete('/mcp', methodNotAllowedHandler);
@@ -81,4 +162,4 @@ export const createHonoApp = (server) => {
     app.options('/mcp', methodNotAllowedHandler);
     return app;
 };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,+BAA+B,CAAC;AACvD,OAAO,EAAE,uBAAuB,EAAE,MAAM,WAAW,CAAC;AAEpD,OAAO,EAAW,IAAI,EAAE,MAAM,MAAM,CAAC;AAGrC,MAAM,MAAM,GAAG,IAAI,MAAM,EAAE,CAAC;AAE5B,MAAM,uBAAuB,GAAG,KAAK,EACnC,CAAwC,EACxC,EAAE;IACF,OAAO,CAAC,CAAC,IAAI,CACX;QACE,OAAO,EAAE,KAAK;QACd,KAAK,EAAE;YACL,IAAI,EAAE,CAAC,KAAK;YACZ,OAAO,EAAE,iBAAiB;SAC3B;QACD,EAAE,EAAE,IAAI;KACT,EACD,EAAE,MAAM,EAAE,GAAG,EAAE,CAChB,CAAC;AACJ,CAAC,CAAC;AAEF,MAAM,WAAW,GAAG,CAClB,CAAwC,EACxC,MAAe,EACf,UAAkB,EAClB,EAAE;IACF,MAAM,YAAY,GAAG,MAAM,YAAY,KAAK;QAC1C,CAAC,CAAC,EAAE,OAAO,EAAE,MAAM,CAAC,OAAO,EAAE,KAAK,EAAE,MAAM,CAAC,KAAK,EAAE,IAAI,EAAE,MAAM,CAAC,IAAI,EAAE;QACrE,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC;IACf,MAAM,CAAC,KAAK,CAAC,UAAU,EAAE,YAAY,CAAC,CAAC;IACvC,OAAO,CAAC,CAAC,IAAI,CACX;QACE,OAAO,EAAE,KAAK;QACd,KAAK,EAAE;YACL,IAAI,EAAE,CAAC,KAAK;YACZ,OAAO,EAAE,WAAW;SACrB;QACD,EAAE,EAAE,IAAI;KACT,EACD,EAAE,MAAM,EAAE,GAAG,EAAE,CAChB,CAAC;AACJ,CAAC,CAAC;AAEF,MAAM,cAAc,GAAG,KAAK,EAAE,MAAiB,EAAE,SAAkC,EAAE,EAAE;IACrF,iCAAiC;IACjC,MAAM,YAAY,GAAG,MAAM,OAAO,CAAC,UAAU,CAAC;QAC5C,SAAS,CAAC,KAAK,EAAE;QACjB,MAAM,CAAC,KAAK,EAAE;KACf,CAAC,CAAC;IAEH,eAAe;IACf,YAAY,CAAC,OAAO,CAAC,CAAC,MAAM,EAAE,KAAK,EAAE,EAAE;QACrC,IAAI,MAAM,CAAC,MAAM,KAAK,UAAU,EAAE,CAAC;YACjC,MAAM,YAAY,GAAG,KAAK,KAAK,CAAC,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,QAAQ,CAAC;YAC1D,MAAM,KAAK,GAAG,MAAM,CAAC,MAAM,CAAC;YAC5B,MAAM,YAAY,GAAG,KAAK,YAAY,KAAK;gBACzC,CAAC,CAAC,EAAE,OAAO,EAAE,KAAK,CAAC,OAAO,EAAE,KAAK,EAAE,KAAK,CAAC,KAAK,EAAE;gBAChD,CAAC,CAAC,KAAK,CAAC;YACV,MAAM,CAAC,KAAK,CAAC,iBAAiB,YAAY,GAAG,EAAE,EAAE,KAAK,EAAE,YAAY,EAAE,CAAC,CAAC;QAC1E,CAAC;IACH,CAAC,CAAC,CAAC;AACL,CAAC,CAAC;AAEF,MAAM,aAAa,GAAG,KAAK,EAAE,MAAiB,EAAE,CAAwC,EAAE,EAAE;IAC1F,MAAM,SAAS,GAAG,IAAI,uBAAuB,CAAC;QAC5C,kBAAkB,EAAE,SAAS,EAAE,2BAA2B;QAC1D,kBAAkB,EAAE,IAAI;KACzB,CAAC,CAAC;IACH,IAAI,CAAC;QACH,MAAM,MAAM,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;QAChC,MAAM,CAAC,KAAK,CAAC,cAAc,CAAC,CAAC;QAC7B,OAAO,MAAM,SAAS,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC;IAC1C,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,IAAI,CAAC;YACH,MAAM,cAAc,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;QAC1C,CAAC;QAAC,OAAO,UAAU,EAAE,CAAC;YACpB,MAAM,YAAY,GAAG,UAAU,YAAY,KAAK;gBAC9C,CAAC,CAAC,EAAE,OAAO,EAAE,UAAU,CAAC,OAAO,EAAE,KAAK,EAAE,UAAU,CAAC,KAAK,EAAE;gBAC1D,CAAC,CAAC,UAAU,CAAC;YACf,MAAM,CAAC,KAAK,CAAC,gDAAgD,EAAE,EAAE,UAAU,EAAE,YAAY,EAAE,CAAC,CAAC;QAC/F,CAAC;QACD,OAAO,WAAW,CAAC,CAAC,EAAE,KAAK,EAAE,cAAc,CAAC,CAAC;IAC/C,CAAC;AAEH,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,aAAa,GAAG,CAAC,MAAiB,EAAE,EAAE;IACjD,MAAM,GAAG,GAAG,IAAI,IAAI,EAAE,CAAC;IAEvB,GAAG,CAAC,IAAI,CAAC,MAAM,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE;QAC3B,OAAO,MAAM,aAAa,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC;IACxC,CAAC,CAAC,CAAC;IAEH,GAAG,CAAC,GAAG,CAAC,MAAM,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE;QAC1B,OAAO,MAAM,aAAa,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC;IACxC,CAAC,CAAC,CAAC;IAEH,GAAG,CAAC,GAAG,CAAC,MAAM,EAAE,uBAAuB,CAAC,CAAC;IACzC,GAAG,CAAC,MAAM,CAAC,MAAM,EAAE,uBAAuB,CAAC,CAAC;IAC5C,GAAG,CAAC,KAAK,CAAC,MAAM,EAAE,uBAAuB,CAAC,CAAC;IAC3C,GAAG,CAAC,OAAO,CAAC,MAAM,EAAE,uBAAuB,CAAC,CAAC;IAE7C,OAAO,GAAG,CAAC;AACb,CAAC,CAAC","sourcesContent":["import { Logger } from '@aws-lambda-powertools/logger';\nimport { StreamableHTTPTransport } from '@hono/mcp';\nimport { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';\nimport { Context, Hono } from 'hono';\nimport { BlankEnv, BlankInput } from 'hono/types';\n\nconst logger = new Logger();\n\nconst methodNotAllowedHandler = async (\n  c: Context<BlankEnv, '/mcp', BlankInput>,\n) => {\n  return c.json(\n    {\n      jsonrpc: '2.0',\n      error: {\n        code: -32000,\n        message: 'メソッドは許可されていません。',\n      },\n      id: null,\n    },\n    { status: 405 },\n  );\n};\n\nconst handleError = (\n  c: Context<BlankEnv, '/mcp', BlankInput>,\n  reason: unknown,\n  logMessage: string,\n) => {\n  const errorDetails = reason instanceof Error\n    ? { message: reason.message, stack: reason.stack, name: reason.name }\n    : { reason };\n  logger.error(logMessage, errorDetails);\n  return c.json(\n    {\n      jsonrpc: '2.0',\n      error: {\n        code: -32603,\n        message: '内部サーバーエラー',\n      },\n      id: null,\n    },\n    { status: 500 },\n  );\n};\n\nconst closeResources = async (server: McpServer, transport: StreamableHTTPTransport) => {\n  // 両方のクローズを確実に実行（片方が失敗してももう片方を実行）\n  const closeResults = await Promise.allSettled([\n    transport.close(),\n    server.close(),\n  ]);\n\n  // クローズエラーをログ出力\n  closeResults.forEach((result, index) => {\n    if (result.status === 'rejected') {\n      const resourceName = index === 0 ? 'transport' : 'server';\n      const error = result.reason;\n      const errorDetails = error instanceof Error\n        ? { message: error.message, stack: error.stack }\n        : error;\n      logger.error(`Error closing ${resourceName}:`, { error: errorDetails });\n    }\n  });\n};\n\nconst handleRequest = async (server: McpServer, c: Context<BlankEnv, '/mcp', BlankInput>) => {\n  const transport = new StreamableHTTPTransport({\n    sessionIdGenerator: undefined, // セッションIDを生成しない（ステートレスモード）\n    enableJsonResponse: true,\n  });\n  try {\n    await server.connect(transport);\n    logger.trace('MCP リクエストを受信');\n    return await transport.handleRequest(c);\n  } catch (error) {\n    try {\n      await closeResources(server, transport);\n    } catch (closeError) {\n      const errorDetails = closeError instanceof Error\n        ? { message: closeError.message, stack: closeError.stack }\n        : closeError;\n      logger.error('Transport close failed after connection error:', { closeError: errorDetails });\n    }\n    return handleError(c, error, 'MCP 接続中のエラー:');\n  }\n\n};\n\nexport const createHonoApp = (server: McpServer) => {\n  const app = new Hono();\n\n  app.post('/mcp', async (c) => {\n    return await handleRequest(server, c);\n  });\n\n  app.get('/mcp', async (c) => {\n    return await handleRequest(server, c);\n  });\n\n  app.put('/mcp', methodNotAllowedHandler);\n  app.delete('/mcp', methodNotAllowedHandler);\n  app.patch('/mcp', methodNotAllowedHandler);\n  app.options('/mcp', methodNotAllowedHandler);\n\n  return app;\n};\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Model Context Protocol (MCP) サーバーを Hono フレームワーク上で動作させるエントリーポイント。\n *\n * @remarks\n * `createHonoApp` 関数を通じて、/mcp エンドポイントでMCPサーバーを提供します。\n * - POST/GET /mcp: MCPリクエストの受信・処理\n * - その他のHTTPメソッド: 405 Method Not Allowed\n *\n * 内部的にエラーハンドリングやリソースクローズ処理も行います。\n */\n\nimport { Logger } from '@aws-lambda-powertools/logger';\nimport { StreamableHTTPTransport } from '@hono/mcp';\nimport { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';\nimport { Context, Hono } from 'hono';\nimport { BlankEnv, BlankInput } from 'hono/types';\n\n/**\n * ロガーインスタンス（AWS Lambda Powertools）。\n *\n * @private\n */\nconst logger = new Logger();\n\n/**\n * 許可されていないHTTPメソッドに対するハンドラーです。\n *\n * @remarks\n * 405エラーのJSONレスポンスを返します。\n *\n * @param c Honoのコンテキスト\n * @returns 405エラーのJSONレスポンス\n * @private\n */\nconst methodNotAllowedHandler = async (\n  c: Context<BlankEnv, '/mcp', BlankInput>,\n) => {\n  return c.json(\n    {\n      jsonrpc: '2.0',\n      error: {\n        code: -32000,\n        message: 'メソッドは許可されていません。',\n      },\n      id: null,\n    },\n    { status: 405 },\n  );\n};\n\n/**\n * サーバーエラー発生時の共通エラーハンドラーです。\n *\n * @remarks\n * エラー内容をロギングし、500エラーのJSONレスポンスを返します。\n *\n * @param c Honoのコンテキスト\n * @param reason エラー理由\n * @param logMessage ログ出力用メッセージ\n * @returns 500エラーのJSONレスポンス\n * @private\n */\nconst handleError = (\n  c: Context<BlankEnv, '/mcp', BlankInput>,\n  reason: unknown,\n  logMessage: string,\n) => {\n  const errorDetails = reason instanceof Error\n    ? { message: reason.message, stack: reason.stack, name: reason.name }\n    : { reason };\n  logger.error(logMessage, errorDetails);\n  return c.json(\n    {\n      jsonrpc: '2.0',\n      error: {\n        code: -32603,\n        message: '内部サーバーエラー',\n      },\n      id: null,\n    },\n    { status: 500 },\n  );\n};\n\n/**\n * MCPサーバーおよびトランスポートのリソースをクローズします。\n *\n * @remarks\n * どちらか一方のクローズに失敗しても、もう一方は必ず実行されます。\n *\n * @param server MCPサーバーインスタンス\n * @param transport トランスポートインスタンス\n * @returns void\n * @private\n */\nconst closeResources = async (server: McpServer, transport: StreamableHTTPTransport) => {\n  // 両方のクローズを確実に実行（片方が失敗してももう片方を実行）\n  const closeResults = await Promise.allSettled([\n    transport.close(),\n    server.close(),\n  ]);\n\n  // クローズエラーをログ出力\n  closeResults.forEach((result, index) => {\n    if (result.status === 'rejected') {\n      const resourceName = index === 0 ? 'transport' : 'server';\n      const error = result.reason;\n      const errorDetails = error instanceof Error\n        ? { message: error.message, stack: error.stack }\n        : error;\n      logger.error(`Error closing ${resourceName}:`, { error: errorDetails });\n    }\n  });\n};\n\n/**\n * MCPリクエストを処理します。\n *\n * @remarks\n * サーバーとトランスポートの接続・リクエスト処理・エラーハンドリングを行います。\n *\n * @param createMcpServer MCPサーバーインスタンスを生成するファクトリ関数\n * @param c Honoのコンテキスト\n * @returns MCPレスポンス\n * @private\n */\nconst handleRequest = async (createMcpServer: () => McpServer, c: Context<BlankEnv, '/mcp', BlankInput>) => {\n  const transport = new StreamableHTTPTransport({\n    sessionIdGenerator: undefined, // セッションIDを生成しない（ステートレスモード）\n    enableJsonResponse: true,\n  });\n  const server = createMcpServer();\n  try {\n    await server.connect(transport);\n    logger.trace('MCP リクエストを受信');\n    return await transport.handleRequest(c);\n  } catch (error) {\n    return handleError(c, error, 'MCP 接続中のエラー:');\n  } finally {\n    // エラーの有無に関わらず必ずリソースをクローズ\n    try {\n      await closeResources(server, transport);\n    } catch (closeError) {\n      // クローズエラーは既にcloseResources内でログ出力されているため、\n      // ここでは追加のエラーハンドリングは不要だが、エラーの詳細を記録\n      const errorDetails = closeError instanceof Error\n        ? { message: closeError.message, stack: closeError.stack }\n        : closeError;\n      logger.error('リソースクローズ中に追加エラーが発生しましたが、処理を継続します', { closeError: errorDetails });\n    }\n  }\n};\n\n/**\n * Honoアプリケーションを生成し、/mcpエンドポイントでMCPサーバーを提供します。\n *\n * @remarks\n * POST/GET /mcp でMCPリクエストを受け付け、他のHTTPメソッドは405を返します。\n *\n * @param createMcpServer MCPサーバーインスタンスを生成するファクトリ関数\n * @returns Honoアプリケーションインスタンス\n *\n * @example\n * ```ts\n * import { createHonoApp } from '...';\n * import { createMcpServer } from './your-mcp-server';\n * const app = createHonoApp(createMcpServer);\n * ```\n */\nexport const createHonoApp = (createMcpServer: () => McpServer) => {\n  const app = new Hono();\n\n  app.post('/mcp', async (c) => {\n    return await handleRequest(createMcpServer, c);\n  });\n\n  app.get('/mcp', async (c) => {\n    return await handleRequest(createMcpServer, c);\n  });\n\n  app.put('/mcp', methodNotAllowedHandler);\n  app.delete('/mcp', methodNotAllowedHandler);\n  app.patch('/mcp', methodNotAllowedHandler);\n  app.options('/mcp', methodNotAllowedHandler);\n\n  return app;\n};\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aws-lambda-mcp-server",
-  "version": "0.0.2",
+  "version": "0.0.3",
   "description": "A Hono wrapper for building an MCP (Model Context Protocol) Server that runs on AWS Lambda functions.",
   "type": "module",
   "keywords": [
@@ -34,25 +34,25 @@
   "license": "ISC",
   "devDependencies": {
     "@eslint/compat": "^1.4.1",
-    "@eslint/js": "^9.39.0",
+    "@eslint/js": "^9.39.1",
     "@stylistic/eslint-plugin": "^5.5.0",
-    "@types/node": "24.9.2",
-    "eslint": "^9.39.0",
+    "@types/node": "24.10.0",
+    "eslint": "^9.39.1",
     "eslint-import-resolver-typescript": "^4.4.4",
     "eslint-plugin-import": "^2.32.0",
     "eslint-plugin-promise": "^7.2.1",
     "jiti": "^2.6.1",
     "tsx": "^4.20.6",
     "typescript": "^5.9.3",
-    "typescript-eslint": "^8.46.2",
-    "vitest": "^4.0.6"
+    "typescript-eslint": "^8.46.3",
+    "vitest": "^4.0.7"
   },
   "dependencies": {
     "@aws-lambda-powertools/logger": "^2.28.1",
     "@hono/mcp": "^0.1.5",
-    "@modelcontextprotocol/sdk": "^1.20.2",
+    "@modelcontextprotocol/sdk": "^1.21.0",
     "hono": "^4.10.4",
-    "zod": "^3.25.76"
+    "zod": "^4.1.12"
   },
   "scripts": {
     "build": "tsc",