Merge branch 'main' into dotnet-everything

Author: stephentoub

samples/QuickstartWeatherServer/Tools/WeatherTools.cs

@@ -1,7 +1,6 @@
 using ModelContextProtocol;
 using ModelContextProtocol.Server;
 using System.ComponentModel;
-using System.Net.Http.Json;
 using System.Text.Json;
 
 namespace QuickstartWeatherServer.Tools;

src/ModelContextProtocol/Client/IMcpClient.cs

@@ -8,19 +8,21 @@ namespace ModelContextProtocol.Client;
 public interface IMcpClient : IMcpEndpoint
 {
     /// <summary>
-    /// Gets the capabilities supported by the server.
+    /// Gets the capabilities supported by the connected server.
     /// </summary>
-    ServerCapabilities? ServerCapabilities { get; }
+    ServerCapabilities ServerCapabilities { get; }
 
     /// <summary>
-    /// Gets the version and implementation information of the server.
+    /// Gets the implementation information of the connected server.
     /// </summary>
-    Implementation? ServerInfo { get; }
+    Implementation ServerInfo { get; }
 
     /// <summary>
-    /// Instructions describing how to use the server and its features.
-    /// This can be used by clients to improve the LLM's understanding of available tools, resources, etc. 
-    /// It can be thought of like a "hint" to the model. For example, this information MAY be added to the system prompt.
+    /// Gets any instructions describing how to use the connected server and its features.
     /// </summary>
+    /// <remarks>
+    /// This can be used by clients to improve an LLM's understanding of available tools, prompts, and resources. 
+    /// It can be thought of like a "hint" to the model and may be added to a system prompt.
+    /// </remarks>
     string? ServerInstructions { get; }
 }

src/ModelContextProtocol/Client/McpClient.cs

@@ -12,67 +12,87 @@ namespace ModelContextProtocol.Client;
 /// <inheritdoc/>
 internal sealed class McpClient : McpEndpoint, IMcpClient
 {
+    private static Implementation DefaultImplementation { get; } = new()
+    {
+        Name = DefaultAssemblyName.Name ?? nameof(McpClient),
+        Version = DefaultAssemblyName.Version?.ToString() ?? "1.0.0",
+    };
+
     private readonly IClientTransport _clientTransport;
     private readonly McpClientOptions _options;
 
     private ITransport? _sessionTransport;
     private CancellationTokenSource? _connectCts;
 
+    private ServerCapabilities? _serverCapabilities;
+    private Implementation? _serverInfo;
+    private string? _serverInstructions;
+
     /// <summary>
     /// Initializes a new instance of the <see cref="McpClient"/> class.
     /// </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, McpServerConfig serverConfig, ILoggerFactory? loggerFactory)
         : base(loggerFactory)
     {
+        options ??= new();
+
         _clientTransport = clientTransport;
         _options = options;
 
         EndpointName = $"Client ({serverConfig.Id}: {serverConfig.Name})";
 
-        if (options.Capabilities?.Sampling is { } samplingCapability)
+        if (options.Capabilities is { } capabilities)
         {
-            if (samplingCapability.SamplingHandler is not { } samplingHandler)
+            if (capabilities.NotificationHandlers is { } notificationHandlers)
             {
-                throw new InvalidOperationException($"Sampling capability was set but it did not provide a handler.");
+                NotificationHandlers.AddRange(notificationHandlers);
             }
 
-            SetRequestHandler(
-                RequestMethods.SamplingCreateMessage,
-                (request, cancellationToken) => samplingHandler(
-                    request,
-                    request?.Meta?.ProgressToken is { } token ? new TokenProgress(this, token) : NullProgress.Instance,
-                    cancellationToken),
-                McpJsonUtilities.JsonContext.Default.CreateMessageRequestParams,
-                McpJsonUtilities.JsonContext.Default.CreateMessageResult);
-        }
-
-        if (options.Capabilities?.Roots is { } rootsCapability)
-        {
-            if (rootsCapability.RootsHandler is not { } rootsHandler)
+            if (capabilities.Sampling is { } samplingCapability)
             {
-                throw new InvalidOperationException($"Roots capability was set but it did not provide a handler.");
+                if (samplingCapability.SamplingHandler is not { } samplingHandler)
+                {
+                    throw new InvalidOperationException($"Sampling capability was set but it did not provide a handler.");
+                }
+
+                RequestHandlers.Set(
+                    RequestMethods.SamplingCreateMessage,
+                    (request, cancellationToken) => samplingHandler(
+                        request,
+                        request?.Meta?.ProgressToken is { } token ? new TokenProgress(this, token) : NullProgress.Instance,
+                        cancellationToken),
+                    McpJsonUtilities.JsonContext.Default.CreateMessageRequestParams,
+                    McpJsonUtilities.JsonContext.Default.CreateMessageResult);
             }
 
-            SetRequestHandler(
-                RequestMethods.RootsList,
-                rootsHandler,
-                McpJsonUtilities.JsonContext.Default.ListRootsRequestParams,
-                McpJsonUtilities.JsonContext.Default.ListRootsResult);
+            if (capabilities.Roots is { } rootsCapability)
+            {
+                if (rootsCapability.RootsHandler is not { } rootsHandler)
+                {
+                    throw new InvalidOperationException($"Roots capability was set but it did not provide a handler.");
+                }
+
+                RequestHandlers.Set(
+                    RequestMethods.RootsList,
+                    rootsHandler,
+                    McpJsonUtilities.JsonContext.Default.ListRootsRequestParams,
+                    McpJsonUtilities.JsonContext.Default.ListRootsResult);
+            }
         }
     }
 
     /// <inheritdoc/>
-    public ServerCapabilities? ServerCapabilities { get; private set; }
+    public ServerCapabilities ServerCapabilities => _serverCapabilities ?? throw new InvalidOperationException("The client is not connected.");
 
     /// <inheritdoc/>
-    public Implementation? ServerInfo { get; private set; }
+    public Implementation ServerInfo => _serverInfo ?? throw new InvalidOperationException("The client is not connected.");
 
     /// <inheritdoc/>
-    public string? ServerInstructions { get; private set; }
+    public string? ServerInstructions => _serverInstructions;
 
     /// <inheritdoc/>
     public override string EndpointName { get; }
@@ -92,46 +112,46 @@ public async Task ConnectAsync(CancellationToken cancellationToken = default)
             using var initializationCts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
             initializationCts.CancelAfter(_options.InitializationTimeout);
 
-        try
-        {
-            // Send initialize request
-            var initializeResponse = await this.SendRequestAsync(
-                RequestMethods.Initialize,
-                new InitializeRequestParams
-                {
-                    ProtocolVersion = _options.ProtocolVersion,
-                    Capabilities = _options.Capabilities ?? new ClientCapabilities(),
-                    ClientInfo = _options.ClientInfo
-                },
-                McpJsonUtilities.JsonContext.Default.InitializeRequestParams,
-                McpJsonUtilities.JsonContext.Default.InitializeResult,
-                cancellationToken: initializationCts.Token).ConfigureAwait(false);
+            try
+            {
+                // Send initialize request
+                var initializeResponse = await this.SendRequestAsync(
+                    RequestMethods.Initialize,
+                    new InitializeRequestParams
+                    {
+                        ProtocolVersion = _options.ProtocolVersion,
+                        Capabilities = _options.Capabilities ?? new ClientCapabilities(),
+                        ClientInfo = _options.ClientInfo ?? DefaultImplementation,
+                    },
+                    McpJsonUtilities.JsonContext.Default.InitializeRequestParams,
+                    McpJsonUtilities.JsonContext.Default.InitializeResult,
+                    cancellationToken: initializationCts.Token).ConfigureAwait(false);
 
                 // Store server information
                 _logger.ServerCapabilitiesReceived(EndpointName,
                     capabilities: JsonSerializer.Serialize(initializeResponse.Capabilities, McpJsonUtilities.JsonContext.Default.ServerCapabilities),
                     serverInfo: JsonSerializer.Serialize(initializeResponse.ServerInfo, McpJsonUtilities.JsonContext.Default.Implementation));
 
-                ServerCapabilities = initializeResponse.Capabilities;
-                ServerInfo = initializeResponse.ServerInfo;
-                ServerInstructions = initializeResponse.Instructions;
+                _serverCapabilities = initializeResponse.Capabilities;
+                _serverInfo = initializeResponse.ServerInfo;
+                _serverInstructions = initializeResponse.Instructions;
 
                 // Validate protocol version
                 if (initializeResponse.ProtocolVersion != _options.ProtocolVersion)
                 {
                     _logger.ServerProtocolVersionMismatch(EndpointName, _options.ProtocolVersion, initializeResponse.ProtocolVersion);
-                    throw new McpClientException($"Server protocol version mismatch. Expected {_options.ProtocolVersion}, got {initializeResponse.ProtocolVersion}");
+                    throw new McpException($"Server protocol version mismatch. Expected {_options.ProtocolVersion}, got {initializeResponse.ProtocolVersion}");
                 }
 
                 // Send initialized notification
                 await SendMessageAsync(
                     new JsonRpcNotification { Method = NotificationMethods.InitializedNotification },
                     initializationCts.Token).ConfigureAwait(false);
             }
-            catch (OperationCanceledException) when (initializationCts.IsCancellationRequested)
+            catch (OperationCanceledException oce) when (initializationCts.IsCancellationRequested)
             {
                 _logger.ClientInitializationTimeout(EndpointName);
-                throw new McpClientException("Initialization timed out");
+                throw new McpException("Initialization timed out", oce);
             }
         }
         catch (Exception e)