From 79b2dbeb20839f86c7c54a6d90a768d42b54bb6c Mon Sep 17 00:00:00 2001 From: Copilot <198982749+Copilot@users.noreply.github.com> Date: Sat, 21 Feb 2026 00:36:30 -0500 Subject: [PATCH] Fix Metadata delegation in DelegatingMcpServerTool/Prompt/Resource (#1338) Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com> Co-authored-by: stephentoub <2642209+stephentoub@users.noreply.github.com> Co-authored-by: jeffhandley <1031940+jeffhandley@users.noreply.github.com> --- .../Server/DelegatingMcpServerPrompt.cs | 3 + .../Server/DelegatingMcpServerResource.cs | 3 + .../Server/DelegatingMcpServerTool.cs | 3 + .../Server/DelegatingMcpServerPromptTests.cs | 58 +++++++++++++++++ .../DelegatingMcpServerResourceTests.cs | 63 +++++++++++++++++++ .../Server/DelegatingMcpServerToolTests.cs | 58 +++++++++++++++++ 6 files changed, 188 insertions(+) create mode 100644 tests/ModelContextProtocol.Tests/Server/DelegatingMcpServerPromptTests.cs create mode 100644 tests/ModelContextProtocol.Tests/Server/DelegatingMcpServerResourceTests.cs create mode 100644 tests/ModelContextProtocol.Tests/Server/DelegatingMcpServerToolTests.cs diff --git a/src/ModelContextProtocol.Core/Server/DelegatingMcpServerPrompt.cs b/src/ModelContextProtocol.Core/Server/DelegatingMcpServerPrompt.cs index 9fc4b57..b652efd 100644 --- a/src/ModelContextProtocol.Core/Server/DelegatingMcpServerPrompt.cs +++ b/src/ModelContextProtocol.Core/Server/DelegatingMcpServerPrompt.cs @@ -23,6 +23,9 @@ public abstract class DelegatingMcpServerPrompt : McpServerPrompt /// public override Prompt ProtocolPrompt => _innerPrompt.ProtocolPrompt; + /// + public override IReadOnlyList Metadata => _innerPrompt.Metadata; + /// public override ValueTask GetAsync( RequestContext request, diff --git a/src/ModelContextProtocol.Core/Server/DelegatingMcpServerResource.cs b/src/ModelContextProtocol.Core/Server/DelegatingMcpServerResource.cs index 3058878..565f3e1 100644 --- a/src/ModelContextProtocol.Core/Server/DelegatingMcpServerResource.cs +++ b/src/ModelContextProtocol.Core/Server/DelegatingMcpServerResource.cs @@ -26,6 +26,9 @@ public abstract class DelegatingMcpServerResource : McpServerResource /// public override ResourceTemplate ProtocolResourceTemplate => _innerResource.ProtocolResourceTemplate; + /// + public override IReadOnlyList Metadata => _innerResource.Metadata; + /// public override bool IsMatch(string uri) => _innerResource.IsMatch(uri); diff --git a/src/ModelContextProtocol.Core/Server/DelegatingMcpServerTool.cs b/src/ModelContextProtocol.Core/Server/DelegatingMcpServerTool.cs index cd14664..7759300 100644 --- a/src/ModelContextProtocol.Core/Server/DelegatingMcpServerTool.cs +++ b/src/ModelContextProtocol.Core/Server/DelegatingMcpServerTool.cs @@ -23,6 +23,9 @@ public abstract class DelegatingMcpServerTool : McpServerTool /// public override Tool ProtocolTool => _innerTool.ProtocolTool; + /// + public override IReadOnlyList Metadata => _innerTool.Metadata; + /// public override ValueTask InvokeAsync( RequestContext request, diff --git a/tests/ModelContextProtocol.Tests/Server/DelegatingMcpServerPromptTests.cs b/tests/ModelContextProtocol.Tests/Server/DelegatingMcpServerPromptTests.cs new file mode 100644 index 0000000..3019e58 --- /dev/null +++ b/tests/ModelContextProtocol.Tests/Server/DelegatingMcpServerPromptTests.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("innerPrompt", () => new TestDelegatingPrompt(null!)); + } + + [Fact] + public async Task AllMembers_DelegateToInnerPrompt() + { + Prompt expectedPrompt = new() { Name = "sentinel-prompt" }; + IReadOnlyList 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 metadata, GetPromptResult result) : McpServerPrompt + { + public override Prompt ProtocolPrompt => protocolPrompt; + public override IReadOnlyList Metadata => metadata; + public override ValueTask GetAsync(RequestContext request, CancellationToken cancellationToken = default) => new(result); + public override string ToString() => "inner-prompt"; + } +} diff --git a/tests/ModelContextProtocol.Tests/Server/DelegatingMcpServerResourceTests.cs b/tests/ModelContextProtocol.Tests/Server/DelegatingMcpServerResourceTests.cs new file mode 100644 index 0000000..53278a0 --- /dev/null +++ b/tests/ModelContextProtocol.Tests/Server/DelegatingMcpServerResourceTests.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("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 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 metadata, ReadResourceResult result) : McpServerResource + { + public override ResourceTemplate ProtocolResourceTemplate => protocolResourceTemplate; + public override Resource? ProtocolResource => protocolResource; + public override IReadOnlyList Metadata => metadata; + public override bool IsMatch(string uri) => true; + public override ValueTask ReadAsync(RequestContext request, CancellationToken cancellationToken = default) => new(result); + public override string ToString() => "inner-resource"; + } +} diff --git a/tests/ModelContextProtocol.Tests/Server/DelegatingMcpServerToolTests.cs b/tests/ModelContextProtocol.Tests/Server/DelegatingMcpServerToolTests.cs new file mode 100644 index 0000000..8f453c1 --- /dev/null +++ b/tests/ModelContextProtocol.Tests/Server/DelegatingMcpServerToolTests.cs @@ -0,0 +1,58 @@ +using ModelContextProtocol.Protocol; +using ModelContextProtocol.Server; +using System.Reflection; + +namespace ModelContextProtocol.Tests.Server; + +public class DelegatingMcpServerToolTests +{ + [Fact] + public void Ctor_NullInnerTool_Throws() + { + Assert.Throws("innerTool", () => new TestDelegatingTool(null!)); + } + + [Fact] + public async Task AllMembers_DelegateToInnerTool() + { + Tool expectedTool = new() { Name = "sentinel-tool" }; + IReadOnlyList expectedMetadata = new object[] { "m1" }; + CallToolResult expectedResult = new() { Content = [] }; + InnerTool inner = new(expectedTool, expectedMetadata, expectedResult); + + TestDelegatingTool delegating = new(inner); + + Assert.Same(expectedTool, delegating.ProtocolTool); + Assert.Same(expectedMetadata, delegating.Metadata); + Assert.Same(expectedResult, await delegating.InvokeAsync(null!, CancellationToken.None)); + Assert.Equal(inner.ToString(), delegating.ToString()); + } + + [Fact] + public void OverridesAllVirtualAndAbstractMembers() + { + MethodInfo[] baseMethods = typeof(McpServerTool).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(DelegatingMcpServerTool).GetMethods(BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly) + .Any(m => m.Name == baseMethod.Name), + $"DelegatingMcpServerTool does not override {baseMethod.Name} from McpServerTool."); + } + } + + private sealed class TestDelegatingTool(McpServerTool innerTool) : DelegatingMcpServerTool(innerTool); + + private sealed class InnerTool(Tool protocolTool, IReadOnlyList metadata, CallToolResult result) : McpServerTool + { + public override Tool ProtocolTool => protocolTool; + public override IReadOnlyList Metadata => metadata; + public override ValueTask InvokeAsync(RequestContext request, CancellationToken cancellationToken = default) => new(result); + public override string ToString() => "inner-tool"; + } +}