Add Response.withEvents for SSE support (#4120)

## Summary

Add a public method to set Server-Sent Events on HTTP Response, enabling
endpoints to dynamically choose between JSON responses and SSE
streaming.

## Changes

- Add `Response.withEvents(Rx[ServerSentEvent])` method that:
  - Sets the SSE events stream on the response
- Automatically sets `Content-Type: text/event-stream` if not already
set
  - Preserves existing event-stream content type if already specified
- Add `HttpHeader.MediaType.TextEventStream` constant
- Add unit tests for the new functionality

## Use Case

This enables building API endpoints that can return either:
- A standard JSON response (non-streaming)
- An SSE stream (streaming)

Based on request parameters, for example:

```scala
def messages(request: MessagesRequest): Response = {
  if (request.stream.getOrElse(false)) {
    val events: Rx[ServerSentEvent] = streamingService.stream(request)
    Http.response().withEvents(events)
  } else {
    val response = blockingService.complete(request)
    Http.response().withJson(response.toJson)
  }
}
```

🤖 Generated with [Claude Code](https://claude.com/claude-code)

---------

Co-authored-by: Claude <noreply@anthropic.com>

Author: xerial

airframe-http/.jvm/src/test/scala/wvlet/airframe/http/HttpMessageTest.scala

@@ -170,4 +170,33 @@ class HttpMessageTest extends AirSpec {
 
     req1.message.contentHash shouldBe req2.message.contentHash
   }
+
+  test("create SSE response with withEvents") {
+    import wvlet.airframe.rx.Rx
+
+    val events = Rx.sequence(
+      ServerSentEvent(data = "event1"),
+      ServerSentEvent(data = "event2"),
+      ServerSentEvent(data = "event3")
+    )
+
+    val response = Http.response().withEvents(events)
+
+    // Content-Type should be automatically set
+    response.isContentTypeEventStream shouldBe true
+    response.contentType shouldBe Some(HttpHeader.MediaType.TextEventStream)
+
+    // Events should be accessible
+    response.events.toSeq.size shouldBe 3
+  }
+
+  test("withEvents preserves existing event-stream content type") {
+    import wvlet.airframe.rx.Rx
+
+    val events   = Rx.single(ServerSentEvent(data = "test"))
+    val response = Http.response().withContentType("text/event-stream; charset=utf-8").withEvents(events)
+
+    // Should preserve the existing content type with charset
+    response.contentType shouldBe Some("text/event-stream; charset=utf-8")
+  }
 }

airframe-http/src/main/scala/wvlet/airframe/http/HttpHeader.scala

@@ -87,5 +87,6 @@ object HttpHeader {
     final val ApplicationJson    = "application/json;charset=utf-8"
     final val ApplicationMsgPack = "application/msgpack"
     final val OctetStream        = "application/octet-stream"
+    final val TextEventStream    = "text/event-stream"
   }
 }

airframe-http/src/main/scala/wvlet/airframe/http/HttpMessage.scala

@@ -332,6 +332,26 @@ object HttpMessage {
 
     def statusCode: Int                             = status.code
     def withStatus(newStatus: HttpStatus): Response = this.copy(status = newStatus)
+
+    /**
+      * Set Server-Sent Events stream for SSE responses. This method also sets the Content-Type header to
+      * "text/event-stream" if not already set.
+      *
+      * @param events
+      *   Rx stream of ServerSentEvent
+      * @return
+      *   Response with SSE events
+      */
+    def withEvents(newEvents: Rx[ServerSentEvent]): Response = {
+      if (isContentTypeEventStream) {
+        this.copy(events = newEvents)
+      } else {
+        this.copy(
+          header = header.set(HttpHeader.ContentType, HttpHeader.MediaType.TextEventStream),
+          events = newEvents
+        )
+      }
+    }
   }
 
   object Response {