Add server-side Streamable HTTP transport support (#330)

- Changes IJsonRpcMessage to an abstract base class so RelatedTransport will always be available
- Streamable HTTP supports multiple concurrent HTTP request with their own indpendent SSE response streams
- RelatedTransport indicates the source or destination of the JsonRpcMessage

- Changes the default RequestId to a JSON number for better compatibility with MCP servers in the wild

src/ModelContextProtocol/Protocol/Transport/StreamableHttpServerTransport.cs

@@ -0,0 +1,99 @@
+using ModelContextProtocol.Protocol.Messages;
+using System.IO.Pipelines;
+using System.Threading.Channels;
+
+namespace ModelContextProtocol.Protocol.Transport;
+
+/// <summary>
+/// Provides an <see cref="ITransport"/> implementation using Server-Sent Events (SSE) for server-to-client communication.
+/// </summary>
+/// <remarks>
+/// <para>
+/// This transport provides one-way communication from server to client using the SSE protocol over HTTP,
+/// while receiving client messages through a separate mechanism. It writes messages as 
+/// SSE events to a response stream, typically associated with an HTTP response.
+/// </para>
+/// <para>
+/// This transport is used in scenarios where the server needs to push messages to the client in real-time,
+/// such as when streaming completion results or providing progress updates during long-running operations.
+/// </para>
+/// </remarks>
+public sealed class StreamableHttpServerTransport : ITransport
+{
+    // For JsonRpcMessages without a RelatedTransport, we don't want to block just because the client didn't make a GET request to handle unsolicited messages.
+    private readonly SseWriter _sseWriter = new(channelOptions: new BoundedChannelOptions(1)
+    {
+        SingleReader = true,
+        SingleWriter = false,
+        FullMode = BoundedChannelFullMode.DropOldest,
+    });
+    private readonly Channel<JsonRpcMessage> _incomingChannel = Channel.CreateBounded<JsonRpcMessage>(new BoundedChannelOptions(1)
+    {
+        SingleReader = true,
+        SingleWriter = false,
+    });
+    private readonly CancellationTokenSource _disposeCts = new();
+
+    private int _getRequestStarted;
+
+    /// <summary>
+    /// Handles an optional SSE GET request a client using the Streamable HTTP transport might make by
+    /// writing any unsolicited JSON-RPC messages sent via <see cref="SendMessageAsync"/>
+    /// to the SSE response stream until cancellation is requested or the transport is disposed.
+    /// </summary>
+    /// <param name="sseResponseStream">The response stream to write MCP JSON-RPC messages as SSE events to.</param>
+    /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
+    /// <returns>A task representing the send loop that writes JSON-RPC messages to the SSE response stream.</returns>
+    public async Task HandleGetRequest(Stream sseResponseStream, CancellationToken cancellationToken)
+    {
+        if (Interlocked.Exchange(ref _getRequestStarted, 1) == 1)
+        {
+            throw new InvalidOperationException("Session resumption is not yet supported. Please start a new session.");
+        }
+
+        using var getCts = CancellationTokenSource.CreateLinkedTokenSource(_disposeCts.Token, cancellationToken);
+        await _sseWriter.WriteAllAsync(sseResponseStream, getCts.Token).ConfigureAwait(false);
+    }
+
+    /// <summary>
+    /// Handles a Streamable HTTP POST request processing both the request body and response body ensuring that
+    /// <see cref="JsonRpcResponse"/> and other correlated messages are sent back to the client directly in response
+    /// to the <see cref="JsonRpcRequest"/> that initiated the message.
+    /// </summary>
+    /// <param name="httpBodies">The duplex pipe facilitates the reading and writing of HTTP request and response data.</param>
+    /// <param name="cancellationToken">This token allows for the operation to be canceled if needed.</param>
+    /// <returns>
+    /// True, if data was written to the respond body.
+    /// False, if nothing was written because the request body did not contain any <see cref="JsonRpcRequest"/> messages to respond to.
+    /// The HTTP application should typically respond with an empty "202 Accepted" response in this scenario.
+    /// </returns>
+    public async Task<bool> HandlePostRequest(IDuplexPipe httpBodies, CancellationToken cancellationToken)
+    {
+        using var postCts = CancellationTokenSource.CreateLinkedTokenSource(_disposeCts.Token, cancellationToken);
+        await using var postTransport = new StreamableHttpPostTransport(_incomingChannel.Writer, httpBodies);
+        return await postTransport.RunAsync(postCts.Token).ConfigureAwait(false);
+    }
+
+    /// <inheritdoc/>
+    public ChannelReader<JsonRpcMessage> MessageReader => _incomingChannel.Reader;
+
+    /// <inheritdoc/>
+    public async Task SendMessageAsync(JsonRpcMessage message, CancellationToken cancellationToken = default)
+    {
+        await _sseWriter.SendMessageAsync(message, cancellationToken).ConfigureAwait(false);
+    }
+
+    /// <inheritdoc/>
+    public async ValueTask DisposeAsync()
+    {
+        _disposeCts.Cancel();
+        try
+        {
+            await _sseWriter.DisposeAsync().ConfigureAwait(false);
+        }
+        finally
+        {
+            _disposeCts.Dispose();
+        }
+    }
+}