Add MCP endpoint for audit and failed messages

src/Directory.Packages.props

@@ -82,6 +82,7 @@
     <PackageVersion Include="System.Reflection.MetadataLoadContext" Version="10.0.5" />
     <PackageVersion Include="System.ServiceProcess.ServiceController" Version="10.0.5" />
     <PackageVersion Include="Validar.Fody" Version="1.9.0" />
+    <PackageVersion Include="ModelContextProtocol.AspNetCore" Version="1.1.0" />
     <PackageVersion Include="Yarp.ReverseProxy" Version="2.3.0" />
   </ItemGroup>
   <ItemGroup Label="Versions to pin transitive references">

src/ServiceControl.AcceptanceTesting/Mcp/McpAcceptanceJsonContext.cs

@@ -0,0 +1,15 @@
+namespace ServiceControl.AcceptanceTesting.Mcp;
+
+using System.Collections.Generic;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+[JsonSourceGenerationOptions(
+    PropertyNamingPolicy = JsonKnownNamingPolicy.CamelCase,
+    DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull,
+    WriteIndented = true)]
+[JsonSerializable(typeof(List<JsonElement>))]
+[JsonSerializable(typeof(McpListToolsResponse))]
+[JsonSerializable(typeof(McpCallToolResponse))]
+[JsonSerializable(typeof(McpInitializeResponse))]
+public partial class McpAcceptanceJsonContext : JsonSerializerContext;

src/ServiceControl.AcceptanceTesting/Mcp/McpAcceptanceTestSupport.cs

@@ -0,0 +1,194 @@
+namespace ServiceControl.AcceptanceTesting.Mcp;
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net.Http;
+using System.Net.Http.Json;
+using System.Text.Json;
+using System.Threading.Tasks;
+using NUnit.Framework;
+
+public static class McpAcceptanceTestSupport
+{
+    const string RequestedProtocolVersion = "2025-11-25";
+
+    public static async Task<HttpResponseMessage> InitializeMcpSession(HttpClient httpClient)
+    {
+        var request = new HttpRequestMessage(HttpMethod.Post, "/mcp")
+        {
+            Content = JsonContent.Create(new
+            {
+                jsonrpc = "2.0",
+                id = 1,
+                method = "initialize",
+                @params = new
+                {
+                    protocolVersion = RequestedProtocolVersion,
+                    capabilities = new { },
+                    clientInfo = new { name = "test-client", version = "1.0" }
+                }
+            })
+        };
+        request.Headers.Accept.Add(new System.Net.Http.Headers.MediaTypeWithQualityHeaderValue("application/json"));
+        request.Headers.Accept.Add(new System.Net.Http.Headers.MediaTypeWithQualityHeaderValue("text/event-stream"));
+        request.Headers.Add("MCP-Protocol-Version", RequestedProtocolVersion);
+        return await httpClient.SendAsync(request);
+    }
+
+    public static async Task<McpSessionInfo> InitializeAndGetSessionInfo(HttpClient httpClient)
+    {
+        var response = await InitializeMcpSession(httpClient);
+        if (!response.IsSuccessStatusCode)
+        {
+            return null;
+        }
+
+        var initializeResponse = JsonSerializer.Deserialize(await ReadMcpResponseJson(response), McpAcceptanceJsonContext.Default.McpInitializeResponse)!;
+        var protocolVersion = initializeResponse.Result.ProtocolVersion;
+
+        if (!response.Headers.TryGetValues("mcp-session-id", out var values))
+        {
+            return null;
+        }
+
+        var sessionId = values.FirstOrDefault();
+        if (sessionId == null)
+        {
+            return null;
+        }
+
+        var initializedResponse = await SendInitializedNotification(httpClient, sessionId, protocolVersion);
+        if (!initializedResponse.IsSuccessStatusCode)
+        {
+            return null;
+        }
+
+        return new McpSessionInfo(sessionId, protocolVersion);
+    }
+
+    public static async Task<HttpResponseMessage> SendMcpRequest(HttpClient httpClient, McpSessionInfo sessionInfo, string method, object @params)
+    {
+        var request = new HttpRequestMessage(HttpMethod.Post, "/mcp")
+        {
+            Content = JsonContent.Create(new
+            {
+                jsonrpc = "2.0",
+                id = 2,
+                method,
+                @params
+            })
+        };
+        request.Headers.Accept.Add(new System.Net.Http.Headers.MediaTypeWithQualityHeaderValue("application/json"));
+        request.Headers.Accept.Add(new System.Net.Http.Headers.MediaTypeWithQualityHeaderValue("text/event-stream"));
+        request.Headers.Add("mcp-session-id", sessionInfo.SessionId);
+        request.Headers.Add("MCP-Protocol-Version", sessionInfo.ProtocolVersion);
+        return await httpClient.SendAsync(request);
+    }
+
+    public static async Task<string> ReadMcpResponseJson(HttpResponseMessage response)
+    {
+        var body = await response.Content.ReadAsStringAsync();
+        var contentType = response.Content.Headers.ContentType?.MediaType;
+
+        if (contentType == "text/event-stream")
+        {
+            foreach (var line in body.Split('\n'))
+            {
+                if (line.StartsWith("data: "))
+                {
+                    return line.Substring("data: ".Length);
+                }
+            }
+        }
+
+        return body;
+    }
+
+    public static McpListToolsResponse DeserializeListToolsResponse(string toolsJson) =>
+        JsonSerializer.Deserialize(toolsJson, McpAcceptanceJsonContext.Default.McpListToolsResponse)!;
+
+    public static McpCallToolResponse DeserializeCallToolResponse(string toolResult) =>
+        JsonSerializer.Deserialize(toolResult, McpAcceptanceJsonContext.Default.McpCallToolResponse)!;
+
+    public static string FormatToolsForApproval(List<JsonElement> sortedTools) =>
+        JsonSerializer.Serialize(sortedTools, McpAcceptanceJsonContext.Default.ListJsonElement);
+
+    public static void AssertToolsHaveOutputSchema(IEnumerable<JsonElement> tools)
+    {
+        foreach (var tool in tools)
+        {
+            Assert.That(tool.TryGetProperty("outputSchema", out var outputSchema), Is.True, $"Tool '{tool.GetProperty("name").GetString()}' should expose outputSchema.");
+            Assert.That(outputSchema.ValueKind, Is.EqualTo(JsonValueKind.Object), $"Tool '{tool.GetProperty("name").GetString()}' should expose object outputSchema.");
+        }
+    }
+
+    public static void AssertStructuredToolResponse(string rawResponse, JsonElement structuredContent, IReadOnlyList<McpContent> content, Action<JsonElement> assertStructuredContent)
+    {
+        Assert.That(structuredContent.ValueKind, Is.EqualTo(JsonValueKind.Object), rawResponse);
+        assertStructuredContent(structuredContent);
+
+        Assert.That(content, Has.Count.GreaterThanOrEqualTo(1), rawResponse);
+        Assert.That(content[0].Type, Is.EqualTo("text"), rawResponse);
+        Assert.That(content[0].Text, Is.Not.Null.And.Not.Empty, rawResponse);
+
+        using var textPayload = JsonDocument.Parse(content[0].Text);
+        Assert.That(JsonElement.DeepEquals(structuredContent, textPayload.RootElement), Is.True, $"text content should serialize the structured payload. Raw response: {rawResponse}");
+    }
+
+    static async Task<HttpResponseMessage> SendInitializedNotification(HttpClient httpClient, string sessionId, string protocolVersion)
+    {
+        var request = new HttpRequestMessage(HttpMethod.Post, "/mcp")
+        {
+            Content = JsonContent.Create(new
+            {
+                jsonrpc = "2.0",
+                method = "notifications/initialized"
+            })
+        };
+        request.Headers.Accept.Add(new System.Net.Http.Headers.MediaTypeWithQualityHeaderValue("application/json"));
+        request.Headers.Accept.Add(new System.Net.Http.Headers.MediaTypeWithQualityHeaderValue("text/event-stream"));
+        request.Headers.Add("mcp-session-id", sessionId);
+        request.Headers.Add("MCP-Protocol-Version", protocolVersion);
+        return await httpClient.SendAsync(request);
+    }
+}
+
+public record McpSessionInfo(string SessionId, string ProtocolVersion);
+
+public class McpListToolsResponse
+{
+    public McpListToolsResult Result { get; set; }
+}
+
+public class McpListToolsResult
+{
+    public List<object> Tools { get; set; } = [];
+}
+
+public class McpCallToolResponse
+{
+    public McpCallToolResult Result { get; set; }
+}
+
+public class McpCallToolResult
+{
+    public JsonElement StructuredContent { get; set; }
+    public List<McpContent> Content { get; set; } = [];
+}
+
+public class McpContent
+{
+    public string Type { get; set; }
+    public string Text { get; set; }
+}
+
+public class McpInitializeResponse
+{
+    public McpInitializeResult Result { get; set; }
+}
+
+public class McpInitializeResult
+{
+    public string ProtocolVersion { get; set; }
+}

src/ServiceControl.AcceptanceTesting/ServiceControl.AcceptanceTesting.csproj

@@ -18,7 +18,8 @@
     <PackageReference Include="NServiceBus.AcceptanceTesting" />
     <PackageReference Include="NServiceBus.Extensions.Logging" />
     <PackageReference Include="NServiceBus.Persistence.NonDurable" />
+    <PackageReference Include="NUnit" />
     <PackageReference Include="System.IdentityModel.Tokens.Jwt" />
   </ItemGroup>
 
-</Project>
+</Project>