Address feedback and use lists when representing stdio arguments.

Author: eiriktsarpalis

samples/ChatWithTools/Program.cs

@@ -8,10 +8,9 @@
 var mcpClient = await McpClientFactory.CreateAsync(
     new StdioClientTransport(new()
     {
-        Id = "everything",
-        Name = "Everything",
         Command = "npx",
-        Arguments = "-y --verbose @modelcontextprotocol/server-everything",
+        Arguments = ["-y", "--verbose", "@modelcontextprotocol/server-everything"],
+        Description = "Everything",
     }));
 
 // Get all available tools

samples/QuickstartClient/Program.cs

@@ -15,10 +15,9 @@
 
 await using var mcpClient = await McpClientFactory.CreateAsync(new StdioClientTransport(new()
 {
-    Id = "demo-server",
-    Name = "Demo Server",
     Command = command,
     Arguments = arguments,
+    Description = "Demo Server",
 }));
 
 var tools = await mcpClient.ListToolsAsync();
@@ -82,13 +81,13 @@ static void PromptForInput()
 /// 
 /// This method would only be required if you're creating a generic client, such as we use for the quickstart.
 /// </remarks>
-static (string command, string arguments) GetCommandAndArguments(string[] args)
+static (string command, string[] arguments) GetCommandAndArguments(string[] args)
 {
     return args switch
     {
-        [var script] when script.EndsWith(".py") => ("python", script),
-        [var script] when script.EndsWith(".js") => ("node", script),
-        [var script] when Directory.Exists(script) || (File.Exists(script) && script.EndsWith(".csproj")) => ("dotnet", $"run --project {script} --no-build"),
-        _ => ("dotnet", "run --project ../../../../QuickstartWeatherServer --no-build")
+        [var script] when script.EndsWith(".py") => ("python", args),
+        [var script] when script.EndsWith(".js") => ("node", args),
+        [var script] when Directory.Exists(script) || (File.Exists(script) && script.EndsWith(".csproj")) => ("dotnet", ["run", "--project", script, "--no-build"]),
+        _ => ("dotnet", ["run", "--project", "../../../../QuickstartWeatherServer", "--no-build"])
     };
 }

src/Common/Polyfills/System/PasteArgument.cs

@@ -0,0 +1,101 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+// Copied from:
+// https://github.com/dotnet/runtime/blob/d2650b6ae7023a2d9d2c74c56116f1f18472ab04/src/libraries/System.Private.CoreLib/src/System/PasteArguments.cs
+// and changed from using ValueStringBuilder to StringBuilder.
+
+using System.Text;
+
+namespace System;
+
+internal static partial class PasteArguments
+{
+    internal static void AppendArgument(StringBuilder stringBuilder, string argument)
+    {
+        if (stringBuilder.Length != 0)
+        {
+            stringBuilder.Append(' ');
+        }
+
+        // Parsing rules for non-argv[0] arguments:
+        //   - Backslash is a normal character except followed by a quote.
+        //   - 2N backslashes followed by a quote ==> N literal backslashes followed by unescaped quote
+        //   - 2N+1 backslashes followed by a quote ==> N literal backslashes followed by a literal quote
+        //   - Parsing stops at first whitespace outside of quoted region.
+        //   - (post 2008 rule): A closing quote followed by another quote ==> literal quote, and parsing remains in quoting mode.
+        if (argument.Length != 0 && ContainsNoWhitespaceOrQuotes(argument))
+        {
+            // Simple case - no quoting or changes needed.
+            stringBuilder.Append(argument);
+        }
+        else
+        {
+            stringBuilder.Append(Quote);
+            int idx = 0;
+            while (idx < argument.Length)
+            {
+                char c = argument[idx++];
+                if (c == Backslash)
+                {
+                    int numBackSlash = 1;
+                    while (idx < argument.Length && argument[idx] == Backslash)
+                    {
+                        idx++;
+                        numBackSlash++;
+                    }
+
+                    if (idx == argument.Length)
+                    {
+                        // We'll emit an end quote after this so must double the number of backslashes.
+                        stringBuilder.Append(Backslash, numBackSlash * 2);
+                    }
+                    else if (argument[idx] == Quote)
+                    {
+                        // Backslashes will be followed by a quote. Must double the number of backslashes.
+                        stringBuilder.Append(Backslash, numBackSlash * 2 + 1);
+                        stringBuilder.Append(Quote);
+                        idx++;
+                    }
+                    else
+                    {
+                        // Backslash will not be followed by a quote, so emit as normal characters.
+                        stringBuilder.Append(Backslash, numBackSlash);
+                    }
+
+                    continue;
+                }
+
+                if (c == Quote)
+                {
+                    // Escape the quote so it appears as a literal. This also guarantees that we won't end up generating a closing quote followed
+                    // by another quote (which parses differently pre-2008 vs. post-2008.)
+                    stringBuilder.Append(Backslash);
+                    stringBuilder.Append(Quote);
+                    continue;
+                }
+
+                stringBuilder.Append(c);
+            }
+
+            stringBuilder.Append(Quote);
+        }
+    }
+
+    private static bool ContainsNoWhitespaceOrQuotes(string s)
+    {
+        for (int i = 0; i < s.Length; i++)
+        {
+            char c = s[i];
+            if (char.IsWhiteSpace(c) || c == Quote)
+            {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    private const char Quote = '\"';
+    private const char Backslash = '\\';
+}

src/ModelContextProtocol/Client/McpClientFactory.cs

@@ -34,31 +34,16 @@ public static async Task<IMcpClient> CreateAsync(
         var logger = loggerFactory?.CreateLogger(typeof(McpClientFactory)) ?? NullLogger.Instance;
         logger.CreatingClient(endpointName);
 
+        McpClient client = new(clientTransport, clientOptions, loggerFactory);
         try
         {
-            McpClient client = new(clientTransport, clientOptions, loggerFactory);
-            try
-            {
-                await client.ConnectAsync(cancellationToken).ConfigureAwait(false);
-                logger.ClientCreated(endpointName);
-                return client;
-            }
-            catch
-            {
-                await client.DisposeAsync().ConfigureAwait(false);
-                throw;
-            }
+            await client.ConnectAsync(cancellationToken).ConfigureAwait(false);
+            logger.ClientCreated(endpointName);
+            return client;
         }
         catch
         {
-            if (clientTransport is IAsyncDisposable asyncDisposableTransport)
-            {
-                await asyncDisposableTransport.DisposeAsync().ConfigureAwait(false);
-            }
-            else if (clientTransport is IDisposable disposableTransport)
-            {
-                disposableTransport.Dispose();
-            }
+            await client.DisposeAsync().ConfigureAwait(false);
             throw;
         }
     }

src/ModelContextProtocol/Protocol/Transport/SseClientSessionTransport.cs

@@ -16,6 +16,7 @@ namespace ModelContextProtocol.Protocol.Transport;
 /// </summary>
 internal sealed class SseClientSessionTransport : TransportBase
 {
+    private readonly string _endpointName;
     private readonly HttpClient _httpClient;
     private readonly SseClientTransportOptions _options;
     private readonly Uri _sseEndpoint;
@@ -25,16 +26,15 @@ internal sealed class SseClientSessionTransport : TransportBase
     private readonly ILogger _logger;
     private readonly TaskCompletionSource<bool> _connectionEstablished;
 
-    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="httpClient">The HTTP client instance used for requests.</param>
     /// <param name="loggerFactory">Logger factory for creating loggers.</param>
-    public SseClientSessionTransport(SseClientTransportOptions transportOptions, HttpClient httpClient, ILoggerFactory? loggerFactory)
+    /// <param name="endpointName">The endpoint name used for logging purposes.</param>
+    public SseClientSessionTransport(SseClientTransportOptions transportOptions, HttpClient httpClient, ILoggerFactory? loggerFactory, string endpointName)
         : base(loggerFactory)
     {
         Throw.IfNull(transportOptions);
@@ -46,6 +46,7 @@ public SseClientSessionTransport(SseClientTransportOptions transportOptions, Htt
         _connectionCts = new CancellationTokenSource();
         _logger = (ILogger?)loggerFactory?.CreateLogger<SseClientTransport>() ?? NullLogger.Instance;
         _connectionEstablished = new TaskCompletionSource<bool>();
+        _endpointName = endpointName;
     }
 
     /// <inheritdoc/>
@@ -55,14 +56,14 @@ public async Task ConnectAsync(CancellationToken cancellationToken = default)
         {
             if (IsConnected)
             {
-                _logger.TransportAlreadyConnected(EndpointName);
+                _logger.TransportAlreadyConnected(_endpointName);
                 throw new McpTransportException("Transport is already connected");
             }
 
             // Start message receiving loop
             _receiveTask = ReceiveMessagesAsync(_connectionCts.Token);
 
-            _logger.TransportReadingMessages(EndpointName);
+            _logger.TransportReadingMessages(_endpointName);
 
             await _connectionEstablished.Task.WaitAsync(_options.ConnectionTimeout, cancellationToken).ConfigureAwait(false);
         }
@@ -73,7 +74,7 @@ public async Task ConnectAsync(CancellationToken cancellationToken = default)
         }
         catch (Exception ex)
         {
-            _logger.TransportConnectFailed(EndpointName, ex);
+            _logger.TransportConnectFailed(_endpointName, ex);
             await CloseAsync().ConfigureAwait(false);
             throw new McpTransportException("Failed to connect transport", ex);
         }
@@ -116,29 +117,29 @@ public override async Task SendMessageAsync(
             // If the response is not a JSON-RPC response, it is an SSE message
             if (responseContent.Equals("accepted", StringComparison.OrdinalIgnoreCase))
             {
-                _logger.SSETransportPostAccepted(EndpointName, messageId);
+                _logger.SSETransportPostAccepted(_endpointName, messageId);
                 // The response will arrive as an SSE message
             }
             else
             {
                 JsonRpcResponse initializeResponse = JsonSerializer.Deserialize(responseContent, McpJsonUtilities.JsonContext.Default.JsonRpcResponse) ??
                     throw new McpTransportException("Failed to initialize client");
 
-                _logger.TransportReceivedMessageParsed(EndpointName, messageId);
+                _logger.TransportReceivedMessageParsed(_endpointName, messageId);
                 await WriteMessageAsync(initializeResponse, cancellationToken).ConfigureAwait(false);
-                _logger.TransportMessageWritten(EndpointName, messageId);
+                _logger.TransportMessageWritten(_endpointName, messageId);
             }
             return;
         }
 
         // Otherwise, check if the response was accepted (the response will come as an SSE message)
         if (responseContent.Equals("accepted", StringComparison.OrdinalIgnoreCase))
         {
-            _logger.SSETransportPostAccepted(EndpointName, messageId);
+            _logger.SSETransportPostAccepted(_endpointName, messageId);
         }
         else
         {
-            _logger.SSETransportPostNotAccepted(EndpointName, messageId, responseContent);
+            _logger.SSETransportPostNotAccepted(_endpointName, messageId, responseContent);
             throw new McpTransportException("Failed to send message");
         }
     }
@@ -216,17 +217,17 @@ private async Task ReceiveMessagesAsync(CancellationToken cancellationToken)
             }
             catch (OperationCanceledException) when (cancellationToken.IsCancellationRequested)
             {
-                _logger.TransportReadMessagesCancelled(EndpointName);
+                _logger.TransportReadMessagesCancelled(_endpointName);
                 // Normal shutdown
             }
             catch (IOException) when (cancellationToken.IsCancellationRequested)
             {
-                _logger.TransportReadMessagesCancelled(EndpointName);
+                _logger.TransportReadMessagesCancelled(_endpointName);
                 // Normal shutdown
             }
             catch (Exception ex) when (!cancellationToken.IsCancellationRequested)
             {
-                _logger.TransportConnectionError(EndpointName, ex);
+                _logger.TransportConnectionError(_endpointName, ex);
 
                 reconnectAttempts++;
                 if (reconnectAttempts >= _options.MaxReconnectAttempts)
@@ -245,7 +246,7 @@ private async Task ProcessSseMessage(string data, CancellationToken cancellation
     {
         if (!IsConnected)
         {
-            _logger.TransportMessageReceivedBeforeConnected(EndpointName, data);
+            _logger.TransportMessageReceivedBeforeConnected(_endpointName, data);
             return;
         }
 
@@ -254,7 +255,7 @@ private async Task ProcessSseMessage(string data, CancellationToken cancellation
             var message = JsonSerializer.Deserialize(data, McpJsonUtilities.JsonContext.Default.IJsonRpcMessage);
             if (message == null)
             {
-                _logger.TransportMessageParseUnexpectedType(EndpointName, data);
+                _logger.TransportMessageParseUnexpectedType(_endpointName, data);
                 return;
             }
 
@@ -264,13 +265,13 @@ private async Task ProcessSseMessage(string data, CancellationToken cancellation
                 messageId = messageWithId.Id.ToString();
             }
 
-            _logger.TransportReceivedMessageParsed(EndpointName, messageId);
+            _logger.TransportReceivedMessageParsed(_endpointName, messageId);
             await WriteMessageAsync(message, cancellationToken).ConfigureAwait(false);
-            _logger.TransportMessageWritten(EndpointName, messageId);
+            _logger.TransportMessageWritten(_endpointName, messageId);
         }
         catch (JsonException ex)
         {
-            _logger.TransportMessageParseFailed(EndpointName, data, ex);
+            _logger.TransportMessageParseFailed(_endpointName, data, ex);
         }
     }
 
@@ -280,7 +281,7 @@ private void HandleEndpointEvent(string data)
         {
             if (string.IsNullOrEmpty(data))
             {
-                _logger.TransportEndpointEventInvalid(EndpointName, data);
+                _logger.TransportEndpointEventInvalid(_endpointName, data);
                 return;
             }
 
@@ -308,7 +309,7 @@ private void HandleEndpointEvent(string data)
         }
         catch (JsonException ex)
         {
-            _logger.TransportEndpointEventParseFailed(EndpointName, data, ex);
+            _logger.TransportEndpointEventParseFailed(_endpointName, data, ex);
             throw new McpTransportException("Failed to parse endpoint event", ex);
         }
     }

src/ModelContextProtocol/Protocol/Transport/SseClientTransport.cs

@@ -41,15 +41,16 @@ public SseClientTransport(SseClientTransportOptions transportOptions, HttpClient
         _httpClient = httpClient;
         _loggerFactory = loggerFactory;
         _ownsHttpClient = ownsHttpClient;
+        EndpointName = $"Client (SSE) for ({transportOptions.Description ?? transportOptions.Endpoint.ToString()})";
     }
 
     /// <inheritdoc />
-    public string EndpointName => $"Client (SSE) for ({_options.Id}: {_options.Name})";
+    public string EndpointName { get; }
 
     /// <inheritdoc />
     public async Task<ITransport> ConnectAsync(CancellationToken cancellationToken = default)
     {
-        var sessionTransport = new SseClientSessionTransport(_options, _httpClient, _loggerFactory);
+        var sessionTransport = new SseClientSessionTransport(_options, _httpClient, _loggerFactory, EndpointName);
 
         try
         {