Elicitation extension methods to improve code readability and reduce potential string comparison errors

Author: dogukandemir

src/ModelContextProtocol.Core/ExtensionMethods/ElicitResultExtensions.cs

@@ -0,0 +1,45 @@
+using ModelContextProtocol.Protocol;
+
+namespace ModelContextProtocol.ExtensionMethods;
+
+/// <summary>
+/// Provides extension methods for interacting with an <see cref="ElicitResult"/> instance.
+/// </summary>
+public static class ElicitResultExtensions
+{
+    /// <summary>
+    /// Determines whether given <see cref="ElicitResult"/> represents an accepted action.
+    /// </summary>
+    /// <param name="result">Elicit result to check.</param>
+    /// <returns><see langword="true"/> if the action is "accept"; otherwise, <see langword="false"/>.</returns>
+    /// <exception cref="ArgumentNullException">Thrown when <paramref name="result"/> is <see langword="null"/>.</exception>
+    public static bool IsAccepted(this ElicitResult result)
+    {
+        Throw.IfNull(result);
+        return string.Equals(result.Action, "accept", StringComparison.OrdinalIgnoreCase);
+    }
+
+    /// <summary>
+    /// Determines whether given <see cref="ElicitResult"/> represents a declined action.
+    /// </summary>
+    /// <param name="result">Elicit result to check.</param>
+    /// <returns><see langword="true"/> if the action is "decline"; otherwise, <see langword="false"/>.</returns>
+    /// <exception cref="ArgumentNullException">Thrown when <paramref name="result"/> is <see langword="null"/>.</exception>
+    public static bool IsDeclined(this ElicitResult result)
+    {
+        Throw.IfNull(result);
+        return string.Equals(result.Action, "decline", StringComparison.OrdinalIgnoreCase);
+    }
+
+    /// <summary>
+    /// Determines whether given <see cref="ElicitResult"/> represents a cancelled action.
+    /// </summary>
+    /// <param name="result">Elicit result to check.</param>
+    /// <returns><see langword="true"/> if the action is "cancel"; otherwise, <see langword="false"/>.</returns>
+    /// <exception cref="ArgumentNullException">Thrown when <paramref name="result"/> is <see langword="null"/>.</exception>
+    public static bool IsCancelled(this ElicitResult result)
+    {
+        Throw.IfNull(result);
+        return string.Equals(result.Action, "cancel", StringComparison.OrdinalIgnoreCase);
+    }
+}

src/ModelContextProtocol.Core/Server/McpServerExtensions.cs

@@ -234,6 +234,23 @@ public static ValueTask<ElicitResult> ElicitAsync(
             cancellationToken: cancellationToken);
     }
 
+    /// <summary>
+    /// Determines whether client supports elicitation capability.
+    /// </summary>
+    /// <param name="server">McpServer instance to check.</param>
+    /// <returns>
+    /// <see langword="true"/> if client supports elicitation requests; otherwise, <see langword="false"/>.
+    /// </returns>
+    /// <exception cref="ArgumentNullException"><paramref name="server"/> is <see langword="null"/>.</exception>
+    /// <remarks>
+    /// When <see langword="true"/>, the server can call <see cref="McpServerExtensions.ElicitAsync"/> to request additional information from the user via the client.
+    /// </remarks>
+    public static bool SupportsElicitation(this IMcpServer server)
+    {
+        Throw.IfNull(server);
+        return server.ClientCapabilities?.Elicitation is not null;
+    }
+
     private static void ThrowIfSamplingUnsupported(IMcpServer server)
     {
         if (server.ClientCapabilities?.Sampling is null)

tests/ModelContextProtocol.Tests/ExtensionMethods/ElicitResultExtensionsTests.cs

@@ -0,0 +1,118 @@
+using ModelContextProtocol.ExtensionMethods;
+using ModelContextProtocol.Protocol;
+
+namespace ModelContextProtocol.Tests.ExtensionMethods;
+
+public class ElicitResultExtensionsTests
+{
+    [Fact]
+    public void IsAccepted_Throws_ArgumentNullException_If_Result_Is_Null()
+    {
+        // Arrange
+        ElicitResult? result = null;
+
+        // Act & Assert
+        Assert.Throws<ArgumentNullException>(() => result!.IsAccepted());
+    }
+
+    [Fact]
+    public void IsDeclined_Throws_ArgumentNullException_If_Result_Is_Null()
+    {
+        // Arrange
+        ElicitResult? result = null;
+
+        // Act & Assert
+        Assert.Throws<ArgumentNullException>(() => result!.IsDeclined());
+    }
+
+    [Fact]
+    public void IsCancelled_Throws_ArgumentNullException_If_Result_Is_Null()
+    {
+        // Arrange
+        ElicitResult? result = null;
+
+        // Act & Assert
+        Assert.Throws<ArgumentNullException>(() => result!.IsCancelled());
+    }
+
+    [Theory]
+    [InlineData("accept")]
+    [InlineData("ACCEPT")]
+    [InlineData("Accept")]
+    [InlineData("AccEpt")]
+    public void IsAccepted_Returns_True_For_VariousActions(string action)
+    {
+        // Arrange
+        var result = new ElicitResult { Action = action };
+
+        // Act & Assert
+        Assert.True(result.IsAccepted());
+    }
+
+    [Theory]
+    [InlineData("decline")]
+    [InlineData("cancel")]
+    [InlineData("unknown")]
+    public void IsAccepted_Returns_False_For_NonAcceptedActions(string action)
+    {
+        // Arrange
+        var result = new ElicitResult { Action = action };
+
+        // Act & Assert
+        Assert.False(result.IsAccepted());
+    }
+
+    [Theory]
+    [InlineData("accept")]
+    [InlineData("cancel")]
+    [InlineData("unknown")]
+    public void IsDeclined_Returns_False_For_NonDeclinedActions(string action)
+    {
+        // Arrange
+        var result = new ElicitResult { Action = action };
+
+        // Act & Assert
+        Assert.False(result.IsDeclined());
+    }
+
+    [Theory]
+    [InlineData("accept")]
+    [InlineData("decline")]
+    [InlineData("unknown")]
+    public void IsCancelled_Returns_False_For_NonCancelledActions(string action)
+    {
+        // Arrange
+        var result = new ElicitResult { Action = action };
+
+        // Act & Assert
+        Assert.False(result.IsCancelled());
+    }
+
+    [Theory]
+    [InlineData("decline")]
+    [InlineData("DECLINE")]
+    [InlineData("Decline")]
+    [InlineData("DecLine")]
+    public void IsDeclined_Returns_True_For_VariousActions(string action)
+    {
+        // Arrange
+        var result = new ElicitResult { Action = action };
+
+        // Act & Assert
+        Assert.True(result.IsDeclined());
+    }
+
+    [Theory]
+    [InlineData("cancel")]
+    [InlineData("CANCEL")]
+    [InlineData("Cancel")]
+    [InlineData("CanCel")]
+    public void IsCancelled_Returns_True_For_VariousActions(string action)
+    {
+        // Arrange
+        var result = new ElicitResult { Action = action };
+
+        // Act & Assert
+        Assert.True(result.IsCancelled());
+    }
+}

tests/ModelContextProtocol.Tests/Server/McpServerTests.cs

@@ -177,6 +177,31 @@ public async Task ElicitAsync_Should_Throw_Exception_If_Client_Does_Not_Support_
         await Assert.ThrowsAsync<InvalidOperationException>(async () => await server.ElicitAsync(new ElicitRequestParams(), CancellationToken.None));
     }
 
+    [Fact]
+    public void SupportsElicitation_Should_Throw_ArgumentNullException_If_Server_Is_Null()
+    {
+        // Arrange
+        IMcpServer? server = null;
+
+        // Act & Assert
+        Assert.Throws<ArgumentNullException>(() => server!.SupportsElicitation());
+    }
+
+    [Fact]
+    public async Task SupportsElicitation_Should_Return_False_If_ElicitationCapability_Is_Not_Set()
+    {
+        // Arrange
+        await using var transport = new TestServerTransport();
+        await using var server = McpServerFactory.Create(transport, _options, LoggerFactory);
+        SetClientCapabilities(server, new ClientCapabilities { Elicitation = null });
+
+        // Act
+        var supportsElicitation = server.SupportsElicitation();
+
+        // Assert
+        Assert.False(supportsElicitation);
+    }
+
     [Fact]
     public async Task ElicitAsync_Should_SendRequest()
     {