SSE Transport Support (PederHP#13)

* First iteration

* Tests

* SSE support

Author: PederHP

README.MD

@@ -1,5 +1,5 @@
 # mcpdotnet
-[![NuGet version](https://img.shields.io/nuget/v/mcpdotnet.svg?style=flat)](https://www.nuget.org/packages/mcpdotnet/)
+[![NuGet version](https://img.shields.io/nuget/v/mcpdotnet.svg)](https://www.nuget.org/packages/mcpdotnet/)
 
 A .NET client implementation of the Model Context Protocol (MCP), enabling .NET applications to connect to and interact with MCP servers.
 
@@ -12,31 +12,29 @@ For more information about MCP:
 - [Protocol Specification](https://spec.modelcontextprotocol.io/)
 - [GitHub Organization](https://github.com/modelcontextprotocol)
 
-## Status
+## Design Goals
 
-This project is in early development. While functional, it may undergo significant changes as the protocol and implementation evolve.
-
-### Current Limitations
-- Only stdio transport is currently supported (HTTP/SSE transport coming soon)
-- Client library only - server implementation support may be added in the future
-- Provider-agnostic implementation focused purely on the MCP protocol
-- Applications using this library need to implement their own integration with LLM APIs/clients
-
-The library's current focus is on implementing the core MCP protocol, with the main utility being the ability to launch and connect to MCP servers based on configuration objects.
+This library aims to provide a clean, specification-compliant implementation of the MCP protocol, with minimal additional abstraction. While transport implementations necessarily include additional code, they follow patterns established by the official SDKs where possible.
 
 ## Features
 
 - MCP client implementation for .NET applications
-- Support for stdio transport
-- Support for all capabilities: Tool, Resource, Prompt, Sampling, Roots
+- Support for stdio and SSE transports
+- Support for all MCP capabilities: Tool, Resource, Prompt, Sampling, Roots
 - Support for pagination and notifications
 - Async/await pattern throughout
 - Comprehensive logging support
 - Compatible with .NET 8.0 and later
 
 ## Getting Started
 
-To create a client you need to instantiate a factory with configuration objects:
+To use mcpdotnet, first install it via NuGet:
+
+```powershell
+dotnet add package mcpdotnet
+```
+
+Then create a client and start using tools, or other capabilities, from the servers you configure:
 ```csharp
 var options = new McpClientOptions() 
     { ClientInfo = new() { Name = "TestClient", Version = "1.0.0" } };
@@ -58,14 +56,12 @@ var factory = new McpClientFactory(
             options,
             NullLoggerFactory.Instance
         );
-```
-
-You can then retrieve an IMcpClient reference using the `id` of a server from the configuration, and use `ListToolsAsync` and `CallToolAsync` to integrate with your LLM-based code.
 
-```csharp
 var client = await factory.GetClientAsync("everything");
+
 // Get the list of tools, for passing to an LLM
 var tools = await client.ListToolsAsync();
+
 // Execute a tool, in practice this would normally be driven by LLM tool invocations
 var result = await client.CallToolAsync(
             "echo",
@@ -75,6 +71,7 @@ var result = await client.CallToolAsync(
             },
             CancellationToken.None
         );
+
 // echo always returns one and only one text content object
 Console.WriteLine(result.Content.FirstOrDefault(c => c.Type == "text").Text);
 ```
@@ -85,6 +82,16 @@ It is also highly recommended that you pass a proper LoggerFactory instance to t
 
 Additional examples and documentation will be added as in the near future.
 
+## Roadmap
+
+- Expand documentation with detailed guides for:
+  - Advanced scenarios (Sampling, Resources, Prompts)
+  - Transport configuration
+  - Error handling and recovery
+- Increase test coverage
+- Add example applications
+- Performance optimization and profiling
+
 ## License
 
 This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

TODO.md

@@ -1,13 +1,18 @@
 # TODOs for mcpdotnet
 
 ## Integration Testing
-- [ ] Add comprehensive Roots feature testing once reference servers implement support
-  - (Contribute PR to everything server adding `listRoots` tool)
-  - Add integration tests similar to Sampling tests
-  - Verify roots notification handling
+- Add comprehensive Roots feature testing once reference servers implement support
+  - Consider using everything server adding `listRoots` tool)
+- Add integration tests similar to Sampling tests
+- Verify roots notification handling
+- Expand SSE test server to support all features or use a reference SSE server if one becomes available
 
 ## Future Improvements
-- [ ] Add HTTPS/SSE transport support
+- [X] Add HTTPS/SSE transport support
+- [ ] Add more example applications showing different capabilities
+- [ ] Add comprehensive documentation for advanced scenarios
+- [ ] Profile and optimize performance
+- [ ] Linux support in stdio transport
 
 ## Code Improvements
 - [ ] Consolidate notification handling in McpClient to reduce duplication between SendNotificationAsync overloads

src/mcpdotnet.Tests/IntegrationTests.cs

@@ -2,7 +2,6 @@
 using McpDotNet.Configuration;
 using McpDotNet.Protocol.Messages;
 using McpDotNet.Protocol.Types;
-using Microsoft.Extensions.Logging;
 
 namespace McpDotNet.Tests;
 

src/mcpdotnet.Tests/McpClientFactoryTests.cs

@@ -1,12 +1,10 @@
-using Castle.Core.Logging;
 using McpDotNet.Client;
 using McpDotNet.Configuration;
 using McpDotNet.Protocol.Messages;
 using McpDotNet.Protocol.Transport;
 using Microsoft.Extensions.Logging.Abstractions;
 using Moq;
 using System.Threading.Channels;
-using Xunit;
 
 namespace McpDotNet.Tests.Client;
 
@@ -192,23 +190,177 @@ public void Constructor_WithDuplicateServerIds_ThrowsArgumentException()
     }
 
     [Fact]
-    public async Task GetClientAsync_WithHttpTransport_ThrowsNotImplementedException()
+    public async Task GetClientAsync_WithSseTransport_CanCreateClient()
     {
         // Arrange
         var config = new McpServerConfig
         {
             Id = "test-server",
             Name = "Test Server",
-            TransportType = "http",
+            TransportType = "sse",
             Location = "http://localhost:8080"
         };
+                
+        // Create a mock transport
+        var mockTransport = new Mock<IMcpTransport>();
+        mockTransport.Setup(t => t.ConnectAsync(It.IsAny<CancellationToken>()))
+            .Returns(Task.CompletedTask);
+        mockTransport.Setup(t => t.IsConnected).Returns(true);
+        mockTransport.Setup(t => t.MessageReader).Returns(Mock.Of<ChannelReader<IJsonRpcMessage>>());
 
-        var factory = new McpClientFactory([config], _defaultOptions,
-            NullLoggerFactory.Instance);
+        // Create a mock client
+        var mockClient = new Mock<IMcpClient>();
+        mockClient.Setup(c => c.ConnectAsync(It.IsAny<CancellationToken>()))
+            .Returns(Task.CompletedTask);
+        mockClient.Setup(c => c.IsInitialized).Returns(true);
 
-        // Act & Assert
-        await Assert.ThrowsAsync<ArgumentException>(
-            () => factory.GetClientAsync("test-server")
+        // Inject the mock transport into the factory
+        var factory = new McpClientFactory(
+            [config],
+            _defaultOptions,
+            NullLoggerFactory.Instance,
+            transportFactoryMethod: _ => mockTransport.Object,
+            clientFactoryMethod: (_, _, _) => mockClient.Object
         );
+
+        // Act
+        var client = await factory.GetClientAsync("test-server");
+
+        // Assert
+        Assert.NotNull(client);
+    }
+
+    [Fact]
+    public void McpFactory_WithSse_CreatesCorrectTransportOptions()
+    {
+        // Arrange
+        var config = new McpServerConfig
+        {
+            Id = "test-server",
+            Name = "Test Server",
+            TransportType = "sse",
+            Location = "http://localhost:8080",
+            TransportOptions = new Dictionary<string, string>
+            {
+                ["connectionTimeout"] = "10",
+                ["maxReconnectAttempts"] = "2",
+                ["reconnectDelay"] = "5",
+                ["header.test"] = "the_header_value"
+            }
+        };
+
+        // Act
+        var factory = new McpClientFactory(
+            [config],
+            _defaultOptions,
+            NullLoggerFactory.Instance
+        );
+
+        var transport = factory.TransportFactoryMethod(config) as SseTransport;
+
+        // Assert
+        Assert.NotNull(transport);
+        Assert.True(transport.Options.ConnectionTimeout == TimeSpan.FromSeconds(10));
+        Assert.True(transport.Options.MaxReconnectAttempts == 2);
+        Assert.True(transport.Options.ReconnectDelay == TimeSpan.FromSeconds(5));
+        Assert.True(transport.Options.AdditionalHeaders["test"] == "the_header_value");
+    }
+
+    [Fact]
+    public void McpFactory_WithSseAndNoOptions_CreatesDefaultTransportOptions()
+    {
+        // Arrange
+        var config = new McpServerConfig
+        {
+            Id = "test-server",
+            Name = "Test Server",
+            TransportType = "sse",
+            Location = "http://localhost:8080"
+        };
+
+        var defaultOptions = new SseTransportOptions();
+
+        // Act
+        var factory = new McpClientFactory(
+            [config],
+            _defaultOptions,
+            NullLoggerFactory.Instance
+        );
+
+        var transport = factory.TransportFactoryMethod(config) as SseTransport;
+
+        // Assert
+        Assert.NotNull(transport);
+        Assert.True(transport.Options.ConnectionTimeout == defaultOptions.ConnectionTimeout);
+        Assert.True(transport.Options.MaxReconnectAttempts == defaultOptions.MaxReconnectAttempts);
+        Assert.True(transport.Options.ReconnectDelay == defaultOptions.ReconnectDelay);
+        Assert.True(transport.Options.AdditionalHeaders == null && defaultOptions.AdditionalHeaders == null);
+    }
+
+    [Fact]
+    public void McpFactory_WithSseAndMissingOptions_CreatesCorrectTransportOptions()
+    {
+        // Arrange
+        var config = new McpServerConfig
+        {
+            Id = "test-server",
+            Name = "Test Server",
+            TransportType = "sse",
+            Location = "http://localhost:8080",
+            TransportOptions = new Dictionary<string, string>
+            {
+                ["connectionTimeout"] = "10",
+                ["header.test"] = "the_header_value"
+            }
+        };
+
+        var defaultOptions = new SseTransportOptions();
+
+        // Act
+        var factory = new McpClientFactory(
+            [config],
+            _defaultOptions,
+            NullLoggerFactory.Instance
+        );
+
+        var transport = factory.TransportFactoryMethod(config) as SseTransport;
+
+        // Assert
+        Assert.NotNull(transport);
+        Assert.True(transport.Options.ConnectionTimeout == TimeSpan.FromSeconds(10));
+        Assert.True(transport.Options.MaxReconnectAttempts == defaultOptions.MaxReconnectAttempts);
+        Assert.True(transport.Options.ReconnectDelay == defaultOptions.ReconnectDelay);
+        Assert.True(transport.Options.AdditionalHeaders["test"] == "the_header_value");
+    }
+
+    [Theory]
+    [InlineData("connectionTimeout", "not_a_number")]
+    [InlineData("maxReconnectAttempts", "invalid")]
+    [InlineData("reconnectDelay", "bad_value")]
+    public void McpFactory_WithInvalidTransportOptions_ThrowsFormatException(string key, string value)
+    {
+        // arrange
+        var config = new McpServerConfig
+        {
+            Id = "test-server",
+            Name = "Test Server",
+            TransportType = "sse",
+            Location = "http://localhost:8080",
+            TransportOptions = new Dictionary<string, string>
+            {
+                [key] = value
+            }
+        };
+
+        // Act
+        var factory = new McpClientFactory(
+            [config],
+            _defaultOptions,
+            NullLoggerFactory.Instance
+        );
+
+        // act & assert
+        Assert.Throws<FormatException>(() =>
+            factory.TransportFactoryMethod(config));
     }
-}
+}