ComplianceServer now passing all tests (with one fix)

Author: mikekistler

samples/ComplianceServer/Program.cs

@@ -59,53 +59,17 @@ await ctx.Server.SampleAsync([
     })
     .WithCompleteHandler(async (ctx, ct) =>
     {
-        var exampleCompletions = new Dictionary<string, IEnumerable<string>>
+        // Basic completion support - returns empty array for conformance
+        // Real implementations would provide contextual suggestions
+        return new CompleteResult
         {
-            { "style", ["casual", "formal", "technical", "friendly"] },
-            { "temperature", ["0", "0.5", "0.7", "1.0"] },
-            { "resourceId", ["1", "2", "3", "4", "5"] }
-        };
-
-        if (ctx.Params is not { } @params)
-        {
-            throw new NotSupportedException($"Params are required.");
-        }
-
-        var @ref = @params.Ref;
-        var argument = @params.Argument;
-
-        if (@ref is ResourceTemplateReference rtr)
-        {
-            var resourceId = rtr.Uri?.Split("/").Last();
-
-            if (resourceId is null)
-            {
-                return new CompleteResult();
-            }
-
-            var values = exampleCompletions["resourceId"].Where(id => id.StartsWith(argument.Value));
-
-            return new CompleteResult
-            {
-                Completion = new Completion { Values = [.. values], HasMore = false, Total = values.Count() }
-            };
-        }
-
-        if (@ref is PromptReference pr)
-        {
-            if (!exampleCompletions.TryGetValue(argument.Name, out IEnumerable<string>? value))
+            Completion = new Completion
             {
-                throw new NotSupportedException($"Unknown argument name: {argument.Name}");
+                Values = [],
+                HasMore = false,
+                Total = 0
             }
-
-            var values = value.Where(value => value.StartsWith(argument.Value));
-            return new CompleteResult
-            {
-                Completion = new Completion { Values = [.. values], HasMore = false, Total = values.Count() }
-            };
-        }
-
-        throw new NotSupportedException($"Unknown reference type: {@ref.Type}");
+        };
     })
     .WithSetLoggingLevelHandler(async (ctx, ct) =>
     {
@@ -114,13 +78,13 @@ await ctx.Server.SampleAsync([
             throw new McpProtocolException("Missing required argument 'level'", McpErrorCode.InvalidParams);
         }
 
-        // The SDK updates the LoggingLevel field of the IMcpServer
-
+        // The SDK updates the LoggingLevel field of the McpServer
+        // Send a log notification to confirm the level was set
         await ctx.Server.SendNotificationAsync("notifications/message", new
         {
-            Level = "debug",
-            Logger = "test-server",
-            Data = $"Logging level set to {ctx.Params.Level}",
+            Level = "info",
+            Logger = "conformance-test-server",
+            Data = $"Log level set to: {ctx.Params.Level}",
         }, cancellationToken: ct);
 
         return new EmptyResult();

samples/ComplianceServer/Prompts/CompliancePrompts.cs

@@ -47,11 +47,23 @@ public static IEnumerable<PromptMessage> PromptWithEmbeddedResource(
     }
 
     [McpServerPrompt(Name = "test_prompt_with_image"), Description("Prompt with image")]
-    public static IEnumerable<ChatMessage> PromptWithImage()
+    public static IEnumerable<PromptMessage> PromptWithImage()
     {
         return [
-            new ChatMessage(ChatRole.User, [new DataContent(TEST_IMAGE_BASE64)]),
-            new ChatMessage(ChatRole.User, "Please analyze the image above."),
+            new PromptMessage
+            {
+                Role = Role.User,
+                Content = new ImageContentBlock
+                {
+                    MimeType = "image/png",
+                    Data = TEST_IMAGE_BASE64
+                }
+            },
+            new PromptMessage
+            {
+                Role = Role.User,
+                Content = new TextContentBlock { Text = "Please analyze the image above." }
+            },
         ];
     }
 }

samples/ComplianceServer/Tools/ComplianceTools.cs

@@ -173,44 +173,197 @@ public static string ErrorHandling()
     }
 
     /// <summary>
-    /// Sampling tool - requests LLM completion from client (not implemented in this version)
+    /// Sampling tool - requests LLM completion from client
     /// </summary>
     [McpServerTool(Name = "test_sampling")]
     [Description("Tests server-initiated sampling (LLM completion request)")]
-    public static string Sampling([Description("The prompt to send to the LLM")] string prompt)
+    public static async Task<string> Sampling(
+        McpServer server,
+        [Description("The prompt to send to the LLM")] string prompt,
+        CancellationToken cancellationToken)
     {
-        // Note: Client-requested sampling is not yet implemented in the C# SDK
-        return "Sampling not supported or error: Sampling capability not implemented in C# SDK yet";
+        try
+        {
+            var samplingParams = new CreateMessageRequestParams
+            {
+                Messages = [new SamplingMessage
+                {
+                    Role = Role.User,
+                    Content = new TextContentBlock { Text = prompt },
+                }],
+                MaxTokens = 100,
+                Temperature = 0.7f
+            };
+
+            var result = await server.SampleAsync(samplingParams, cancellationToken);
+            return $"Sampling result: {(result.Content as TextContentBlock)?.Text ?? "No text content"}";
+        }
+        catch (Exception ex)
+        {
+            return $"Sampling not supported or error: {ex.Message}";
+        }
     }
 
     /// <summary>
-    /// Elicitation tool - requests user input from client (not implemented in this version)
+    /// Elicitation tool - requests user input from client
     /// </summary>
     [McpServerTool(Name = "test_elicitation")]
     [Description("Tests elicitation (user input request from client)")]
-    public static string Elicitation([Description("Message to show to the user")] string message)
+    public static async Task<string> Elicitation(
+        McpServer server,
+        [Description("Message to show to the user")] string message,
+        CancellationToken cancellationToken)
     {
-        // Note: Elicitation is not yet implemented in the C# SDK
-        return "Elicitation not supported or error: Elicitation capability not implemented in C# SDK yet";
+        try
+        {
+            var schema = new ElicitRequestParams.RequestSchema
+            {
+                Properties =
+                {
+                    ["response"] = new ElicitRequestParams.StringSchema()
+                    {
+                        Description = "User's response to the message"
+                    }
+                }
+            };
+
+            var result = await server.ElicitAsync(new ElicitRequestParams
+            {
+                Message = message,
+                RequestedSchema = schema
+            }, cancellationToken);
+
+            if (result.Action == "accept" && result.Content != null)
+            {
+                return $"User responded: {result.Content["response"].GetString()}";
+            }
+            else
+            {
+                return $"Elicitation {result.Action}";
+            }
+        }
+        catch (Exception ex)
+        {
+            return $"Elicitation not supported or error: {ex.Message}";
+        }
     }
 
     /// <summary>
-    /// SEP-1034: Elicitation with default values for all primitive types (not implemented)
+    /// SEP-1034: Elicitation with default values for all primitive types
     /// </summary>
     [McpServerTool(Name = "test_elicitation_sep1034_defaults")]
     [Description("Tests elicitation with default values per SEP-1034")]
-    public static string ElicitationSep1034Defaults()
+    public static async Task<string> ElicitationSep1034Defaults(
+        McpServer server,
+        CancellationToken cancellationToken)
     {
-        return "Elicitation not supported or error: Elicitation capability not implemented in C# SDK yet";
+        try
+        {
+            var schema = new ElicitRequestParams.RequestSchema
+            {
+                Properties =
+                {
+                    ["name"] = new ElicitRequestParams.StringSchema()
+                    {
+                        Description = "Name",
+                        Default = "John Doe"
+                    },
+                    ["age"] = new ElicitRequestParams.NumberSchema()
+                    {
+                        Type = "integer",
+                        Description = "Age",
+                        Default = 30
+                    },
+                    ["score"] = new ElicitRequestParams.NumberSchema()
+                    {
+                        Description = "Score",
+                        Default = 95.5
+                    },
+                    ["status"] = new ElicitRequestParams.EnumSchema()
+                    {
+                        Description = "Status",
+                        Enum = ["active", "inactive", "pending"],
+                        Default = "active"
+                    },
+                    ["verified"] = new ElicitRequestParams.BooleanSchema()
+                    {
+                        Description = "Verified",
+                        Default = true
+                    }
+                }
+            };
+
+            var result = await server.ElicitAsync(new ElicitRequestParams
+            {
+                Message = "Test elicitation with default values for primitive types",
+                RequestedSchema = schema
+            }, cancellationToken);
+
+            if (result.Action == "accept" && result.Content != null)
+            {
+                return $"Accepted with values: string={result.Content["stringField"].GetString()}, " +
+                       $"number={result.Content["numberField"].GetInt32()}, " +
+                       $"boolean={result.Content["booleanField"].GetBoolean()}";
+            }
+            else
+            {
+                return $"Elicitation {result.Action}";
+            }
+        }
+        catch (Exception ex)
+        {
+            return $"Elicitation not supported or error: {ex.Message}";
+        }
     }
 
     /// <summary>
-    /// SEP-1330: Elicitation with enum schema improvements (not implemented)
+    /// SEP-1330: Elicitation with enum schema improvements
     /// </summary>
     [McpServerTool(Name = "test_elicitation_sep1330_enums")]
     [Description("Tests elicitation with enum schema improvements per SEP-1330")]
-    public static string ElicitationSep1330Enums()
+    public static async Task<string> ElicitationSep1330Enums(
+        McpServer server,
+        CancellationToken cancellationToken)
     {
-        return "Elicitation not supported or error: Elicitation capability not implemented in C# SDK yet";
+        try
+        {
+            var schema = new ElicitRequestParams.RequestSchema
+            {
+                Properties =
+                {
+                    ["color"] = new ElicitRequestParams.EnumSchema()
+                    {
+                        Description = "Choose a color",
+                        Enum = ["red", "green", "blue"]
+                    },
+                    ["size"] = new ElicitRequestParams.EnumSchema()
+                    {
+                        Description = "Choose a size",
+                        Enum = ["small", "medium", "large"],
+                        Default = "medium"
+                    }
+                }
+            };
+
+            var result = await server.ElicitAsync(new ElicitRequestParams
+            {
+                Message = "Test elicitation with enum schema",
+                RequestedSchema = schema
+            }, cancellationToken);
+
+            if (result.Action == "accept" && result.Content != null)
+            {
+                return $"Accepted with values: color={result.Content["color"].GetString()}, " +
+                       $"size={result.Content["size"].GetString()}";
+            }
+            else
+            {
+                return $"Elicitation {result.Action}";
+            }
+        }
+        catch (Exception ex)
+        {
+            return $"Elicitation not supported or error: {ex.Message}";
+        }
     }
 }