Remove McpServerConfig and have McpClientFactory accept IClientTransport instances directly.

Author: eiriktsarpalis

samples/ChatWithTools/Program.cs

@@ -6,16 +6,13 @@
 // Connect to an MCP server
 Console.WriteLine("Connecting client to MCP 'everything' server");
 var mcpClient = await McpClientFactory.CreateAsync(
-    new()
+    new StdioClientTransport(new()
     {
         Id = "everything",
         Name = "Everything",
-        TransportType = TransportTypes.StdIo,
-        TransportOptions = new()
-        {
-            ["command"] = "npx", ["arguments"] = "-y @modelcontextprotocol/server-everything",
-        }
-    });
+        Command = "npx",
+        Arguments = "-y --verbose @modelcontextprotocol/server-everything",
+    }));
 
 // Get all available tools
 Console.WriteLine("Tools available:");

samples/QuickstartClient/Program.cs

@@ -13,17 +13,13 @@
 
 var (command, arguments) = GetCommandAndArguments(args);
 
-await using var mcpClient = await McpClientFactory.CreateAsync(new()
+await using var mcpClient = await McpClientFactory.CreateAsync(new StdioClientTransport(new()
 {
     Id = "demo-server",
     Name = "Demo Server",
-    TransportType = TransportTypes.StdIo,
-    TransportOptions = new()
-    {
-        ["command"] = command,
-        ["arguments"] = arguments,
-    }
-});
+    Command = command,
+    Arguments = arguments,
+}));
 
 var tools = await mcpClient.ListToolsAsync();
 foreach (var tool in tools)

src/ModelContextProtocol/Client/McpClient.cs

@@ -33,17 +33,16 @@ internal sealed class McpClient : McpEndpoint, IMcpClient
     /// </summary>
     /// <param name="clientTransport">The transport to use for communication with the server.</param>
     /// <param name="options">Options for the client, defining protocol version and capabilities.</param>
-    /// <param name="serverConfig">The server configuration.</param>
     /// <param name="loggerFactory">The logger factory.</param>
-    public McpClient(IClientTransport clientTransport, McpClientOptions? options, McpServerConfig serverConfig, ILoggerFactory? loggerFactory)
+    public McpClient(IClientTransport clientTransport, McpClientOptions? options, ILoggerFactory? loggerFactory)
         : base(loggerFactory)
     {
         options ??= new();
 
         _clientTransport = clientTransport;
         _options = options;
 
-        EndpointName = $"Client ({serverConfig.Id}: {serverConfig.Name})";
+        EndpointName = clientTransport.EndpointName;
 
         if (options.Capabilities is { } capabilities)
         {

src/ModelContextProtocol/Client/McpClientFactory.cs

@@ -12,42 +12,31 @@ namespace ModelContextProtocol.Client;
 public static class McpClientFactory
 {
     /// <summary>Creates an <see cref="IMcpClient"/>, connecting it to the specified server.</summary>
-    /// <param name="serverConfig">Configuration for the target server to which the client should connect.</param>
+    /// <param name="clientTransport">The transport instance used to communicate with the server.</param>
     /// <param name="clientOptions">
     /// A client configuration object which specifies client capabilities and protocol version.
     /// If <see langword="null"/>, details based on the current process will be employed.
     /// </param>
-    /// <param name="createTransportFunc">An optional factory method which returns transport implementations based on a server configuration.</param>
     /// <param name="loggerFactory">A logger factory for creating loggers for clients.</param>
     /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
     /// <returns>An <see cref="IMcpClient"/> that's connected to the specified server.</returns>
-    /// <exception cref="ArgumentNullException"><paramref name="serverConfig"/> is <see langword="null"/>.</exception>
+    /// <exception cref="ArgumentNullException"><paramref name="clientTransport"/> is <see langword="null"/>.</exception>
     /// <exception cref="ArgumentNullException"><paramref name="clientOptions"/> is <see langword="null"/>.</exception>
-    /// <exception cref="ArgumentException"><paramref name="serverConfig"/> contains invalid information.</exception>
-    /// <exception cref="InvalidOperationException"><paramref name="createTransportFunc"/> returns an invalid transport.</exception>
     public static async Task<IMcpClient> CreateAsync(
-        McpServerConfig serverConfig,
+        IClientTransport clientTransport,
         McpClientOptions? clientOptions = null,
-        Func<McpServerConfig, ILoggerFactory?, IClientTransport>? createTransportFunc = null,
         ILoggerFactory? loggerFactory = null,
         CancellationToken cancellationToken = default)
     {
-        Throw.IfNull(serverConfig);
-
-        createTransportFunc ??= CreateTransport;
-        
-        string endpointName = $"Client ({serverConfig.Id}: {serverConfig.Name})";
+        Throw.IfNull(clientTransport);
 
+        string endpointName = clientTransport.EndpointName;
         var logger = loggerFactory?.CreateLogger(typeof(McpClientFactory)) ?? NullLogger.Instance;
         logger.CreatingClient(endpointName);
 
-        var transport = 
-            createTransportFunc(serverConfig, loggerFactory) ??
-            throw new InvalidOperationException($"{nameof(createTransportFunc)} returned a null transport.");
-
         try
         {
-            McpClient client = new(transport, clientOptions, serverConfig, loggerFactory);
+            McpClient client = new(clientTransport, clientOptions, loggerFactory);
             try
             {
                 await client.ConnectAsync(cancellationToken).ConfigureAwait(false);
@@ -62,78 +51,15 @@ public static async Task<IMcpClient> CreateAsync(
         }
         catch
         {
-            if (transport is IAsyncDisposable asyncDisposableTransport)
+            if (clientTransport is IAsyncDisposable asyncDisposableTransport)
             {
                 await asyncDisposableTransport.DisposeAsync().ConfigureAwait(false);
             }
-            else if (transport is IDisposable disposableTransport)
+            else if (clientTransport is IDisposable disposableTransport)
             {
                 disposableTransport.Dispose();
             }
             throw;
         }
     }
-
-    private static IClientTransport CreateTransport(McpServerConfig serverConfig, ILoggerFactory? loggerFactory)
-    {
-        if (string.Equals(serverConfig.TransportType, TransportTypes.StdIo, StringComparison.OrdinalIgnoreCase))
-        {
-            string? command = serverConfig.TransportOptions?.GetValueOrDefault("command");
-            if (string.IsNullOrWhiteSpace(command))
-            {
-                command = serverConfig.Location;
-                if (string.IsNullOrWhiteSpace(command))
-                {
-                    throw new ArgumentException("Command is required for stdio transport.", nameof(serverConfig));
-                }
-            }
-
-            string? arguments = serverConfig.TransportOptions?.GetValueOrDefault("arguments");
-
-            if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows) &&
-                serverConfig.TransportType.Equals(TransportTypes.StdIo, StringComparison.OrdinalIgnoreCase) &&
-                !string.IsNullOrEmpty(command) &&
-                !string.Equals(Path.GetFileName(command), "cmd.exe", StringComparison.OrdinalIgnoreCase))
-            {
-                // On Windows, for stdio, we need to wrap non-shell commands with cmd.exe /c {command} (usually npx or uvicorn).
-                // The stdio transport will not work correctly if the command is not run in a shell.
-                arguments = string.IsNullOrWhiteSpace(arguments) ? 
-                    $"/c {command}" :
-                    $"/c {command} {arguments}";
-                command = "cmd.exe";
-            }
-
-            return new StdioClientTransport(new StdioClientTransportOptions
-            {
-                Command = command!,
-                Arguments = arguments,
-                WorkingDirectory = serverConfig.TransportOptions?.GetValueOrDefault("workingDirectory"),
-                EnvironmentVariables = serverConfig.TransportOptions?
-                    .Where(kv => kv.Key.StartsWith("env:", StringComparison.Ordinal))
-                    .ToDictionary(kv => kv.Key.Substring("env:".Length), kv => kv.Value),
-                ShutdownTimeout = TimeSpan.TryParse(serverConfig.TransportOptions?.GetValueOrDefault("shutdownTimeout"), CultureInfo.InvariantCulture, out var timespan) ? timespan : StdioClientTransportOptions.DefaultShutdownTimeout
-            }, serverConfig, loggerFactory);
-        }
-
-        if (string.Equals(serverConfig.TransportType, TransportTypes.Sse, StringComparison.OrdinalIgnoreCase) ||
-            string.Equals(serverConfig.TransportType, "http", StringComparison.OrdinalIgnoreCase))
-        {
-            return new SseClientTransport(new SseClientTransportOptions
-            {
-                ConnectionTimeout = TimeSpan.FromSeconds(ParseInt32OrDefault(serverConfig.TransportOptions, "connectionTimeout", 30)),
-                MaxReconnectAttempts = ParseInt32OrDefault(serverConfig.TransportOptions, "maxReconnectAttempts", 3),
-                ReconnectDelay = TimeSpan.FromSeconds(ParseInt32OrDefault(serverConfig.TransportOptions, "reconnectDelay", 5)),
-                AdditionalHeaders = serverConfig.TransportOptions?
-                    .Where(kv => kv.Key.StartsWith("header.", StringComparison.Ordinal))
-                    .ToDictionary(kv => kv.Key.Substring("header.".Length), kv => kv.Value)
-            }, serverConfig, loggerFactory);
-
-            static int ParseInt32OrDefault(Dictionary<string, string>? options, string key, int defaultValue) =>
-                options?.TryGetValue(key, out var value) is not true ? defaultValue :
-                int.TryParse(value, out var result) ? result :
-                throw new ArgumentException($"Invalid value '{value}' for option '{key}' in transport options.", nameof(serverConfig));
-        }
-
-        throw new ArgumentException($"Unsupported transport type '{serverConfig.TransportType}'.", nameof(serverConfig));
-    }
 }

src/ModelContextProtocol/Configuration/McpServerConfig.cs

@@ -7,6 +7,7 @@
     <PackageId>ModelContextProtocol</PackageId>
     <Description>.NET SDK for the Model Context Protocol (MCP)</Description>
     <PackageReadmeFile>README.md</PackageReadmeFile>
+    <LangVersion>preview</LangVersion>
   </PropertyGroup>
 
   <PropertyGroup Condition="'$(TargetFramework)' != 'netstandard2.0'">

src/ModelContextProtocol/ModelContextProtocol.csproj

@@ -5,6 +5,11 @@
 /// </summary>
 public interface IClientTransport
 {
+    /// <summary>
+    /// Gets a description of the endpoint the client is connecting to.
+    /// </summary>
+    string EndpointName { get; }
+
     /// <summary>
     /// Asynchronously establishes a transport session with an MCP server and returns an interface for the duplex JSON-RPC message stream.
     /// </summary>

src/ModelContextProtocol/Protocol/Transport/IClientTransport.cs

@@ -23,29 +23,25 @@ internal sealed class SseClientSessionTransport : TransportBase
     private readonly CancellationTokenSource _connectionCts;
     private Task? _receiveTask;
     private readonly ILogger _logger;
-    private readonly McpServerConfig _serverConfig;
     private readonly TaskCompletionSource<bool> _connectionEstablished;
 
-    private string EndpointName => $"Client (SSE) for ({_serverConfig.Id}: {_serverConfig.Name})";
+    private string EndpointName => $"Client (SSE) for ({_options.Id}: {_options.Name})";
 
     /// <summary>
     /// SSE transport for client endpoints. Unlike stdio it does not launch a process, but connects to an existing server.
     /// The HTTP server can be local or remote, and must support the SSE protocol.
     /// </summary>
     /// <param name="transportOptions">Configuration options for the transport.</param>
-    /// <param name="serverConfig">The configuration object indicating which server to connect to.</param>
     /// <param name="httpClient">The HTTP client instance used for requests.</param>
     /// <param name="loggerFactory">Logger factory for creating loggers.</param>
-    public SseClientSessionTransport(SseClientTransportOptions transportOptions, McpServerConfig serverConfig, HttpClient httpClient, ILoggerFactory? loggerFactory)
+    public SseClientSessionTransport(SseClientTransportOptions transportOptions, HttpClient httpClient, ILoggerFactory? loggerFactory)
         : base(loggerFactory)
     {
         Throw.IfNull(transportOptions);
-        Throw.IfNull(serverConfig);
         Throw.IfNull(httpClient);
 
         _options = transportOptions;
-        _serverConfig = serverConfig;
-        _sseEndpoint = new Uri(serverConfig.Location!);
+        _sseEndpoint = transportOptions.Endpoint;
         _httpClient = httpClient;
         _connectionCts = new CancellationTokenSource();
         _logger = (ILogger?)loggerFactory?.CreateLogger<SseClientTransport>() ?? NullLogger.Instance;

src/ModelContextProtocol/Protocol/Transport/SseClientSessionTransport.cs

@@ -9,7 +9,6 @@ namespace ModelContextProtocol.Protocol.Transport;
 public sealed class SseClientTransport : IClientTransport, IAsyncDisposable
 {
     private readonly SseClientTransportOptions _options;
-    private readonly McpServerConfig _serverConfig;
     private readonly HttpClient _httpClient;
     private readonly ILoggerFactory? _loggerFactory;
     private readonly bool _ownsHttpClient;
@@ -19,10 +18,9 @@ public sealed class SseClientTransport : IClientTransport, IAsyncDisposable
     /// The HTTP server can be local or remote, and must support the SSE protocol.
     /// </summary>
     /// <param name="transportOptions">Configuration options for the transport.</param>
-    /// <param name="serverConfig">The configuration object indicating which server to connect to.</param>
     /// <param name="loggerFactory">Logger factory for creating loggers.</param>
-    public SseClientTransport(SseClientTransportOptions transportOptions, McpServerConfig serverConfig, ILoggerFactory? loggerFactory)
-        : this(transportOptions, serverConfig, new HttpClient(), loggerFactory, true)
+    public SseClientTransport(SseClientTransportOptions transportOptions, ILoggerFactory? loggerFactory = null)
+        : this(transportOptions, new HttpClient(), loggerFactory, true)
     {
     }
 
@@ -31,27 +29,27 @@ public SseClientTransport(SseClientTransportOptions transportOptions, McpServerC
     /// The HTTP server can be local or remote, and must support the SSE protocol.
     /// </summary>
     /// <param name="transportOptions">Configuration options for the transport.</param>
-    /// <param name="serverConfig">The configuration object indicating which server to connect to.</param>
     /// <param name="httpClient">The HTTP client instance used for requests.</param>
     /// <param name="loggerFactory">Logger factory for creating loggers.</param>
     /// <param name="ownsHttpClient">True to dispose HTTP client on close connection.</param>
-    public SseClientTransport(SseClientTransportOptions transportOptions, McpServerConfig serverConfig, HttpClient httpClient, ILoggerFactory? loggerFactory, bool ownsHttpClient = false)
+    public SseClientTransport(SseClientTransportOptions transportOptions, HttpClient httpClient, ILoggerFactory? loggerFactory = null, bool ownsHttpClient = false)
     {
         Throw.IfNull(transportOptions);
-        Throw.IfNull(serverConfig);
         Throw.IfNull(httpClient);
 
         _options = transportOptions;
-        _serverConfig = serverConfig;
         _httpClient = httpClient;
         _loggerFactory = loggerFactory;
         _ownsHttpClient = ownsHttpClient;
     }
 
+    /// <inheritdoc />
+    public string EndpointName => $"Client (SSE) for ({_options.Id}: {_options.Name})";
+
     /// <inheritdoc />
     public async Task<ITransport> ConnectAsync(CancellationToken cancellationToken = default)
     {
-        var sessionTransport = new SseClientSessionTransport(_options, _serverConfig, _httpClient, _loggerFactory);
+        var sessionTransport = new SseClientSessionTransport(_options, _httpClient, _loggerFactory);
 
         try
         {

src/ModelContextProtocol/Protocol/Transport/SseClientTransport.cs

@@ -5,6 +5,41 @@
 /// </summary>
 public record SseClientTransportOptions
 {
+    /// <summary>
+    /// Unique identifier for this server configuration.
+    /// </summary>
+    public required string Id { get; init; }
+
+    /// <summary>
+    /// Display name for the server.
+    /// </summary>
+    public required string Name { get; init; }
+
+    /// <summary>
+    /// The base address of the server for SSE connections.
+    /// </summary>
+    public required Uri Endpoint
+    {
+        get;
+        init
+        {
+            if (value is null)
+            {
+                throw new ArgumentNullException(nameof(value), "Endpoint cannot be null.");
+            }
+            if (!value.IsAbsoluteUri)
+            {
+                throw new ArgumentException("Endpoint must be an absolute URI.", nameof(value));
+            }
+            if (value.Scheme != Uri.UriSchemeHttp && value.Scheme != Uri.UriSchemeHttps)
+            {
+                throw new ArgumentException("Endpoint must use HTTP or HTTPS scheme.", nameof(value));
+            }
+
+            field = value;
+        }
+    }
+
     /// <summary>
     /// Timeout for initial connection and endpoint event.
     /// </summary>