fix(opencode): chunkTimeout ignores SSE comment heartbeats that keep stalled streams warm - #51879

The following comment was made by an LLM, it may be inaccurate:

cc @thdxr @adamdotdevin — requesting review when you get a chance.

Fix details:

The bug is subtle: wrapSSE re-armed its timeout inside each reader.read() promise, so any bytes — including SSE comment lines (: keepalive) that the spec explicitly reserves for connection keep-alive — reset the clock. A provider or LB that holds a stalled generation open with comment heartbeats produces an infinite warm-but-dead stream: no event, no error, no log line (#43519 has a deterministic repro).

The fix swaps the per-read timer for a single data-stall deadline that only re-arms when a chunk contains the start of a non-comment SSE line:

• sseFieldScanner() checks each line's head byte — :/\n/\r are not progress, anything else is. Because it tracks line-head state across chunk boundaries, a data: marker split across two reads still counts (and a comment split the same way still doesn't).
• Byte-level silence is still covered: no bytes → no field lines → deadline fires.
• Error type, message and retryability are unchanged: ResponseStreamError("SSE read timed out") (v1) / Error("SSE read timed out") (v2 aisdk.ts).

One semantic difference worth noting in review: while consumer backpressure pauses pull(), the deadline keeps running — if it expires mid-backpressure the abort lands via ctl.abort + reader.cancel and surfaces on the next read. Given the default chunkTimeout is 300s, a consumer stalled that long was already a candidate for the timeout.

New regression test reproduces the keepalive-warm stall end-to-end (data event → : keepalive every 10ms, chunkTimeout: 100): now errors in ~900ms instead of hanging forever. The 3 remaining failures in that file are pre-existing env flakes (identical on baseline origin/dev).

Both wrapSSE copies updated — packages/opencode/src/provider/provider.ts (v1) and packages/core/src/aisdk.ts (v2).

Reviewed — this is the right fix for #43519 and the sseFieldScanner approach is nicely minimal: line-head inspection catches the comment-heartbeat case without parsing full events, and tracking atLineHead across chunk boundaries handles split markers correctly. Findings:

Consider — continuation bytes of a field line don't count as progress. The scanner only credits a line's head. A single data: line longer than one read — a large payload streamed slowly — emits no further progress until its \n, so a generation streaming one huge line over >chunkTimeout will abort mid-line even though bytes are flowing. With the 300s default this is near-impossible; with aggressive chunkTimeout configs it could bite. Cheap hardening if you want it: keep a lineIsField flag and count any byte consumed while inside a non-comment line as progress (comment lines still don't count, so the keepalive bypass stays closed).

FYI — event-level heartbeats still keep the deadline warm. Providers/LBs that heartbeat with real SSE events — Anthropic-style event: ping + data: {"type": "ping"} — re-arm the deadline forever, so a generation stalled-but-pinging still hangs. Closing that requires parsing the event type, not just line heads — legitimately out of scope here, but worth a follow-up issue so the remaining gap is tracked.

Verified the backpressure trade-off the author flagged: the deadline keeps running while the consumer pauses pull(), so a >300s stall downstream now kills the stream rather than waiting as before. Agree that's acceptable — a consumer stalled that long was already pathological, and ctl.abort + reader.cancel surface the error on the next read rather than losing it.

Verified both copies are identical (provider.ts v1 / aisdk.ts v2) — same scanner, same error type and message, so retry classification is unchanged on both paths.

Verdict: approve — closes the deterministic infinite-hang repro with minimal machinery and no contract change.

cc @Hona @Brendonovich — could you review and approve? Provider-side counterpart to the client watchdog in #51871; together they close the silent-stall class on both SSE boundaries.