fix(client): stream bytes as they arrive instead of filling an 8KB buffer

The streaming read loop used `readbytes!(io, buf)` with an 8KB buffer, which
blocks until the buffer is completely full (or EOF). On a low-traffic stream —
e.g. a mostly-idle Kubernetes watch — an event smaller than 8KB sits unflushed
until enough *more* bytes arrive or the connection closes, stalling the
consumer: a watch silently misses state transitions for minutes, until the
apiserver drops the connection (surfacing as "Unexpected end of input").

Replace it with `readavailable(io)`, which returns whatever is currently
buffered immediately and works on both HTTP.jl 1.x and 2.x streams. This
restores the prompt delivery of the pre-0.2.3 `read(io, 8192)` loop (swapped out
for HTTP 2.0 compatibility) without reintroducing the `read(io, n)` call that
2.0 streams don't support.

Bumps to 0.2.6.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: krynju

Project.toml

@@ -4,7 +4,7 @@ keywords = ["Swagger", "OpenAPI", "REST"]
 license = "MIT"
 desc = "OpenAPI server and client helper for Julia"
 authors = ["JuliaHub Inc."]
-version = "0.2.5"
+version = "0.2.6"
 
 [deps]
 Base64 = "2a0f44e3-6c83-55bd-87e4-b1978d98bd5f"

src/client/httplibs/juliaweb_http.jl

@@ -317,13 +317,21 @@ function _http_streaming_request(ctx, method, url, headers, body, timeout, bytes
                     write(io, body)
                     captured_response[] = http_response = startread(io)
                     try
-                        # `read(io, n)` is unavailable on 2.0 streams; read into a reusable
-                        # buffer with `readbytes!`, which works on both 1.x and 2.x.
-                        buf = Vector{UInt8}(undef, 8192)  # 8KB chunks
+                        # Forward bytes to `output` as soon as they arrive.
+                        #
+                        # Use `readavailable`, NOT `readbytes!(io, buf)`: the latter
+                        # blocks until the whole buffer is filled (or EOF), so on a
+                        # low-traffic stream — e.g. a mostly-idle Kubernetes watch — a
+                        # single event smaller than the buffer sits unflushed until
+                        # enough *more* bytes arrive or the connection closes, stalling
+                        # the consumer (a watch would miss state transitions until the
+                        # apiserver eventually drops the connection). `readavailable`
+                        # returns whatever is currently buffered immediately and works
+                        # on both HTTP.jl 1.x and 2.x streams (`read(io, n)` does not).
                         while !eof(io)
-                            n = readbytes!(io, buf)
-                            n == 0 && break
-                            bytesread[] += write(output, view(buf, 1:n))
+                            data = readavailable(io)
+                            isempty(data) && continue
+                            bytesread[] += write(output, data)
                         end
                     finally
                         close(output)