Undo some commenting

Author: stephentoub

src/Common/Throw.cs

@@ -9,22 +9,6 @@ internal static class Throw
     // NOTE: Most of these should be replaced with extension statics for the relevant extension
     // type as downlevel polyfills once the C# 14 extension everything feature is available.
 
-    /// <summary>
-    /// Throws an <see cref="ArgumentNullException"/> if the specified argument is null.
-    /// </summary>
-    /// <param name="arg">The argument to check for null.</param>
-    /// <param name="parameterName">The name of the parameter being checked. This value is automatically provided by the compiler.</param>
-    /// <exception cref="ArgumentNullException">Thrown when <paramref name="arg"/> is null.</exception>
-    /// <example>
-    /// <code>
-    /// public void ProcessData(DataObject data)
-    /// {
-    ///     Throw.IfNull(data); // Throws ArgumentNullException if data is null
-    ///     
-    ///     // Process the data
-    /// }
-    /// </code>
-    /// </example>
     public static void IfNull([NotNull] object? arg, [CallerArgumentExpression(nameof(arg))] string? parameterName = null)
     {
         if (arg is null)
@@ -33,23 +17,6 @@ public static void IfNull([NotNull] object? arg, [CallerArgumentExpression(nameo
         }
     }
 
-    /// <summary>
-    /// Throws an <see cref="ArgumentException"/> if the specified string is null, empty, or consists only of white-space characters.
-    /// </summary>
-    /// <param name="arg">The string argument to check.</param>
-    /// <param name="parameterName">The name of the parameter being checked. This value is automatically provided by the compiler.</param>
-    /// <exception cref="ArgumentNullException">Thrown when <paramref name="arg"/> is null.</exception>
-    /// <exception cref="ArgumentException">Thrown when <paramref name="arg"/> is empty or consists only of white-space characters.</exception>
-    /// <example>
-    /// <code>
-    /// public void ProcessMessage(string messageId)
-    /// {
-    ///     Throw.IfNullOrWhiteSpace(messageId); // Throws if messageId is null, empty, or whitespace
-    ///     
-    ///     // Process the message
-    /// }
-    /// </code>
-    /// </example>
     public static void IfNullOrWhiteSpace([NotNull] string? arg, [CallerArgumentExpression(nameof(arg))] string? parameterName = null)
     {
         if (arg is null || arg.AsSpan().IsWhiteSpace())
@@ -71,4 +38,4 @@ private static void ThrowArgumentNullOrWhiteSpaceException(string? parameterName
 
     [DoesNotReturn]
     private static void ThrowArgumentNullException(string? parameterName) => throw new ArgumentNullException(parameterName);
-}
+}

src/ModelContextProtocol/Configuration/McpServerOptionsSetup.cs

@@ -31,7 +31,7 @@ public void Configure(McpServerOptions options)
         McpServerPrimitiveCollection<McpServerTool> toolCollection = options.Capabilities?.Tools?.ToolCollection ?? [];
         foreach (var tool in serverTools)
         {
-            toolCollection.TryAdd(tool); // Use TryAdd to avoid exceptions if a tool with the same name already exists
+            toolCollection.TryAdd(tool);
         }
 
         if (!toolCollection.IsEmpty)
@@ -48,7 +48,7 @@ public void Configure(McpServerOptions options)
         McpServerPrimitiveCollection<McpServerPrompt> promptCollection = options.Capabilities?.Prompts?.PromptCollection ?? [];
         foreach (var prompt in serverPrompts)
         {
-            promptCollection.TryAdd(prompt); // Use TryAdd to avoid exceptions if a prompt with the same name already exists
+            promptCollection.TryAdd(prompt);
         }
 
         if (!promptCollection.IsEmpty)

src/ModelContextProtocol/Logging/Log.cs

@@ -229,35 +229,6 @@ public static partial void TransportEndpointEventParseFailed(
         string data,
         Exception exception);
 
-    /// <summary>
-    /// Logs an error that occurred during JSON-RPC message handling.
-    /// </summary>
-    /// <param name="logger">The logger to write the error message to.</param>
-    /// <param name="endpointName">The name of the endpoint where the error occurred.</param>
-    /// <param name="messageType">The type name of the message that was being processed.</param>
-    /// <param name="payload">The serialized JSON content of the message for debugging.</param>
-    /// <param name="exception">The exception that was thrown during message handling.</param>
-    /// <remarks>
-    /// <para>
-    /// This method logs at Error level (EventId 7008) and captures details about unexpected exceptions
-    /// that occur during the processing of JSON-RPC messages that aren't handled by more specific
-    /// error logging methods.
-    /// </para>
-    /// <para>
-    /// Example usage:
-    /// </para>
-    /// <code>
-    /// try 
-    /// {
-    ///     await HandleMessageAsync(message, cancellationToken);
-    /// }
-    /// catch (Exception ex) when (ex is not OperationCanceledException)
-    /// {
-    ///     var payload = JsonSerializer.Serialize(message, McpJsonUtilities.JsonContext.Default.IJsonRpcMessage);
-    ///     _logger.MessageHandlerError(EndpointName, message.GetType().Name, payload, ex);
-    /// }
-    /// </code>
-    /// </remarks>
     [LoggerMessage(
         EventId = 7008,
         Level = LogLevel.Error,
@@ -279,15 +250,6 @@ public static partial void TransportWritingMessageToChannel(
         this ILogger logger,
         IJsonRpcMessage message);
 
-    /// <summary>
-    /// Logs when a message has been successfully written to a transport channel.
-    /// </summary>
-    /// <param name="logger">The logger to write the message to.</param>
-    /// <remarks>
-    /// This method logs at Trace level and is primarily used for debugging transport-level
-    /// message flow. The message contains no parameters and simply indicates that a message 
-    /// was written to the channel.
-    /// </remarks>
     [LoggerMessage(
         EventId = 7010,
         Level = LogLevel.Trace,
@@ -305,29 +267,6 @@ public static partial void TransportMessageRead(
         string endpointName,
         string messageType);
 
-    /// <summary>
-    /// Logs a warning when no handler is found for a JSON-RPC request method.
-    /// </summary>
-    /// <param name="logger">The logger to write the warning message to.</param>
-    /// <param name="endpointName">The name of the endpoint that received the request.</param>
-    /// <param name="method">The method name in the request that has no registered handler.</param>
-    /// <remarks>
-    /// <para>
-    /// This method logs at Warning level (EventId 7012) when a JSON-RPC request is received
-    /// but no handler has been registered for the requested method. This typically indicates
-    /// a client is requesting a capability that the server doesn't support.
-    /// </para>
-    /// <para>
-    /// Example usage:
-    /// </para>
-    /// <code>
-    /// if (!_requestHandlers.TryGetValue(request.Method, out var handler))
-    /// {
-    ///     _logger.NoHandlerFoundForRequest(EndpointName, request.Method);
-    ///     throw new McpException("The method does not exist or is not available.", ErrorCodes.MethodNotFound);
-    /// }
-    /// </code>
-    /// </remarks>
     [LoggerMessage(
         EventId = 7012,
         Level = LogLevel.Warning,
@@ -338,29 +277,6 @@ public static partial void NoHandlerFoundForRequest(
         string endpointName,
         string method);
 
-    /// <summary>
-    /// Logs at trace level when a response message has been successfully matched to a pending request by its message ID.
-    /// </summary>
-    /// <param name="logger">The logger to write the trace message to.</param>
-    /// <param name="endpointName">The name of the endpoint that received the response message.</param>
-    /// <param name="messageId">The unique identifier of the message that was matched to a pending request.</param>
-    /// <remarks>
-    /// <para>
-    /// This method logs at Trace level (EventId 7013) when the JSON-RPC message correlation system 
-    /// successfully identifies a response message that corresponds to a previously sent request.
-    /// This is part of the request/response tracking mechanism in the MCP framework.
-    /// </para>
-    /// <para>
-    /// Example usage:
-    /// </para>
-    /// <code>
-    /// if (_pendingRequests.TryRemove(messageWithId.Id, out var tcs))
-    /// {
-    ///     _logger.ResponseMatchedPendingRequest(EndpointName, messageWithId.Id.ToString());
-    ///     tcs.TrySetResult(message);
-    /// }
-    /// </code>
-    /// </remarks>
     [LoggerMessage(
         EventId = 7013,
         Level = LogLevel.Trace,
@@ -371,14 +287,6 @@ public static partial void ResponseMatchedPendingRequest(
         string endpointName,
         string messageId);
 
-    /// <summary>
-    /// Logs a warning when an endpoint handler receives a message with an unexpected type.
-    /// This occurs when a message doesn't match any of the expected JSON-RPC message types
-    /// (request, notification, or message with ID).
-    /// </summary>
-    /// <param name="logger">The logger to use.</param>
-    /// <param name="endpointName">The name of the endpoint that received the message.</param>
-    /// <param name="messageType">The type name of the unexpected message.</param>
     [LoggerMessage(
         EventId = 7014,
         Level = LogLevel.Warning,
@@ -389,28 +297,6 @@ public static partial void EndpointHandlerUnexpectedMessageType(
         string endpointName,
         string messageType);
 
-    /// <summary>
-    /// Logs a debug message when a request has been sent and the system is waiting for a response.
-    /// </summary>
-    /// <param name="logger">The logger to write the message to.</param>
-    /// <param name="endpointName">The name of the endpoint the request was sent to.</param>
-    /// <param name="method">The method name in the request.</param>
-    /// <param name="id">The ID of the request being tracked.</param>
-    /// <remarks>
-    /// <para>
-    /// This method logs at Debug level and tracks that a request has been successfully sent through
-    /// the transport layer and the system is now awaiting a response.
-    /// </para>
-    /// <para>
-    /// Example usage:
-    /// </para>
-    /// <code>
-    /// await _transport.SendMessageAsync(request, cancellationToken).ConfigureAwait(false);
-    /// 
-    /// _logger.RequestSentAwaitingResponse(EndpointName, request.Method, request.Id.ToString());
-    /// var response = await tcs.Task.WaitAsync(cancellationToken).ConfigureAwait(false);
-    /// </code>
-    /// </remarks>
     [LoggerMessage(
         EventId = 7015,
         Level = LogLevel.Debug,
@@ -422,35 +308,6 @@ public static partial void RequestSentAwaitingResponse(
         string method,
         string id);
 
-    /// <summary>
-    /// Logs an error when a server initialization attempt is made while the server is already initializing.
-    /// </summary>
-    /// <param name="logger">The logger to write the error message to.</param>
-    /// <param name="endpointName">The name of the endpoint that is already initializing.</param>
-    /// <remarks>
-    /// <para>
-    /// This method logs at Error level (EventId 7016) when a second attempt is made to initialize
-    /// a server that is already in the initialization process. This typically occurs when multiple
-    /// initialization requests are sent to the same server endpoint concurrently.
-    /// </para>
-    /// <para>
-    /// During the initialization sequence, a server can only process one initialization request at a time.
-    /// Attempting to start initialization when it's already in progress indicates a potential race condition
-    /// or improper sequencing of client-server communication.
-    /// </para>
-    /// <para>
-    /// Example usage:
-    /// </para>
-    /// <code>
-    /// if (_isInitializing)
-    /// {
-    ///     _logger.ServerAlreadyInitializing(EndpointName);
-    ///     throw new McpException("Server is already initializing", ErrorCodes.ServerAlreadyInitialized);
-    /// }
-    /// 
-    /// _isInitializing = true;
-    /// </code>
-    /// </remarks>
     [LoggerMessage(
         EventId = 7016,
         Level = LogLevel.Error,
@@ -460,33 +317,6 @@ public static partial void ServerAlreadyInitializing(
         this ILogger logger,
         string endpointName);
 
-    /// <summary>
-    /// Logs an error that occurs during server initialization.
-    /// </summary>
-    /// <param name="logger">The logger to write the error message to.</param>
-    /// <param name="endpointName">The name of the endpoint where the initialization error occurred.</param>
-    /// <param name="e">The exception that was thrown during server initialization.</param>
-    /// <remarks>
-    /// <para>
-    /// This method logs at Error level (EventId 7017) when an error occurs during the initialization
-    /// of a server endpoint. This typically indicates a problem with establishing the initial connection
-    /// or handshake with the server component.
-    /// </para>
-    /// <para>
-    /// Example usage:
-    /// </para>
-    /// <code>
-    /// try
-    /// {
-    ///     await InitializeServerAsync(cancellationToken).ConfigureAwait(false);
-    /// }
-    /// catch (Exception ex) when (ex is not OperationCanceledException)
-    /// {
-    ///     _logger.ServerInitializationError(EndpointName, ex);
-    ///     throw;
-    /// }
-    /// </code>
-    /// </remarks>
     [LoggerMessage(
         EventId = 7017,
         Level = LogLevel.Error,
@@ -497,32 +327,6 @@ public static partial void ServerInitializationError(
         string endpointName,
         Exception e);
 
-    /// <summary>
-    /// Logs at debug level when a POST request to the SSE transport has been accepted by the server.
-    /// </summary>
-    /// <param name="logger">The logger to write the debug message to.</param>
-    /// <param name="endpointName">The name of the endpoint that sent the POST request.</param>
-    /// <param name="messageId">The unique identifier of the message that was accepted.</param>
-    /// <remarks>
-    /// <para>
-    /// This method logs at Debug level (EventId 7018) when a JSON-RPC message sent via HTTP POST 
-    /// to an SSE endpoint has been accepted by the server. The server responds with "accepted" 
-    /// to indicate that it has received the message and will process it asynchronously.
-    /// </para>
-    /// <para>
-    /// The actual response to the message will be delivered later via the Server-Sent Events (SSE) stream.
-    /// This logging helps track the asynchronous message flow in the SSE transport implementation.
-    /// </para>
-    /// <para>
-    /// Example usage:
-    /// </para>
-    /// <code>
-    /// if (responseContent.Equals("accepted", StringComparison.OrdinalIgnoreCase))
-    /// {
-    ///     _logger.SSETransportPostAccepted(EndpointName, messageId);
-    /// }
-    /// </code>
-    /// </remarks>
     [LoggerMessage(
         EventId = 7018,
         Level = LogLevel.Debug,

src/ModelContextProtocol/Protocol/Types/UnsubscribeRequestParams.cs

@@ -17,30 +17,6 @@ namespace ModelContextProtocol.Protocol.Types;
 /// for the same resource without causing errors, even if there is no active subscription.
 /// </para>
 /// </remarks>
-/// <example>
-/// <code>
-/// // First subscribe to a resource
-/// await client.SubscribeToResourceAsync("resource://documents/123", cancellationToken);
-/// 
-/// // When updates are no longer needed
-/// await client.UnsubscribeFromResourceAsync("resource://documents/123", cancellationToken);
-/// 
-/// // Server-side handler implementation
-/// server.WithUnsubscribeFromResourcesHandler((context, cancellationToken) =>
-/// {
-///     var resourceUri = context.Params?.Uri;
-///     if (!string.IsNullOrEmpty(resourceUri))
-///     {
-///         // Remove the subscription from the server's tracking system
-///         _subscriptionManager.RemoveSubscription(context.ClientId, resourceUri);
-///     }
-///     return Task.FromResult(new EmptyResult());
-/// });
-/// </code>
-/// </example>
-/// <seealso cref="SubscribeRequestParams"/>
-/// <seealso cref="ResourceUpdatedNotificationParams"/>
-/// <seealso href="https://github.com/modelcontextprotocol/specification/blob/main/schema/">See the schema for details</seealso>
 public class UnsubscribeRequestParams : RequestParams
 {
     /// <summary>

src/ModelContextProtocol/Shared/RequestHandlers.cs

@@ -28,15 +28,6 @@ internal sealed class RequestHandlers : Dictionary<string, Func<JsonRpcRequest,
     /// a response object that will be serialized back to the client.
     /// </para>
     /// </remarks>
-    /// <example>
-    /// <code>
-    /// RequestHandlers.Set(
-    ///     RequestMethods.LoggingSetLevel,        // Method name from protocol
-    ///     MyLoggingLevelHandler,                 // Handler function
-    ///     JsonContext.Default.SetLevelRequestParams,    // Request type info
-    ///     JsonContext.Default.EmptyResult);      // Response type info
-    /// </code>
-    /// </example>
     public void Set<TRequest, TResponse>(
         string method,
         Func<TRequest?, CancellationToken, Task<TResponse>> handler,