Returning an EventSourceResponse from a path operation sends an empty 200 body instead of the stream #16107

Good catch and solid repro. The root cause is clear:

When response_class=EventSourceResponse is set on the decorator,
FastAPI's routing layer sees the return type matches the response
class and tries to handle it as a raw SSE response but it skips
awaiting the endpoint coroutine, so the generator never runs.

The /no-response-class case works because FastAPI falls through
to the normal response handling path which correctly awaits the
endpoint before passing the result to EventSourceResponse.

The fix should be in the routing layer when the return value is
already an instance of the declared response_class, FastAPI
should still ensure the endpoint coroutine is fully awaited before
handing off to the response. Specifically the SSE branch needs to
check isinstance(response, Response) rather than branching solely
on the response_class declaration.

Since you already have a fix and tests ready, go ahead and open
the PR this is clearly a real bug that's been there since SSE
was added in 0.135.0.

Thanks for looking at this.

One correction on the mechanism, since it changes what the fix can be, the return annotation isn't involved and the branch is taken before the endpoint runs:

# fastapi/routing.py
if is_sse_stream:   # from lenient_issubclass(actual_response_class, EventSourceResponse)
    gen = dependant.call(**solved_result.values)   # endpoint called inside the branch

So there is no response object to isinstance-check at that point. The coroutine goes to iterate_in_threadpool(gen), which is where TypeError: 'coroutine' object is not iterable is coming from.

That also means it is not limited to endpoints that return a Response but any non-generator with response_class=EventSourceResponse is affected, and the sync case fails silently:

from fastapi import FastAPI
from fastapi.responses import EventSourceResponse
from fastapi.testclient import TestClient

app = FastAPI()

@app.get("/async-dict", response_class=EventSourceResponse)
async def async_dict():
    return {"msg": "hello"}

@app.get("/sync-dict", response_class=EventSourceResponse)
def sync_dict():
    return {"msg": "hello"}

client = TestClient(app, raise_server_exceptions=False)
for path in ("/async-dict", "/sync-dict"):
    r = client.get(path)
    print(path, r.status_code, repr(r.text))

On 0.141.0:

/async-dict  200  ''                 # coroutine never awaited
/sync-dict   200  'data: "msg"\n\n'  # iterates the dict's keys, no error at all

The sync one is one that worries me — no exception, no warning, just wrong data on the wire.

The route object already computes this correctly, generator check included:

# fastapi/routing.py, in get_api_route / route setup
route.is_sse_stream = is_generator and lenient_issubclass(
    response_class, EventSourceResponse
)
route.is_json_stream = is_generator and isinstance(response_class, DefaultPlaceholder)

It's just never handed to the request handler. At the get_request_handler(...) call site, its sibling is passed and it isn't:

            stream_item_field=route.stream_item_field,
            is_json_stream=route.is_json_stream,
            # is_sse_stream=route.is_sse_stream   <-- missing
        )

So is_json_stream reaches the dispatch with its generator check intact, while is_sse_stream gets recomputed locally inside get_request_handler without one. Passing route.is_sse_stream through and dropping the local recomputation is what my patch does.

This occurs due to double-wrapping of the EventSourceResponse instance by FastAPI's path operation handler.

Root Cause

When you declare @app.get("/", response_class=EventSourceResponse), FastAPI expects your endpoint function to return the raw data/generator gen(), which FastAPI then automatically wraps in EventSourceResponse(gen()).

If your endpoint returns an EventSourceResponse instance directly and the decorator specifies response_class=EventSourceResponse, FastAPI passes the EventSourceResponse object itself into iterate_in_threadpool(res) as if it were data. Because a Response instance is not an iterable generator, it causes an empty 200 response or TypeError: 'coroutine' object is not iterable.

Fix

You have two clean ways to fix this depending on your preferred pattern:

Pattern 1: Return the generator directly when using response_class decorator

@app.get("/with-response-class", response_class=EventSourceResponse)
async def with_rc():
    async for item in gen():
        yield item

Pattern 2: Omit response_class from decorator when returning EventSourceResponse manually

@app.get("/no-response-class")
async def no_rc() -> EventSourceResponse:
    return EventSourceResponse(gen())

Thanks — both of those do work, and they're what I'd tell someone to do today to get unstuck.

I want to flag though that they're avoidance rather than resolution: each one sidesteps the broken combination by not using it. Dropping response_class=EventSourceResponse loses the OpenAPI documentation of the endpoint as text/event-stream, which is the reason to declare it in the first place, and yielding from the generator isn't always an option — returning the response directly is what lets you decide on a status code before the stream is committed.

The part I'd still like a maintainer's read on is that the combination fails silently. An async endpoint returns 200 with an empty body, and a sync one streams the dict's keys as events with no error at all:

/async-dict  200  ''                 # coroutine never awaited
/sync-dict   200  'data: "msg"\n\n'  # iterates the dict's keys, no error

If the intended answer is "these two are simply not meant to be combined", then the fix is arguably a startup-time error rather than a silent 200 — but right now nothing tells the user either way.

I have a patch and tests ready either way, happy to open a PR if that's the preferred direction.

Opened a PR with the fix and tests: #16192 on #16107.