Update start_mcp.py

start_mcp.py

@@ -116,22 +116,54 @@ def run_sse(host: str, port: int):
         if session_id not in connections:
             return JSONResponse({"error": "invalid session"}, status_code=400)
 
-        body = await request.json()
+        try:
+            body = await request.json()
+        except Exception as e:
+            logger.error("Failed to parse request body: %s", e)
+            return JSONResponse({"error": "Invalid JSON"}, status_code=400)
+        
+        if not isinstance(body, dict):
+            logger.error("Request body is not a dictionary")
+            return JSONResponse({"error": "Invalid request format"}, status_code=400)
+        
         method = body.get("method")
         params = body.get("params", {})
         message_id = body.get("id")
 
-        logger.info("Received method=%s id=%s", method, message_id)
+        # Check if this is a notification (no id) or a request (has id)
+        is_notification = message_id is None
+
+        if not method:
+            logger.error("Missing 'method' field in request")
+            if not is_notification:
+                # Send error response for requests without method
+                async def send_error():
+                    error_response = {
+                        "jsonrpc": "2.0",
+                        "id": message_id,
+                        "error": {"code": -32600, "message": "Invalid Request: missing 'method' field"},
+                    }
+                    await connections[session_id].put(error_response)
+                asyncio.create_task(send_error())
+            return JSONResponse({"error": "Missing method"}, status_code=400)
+
+        logger.info("Received method=%s id=%s (notification=%s)", method, message_id, is_notification)
 
         async def handle_request():
             try:
                 if method == "initialize":
+                    if is_notification:
+                        logger.warning("initialize received as notification, ignoring")
+                        return
                     result: Dict[str, Any] = {
                         "protocolVersion": "2024-11-05",
                         "serverInfo": {"name": "GNoME-Materials-Discovery", "version": "1.0.0"},
                         "capabilities": {"tools": {}},
                     }
                 elif method == "tools/list":
+                    if is_notification:
+                        logger.warning("tools/list received as notification, ignoring")
+                        return
                     tools = []
                     for tool in service._tool_manager._tools.values():
                         tools.append(
@@ -143,6 +175,9 @@ def run_sse(host: str, port: int):
                         )
                     result = {"tools": tools}
                 elif method == "tools/call":
+                    if is_notification:
+                        logger.warning("tools/call received as notification, ignoring")
+                        return
                     tool_name = params.get("name")
                     arguments = params.get("arguments", {})
                     tool = service._tool_manager._tools.get(tool_name)
@@ -155,21 +190,29 @@ def run_sse(host: str, port: int):
                         tool_response = tool.fn(**arguments)
                     result = {"content": [{"type": "text", "text": json.dumps(tool_response)}]}
                 elif method == "notifications/initialized":
-                    await connections[session_id].put({"jsonrpc": "2.0", "id": message_id, "result": {"ok": True}})
+                    # This is a notification, no response needed
+                    logger.info("Client initialized notification received")
                     return
                 else:
+                    if is_notification:
+                        logger.info("Unknown notification method: %s, ignoring", method)
+                        return
                     raise ValueError(f"Unsupported method: {method}")
 
-                response = {"jsonrpc": "2.0", "id": message_id, "result": result}
+                # Only send response for requests (not notifications)
+                if not is_notification:
+                    response = {"jsonrpc": "2.0", "id": message_id, "result": result}
+                    await connections[session_id].put(response)
             except Exception as exc:
                 logger.exception("Error handling request")
-                response = {
-                    "jsonrpc": "2.0",
-                    "id": message_id,
-                    "error": {"code": -32000, "message": str(exc)},
-                }
-
-            await connections[session_id].put(response)
+                # Only send error response for requests (not notifications)
+                if not is_notification:
+                    response = {
+                        "jsonrpc": "2.0",
+                        "id": message_id,
+                        "error": {"code": -32000, "message": str(exc)},
+                    }
+                    await connections[session_id].put(response)
 
         asyncio.create_task(handle_request())
         return JSONResponse({"ok": True})