ModelContextProtocol.AspNetCore doesn't support .NET Standard?

[jerryeechan]

I tried to integrate c# mcp server into Unity, but the warning shows:
"Can't find a matching dependency group for the NuGet Package ModelContextProtocol.AspNetCore 0.3.0-preview.1 that has a TargetFramework supported by the current Unity Scripting Backend. The NuGet Package supports the following TargetFramework's: net8.0, net9.0 "

Is there technical limitation to net8.0 and 9.0?

[stephentoub]

Is there technical limitation to net8.0 and 9.0?

ASP.NET Core itself doesn't target netstandard.

[jerryeechan]

Is it possible to use HttpListener to create a HttpStreamTransport?

builder.Services.AddMcpServer().WithStreamServerTransport(_httpTransport.InputStream, _httpTransport.OutputStream)

[jerryeechan]

It works.

settings.json:

      "UnityMCPServer": {
        "url": "http://localhost:3001/model_context_protocol/2024-11-05/sse"
      },

using System;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;
using ModelContextProtocol.Server;

using System.ComponentModel;
using System.IO;
using Microsoft.Extensions.DependencyInjection;
using UnityEditor;
using UnityEngine;
using ILogger = Microsoft.Extensions.Logging.ILogger;
using ILoggerProvider = Microsoft.Extensions.Logging.ILoggerProvider;
using System.Net;
using System.Threading;
using System.Threading.Tasks;
using System.Text;

// Unity Logger Provider
public class UnityLoggerProvider : ILoggerProvider
{
    public ILogger CreateLogger(string categoryName) => new UnityLogger(categoryName);
    public void Dispose() { }
}

public class UnityLogger : ILogger
{
    private readonly string _categoryName;
    public UnityLogger(string categoryName) => _categoryName = categoryName;
    public IDisposable BeginScope<TState>(TState state) => null;
    public bool IsEnabled(LogLevel logLevel) => true;
    public void Log<TState>(LogLevel logLevel, EventId eventId, TState state, Exception exception, Func<TState, Exception, string> formatter)
    {
        var message = $"[{_categoryName}] {formatter(state, exception)}";
        if (exception != null) message += $"\n{exception}";
        switch (logLevel)
        {
            case LogLevel.Critical:
            case LogLevel.Error:
                Debug.LogError(message);
                break;
            case LogLevel.Warning:
                Debug.LogWarning(message);
                break;
            case LogLevel.Information:
            case LogLevel.Debug:
            case LogLevel.Trace:
            default:
                Debug.Log(message);
                break;
        }
    }
}

public static class UnityMCPServer
{
    private static IHost _host;
    private static HttpStreamTransport _httpTransport;

    [InitializeOnLoadMethod]
    private static async void UnityMCPServerInit()
    {
        try
        {
            await InitializeServerAsync();
        }
        catch (Exception e)
        {
            Debug.LogError($"Failed to initialize MCP server: {e.Message}");
        }
    }
    private static async Task InitializeServerAsync()
    {
        var builder = Host.CreateApplicationBuilder();
        builder.Logging.ClearProviders();
        builder.Logging.AddProvider(new UnityLoggerProvider());

        // Create logger for HttpTransport
        var logger = new UnityLogger("HttpStreamTransport");

        // Initialize HTTP transport
        _httpTransport = new HttpStreamTransport("http://localhost:3001/", logger);
        await _httpTransport.StartAsync();

        builder.Services.AddMcpServer().WithStreamServerTransport(_httpTransport.InputStream, _httpTransport.OutputStream)
            .WithToolsFromAssembly();

        var app = builder.Build();
        _host = app;

        // Start the MCP server in background
        _ = Task.Run(async () =>
        {
            try
            {
                await app.RunAsync();
            }
            catch (Exception ex)
            {
                Debug.LogError($"MCP Server runtime error: {ex.Message}");
            }
        });
    }

    [MenuItem("Tools/MCP Server/Start Server")]
    public static async void StartServer()
    {
        if (_host == null)
        {
            try
            {
                await InitializeServerAsync();
            }
            catch (Exception e)
            {
                Debug.LogError($"Failed to start MCP server: {e.Message}");
            }
        }
        else
        {
            Debug.Log("MCP Server is already running");
        }
    }

    [MenuItem("Tools/MCP Server/Stop Server")]
    public static void StopServer()
    {
        try
        {
            _httpTransport?.Stop();
            _host?.StopAsync();
            _host = null;
            _httpTransport = null;
            Debug.Log("MCP Server stopped");
        }
        catch (Exception e)
        {
            Debug.LogError($"Error stopping MCP server: {e.Message}");
        }
    }

    // Clean up when Unity editor is closing
    static UnityMCPServer()
    {
        EditorApplication.quitting += () =>
        {
            StopServer();
        };
    }
}


[McpServerToolType]
public static class EchoTool
{
    [McpServerTool, Description("Echoes the message back to the client.")]
    public static string Echo(string message) => $"hello {message}";
}

// HTTP Stream Transport for MCP Server
public class HttpStreamTransport : IDisposable
{
    private readonly HttpListener _httpListener;
    private readonly string _prefix;
    private readonly ILogger _logger;
    private CancellationTokenSource _cancellationTokenSource;
    private Task _listenerTask;    // Use PipeStream for bidirectional communication
    private readonly System.IO.Pipes.AnonymousPipeServerStream _inputPipeServer;
    private readonly System.IO.Pipes.AnonymousPipeClientStream _inputPipeClient;
    private readonly System.IO.Pipes.AnonymousPipeServerStream _outputPipeServer;
    private readonly System.IO.Pipes.AnonymousPipeClientStream _outputPipeClient;

    public Stream InputStream { get; private set; }
    public Stream OutputStream { get; private set; }

    public HttpStreamTransport(string prefix, ILogger logger)
    {
        _prefix = prefix;
        _logger = logger;
        _httpListener = new HttpListener();
        _httpListener.Prefixes.Add(_prefix);
        _cancellationTokenSource = new CancellationTokenSource();

        // Create pipe streams for MCP communication
        // Input pipe: HTTP -> MCP Server
        _inputPipeServer = new System.IO.Pipes.AnonymousPipeServerStream(System.IO.Pipes.PipeDirection.Out);
        _inputPipeClient = new System.IO.Pipes.AnonymousPipeClientStream(System.IO.Pipes.PipeDirection.In, _inputPipeServer.ClientSafePipeHandle);

        // Output pipe: MCP Server -> HTTP
        _outputPipeServer = new System.IO.Pipes.AnonymousPipeServerStream(System.IO.Pipes.PipeDirection.In);
        _outputPipeClient = new System.IO.Pipes.AnonymousPipeClientStream(System.IO.Pipes.PipeDirection.Out, _outputPipeServer.ClientSafePipeHandle);

        // MCP Server reads from input pipe client, writes to output pipe client
        InputStream = _inputPipeClient;
        OutputStream = _outputPipeClient;
    }

    public Task StartAsync()
    {
        try
        {
            _httpListener.Start();
            _logger.LogInformation($"HTTP listener started on {_prefix}");

            _listenerTask = Task.Run(async () => await ListenForRequestsAsync(_cancellationTokenSource.Token));
            return Task.CompletedTask;
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Failed to start HTTP listener");
            throw;
        }
    }

    private async Task ListenForRequestsAsync(CancellationToken cancellationToken)
    {
        while (!cancellationToken.IsCancellationRequested && _httpListener.IsListening)
        {
            try
            {
                var context = await _httpListener.GetContextAsync();
                _ = Task.Run(() => HandleRequestAsync(context), cancellationToken);
            }
            catch (ObjectDisposedException)
            {
                break;
            }
            catch (HttpListenerException ex) when (ex.ErrorCode == 995) // Operation aborted
            {
                break;
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Error in HTTP listener");
            }
        }
    }
    private async Task HandleRequestAsync(HttpListenerContext context)
    {
        try
        {
            var request = context.Request;
            var response = context.Response;

            _logger.LogInformation($"Received {request.HttpMethod} request from {request.RemoteEndPoint}");

            if (request.HttpMethod == "POST")
            {
                // Read the request body
                string requestBody;
                using (var reader = new StreamReader(request.InputStream))
                {
                    requestBody = await reader.ReadToEndAsync();
                    _logger.LogInformation($"Request body: {requestBody}");
                }

                // Forward the request to the input pipe (HTTP -> MCP Server)
                var requestBytes = Encoding.UTF8.GetBytes(requestBody + "\n");
                await _inputPipeServer.WriteAsync(requestBytes, 0, requestBytes.Length);
                await _inputPipeServer.FlushAsync();

                // Set appropriate headers
                response.ContentType = "application/json";
                response.StatusCode = 200;
                response.KeepAlive = true;

                // Read response from output pipe (MCP Server -> HTTP)
                var responseBuffer = new byte[4096];
                var responseBuilder = new StringBuilder();

                // Set a timeout to avoid waiting forever
                var responseTask = Task.Run(async () =>
                {
                    var bytesRead = await _outputPipeServer.ReadAsync(responseBuffer, 0, responseBuffer.Length);
                    if (bytesRead > 0)
                    {
                        var responseText = Encoding.UTF8.GetString(responseBuffer, 0, bytesRead);
                        responseBuilder.Append(responseText);
                        _logger.LogInformation($"MCP Response: {responseText}");
                        return responseText;
                    }
                    return null;
                });

                // Wait for response with timeout
                var completedTask = await Task.WhenAny(responseTask, Task.Delay(5000));
                string mcpResponse;

                if (completedTask == responseTask)
                {
                    mcpResponse = await responseTask;
                }
                else
                {
                    // Timeout - send a default response
                    mcpResponse = "{\"jsonrpc\":\"2.0\",\"id\":1,\"result\":{\"protocolVersion\":\"2024-11-05\",\"capabilities\":{},\"serverInfo\":{\"name\":\"UnityMCP\",\"version\":\"1.0.0\"}}}";
                    _logger.LogWarning("MCP Server response timeout, sending default response");
                }

                // Write response back to HTTP client
                if (!string.IsNullOrEmpty(mcpResponse))
                {
                    var responseBytes = Encoding.UTF8.GetBytes(mcpResponse);
                    await response.OutputStream.WriteAsync(responseBytes, 0, responseBytes.Length);
                }

                response.Close();
                _logger.LogInformation("HTTP request processed and MCP response sent");
            }
            else
            {
                response.StatusCode = 405; // Method Not Allowed
                var errorMessage = "Only POST method is supported";
                var errorBytes = Encoding.UTF8.GetBytes(errorMessage);
                response.ContentLength64 = errorBytes.Length;
                await response.OutputStream.WriteAsync(errorBytes, 0, errorBytes.Length);
                response.Close();
            }
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Error handling HTTP request");
            try
            {
                context.Response.StatusCode = 500;
                context.Response.Close();
            }
            catch { /* Ignore cleanup errors */ }
        }
    }

    public void Stop()
    {
        try
        {
            _cancellationTokenSource?.Cancel();
            _httpListener?.Stop();
            _listenerTask?.Wait(TimeSpan.FromSeconds(5));
            _logger.LogInformation("HTTP listener stopped");
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Error stopping HTTP listener");
        }
    }

    public void Dispose()
    {
        Stop();
        _cancellationTokenSource?.Dispose();
        _httpListener?.Close();
        _inputPipeServer?.Dispose();
        _inputPipeClient?.Dispose();
        _outputPipeServer?.Dispose();
        _outputPipeClient?.Dispose();
    }
}

[eiriktsarpalis]

Is it possible to use HttpListener to create a HttpStreamTransport?

Earlier versions of the library did use an HttpListener-based implementation before it got replaced with ASP.NET Core. Perhaps it makes sense to include a sample project that uses HttpListener for documentation purposes? cc @halter73