Add AspNetCoreSseServer sample (#81)

* Add AspNetCoreSseMcpTransport sample

* Fix build errors after rebase

* React to McpServerFactory changes

* Make Utf8JsonWriter non thread static

* Fix test errors caused by not rebasing the HttpLister changes on factory overhaul commit

samples/AspNetCoreSseServer/AspNetCoreSseServer.csproj

@@ -0,0 +1,17 @@
+<Project Sdk="Microsoft.NET.Sdk.Web">
+
+  <PropertyGroup>
+    <TargetFramework>net9.0</TargetFramework>
+    <Nullable>enable</Nullable>
+    <ImplicitUsings>enable</ImplicitUsings>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\src\mcpdotnet\mcpdotnet.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="System.Net.ServerSentEvents" Version="10.0.0-preview.1.25080.5" />
+  </ItemGroup>
+
+</Project>

samples/AspNetCoreSseServer/McpEndpointRouteBuilderExtensions.cs

@@ -0,0 +1,62 @@
+using McpDotNet.Protocol.Messages;
+using McpDotNet.Server;
+using McpDotNet.Utils.Json;
+using Microsoft.Extensions.Options;
+
+namespace AspNetCoreSseServer;
+
+public static class McpEndpointRouteBuilderExtensions
+{
+    public static IEndpointConventionBuilder MapMcpSse(this IEndpointRouteBuilder endpoints)
+    {
+        IMcpServer? server = null;
+        SseServerStreamTransport? transport = null;
+        var loggerFactory = endpoints.ServiceProvider.GetRequiredService<ILoggerFactory>();
+        var mcpServerOptions = endpoints.ServiceProvider.GetRequiredService<IOptions<McpServerOptions>>();
+
+        var routeGroup = endpoints.MapGroup("");
+
+        routeGroup.MapGet("/sse", async (HttpResponse response, CancellationToken requestAborted) =>
+        {
+            await using var localTransport = transport = new SseServerStreamTransport(response.Body);
+            await using var localServer = server = McpServerFactory.Create(transport, mcpServerOptions.Value, loggerFactory, endpoints.ServiceProvider);
+
+            await localServer.StartAsync(requestAborted);
+
+            response.Headers.ContentType = "text/event-stream";
+            response.Headers.CacheControl = "no-cache";
+
+            try
+            {
+                await transport.RunAsync(requestAborted);
+            }
+            catch (OperationCanceledException) when (requestAborted.IsCancellationRequested)
+            {
+                // RequestAborted always triggers when the client disconnects before a complete response body is written,
+                // but this is how SSE connections are typically closed.
+            }
+        });
+
+        routeGroup.MapPost("/message", async (HttpContext context) =>
+        {
+            if (transport is null)
+            {
+                await Results.BadRequest("Connect to the /sse endpoint before sending messages.").ExecuteAsync(context);
+                return;
+            }
+
+            var message = await context.Request.ReadFromJsonAsync<IJsonRpcMessage>(JsonSerializerOptionsExtensions.DefaultOptions, context.RequestAborted);
+            if (message is null)
+            {
+                await Results.BadRequest("No message in request body.").ExecuteAsync(context);
+                return;
+            }
+
+            await transport.OnMessageReceivedAsync(message, context.RequestAborted);
+            context.Response.StatusCode = StatusCodes.Status202Accepted;
+            await context.Response.WriteAsync("Accepted");
+        });
+
+        return routeGroup;
+    }
+}

samples/AspNetCoreSseServer/Program.cs

@@ -0,0 +1,11 @@
+using McpDotNet;
+using AspNetCoreSseServer;
+
+var builder = WebApplication.CreateBuilder(args);
+builder.Services.AddMcpServer().WithTools();
+var app = builder.Build();
+
+app.MapGet("/", () => "Hello World!");
+app.MapMcpSse();
+
+app.Run();

samples/AspNetCoreSseServer/Properties/launchSettings.json

@@ -0,0 +1,23 @@
+{
+  "$schema": "https://json.schemastore.org/launchsettings.json",
+  "profiles": {
+    "http": {
+      "commandName": "Project",
+      "dotnetRunMessages": true,
+      "launchBrowser": true,
+      "applicationUrl": "http://localhost:3001",
+      "environmentVariables": {
+        "ASPNETCORE_ENVIRONMENT": "Development"
+      }
+    },
+    "https": {
+      "commandName": "Project",
+      "dotnetRunMessages": true,
+      "launchBrowser": true,
+      "applicationUrl": "https://localhost:7133;http://localhost:3001",
+      "environmentVariables": {
+        "ASPNETCORE_ENVIRONMENT": "Development"
+      }
+    }
+  }
+}

samples/AspNetCoreSseServer/SseServerStreamTransport.cs

@@ -0,0 +1,84 @@
+using System.Buffers;
+using System.Net.ServerSentEvents;
+using System.Text.Json;
+using System.Threading.Channels;
+using McpDotNet.Protocol.Messages;
+using McpDotNet.Protocol.Transport;
+using McpDotNet.Utils.Json;
+
+namespace AspNetCoreSseServer;
+
+public class SseServerStreamTransport(Stream sseResponseStream) : ITransport
+{
+    private readonly Channel<IJsonRpcMessage> _incomingChannel = CreateSingleItemChannel<IJsonRpcMessage>();
+    private readonly Channel<SseItem<IJsonRpcMessage?>> _outgoingSseChannel = CreateSingleItemChannel<SseItem<IJsonRpcMessage?>>();
+
+    private Task? _sseWriteTask;
+    private Utf8JsonWriter? _jsonWriter;
+
+    public bool IsConnected => _sseWriteTask?.IsCompleted == false;
+
+    public Task RunAsync(CancellationToken cancellationToken)
+    {
+        void WriteJsonRpcMessageToBuffer(SseItem<IJsonRpcMessage?> item, IBufferWriter<byte> writer)
+        {
+            if (item.EventType == "endpoint")
+            {
+                writer.Write("/message"u8);
+                return;
+            }
+
+            JsonSerializer.Serialize(GetUtf8JsonWriter(writer), item.Data, JsonSerializerOptionsExtensions.DefaultOptions);
+        }
+
+        // The very first SSE event isn't really an IJsonRpcMessage, but there's no API to write a single item of a different type,
+        // so we fib and special-case the "endpoint" event type in the formatter.
+        _outgoingSseChannel.Writer.TryWrite(new SseItem<IJsonRpcMessage?>(null, "endpoint"));
+
+        var sseItems = _outgoingSseChannel.Reader.ReadAllAsync(cancellationToken);
+        return _sseWriteTask = SseFormatter.WriteAsync(sseItems, sseResponseStream, WriteJsonRpcMessageToBuffer, cancellationToken);
+    }
+
+    public ChannelReader<IJsonRpcMessage> MessageReader => _incomingChannel.Reader;
+
+    public ValueTask DisposeAsync()
+    {
+        _incomingChannel.Writer.TryComplete();
+        _outgoingSseChannel.Writer.TryComplete();
+        return new ValueTask(_sseWriteTask ?? Task.CompletedTask);
+    }
+
+    public Task SendMessageAsync(IJsonRpcMessage message, CancellationToken cancellationToken = default) =>
+        _outgoingSseChannel.Writer.WriteAsync(new SseItem<IJsonRpcMessage?>(message), cancellationToken).AsTask();
+
+    public Task OnMessageReceivedAsync(IJsonRpcMessage message, CancellationToken cancellationToken)
+    {
+        if (!IsConnected)
+        {
+            throw new McpTransportException("Transport is not connected");
+        }
+
+        return _incomingChannel.Writer.WriteAsync(message, cancellationToken).AsTask();
+    }
+
+    private static Channel<T> CreateSingleItemChannel<T>() =>
+        Channel.CreateBounded<T>(new BoundedChannelOptions(1)
+        {
+            SingleReader = true,
+            SingleWriter = false,
+        });
+
+    private Utf8JsonWriter GetUtf8JsonWriter(IBufferWriter<byte> writer)
+    {
+        if (_jsonWriter is null)
+        {
+            _jsonWriter = new Utf8JsonWriter(writer);
+        }
+        else
+        {
+            _jsonWriter.Reset(writer);
+        }
+
+        return _jsonWriter;
+    }
+}

samples/AspNetCoreSseServer/Tools/EchoTool.cs

@@ -0,0 +1,14 @@
+using McpDotNet.Server;
+using System.ComponentModel;
+
+namespace TestServerWithHosting.Tools;
+
+[McpToolType]
+public static class EchoTool
+{
+    [McpTool, Description("Echoes the input back to the client.")]
+    public static string Echo(string message)
+    {
+        return "hello " + message;
+    }
+}

samples/AspNetCoreSseServer/Tools/SampleLlmTool.cs

@@ -0,0 +1,51 @@
+using McpDotNet.Protocol.Types;
+using McpDotNet.Server;
+using System.ComponentModel;
+
+namespace TestServerWithHosting.Tools;
+
+/// <summary>
+/// This tool uses depenency injection and async method
+/// </summary>
+[McpToolType]
+public class SampleLlmTool
+{
+    private readonly IMcpServer _server;
+
+    public SampleLlmTool(IMcpServer server)
+    {
+        _server = server ?? throw new ArgumentNullException(nameof(server));
+    }
+
+    [McpTool("sampleLLM"), Description("Samples from an LLM using MCP's sampling feature")]
+    public async Task<string> SampleLLM(
+        [Description("The prompt to send to the LLM")] string prompt,
+        [Description("Maximum number of tokens to generate")] int maxTokens,
+        CancellationToken cancellationToken)
+    {
+        var samplingParams = CreateRequestSamplingParams(prompt ?? string.Empty, "sampleLLM", maxTokens);
+        var sampleResult = await _server.RequestSamplingAsync(samplingParams, cancellationToken);
+
+        return $"LLM sampling result: {sampleResult.Content.Text}";
+    }
+
+    private static CreateMessageRequestParams CreateRequestSamplingParams(string context, string uri, int maxTokens = 100)
+    {
+        return new CreateMessageRequestParams()
+        {
+            Messages = [new SamplingMessage()
+                {
+                    Role = Role.User,
+                    Content = new Content()
+                    {
+                        Type = "text",
+                        Text = $"Resource {uri} context: {context}"
+                    }
+                }],
+            SystemPrompt = "You are a helpful test server.",
+            MaxTokens = maxTokens,
+            Temperature = 0.7f,
+            IncludeContext = ContextInclusion.ThisServer
+        };
+    }
+}

samples/AspNetCoreSseServer/appsettings.Development.json

@@ -0,0 +1,8 @@
+{
+  "Logging": {
+    "LogLevel": {
+      "Default": "Information",
+      "Microsoft.AspNetCore": "Warning"
+    }
+  }
+}

samples/AspNetCoreSseServer/appsettings.json

@@ -0,0 +1,9 @@
+{
+  "Logging": {
+    "LogLevel": {
+      "Default": "Information",
+      "Microsoft.AspNetCore": "Warning"
+    }
+  },
+  "AllowedHosts": "*"
+}