Copilot was unable to review this pull request because the user who requested the review has insufficient remaining quota. Try requesting a review at a lower effort level.

The splitting is correct. One cost issue, though, on long data: lines.

What I checked in _aiter_sse_lines (http_helpers.py:72-87).

• A CRLF split across chunks ("x\r" + "\ny") gives one line x.
• A lone CR followed by non-LF text still ends the line.
• "a\r\r" + "\n" gives a and then an empty line.
• A stream ending in "...\n\r" yields a final "", so the last event is dispatched. That's right, since the CR terminates the empty line.
• An unterminated last line is yielded but never dispatched, because parse_sse_stream only dispatches on an empty line.
• aiter_text() uses the same decoder as aiter_lines() did, so charset handling doesn't change.

Long lines are re-copied and re-scanned on every chunk. text = pending + chunk followed by _SSE_LINE_END.split(text) means a line that spans N chunks costs about N²/2 chunk-lengths of copying and regex scanning. A2A messages put whole file parts (base64 bytes) into a single data: line. So a 20 MB artifact read in 64 KB chunks is around 300 chunks, and about 3 GB of copying for that one line. httpx's own LineDecoder, which aiter_lines() used, avoids this by buffering the pieces in a list and joining them once (httpx _decoders.py, LineDecoder.decode). The same shape works here, and it only scans the new chunk:

async def _aiter_sse_lines(response: httpx.Response) -> AsyncGenerator[str, None]:
    buffer: list[str] = []
    held_cr = False
    async for chunk in response.aiter_text():
        if held_cr:
            chunk, held_cr = '\r' + chunk, False
        if chunk.endswith('\r'):
            chunk, held_cr = chunk[:-1], True
        *lines, rest = _SSE_LINE_END.split(chunk)
        if lines:
            lines[0] = ''.join(buffer) + lines[0]
            buffer = []
            for line in lines:
                yield line
        if rest:
            buffer.append(rest)
    tail = ''.join(buffer)
    if held_cr or tail:
        yield tail

I checked this version with a standalone script of my own (not repo code). It ran 20,000 random strings over a b \r \n U+2028 : space, cut at random chunk boundaries. Its output matched re.split(r'\r\n|\r|\n') on the joined text (terminated lines, plus a non-empty remainder) every time. A test with one multi-megabyte data: line over many small chunks would guard against the slowdown coming back.

Other notes:

• #1259 (leading BOM) also edits the aiter_lines() loop in parse_sse_stream, and git merge-tree shows the two PRs conflict in http_helpers.py. Whichever lands second will need to move the removeprefix('') onto the first line from _aiter_sse_lines.
• git merge-tree against main is clean.

I didn't run the repo's tests.

Reviewed with help from Claude Code.

LGMT