docs: fix streaming response documentation

Replaced incorrect Body_stream example with accurate Server.respond_stream
API explanation:
- Explained next function signature and behavior
- Added working examples for basic streaming and file streaming
- Documented content_length vs chunked encoding

docs/guides/responses.md

···
 
 ## Streaming Responses
 
-For large responses, use streaming:
+For large or dynamically generated responses, use `Server.respond_stream`. This avoids buffering the entire response in memory.
+
+### How Streaming Works
+
+The streaming API uses a `next` function that the server calls repeatedly:
 
 ```ocaml
-let handler req =
-  {
-    status = `OK;
-    headers = [("Content-Type", "text/plain")];
-    response_body = Body_stream (fun write flush ->
-      for i = 1 to 100 do
-        write (Printf.sprintf "Line %d\n" i);
-        if i mod 10 = 0 then flush ()
-      done
-    );
-  }
+Server.respond_stream : 
+  ?status:status -> 
+  ?headers:(string * string) list -> 
+  ?content_length:int64 -> 
+  (unit -> Cstruct.t option) ->  (* The next function *)
+  response
 ```
+
+The `next` function:
+- Returns `Some chunk` to send that chunk to the client
+- Returns `None` to signal end of stream and close the response
+- Is called repeatedly until it returns `None`
+
+The server flushes after each chunk, so data is sent immediately.
+
+### Basic Example
+
+Stream 100 lines of text:
+
+```ocaml
+let handler _req =
+  let counter = ref 0 in
+  let next () =
+    incr counter;
+    if !counter <= 100 then
+      let line = Printf.sprintf "Line %d\n" !counter in
+      Some (Cstruct.of_string line)
+    else
+      None  (* End of stream *)
+  in
+  Server.respond_stream 
+    ~headers:[("Content-Type", "text/plain")]
+    next
+```
+
+### Streaming from a File
+
+```ocaml
+let stream_file path =
+  let ic = open_in path in
+  let buf = Bytes.create 4096 in
+  let next () =
+    match input ic buf 0 4096 with
+    | 0 -> close_in ic; None
+    | n -> Some (Cstruct.of_bytes ~off:0 ~len:n buf)
+    | exception End_of_file -> close_in ic; None
+  in
+  Server.respond_stream next
+```
+
+### With Known Content-Length
+
+If you know the total size, provide `content_length` to avoid chunked encoding:
+
+```ocaml
+let stream_known_size data_size next =
+  Server.respond_stream 
+    ~content_length:(Int64.of_int data_size)
+    next
+```
+
+### Chunked vs Fixed-Length
+
+| Scenario | Behavior |
+|----------|----------|
+| `content_length` provided | Server sends `Content-Length` header, fixed-length body |
+| No `content_length` | Server uses `Transfer-Encoding: chunked` |
+
+### Use Cases
+
+- **Large files**: Stream without loading entire file into memory
+- **Generated content**: Stream as you generate (reports, exports)
+- **Server-Sent Events**: Stream events over time (see [SSE docs](../real-time/sse.md))
+- **Slow data sources**: Stream as data becomes available
 
 ## JSON Responses