Merge branch 'main' into copilot/fix-handler-asymmetry-again

Author: stephentoub

package-lock.json

@@ -280,7 +280,7 @@ public ValueTask<GetPromptResult> GetPromptAsync(
     }
 
     /// <summary>
-    /// Retrieves a list of available prompts from the server.
+    /// Retrieves a specific prompt from the MCP server.
     /// </summary>
     /// <param name="requestParams">The request parameters to send in the request.</param>
     /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
@@ -549,9 +549,9 @@ public ValueTask<CompleteResult> CompleteAsync(
     }
 
     /// <summary>
-    /// Unsubscribes from a resource on the server to stop receiving notifications about its changes.
+    /// Subscribes to a resource on the server to receive notifications when it changes.
     /// </summary>
-    /// <param name="uri">The URI of the resource to which to subscribe.</param>
+    /// <param name="uri">The URI of the resource to subscribe to.</param>
     /// <param name="options">Optional request options including metadata, serialization settings, and progress tracking.</param>
     /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
     /// <returns>A task that represents the asynchronous operation.</returns>
@@ -1036,6 +1036,7 @@ async ValueTask<McpTask> SendTaskAugmentedCallToolRequestWithProgressAsync(
     /// <returns>The current state of the task.</returns>
     /// <exception cref="ArgumentNullException"><paramref name="taskId"/> is <see langword="null"/>.</exception>
     /// <exception cref="ArgumentException"><paramref name="taskId"/> is empty or composed entirely of whitespace.</exception>
+    /// <exception cref="McpException">The request failed or the server returned an error response.</exception>
     [Experimental(Experimentals.Tasks_DiagnosticId, UrlFormat = Experimentals.Tasks_Url)]
     public async ValueTask<McpTask> GetTaskAsync(
         string taskId,
@@ -1073,6 +1074,7 @@ public async ValueTask<McpTask> GetTaskAsync(
     /// <returns>The raw JSON result of the task.</returns>
     /// <exception cref="ArgumentNullException"><paramref name="taskId"/> is <see langword="null"/>.</exception>
     /// <exception cref="ArgumentException"><paramref name="taskId"/> is empty or composed entirely of whitespace.</exception>
+    /// <exception cref="McpException">The request failed or the server returned an error response.</exception>
     /// <remarks>
     /// This method sends a tasks/result request to the server, which will block until the task completes if it hasn't already.
     /// The server handles all polling logic internally.
@@ -1099,6 +1101,7 @@ public ValueTask<JsonElement> GetTaskResultAsync(
     /// <param name="options">Optional request options including metadata, serialization settings, and progress tracking.</param>
     /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
     /// <returns>A list of all tasks.</returns>
+    /// <exception cref="McpException">The request failed or the server returned an error response.</exception>
     [Experimental(Experimentals.Tasks_DiagnosticId, UrlFormat = Experimentals.Tasks_Url)]
     public async ValueTask<IList<McpTask>> ListTasksAsync(
         RequestOptions? options = null,
@@ -1124,6 +1127,7 @@ public async ValueTask<IList<McpTask>> ListTasksAsync(
     /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
     /// <returns>The result of the request as provided by the server.</returns>
     /// <exception cref="ArgumentNullException"><paramref name="requestParams"/> is <see langword="null"/>.</exception>
+    /// <exception cref="McpException">The request failed or the server returned an error response.</exception>
     /// <remarks>
     /// The <see cref="ListTasksAsync(RequestOptions?, CancellationToken)"/> overload retrieves all tasks by automatically handling pagination.
     /// This overload works with the lower-level <see cref="ListTasksRequestParams"/> and <see cref="ListTasksResult"/>, returning the raw result from the server.
@@ -1153,6 +1157,7 @@ public ValueTask<ListTasksResult> ListTasksAsync(
     /// <returns>The updated state of the task after cancellation.</returns>
     /// <exception cref="ArgumentNullException"><paramref name="taskId"/> is <see langword="null"/>.</exception>
     /// <exception cref="ArgumentException"><paramref name="taskId"/> is empty or composed entirely of whitespace.</exception>
+    /// <exception cref="McpException">The request failed or the server returned an error response.</exception>
     /// <remarks>
     /// Cancelling a task requests that the server stop execution. The server may not immediately cancel the task,
     /// and may choose to allow the task to complete if it's close to finishing.

src/ModelContextProtocol.Core/Client/McpClient.Methods.cs

@@ -12,5 +12,5 @@ public sealed class UrlElicitationRequiredErrorData
     /// Gets or sets the elicitations that must be completed before retrying the original request.
     /// </summary>
     [JsonPropertyName("elicitations")]
-    public required IReadOnlyList<ElicitRequestParams> Elicitations { get; init; }
+    public required IList<ElicitRequestParams> Elicitations { get; set; }
 }

src/ModelContextProtocol.Core/Protocol/UrlElicitationRequiredErrorData.cs

@@ -23,6 +23,9 @@ protected DelegatingMcpServerPrompt(McpServerPrompt innerPrompt)
     /// <inheritdoc />
     public override Prompt ProtocolPrompt => _innerPrompt.ProtocolPrompt;
 
+    /// <inheritdoc />
+    public override IReadOnlyList<object> Metadata => _innerPrompt.Metadata;
+
     /// <inheritdoc />
     public override ValueTask<GetPromptResult> GetAsync(
         RequestContext<GetPromptRequestParams> request, 

src/ModelContextProtocol.Core/Server/DelegatingMcpServerPrompt.cs

@@ -26,6 +26,9 @@ protected DelegatingMcpServerResource(McpServerResource innerResource)
     /// <inheritdoc />
     public override ResourceTemplate ProtocolResourceTemplate => _innerResource.ProtocolResourceTemplate;
 
+    /// <inheritdoc />
+    public override IReadOnlyList<object> Metadata => _innerResource.Metadata;
+
     /// <inheritdoc />
     public override bool IsMatch(string uri) => _innerResource.IsMatch(uri);
 

src/ModelContextProtocol.Core/Server/DelegatingMcpServerResource.cs

@@ -23,6 +23,9 @@ protected DelegatingMcpServerTool(McpServerTool innerTool)
     /// <inheritdoc />
     public override Tool ProtocolTool => _innerTool.ProtocolTool;
 
+    /// <inheritdoc />
+    public override IReadOnlyList<object> Metadata => _innerTool.Metadata;
+
     /// <inheritdoc />
     public override ValueTask<CallToolResult> InvokeAsync(
         RequestContext<CallToolRequestParams> request, 

src/ModelContextProtocol.Core/Server/DelegatingMcpServerTool.cs

@@ -1066,6 +1066,7 @@ void IDisposable.Dispose() { } // nop
     /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests.</param>
     /// <returns>A task representing the asynchronous notification operation.</returns>
     /// <exception cref="ArgumentNullException"><paramref name="task"/> is <see langword="null"/>.</exception>
+    /// <exception cref="McpException">The notification failed or the client returned an error response.</exception>
     /// <remarks>
     /// <para>
     /// This method sends an optional status notification to inform the client of task state changes.

src/ModelContextProtocol.Core/Server/McpServer.Methods.cs

@@ -12,7 +12,7 @@ namespace ModelContextProtocol;
 /// </summary>
 public sealed class UrlElicitationRequiredException : McpProtocolException
 {
-    private readonly IReadOnlyList<ElicitRequestParams> _elicitations;
+    private readonly List<ElicitRequestParams> _elicitations;
 
     /// <summary>
     /// Initializes a new instance of the <see cref="UrlElicitationRequiredException"/> class with the specified message and pending elicitations.
@@ -66,7 +66,7 @@ internal static bool TryCreateFromError(
         return true;
     }
 
-    private static bool TryParseElicitations(JsonElement dataElement, out IReadOnlyList<ElicitRequestParams> elicitations)
+    private static bool TryParseElicitations(JsonElement dataElement, out IList<ElicitRequestParams> elicitations)
     {
         elicitations = [];
 
@@ -93,7 +93,7 @@ private static bool TryParseElicitations(JsonElement dataElement, out IReadOnlyL
         return true;
     }
 
-    private static IReadOnlyList<ElicitRequestParams> Validate(IEnumerable<ElicitRequestParams> elicitations)
+    private static List<ElicitRequestParams> Validate(IEnumerable<ElicitRequestParams> elicitations)
     {
         var list = new List<ElicitRequestParams>();
         foreach (var elicitation in elicitations)

src/ModelContextProtocol.Core/UrlElicitationRequiredException.cs

@@ -0,0 +1,58 @@
+using ModelContextProtocol.Protocol;
+using ModelContextProtocol.Server;
+using System.Reflection;
+
+namespace ModelContextProtocol.Tests.Server;
+
+public class DelegatingMcpServerPromptTests
+{
+    [Fact]
+    public void Ctor_NullInnerPrompt_Throws()
+    {
+        Assert.Throws<ArgumentNullException>("innerPrompt", () => new TestDelegatingPrompt(null!));
+    }
+
+    [Fact]
+    public async Task AllMembers_DelegateToInnerPrompt()
+    {
+        Prompt expectedPrompt = new() { Name = "sentinel-prompt" };
+        IReadOnlyList<object> expectedMetadata = new object[] { "m1" };
+        GetPromptResult expectedResult = new() { Messages = [] };
+        InnerPrompt inner = new(expectedPrompt, expectedMetadata, expectedResult);
+
+        TestDelegatingPrompt delegating = new(inner);
+
+        Assert.Same(expectedPrompt, delegating.ProtocolPrompt);
+        Assert.Same(expectedMetadata, delegating.Metadata);
+        Assert.Same(expectedResult, await delegating.GetAsync(null!, CancellationToken.None));
+        Assert.Equal(inner.ToString(), delegating.ToString());
+    }
+
+    [Fact]
+    public void OverridesAllVirtualAndAbstractMembers()
+    {
+        MethodInfo[] baseMethods = typeof(McpServerPrompt).GetMethods(BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly)
+            .Where(m => m.IsVirtual || m.IsAbstract)
+            .ToArray();
+
+        Assert.NotEmpty(baseMethods);
+
+        foreach (MethodInfo baseMethod in baseMethods)
+        {
+            Assert.True(
+                typeof(DelegatingMcpServerPrompt).GetMethods(BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly)
+                    .Any(m => m.Name == baseMethod.Name),
+                $"DelegatingMcpServerPrompt does not override {baseMethod.Name} from McpServerPrompt.");
+        }
+    }
+
+    private sealed class TestDelegatingPrompt(McpServerPrompt innerPrompt) : DelegatingMcpServerPrompt(innerPrompt);
+
+    private sealed class InnerPrompt(Prompt protocolPrompt, IReadOnlyList<object> metadata, GetPromptResult result) : McpServerPrompt
+    {
+        public override Prompt ProtocolPrompt => protocolPrompt;
+        public override IReadOnlyList<object> Metadata => metadata;
+        public override ValueTask<GetPromptResult> GetAsync(RequestContext<GetPromptRequestParams> request, CancellationToken cancellationToken = default) => new(result);
+        public override string ToString() => "inner-prompt";
+    }
+}

tests/ModelContextProtocol.Tests/Server/DelegatingMcpServerPromptTests.cs

@@ -0,0 +1,63 @@
+using ModelContextProtocol.Protocol;
+using ModelContextProtocol.Server;
+using System.Reflection;
+
+namespace ModelContextProtocol.Tests.Server;
+
+public class DelegatingMcpServerResourceTests
+{
+    [Fact]
+    public void Ctor_NullInnerResource_Throws()
+    {
+        Assert.Throws<ArgumentNullException>("innerResource", () => new TestDelegatingResource(null!));
+    }
+
+    [Fact]
+    public async Task AllMembers_DelegateToInnerResource()
+    {
+        ResourceTemplate expectedTemplate = new() { Name = "sentinel-resource", UriTemplate = "test://resource" };
+        Resource expectedResource = new() { Name = "sentinel-resource", Uri = "test://resource" };
+        IReadOnlyList<object> expectedMetadata = new object[] { "m1" };
+        ReadResourceResult expectedResult = new() { Contents = [] };
+        InnerResource inner = new(expectedTemplate, expectedResource, expectedMetadata, expectedResult);
+
+        TestDelegatingResource delegating = new(inner);
+
+        Assert.Same(expectedTemplate, delegating.ProtocolResourceTemplate);
+        Assert.Same(expectedResource, delegating.ProtocolResource);
+        Assert.Same(expectedMetadata, delegating.Metadata);
+        Assert.True(delegating.IsMatch("test://resource"));
+        Assert.Same(expectedResult, await delegating.ReadAsync(null!, CancellationToken.None));
+        Assert.Equal(inner.ToString(), delegating.ToString());
+    }
+
+    [Fact]
+    public void OverridesAllVirtualAndAbstractMembers()
+    {
+        MethodInfo[] baseMethods = typeof(McpServerResource).GetMethods(BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly)
+            .Where(m => m.IsVirtual || m.IsAbstract)
+            .ToArray();
+
+        Assert.NotEmpty(baseMethods);
+
+        foreach (MethodInfo baseMethod in baseMethods)
+        {
+            Assert.True(
+                typeof(DelegatingMcpServerResource).GetMethods(BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly)
+                    .Any(m => m.Name == baseMethod.Name),
+                $"DelegatingMcpServerResource does not override {baseMethod.Name} from McpServerResource.");
+        }
+    }
+
+    private sealed class TestDelegatingResource(McpServerResource innerResource) : DelegatingMcpServerResource(innerResource);
+
+    private sealed class InnerResource(ResourceTemplate protocolResourceTemplate, Resource protocolResource, IReadOnlyList<object> metadata, ReadResourceResult result) : McpServerResource
+    {
+        public override ResourceTemplate ProtocolResourceTemplate => protocolResourceTemplate;
+        public override Resource? ProtocolResource => protocolResource;
+        public override IReadOnlyList<object> Metadata => metadata;
+        public override bool IsMatch(string uri) => true;
+        public override ValueTask<ReadResourceResult> ReadAsync(RequestContext<ReadResourceRequestParams> request, CancellationToken cancellationToken = default) => new(result);
+        public override string ToString() => "inner-resource";
+    }
+}