Echo request id in post-parse Streamable HTTP error responses (modelcontextprotocol#1687)

tarekgh · Tarek Mahmoud Sayed · web-flow · commit e23be1d75ef4 · 2026-07-02T11:09:05.000-07:00
Co-authored-by: Tarek Mahmoud Sayed &lt;tarekms@ntdev.microsoft.com&gt;
diff --git a/src/ModelContextProtocol.AspNetCore/StreamableHttpHandler.cs b/src/ModelContextProtocol.AspNetCore/StreamableHttpHandler.cs
@@ -106,13 +106,18 @@ await WriteJsonRpcErrorAsync(context,
             return;
         }
 
+        // Once the body has been parsed into a request with a readable id, every JSON-RPC error response
+        // for this request MUST echo that id (base protocol responses section; SEP-2243 error format).
+        // Notifications carry no id, so this stays default (null), which is correct.
+        var requestId = message is JsonRpcRequest jsonRpcRequest ? jsonRpcRequest.Id : default;
+
         if (!ValidateMcpHeaders(context, message, mcpServerOptionsSnapshot.Value.ToolCollection, out var errorMessage))
         {
-            await WriteJsonRpcErrorAsync(context, errorMessage, StatusCodes.Status400BadRequest, (int)McpErrorCode.HeaderMismatch);
+            await WriteJsonRpcErrorAsync(context, errorMessage, StatusCodes.Status400BadRequest, (int)McpErrorCode.HeaderMismatch, requestId);
             return;
         }
 
-        var session = await GetOrCreateSessionAsync(context, message);
+        var session = await GetOrCreateSessionAsync(context, message, requestId);
         if (session is null)
         {
             return;
@@ -286,15 +291,15 @@ await WriteJsonRpcErrorAsync(context,
         }
     }
 
-    private async ValueTask<StreamableHttpSession?> GetSessionAsync(HttpContext context, string sessionId)
+    private async ValueTask<StreamableHttpSession?> GetSessionAsync(HttpContext context, string sessionId, RequestId requestId = default)
     {
         if (string.IsNullOrEmpty(sessionId))
         {
             await WriteJsonRpcErrorAsync(context,
                 "Bad Request: Mcp-Session-Id header is required for GET and DELETE requests when the server is using sessions. " +
                 "If your server doesn't need sessions, enable stateless mode by setting HttpServerTransportOptions.Stateless = true. " +
                 "See https://csharp.sdk.modelcontextprotocol.io/concepts/stateless/stateless.html for more details.",
-                StatusCodes.Status400BadRequest);
+                StatusCodes.Status400BadRequest, requestId: requestId);
             return null;
         }
 
@@ -309,7 +314,7 @@ await WriteJsonRpcErrorAsync(context,
                 // One of the few other usages I found was from some Ethereum JSON-RPC documentation and this
                 // JSON-RPC library from Microsoft called StreamJsonRpc where it's called JsonRpcErrorCode.NoMarshaledObjectFound
                 // https://learn.microsoft.com/dotnet/api/streamjsonrpc.protocol.jsonrpcerrorcode?view=streamjsonrpc-2.9#fields
-                await WriteJsonRpcErrorAsync(context, "Session not found", StatusCodes.Status404NotFound, -32001);
+                await WriteJsonRpcErrorAsync(context, "Session not found", StatusCodes.Status404NotFound, -32001, requestId);
                 return null;
             }
         }
@@ -318,7 +323,7 @@ await WriteJsonRpcErrorAsync(context,
         {
             await WriteJsonRpcErrorAsync(context,
                 "Forbidden: The currently authenticated user does not match the user who initiated the session.",
-                StatusCodes.Status403Forbidden);
+                StatusCodes.Status403Forbidden, requestId: requestId);
             return null;
         }
 
@@ -367,7 +372,7 @@ await WriteJsonRpcErrorAsync(context,
         }
     }
 
-    private async ValueTask<StreamableHttpSession?> GetOrCreateSessionAsync(HttpContext context, JsonRpcMessage message)
+    private async ValueTask<StreamableHttpSession?> GetOrCreateSessionAsync(HttpContext context, JsonRpcMessage message, RequestId requestId = default)
     {
         var sessionId = context.Request.Headers[McpSessionIdHeaderName].ToString();
 
@@ -380,7 +385,7 @@ await WriteJsonRpcErrorAsync(context,
                 // A request carrying an Mcp-Session-Id is non-conformant under the 2026-07-28 revision (SEP-2567).
                 await WriteJsonRpcErrorAsync(context,
                     "Bad Request: Mcp-Session-Id is not supported by the 2026-07-28 and later protocol revisions (SEP-2567).",
-                    StatusCodes.Status400BadRequest);
+                    StatusCodes.Status400BadRequest, requestId: requestId);
                 return null;
             }
 
@@ -389,7 +394,7 @@ await WriteJsonRpcErrorAsync(context,
                 // The author explicitly opted into sessions (Stateless = false), which the 2026-07-28
                 // revision cannot provide. Refuse it so a dual-era client falls back to the legacy
                 // initialize handshake and gets the session it asked for (SEP-2575 fallback semantics).
-                await WriteUnsupportedProtocolVersionErrorAsync(context);
+                await WriteUnsupportedProtocolVersionErrorAsync(context, requestId);
                 return null;
             }
 
@@ -408,7 +413,7 @@ await WriteJsonRpcErrorAsync(context,
                     "Bad Request: A new session can only be created by an initialize request. Include a valid Mcp-Session-Id header for non-initialize requests, " +
                     "or enable stateless mode by setting HttpServerTransportOptions.Stateless = true if your server doesn't need sessions. " +
                     "See https://csharp.sdk.modelcontextprotocol.io/concepts/stateless/stateless.html for more details.",
-                    StatusCodes.Status400BadRequest);
+                    StatusCodes.Status400BadRequest, requestId: requestId);
                 return null;
             }
 
@@ -418,12 +423,12 @@ await WriteJsonRpcErrorAsync(context,
         {
             // In stateless mode, we should not be getting existing sessions via sessionId
             // This path should not be reached in stateless mode
-            await WriteJsonRpcErrorAsync(context, "Bad Request: The Mcp-Session-Id header is not supported in stateless mode", StatusCodes.Status400BadRequest);
+            await WriteJsonRpcErrorAsync(context, "Bad Request: The Mcp-Session-Id header is not supported in stateless mode", StatusCodes.Status400BadRequest, requestId: requestId);
             return null;
         }
         else
         {
-            return await GetSessionAsync(context, sessionId);
+            return await GetSessionAsync(context, sessionId, requestId);
         }
     }
 
@@ -568,10 +573,11 @@ await WriteJsonRpcErrorAsync(context,
         return eventStreamReader;
     }
 
-    private static Task WriteJsonRpcErrorAsync(HttpContext context, string errorMessage, int statusCode, int errorCode = -32000)
+    private static Task WriteJsonRpcErrorAsync(HttpContext context, string errorMessage, int statusCode, int errorCode = -32000, RequestId requestId = default)
     {
         var jsonRpcError = new JsonRpcError
         {
+            Id = requestId,
             Error = new()
             {
                 Code = errorCode,
@@ -691,7 +697,7 @@ private static bool ValidateProtocolVersionHeader(HttpContext context, [NotNullW
     /// that excludes 2026-07-28 and later. A dual-era client then falls back to the legacy initialize handshake
     /// (SEP-2575).
     /// </summary>
-    private static Task WriteUnsupportedProtocolVersionErrorAsync(HttpContext context)
+    private static Task WriteUnsupportedProtocolVersionErrorAsync(HttpContext context, RequestId requestId = default)
     {
         var requestedProtocolVersion = context.Request.Headers[McpProtocolVersionHeaderName].ToString();
         var errorDetail = new JsonRpcErrorDetail
@@ -708,7 +714,7 @@ private static Task WriteUnsupportedProtocolVersionErrorAsync(HttpContext contex
                 GetRequiredJsonTypeInfo<UnsupportedProtocolVersionErrorData>()),
         };
 
-        return WriteJsonRpcErrorDetailAsync(context, errorDetail, StatusCodes.Status400BadRequest);
+        return WriteJsonRpcErrorDetailAsync(context, errorDetail, StatusCodes.Status400BadRequest, requestId);
     }
 
     /// <summary>
@@ -1150,9 +1156,9 @@ private static SafeIntegerParse ParseSafeInteger(string text, out long value)
         return SafeIntegerParse.NotNumeric;
     }
 
-    private static Task WriteJsonRpcErrorDetailAsync(HttpContext context, JsonRpcErrorDetail detail, int statusCode)
+    private static Task WriteJsonRpcErrorDetailAsync(HttpContext context, JsonRpcErrorDetail detail, int statusCode, RequestId requestId = default)
     {
-        var jsonRpcError = new JsonRpcError { Error = detail };
+        var jsonRpcError = new JsonRpcError { Id = requestId, Error = detail };
         return Results.Json(jsonRpcError, s_errorTypeInfo, statusCode: statusCode).ExecuteAsync(context);
     }
 
diff --git a/tests/ModelContextProtocol.AspNetCore.Tests/RawHttpConformanceTests.cs b/tests/ModelContextProtocol.AspNetCore.Tests/RawHttpConformanceTests.cs
@@ -174,7 +174,7 @@ public async Task July2026Post_ProtocolVersionHeaderMetaMismatch_ReturnsHeaderMi
         // checks) so a conformant client on this revision surfaces the error instead of mistaking the modern server for a
         // legacy one and falling back to the initialize handshake.
         var body =
-            @"{""jsonrpc"":""2.0"",""id"":1,""method"":""server/discover"",""params"":{" +
+            @"{""jsonrpc"":""2.0"",""id"":4242,""method"":""server/discover"",""params"":{" +
             July2026ProtocolMetaFragment("2025-11-25") + "}}";
 
         using var request = new HttpRequestMessage(HttpMethod.Post, "") { Content = JsonContent(body) };
@@ -184,6 +184,33 @@ public async Task July2026Post_ProtocolVersionHeaderMetaMismatch_ReturnsHeaderMi
 
         var json = await ReadJsonResponseAsync(response, TestContext.Current.CancellationToken);
         Assert.Equal((int)McpErrorCode.HeaderMismatch, json["error"]!["code"]!.GetValue<int>());
+
+        // The body parsed successfully, so per the base protocol responses section (and SEP-2243's error
+        // response format) this error MUST echo the request id rather than emitting id=null (see #1677).
+        Assert.Equal(4242, json["id"]!.GetValue<long>());
+    }
+
+    [Fact]
+    public async Task July2026Post_MissingMcpNameHeader_ReturnsHeaderMismatch_EchoesRequestId()
+    {
+        await StartAsync();
+
+        // A well-formed tools/call whose body parses, but the required Mcp-Name header is absent. The server
+        // rejects it with -32020 HeaderMismatch, and because the request id was readable the JSON-RPC error
+        // MUST carry that same id (regression guard for #1677).
+        var body =
+            @"{""jsonrpc"":""2.0"",""id"":4242,""method"":""tools/call"",""params"":{""name"":""echo"",""arguments"":{""text"":""hi""}," +
+            July2026ProtocolMetaFragment() + "}}";
+
+        using var request = new HttpRequestMessage(HttpMethod.Post, "") { Content = JsonContent(body) };
+        request.Headers.Add(ProtocolVersionHeader, McpHttpHeaders.July2026ProtocolVersion);
+        request.Headers.Add("Mcp-Method", "tools/call");
+        using var response = await HttpClient.SendAsync(request, TestContext.Current.CancellationToken);
+
+        Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);
+        var json = await ReadJsonResponseAsync(response, TestContext.Current.CancellationToken);
+        Assert.Equal((int)McpErrorCode.HeaderMismatch, json["error"]!["code"]!.GetValue<int>());
+        Assert.Equal(4242, json["id"]!.GetValue<long>());
     }
 
     [Fact]
diff --git a/tests/ModelContextProtocol.AspNetCore.Tests/StreamableHttpServerConformanceTests.cs b/tests/ModelContextProtocol.AspNetCore.Tests/StreamableHttpServerConformanceTests.cs
@@ -224,14 +224,19 @@ public async Task PostRequest_IsNotFound_WithUnrecognizedSessionId()
 
         using var request = new HttpRequestMessage(HttpMethod.Post, "")
         {
-            Content = JsonContent(EchoRequest),
+            Content = JsonContent("""{"jsonrpc":"2.0","id":4242,"method":"tools/call","params":{"name":"echo","arguments":{"message":"hi"}}}"""),
             Headers =
             {
                 { "mcp-session-id", "fakeSession" },
             },
         };
         using var response = await HttpClient.SendAsync(request, TestContext.Current.CancellationToken);
         Assert.Equal(HttpStatusCode.NotFound, response.StatusCode);
+
+        // The request body parsed successfully, so the JSON-RPC error MUST echo its id rather than
+        // emitting id=null (base protocol responses section; see #1677).
+        using var doc = JsonDocument.Parse(await response.Content.ReadAsStringAsync(TestContext.Current.CancellationToken));
+        Assert.Equal(4242, doc.RootElement.GetProperty("id").GetInt64());
     }
 
     [Fact]
@@ -245,6 +250,31 @@ public async Task PostWithoutSessionId_NonInitializeRequest_Returns400()
         var body = await response.Content.ReadAsStringAsync(TestContext.Current.CancellationToken);
         Assert.Contains("Mcp-Session-Id", body);
         Assert.Contains("Stateless", body);
+
+        // The request body parsed successfully, so the JSON-RPC error MUST echo its id (see #1677).
+        using var doc = JsonDocument.Parse(body);
+        Assert.Equal(1, doc.RootElement.GetProperty("id").GetInt64());
+    }
+
+    [Fact]
+    public async Task StatelessPostWithSessionId_Returns400_EchoesRequestId()
+    {
+        await StartAsync(stateless: true);
+
+        using var request = new HttpRequestMessage(HttpMethod.Post, "")
+        {
+            Content = JsonContent("""{"jsonrpc":"2.0","id":4242,"method":"tools/list","params":{}}"""),
+            Headers =
+            {
+                { "mcp-session-id", "someSession" },
+            },
+        };
+        using var response = await HttpClient.SendAsync(request, TestContext.Current.CancellationToken);
+        Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);
+
+        // The request body parsed successfully, so the stateless-mode rejection MUST echo its id (see #1677).
+        using var doc = JsonDocument.Parse(await response.Content.ReadAsStringAsync(TestContext.Current.CancellationToken));
+        Assert.Equal(4242, doc.RootElement.GetProperty("id").GetInt64());
     }
 
     [Fact]

Original file line number	Diff line number	Diff line change
`@@ -106,13 +106,18 @@ await WriteJsonRpcErrorAsync(context,`
`106`	`106`	`return;`
`107`	`107`	`}`
`108`	`108`
	`109`	`+ // Once the body has been parsed into a request with a readable id, every JSON-RPC error response`
	`110`	`+ // for this request MUST echo that id (base protocol responses section; SEP-2243 error format).`
	`111`	`+ // Notifications carry no id, so this stays default (null), which is correct.`
	`112`	`+ var requestId = message is JsonRpcRequest jsonRpcRequest ? jsonRpcRequest.Id : default;`
	`113`	`+`
`109`	`114`	`if (!ValidateMcpHeaders(context, message, mcpServerOptionsSnapshot.Value.ToolCollection, out var errorMessage))`
`110`	`115`	`{`
`111`		`- await WriteJsonRpcErrorAsync(context, errorMessage, StatusCodes.Status400BadRequest, (int)McpErrorCode.HeaderMismatch);`
	`116`	`+ await WriteJsonRpcErrorAsync(context, errorMessage, StatusCodes.Status400BadRequest, (int)McpErrorCode.HeaderMismatch, requestId);`
`112`	`117`	`return;`
`113`	`118`	`}`
`114`	`119`
`115`		`- var session = await GetOrCreateSessionAsync(context, message);`
	`120`	`+ var session = await GetOrCreateSessionAsync(context, message, requestId);`
`116`	`121`	`if (session is null)`
`117`	`122`	`{`
`118`	`123`	`return;`
`@@ -286,15 +291,15 @@ await WriteJsonRpcErrorAsync(context,`
`286`	`291`	`}`
`287`	`292`	`}`
`288`	`293`
`289`		`- private async ValueTask<StreamableHttpSession?> GetSessionAsync(HttpContext context, string sessionId)`
	`294`	`+ private async ValueTask<StreamableHttpSession?> GetSessionAsync(HttpContext context, string sessionId, RequestId requestId = default)`
`290`	`295`	`{`
`291`	`296`	`if (string.IsNullOrEmpty(sessionId))`
`292`	`297`	`{`
`293`	`298`	`await WriteJsonRpcErrorAsync(context,`
`294`	`299`	`"Bad Request: Mcp-Session-Id header is required for GET and DELETE requests when the server is using sessions. " +`
`295`	`300`	`"If your server doesn't need sessions, enable stateless mode by setting HttpServerTransportOptions.Stateless = true. " +`
`296`	`301`	`"See https://csharp.sdk.modelcontextprotocol.io/concepts/stateless/stateless.html for more details.",`
`297`		`- StatusCodes.Status400BadRequest);`
	`302`	`+ StatusCodes.Status400BadRequest, requestId: requestId);`
`298`	`303`	`return null;`
`299`	`304`	`}`
`300`	`305`
`@@ -309,7 +314,7 @@ await WriteJsonRpcErrorAsync(context,`
`309`	`314`	`// One of the few other usages I found was from some Ethereum JSON-RPC documentation and this`
`310`	`315`	`// JSON-RPC library from Microsoft called StreamJsonRpc where it's called JsonRpcErrorCode.NoMarshaledObjectFound`
`311`	`316`	`// https://learn.microsoft.com/dotnet/api/streamjsonrpc.protocol.jsonrpcerrorcode?view=streamjsonrpc-2.9#fields`
`312`		`- await WriteJsonRpcErrorAsync(context, "Session not found", StatusCodes.Status404NotFound, -32001);`
	`317`	`+ await WriteJsonRpcErrorAsync(context, "Session not found", StatusCodes.Status404NotFound, -32001, requestId);`
`313`	`318`	`return null;`
`314`	`319`	`}`
`315`	`320`	`}`
`@@ -318,7 +323,7 @@ await WriteJsonRpcErrorAsync(context,`
`318`	`323`	`{`
`319`	`324`	`await WriteJsonRpcErrorAsync(context,`
`320`	`325`	`"Forbidden: The currently authenticated user does not match the user who initiated the session.",`
`321`		`- StatusCodes.Status403Forbidden);`
	`326`	`+ StatusCodes.Status403Forbidden, requestId: requestId);`
`322`	`327`	`return null;`
`323`	`328`	`}`
`324`	`329`
`@@ -367,7 +372,7 @@ await WriteJsonRpcErrorAsync(context,`
`367`	`372`	`}`
`368`	`373`	`}`
`369`	`374`
`370`		`- private async ValueTask<StreamableHttpSession?> GetOrCreateSessionAsync(HttpContext context, JsonRpcMessage message)`
	`375`	`+ private async ValueTask<StreamableHttpSession?> GetOrCreateSessionAsync(HttpContext context, JsonRpcMessage message, RequestId requestId = default)`
`371`	`376`	`{`
`372`	`377`	`var sessionId = context.Request.Headers[McpSessionIdHeaderName].ToString();`
`373`	`378`
`@@ -380,7 +385,7 @@ await WriteJsonRpcErrorAsync(context,`
`380`	`385`	`// A request carrying an Mcp-Session-Id is non-conformant under the 2026-07-28 revision (SEP-2567).`
`381`	`386`	`await WriteJsonRpcErrorAsync(context,`
`382`	`387`	`"Bad Request: Mcp-Session-Id is not supported by the 2026-07-28 and later protocol revisions (SEP-2567).",`
`383`		`- StatusCodes.Status400BadRequest);`
	`388`	`+ StatusCodes.Status400BadRequest, requestId: requestId);`
`384`	`389`	`return null;`
`385`	`390`	`}`
`386`	`391`
`@@ -389,7 +394,7 @@ await WriteJsonRpcErrorAsync(context,`
`389`	`394`	`// The author explicitly opted into sessions (Stateless = false), which the 2026-07-28`
`390`	`395`	`// revision cannot provide. Refuse it so a dual-era client falls back to the legacy`
`391`	`396`	`// initialize handshake and gets the session it asked for (SEP-2575 fallback semantics).`
`392`		`- await WriteUnsupportedProtocolVersionErrorAsync(context);`
	`397`	`+ await WriteUnsupportedProtocolVersionErrorAsync(context, requestId);`
`393`	`398`	`return null;`
`394`	`399`	`}`
`395`	`400`
`@@ -408,7 +413,7 @@ await WriteJsonRpcErrorAsync(context,`
`408`	`413`	`"Bad Request: A new session can only be created by an initialize request. Include a valid Mcp-Session-Id header for non-initialize requests, " +`
`409`	`414`	`"or enable stateless mode by setting HttpServerTransportOptions.Stateless = true if your server doesn't need sessions. " +`
`410`	`415`	`"See https://csharp.sdk.modelcontextprotocol.io/concepts/stateless/stateless.html for more details.",`
`411`		`- StatusCodes.Status400BadRequest);`
	`416`	`+ StatusCodes.Status400BadRequest, requestId: requestId);`
`412`	`417`	`return null;`
`413`	`418`	`}`
`414`	`419`
`@@ -418,12 +423,12 @@ await WriteJsonRpcErrorAsync(context,`
`418`	`423`	`{`
`419`	`424`	`// In stateless mode, we should not be getting existing sessions via sessionId`
`420`	`425`	`// This path should not be reached in stateless mode`
`421`		`- await WriteJsonRpcErrorAsync(context, "Bad Request: The Mcp-Session-Id header is not supported in stateless mode", StatusCodes.Status400BadRequest);`
	`426`	`+ await WriteJsonRpcErrorAsync(context, "Bad Request: The Mcp-Session-Id header is not supported in stateless mode", StatusCodes.Status400BadRequest, requestId: requestId);`
`422`	`427`	`return null;`
`423`	`428`	`}`
`424`	`429`	`else`
`425`	`430`	`{`
`426`		`- return await GetSessionAsync(context, sessionId);`
	`431`	`+ return await GetSessionAsync(context, sessionId, requestId);`
`427`	`432`	`}`
`428`	`433`	`}`
`429`	`434`
`@@ -568,10 +573,11 @@ await WriteJsonRpcErrorAsync(context,`
`568`	`573`	`return eventStreamReader;`
`569`	`574`	`}`
`570`	`575`
`571`		`- private static Task WriteJsonRpcErrorAsync(HttpContext context, string errorMessage, int statusCode, int errorCode = -32000)`
	`576`	`+ private static Task WriteJsonRpcErrorAsync(HttpContext context, string errorMessage, int statusCode, int errorCode = -32000, RequestId requestId = default)`
`572`	`577`	`{`
`573`	`578`	`var jsonRpcError = new JsonRpcError`
`574`	`579`	`{`
	`580`	`+ Id = requestId,`
`575`	`581`	`Error = new()`
`576`	`582`	`{`
`577`	`583`	`Code = errorCode,`
`@@ -691,7 +697,7 @@ private static bool ValidateProtocolVersionHeader(HttpContext context, [NotNullW`
`691`	`697`	`/// that excludes 2026-07-28 and later. A dual-era client then falls back to the legacy initialize handshake`
`692`	`698`	`/// (SEP-2575).`
`693`	`699`	`/// </summary>`
`694`		`- private static Task WriteUnsupportedProtocolVersionErrorAsync(HttpContext context)`
	`700`	`+ private static Task WriteUnsupportedProtocolVersionErrorAsync(HttpContext context, RequestId requestId = default)`
`695`	`701`	`{`
`696`	`702`	`var requestedProtocolVersion = context.Request.Headers[McpProtocolVersionHeaderName].ToString();`
`697`	`703`	`var errorDetail = new JsonRpcErrorDetail`
`@@ -708,7 +714,7 @@ private static Task WriteUnsupportedProtocolVersionErrorAsync(HttpContext contex`
`708`	`714`	`GetRequiredJsonTypeInfo<UnsupportedProtocolVersionErrorData>()),`
`709`	`715`	`};`
`710`	`716`
`711`		`- return WriteJsonRpcErrorDetailAsync(context, errorDetail, StatusCodes.Status400BadRequest);`
	`717`	`+ return WriteJsonRpcErrorDetailAsync(context, errorDetail, StatusCodes.Status400BadRequest, requestId);`
`712`	`718`	`}`
`713`	`719`
`714`	`720`	`/// <summary>`
`@@ -1150,9 +1156,9 @@ private static SafeIntegerParse ParseSafeInteger(string text, out long value)`
`1150`	`1156`	`return SafeIntegerParse.NotNumeric;`
`1151`	`1157`	`}`
`1152`	`1158`
`1153`		`- private static Task WriteJsonRpcErrorDetailAsync(HttpContext context, JsonRpcErrorDetail detail, int statusCode)`
	`1159`	`+ private static Task WriteJsonRpcErrorDetailAsync(HttpContext context, JsonRpcErrorDetail detail, int statusCode, RequestId requestId = default)`
`1154`	`1160`	`{`
`1155`		`- var jsonRpcError = new JsonRpcError { Error = detail };`
	`1161`	`+ var jsonRpcError = new JsonRpcError { Id = requestId, Error = detail };`
`1156`	`1162`	`return Results.Json(jsonRpcError, s_errorTypeInfo, statusCode: statusCode).ExecuteAsync(context);`
`1157`	`1163`	`}`
`1158`	`1164`