why not just make the 2nd and third suspend and be done with it ? I'm curious about your usecase, can you tell me more about it please?

and now it applies quite primitive, let's say I have View.onViewCreated() and ViewModel which has my LiveDate and some CoroutineScope on which it works, and now inside the View.onViewCreated() function (which is not a suspend function) I want to liveData to observe some suspend function so that every time I call it, it will blocks the scope

Generally speaking, all thing it's about making an observer who can suspend a certain scope when notified

Unfortunately, I can only give you something like "pseudocode" as example:

// some simplified LiveData methods(observe and observeWithSuspend) without lifecycle: 
fun observe(observer: LiveDataObserver<T>) {
    observers.add(observer)
}

fun <T : Any> LiveData<T>.observeWithSuspend(
        context: CoroutineContext,
        observer: suspend (data: T) -> Unit
) {
    observe {
        runBlocking(context) {
            observer(it)
        }
    }
}

// Our viewModel
class SomeViewModel(){
    val someJobScope = CoroutineScope(Dispatchers.Default)
    // LiveData will block scope in a way that first will be performed points in order 1. 2. 3. 4.
    val someLiveData = MutableLiveData<Position>()

    //function that set our liveData
    private fun handleCoordinate(position: Position) {
        someJobScope.launch {
            // 1.
            someLiveData.value = position // 2.
            // 4
        }
    }
}

// Our activity/fragment
class SomeActivity(){
    val viewModel: SomeViewModel // our viewModel
    val someCoordinator: SomeCoordinator // our coordinator that will be observed and will suspend viewModel.someJobScope when notified

    override fun onViewCreated() {
        viewModel.someLiveData.observeWithSuspend(viewModel.someJobScope.coroutineContext) { position ->
            // 3
            someCoordinator.performSomeActionWithSuspend(position) // some suspended function to work with coordinator!
        }
    }
}