Closes #163. Sub-task of #146 (the user building a ChatGPT-style backend). Pairs with the SSE wire-format unit tests merged in #162.

What was broken

EventSourceResponse and StreamingResponse were Python facades only. The Zig HTTP server had no awareness of streaming: dispatch read response.body directly, which is b\"\" for streaming responses, so SSE responses arrived with empty bodies (status 200, Content-Type: text/event-stream, Content-Length: 0). Verified with the wire-level probe documented in #163.

Fix

Adds a chunked-transfer write path through a small ABI extension.

• New 5-tuple ABI for streaming: `(status, content_type, b"", iterator, headers_dict)`. Existing 3-tuple stays unchanged for non-streaming responses.
• `python/turboapi/responses.py` — `StreamingResponse.body_iter()` returns a sync iterator of bytes chunks. Sync sources are wrapped directly. Async sources go through `_AsyncToSyncChunkIterator` which drives the worker thread's event loop one chunk at a time (reusing `turboapi.async_pool.ensure_event_loop`), so SSE / token streams flush in real time without blocking the worker on the full stream.
• `python/turboapi/request_handler.py` — five dispatch sites (`create_pos_handler`, `create_async_pos_handler`, `fast_handler_noargs`, `fast_handler`, async `fast_handler`) now detect `StreamingResponse` and return the 5-tuple.
• `python/turboapi/async_pool.py` — `_normalize_response_tuple` (used by `awaitPythonCoroutineResponse` for async dispatch) also detects `StreamingResponse` and returns the 5-tuple. This was the load-bearing fix for async SSE handlers — they go through the normalize path, not the closure wrapper.
• `zig/src/server.zig` — new `sendStreamingResponse(stream, result)`. Writes the response head with `Transfer-Encoding: chunked` plus any custom headers from the headers dict (skipping ones that conflict with framing: Content-Length / Content-Type / Transfer-Encoding / Connection). Then loops `PyIter_Next` on the iterator, writing each chunk as `\r\n\r\n`. Terminates with `0\r\n\r\n`. Skips zero-length yields (would be misinterpreted as the terminator). Clears Python error state on StopIteration.
  • Dispatch hook: `sendTupleResponse`, `sendTupleResponseAndCache`, `sendTupleResponseAndCacheEntry` now check `PyTuple_Size == 5` first and route to the streaming path. Streaming responses are explicitly not cacheable.

Wire-level proof

Re-running the #163 probe (5-event SSE generator, async handler, 50ms between events).

Before this PR — all 5 events disappeared into an empty 200 response (`Content-Length: 0`).

After this PR — raw socket capture:

```
HTTP/1.1 200 OK
Server: TurboAPI
Date: 2026年5月10日 14:06:04 GMT
Content-Type: text/event-stream
Transfer-Encoding: chunked
Connection: keep-alive
cache-control: no-cache
x-accel-buffering: no

10\r\ndata: {"i": 0}\n\n\r\n
10\r\ndata: {"i": 1}\n\n\r\n
10\r\ndata: {"i": 2}\n\n\r\n
10\r\ndata: {"i": 3}\n\n\r\n
10\r\ndata: {"i": 4}\n\n\r\n
0\r\n\r\n
```

httpx-stream view: 5 chunks delivered at ~50ms intervals, TTFB 4ms, TTLB 259ms (matches the `asyncio.sleep` cadence — chunks flush in real time, not pre-buffered).

CI tests

`tests/test_sse_e2e.py` — 6 tests booting a real subprocess server on port 18765 and hitting it with httpx + raw socket:

• sanity ping (non-streaming path still works)
• SSE response uses Transfer-Encoding: chunked, no Content-Length
• custom headers (Cache-Control, X-Accel-Buffering) reach the wire
• events stream as separate chunks, real-time (>=150ms total elapsed)
• chunked terminator `0\r\n\r\n` properly closes the stream
• raw bytes generators (non-SSE) also stream correctly

All 6 pass locally. 44-test regression suite (test_async_handlers, test_request_parsing, test_post_body_parsing, test_returns_model_cache*, test_annotated_depends) all green.

What's NOT done in this PR

• WebSocket — separate next PR. Tracked in zig runtime: real WebSocket support on current turboapi-core architecture #114 .
• `create_enhanced_handler` (slow / Depends path) — its StreamingResponse hookup needs a separate change since it routes through `ResponseHandler.format_json_response`. Most users won't hit this since dep-injection routes are rarely SSE; can be a follow-up if anyone reports it.

Checklist

• Linked issue: feat(zig): chunked transfer encoding for StreamingResponse / SSE end-to-end #163 (sub-task of SSE and WebSocket #146 ).
• Rebased onto current `release/1.0.30`: yes.
• Generated files / lockfiles changed: no. `uv.lock`, `.zig-cache/`, `zig-out/` untouched.
• Dependency surface changed: no.

🤖 Generated with Claude Code