When the sse_starlette module of fastapi implements Server-Sent Events, it cannot be judged that the client is disconnected?

[wnark]

First Check

• I added a very descriptive title here.
• I used the GitHub search to find a similar question and didn't find it.
• I searched the FastAPI documentation, with the integrated search.
• I already searched in Google "How to X in FastAPI" and didn't find any information.
• I already read and followed all the tutorial in the docs and didn't find an answer.
• I already checked if it is not related to FastAPI but to Pydantic.
• I already checked if it is not related to FastAPI but to Swagger UI.
• I already checked if it is not related to FastAPI but to ReDoc.

Commit to Help

• I commit to help with one of those options 👆

Example Code

import asyncio
import uvicorn
from fastapi import FastAPI, Request

from sse_starlette.sse import EventSourceResponse

from demo.fastapi_sse import main

app = FastAPI()


@app.get("/")
async def root():
    return {"message": "Hello World"}

STREAM_DELAY = 1  # second
RETRY_TIMEOUT = 15000  # milisecond

@app.get('/stream')
async def message_stream(request: Request):
    def new_messages():
        # Add logic here to check for new messages
        yield 'Hello World'
    async def event_generator():
        while True:
            # If client closes connection, stop sending events
            if await request.is_disconnected():
                print("The web client connection has been disconnected")
                break

            # Checks for new messages and return them to client if any
            if new_messages():
                yield {
                        "event": "new_message",
                        "id": "message_id",
                        "retry": RETRY_TIMEOUT,
                        "data": "message_content"
                }

            await asyncio.sleep(STREAM_DELAY)

    return EventSourceResponse(event_generator())

if __name__ == "__main__":
    # uvicorn.run("demo.fastapi.main:app",host="0.0.0.0", port=9000, reload=False)

    import asyncio
    import uvloop
    from hypercorn.asyncio import serve
    from hypercorn.config import Config


    config = Config()
    config.bind = [f"0.0.0.0:9000"]

    asyncio.set_event_loop_policy(uvloop.EventLoopPolicy())
    loop = asyncio.new_event_loop()
    asyncio.set_event_loop(loop)

    loop.run_until_complete(serve(main.app, config))

Description

I read this article:
https://devdojo.com/bobbyiliev/how-to-use-server-sent-events-sse-with-fastapi
Referring to the author's writing method, I want to implement sse, but I found that when the browser is closed, the server will not receive the message that the client is closed.
I learned through Google searches that under normal circumstances, when the server uses Server-Sent Events to push messages, it can know that the client is disconnected.
I checked the source code of EventSourceResponse and found that it passed

    @staticmethod
    async def listen_for_disconnect(receive: Receive) -> None:
        while True:
            message = await receive()
            if message["type"] == "http.disconnect":
                _log.debug("Got event: http.disconnect. Stop streaming.")
                break

To monitor whether the client is disconnected, but this code does not take effect in reality.
How can I let the fastapi server know that the client is disconnected when using sse to push messages.

Operating System

Linux

Operating System Details

No response

FastAPI Version

0.91.0

Python Version

Python 3.11.2

Additional Context

I read the fastapi documentation, and the documentation only describes that websocket is clearly able to get the client disconnection event by the server, but here I want to know why this function is used when using EventSourceResponse

    async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
        async with anyio.create_task_group() as task_group:

            # https://trio.readthedocs.io/en/latest/reference-core.html#custom-supervisors
            async def wrap(func: Callable[[], Coroutine[None, None, None]]) -> None:
                await func()
                # noinspection PyAsyncCall
                task_group.cancel_scope.cancel()

            task_group.start_soon(wrap, partial(self.stream_response, send))
            task_group.start_soon(wrap, partial(self._ping, send))
            task_group.start_soon(wrap, self.listen_for_exit_signal)
            await wrap(partial(self.listen_for_disconnect, receive))

        if self.background is not None:  # pragma: no cover, tested in StreamResponse
            await self.background()

The mechanism for judging disconnection has not taken effect, and how to solve it?
Thanks

[wnark]

Sorry, I found this module is not fastapi official project