fix stateless example

Author: ihrpr

src/examples/server/simpleStatelessStreamableHttp.ts

@@ -4,108 +4,114 @@ import { StreamableHTTPServerTransport } from '../../server/streamableHttp.js';
 import { z } from 'zod';
 import { CallToolResult, GetPromptResult, ReadResourceResult } from '../../types.js';
 
-// Create an MCP server with implementation details
-const server = new McpServer({
-  name: 'stateless-streamable-http-server',
-  version: '1.0.0',
-}, { capabilities: { logging: {} } });
-
-// Register a simple prompt
-server.prompt(
-  'greeting-template',
-  'A simple greeting prompt template',
-  {
-    name: z.string().describe('Name to include in greeting'),
-  },
-  async ({ name }): Promise<GetPromptResult> => {
-    return {
-      messages: [
-        {
-          role: 'user',
-          content: {
-            type: 'text',
-            text: `Please greet ${name} in a friendly manner.`,
+const getServer = () => {
+  // Create an MCP server with implementation details
+  const server = new McpServer({
+    name: 'stateless-streamable-http-server',
+    version: '1.0.0',
+  }, { capabilities: { logging: {} } });
+
+  // Register a simple prompt
+  server.prompt(
+    'greeting-template',
+    'A simple greeting prompt template',
+    {
+      name: z.string().describe('Name to include in greeting'),
+    },
+    async ({ name }): Promise<GetPromptResult> => {
+      return {
+        messages: [
+          {
+            role: 'user',
+            content: {
+              type: 'text',
+              text: `Please greet ${name} in a friendly manner.`,
+            },
           },
-        },
-      ],
-    };
-  }
-);
-
-// Register a tool specifically for testing resumability
-server.tool(
-  'start-notification-stream',
-  'Starts sending periodic notifications for testing resumability',
-  {
-    interval: z.number().describe('Interval in milliseconds between notifications').default(100),
-    count: z.number().describe('Number of notifications to send (0 for 100)').default(10),
-  },
-  async ({ interval, count }, { sendNotification }): Promise<CallToolResult> => {
-    const sleep = (ms: number) => new Promise(resolve => setTimeout(resolve, ms));
-    let counter = 0;
-
-    while (count === 0 || counter < count) {
-      counter++;
-      try {
-        await sendNotification({
-          method: "notifications/message",
-          params: {
-            level: "info",
-            data: `Periodic notification #${counter} at ${new Date().toISOString()}`
-          }
-        });
-      }
-      catch (error) {
-        console.error("Error sending notification:", error);
-      }
-      // Wait for the specified interval
-      await sleep(interval);
+        ],
+      };
     }
+  );
+
+  // Register a tool specifically for testing resumability
+  server.tool(
+    'start-notification-stream',
+    'Starts sending periodic notifications for testing resumability',
+    {
+      interval: z.number().describe('Interval in milliseconds between notifications').default(100),
+      count: z.number().describe('Number of notifications to send (0 for 100)').default(10),
+    },
+    async ({ interval, count }, { sendNotification }): Promise<CallToolResult> => {
+      const sleep = (ms: number) => new Promise(resolve => setTimeout(resolve, ms));
+      let counter = 0;
 
-    return {
-      content: [
-        {
-          type: 'text',
-          text: `Started sending periodic notifications every ${interval}ms`,
+      while (count === 0 || counter < count) {
+        counter++;
+        try {
+          await sendNotification({
+            method: "notifications/message",
+            params: {
+              level: "info",
+              data: `Periodic notification #${counter} at ${new Date().toISOString()}`
+            }
+          });
         }
-      ],
-    };
-  }
-);
-
-// Create a simple resource at a fixed URI
-server.resource(
-  'greeting-resource',
-  'https://example.com/greetings/default',
-  { mimeType: 'text/plain' },
-  async (): Promise<ReadResourceResult> => {
-    return {
-      contents: [
-        {
-          uri: 'https://example.com/greetings/default',
-          text: 'Hello, world!',
-        },
-      ],
-    };
-  }
-);
+        catch (error) {
+          console.error("Error sending notification:", error);
+        }
+        // Wait for the specified interval
+        await sleep(interval);
+      }
+
+      return {
+        content: [
+          {
+            type: 'text',
+            text: `Started sending periodic notifications every ${interval}ms`,
+          }
+        ],
+      };
+    }
+  );
+
+  // Create a simple resource at a fixed URI
+  server.resource(
+    'greeting-resource',
+    'https://example.com/greetings/default',
+    { mimeType: 'text/plain' },
+    async (): Promise<ReadResourceResult> => {
+      return {
+        contents: [
+          {
+            uri: 'https://example.com/greetings/default',
+            text: 'Hello, world!',
+          },
+        ],
+      };
+    }
+  );
+  return server;
+}
 
 const app = express();
 app.use(express.json());
 
-const transport: StreamableHTTPServerTransport = new StreamableHTTPServerTransport({
-  sessionIdGenerator: undefined,
-});
 
-// Setup routes for the server
-const setupServer = async () => {
-  await server.connect(transport);
-};
+
 
 app.post('/mcp', async (req: Request, res: Response) => {
-  console.log('Received MCP request:', req.body);
+  const server = getServer();
   try {
-      await transport.handleRequest(req, res, req.body);
+    const transport: StreamableHTTPServerTransport = new StreamableHTTPServerTransport({
+      sessionIdGenerator: undefined,
+    });
+    await server.connect(transport);
+    await transport.handleRequest(req, res, req.body);
+    res.on('close', () => {
+      console.log('Request closed');
+      transport.close();
+      server.close();
+    });
   } catch (error) {
     console.error('Error handling MCP request:', error);
     if (!res.headersSent) {
@@ -145,28 +151,15 @@ app.delete('/mcp', async (req: Request, res: Response) => {
   }));
 });
 
+
 // Start the server
 const PORT = 3000;
-setupServer().then(() => {
-  app.listen(PORT, () => {
-    console.log(`MCP Streamable HTTP Server listening on port ${PORT}`);
-  });
-}).catch(error => {
-  console.error('Failed to set up the server:', error);
-  process.exit(1);
+app.listen(PORT, () => {
+  console.log(`MCP Stateless Streamable HTTP Server listening on port ${PORT}`);
 });
 
 // Handle server shutdown
 process.on('SIGINT', async () => {
   console.log('Shutting down server...');
-    try {
-      console.log(`Closing transport`);
-      await transport.close();
-    } catch (error) {
-      console.error(`Error closing transport:`, error);
-    }
-  
-  await server.close();
-  console.log('Server shutdown complete');
   process.exit(0);
 });