Fix ChatController streaming cancellation handling

Copilot · BenjaminMichaelis · web-flow · commit 4e9b2f6c8fe0 · 2026-05-13T07:02:17.000Z
Agent-Logs-Url: https://github.com/IntelliTect/EssentialCSharp.Web/sessions/c4364690-d679-41d6-a271-69d6c45343af Co-authored-by: BenjaminMichaelis <22186029+BenjaminMichaelis@users.noreply.github.com>
diff --git a/EssentialCSharp.Web/Controllers/ChatController.cs b/EssentialCSharp.Web/Controllers/ChatController.cs
@@ -15,13 +15,13 @@ namespace EssentialCSharp.Web.Controllers;
 [IgnoreAntiforgeryToken]
 public partial class ChatController : ControllerBase
 {
-    private readonly AIChatService _AiChatService;
+    private readonly AIChatService _AIChatService;
     private readonly ResponseIdValidationService _ResponseIdValidationService;
     private readonly ILogger<ChatController> _Logger;
 
     public ChatController(ILogger<ChatController> logger, AIChatService aiChatService, ResponseIdValidationService responseIdValidationService)
     {
-        _AiChatService = aiChatService;
+        _AIChatService = aiChatService;
         _ResponseIdValidationService = responseIdValidationService;
         _Logger = logger;
     }
@@ -46,7 +46,7 @@ public async Task<IActionResult> SendMessage([FromBody] ChatMessageRequest reque
 
         try
         {
-            var (response, responseId) = await _AiChatService.GetChatCompletion(
+            var (response, responseId) = await _AIChatService.GetChatCompletion(
                 prompt: request.Message,
                 previousResponseId: previousResponseId,
                 enableContextualSearch: request.EnableContextualSearch,
@@ -75,15 +75,15 @@ public async Task StreamMessage([FromBody] ChatMessageRequest request, Cancellat
         if (string.IsNullOrEmpty(request.Message))
         {
             Response.StatusCode = 400;
-            await Response.WriteAsJsonAsync(new { error = "Message cannot be empty." }, CancellationToken.None);
+            await Response.WriteAsJsonAsync(new { error = "Message cannot be empty." }, cancellationToken);
             return;
         }
 
         var userId = User.FindFirstValue(ClaimTypes.NameIdentifier);
         if (string.IsNullOrEmpty(userId))
         {
             Response.StatusCode = 401;
-            await Response.WriteAsJsonAsync(new { error = "Unauthorized." }, CancellationToken.None);
+            await Response.WriteAsJsonAsync(new { error = "Unauthorized." }, cancellationToken);
             return;
         }
 
@@ -94,7 +94,7 @@ public async Task StreamMessage([FromBody] ChatMessageRequest request, Cancellat
         if (!_ResponseIdValidationService.ValidateResponseId(userId, previousResponseId))
         {
             Response.StatusCode = 400;
-            await Response.WriteAsJsonAsync(new { error = "Invalid conversation context." }, CancellationToken.None);
+            await Response.WriteAsJsonAsync(new { error = "Invalid conversation context." }, cancellationToken);
             return;
         }
 
@@ -104,7 +104,7 @@ public async Task StreamMessage([FromBody] ChatMessageRequest request, Cancellat
 
         try
         {
-            await foreach (var (text, responseId) in _AiChatService.GetChatCompletionStream(
+            await foreach (var (text, responseId) in _AIChatService.GetChatCompletionStream(
                 prompt: request.Message,
                 previousResponseId: previousResponseId,
                 enableContextualSearch: request.EnableContextualSearch,
@@ -133,46 +133,49 @@ public async Task StreamMessage([FromBody] ChatMessageRequest request, Cancellat
             await Response.WriteAsync("data: [DONE]\n\n", cancellationToken);
             await Response.Body.FlushAsync(cancellationToken);
         }
-        catch (OperationCanceledException) when (cancellationToken.IsCancellationRequested || HttpContext.RequestAborted.IsCancellationRequested)
+        catch (OperationCanceledException)
         {
             LogChatStreamCancelled(_Logger, User.Identity?.Name);
         }
-        catch (ConversationContextLimitExceededException) when (!Response.HasStarted)
-        {
-            Response.StatusCode = 400;
-            Response.ContentType = "application/json";
-            await Response.WriteAsJsonAsync(new { error = "This conversation has grown too long. Please start a new one.", errorCode = "context_limit_exceeded" }, CancellationToken.None);
-        }
         catch (ConversationContextLimitExceededException ex)
         {
-            LogChatStreamErrorMidStream(_Logger, ex, User.Identity?.Name);
-            try
+            if (!Response.HasStarted)
             {
-                await Response.WriteAsync("data: {\"type\":\"error\",\"message\":\"This conversation has grown too long. Please start a new one.\",\"errorCode\":\"context_limit_exceeded\"}\n\n", CancellationToken.None);
-                await Response.Body.FlushAsync(CancellationToken.None);
+                Response.StatusCode = 400;
+                Response.ContentType = "application/json";
+                await Response.WriteAsJsonAsync(new { error = "This conversation has grown too long. Please start a new one.", errorCode = "context_limit_exceeded" }, cancellationToken);
             }
-            catch (Exception)
+            else
             {
-                // Best-effort write to an already-streaming response. Kestrel can throw
-                // IOException (connection reset), OperationCanceledException, or
-                // ObjectDisposedException on abrupt client disconnect — swallow all to
-                // avoid masking the original exception.
+                LogChatStreamErrorMidStream(_Logger, ex, User.Identity?.Name);
+                try
+                {
+                    await Response.WriteAsync("data: {\"type\":\"error\",\"message\":\"This conversation has grown too long. Please start a new one.\",\"errorCode\":\"context_limit_exceeded\"}\n\n", cancellationToken);
+                    await Response.Body.FlushAsync(cancellationToken);
+                }
+                catch (Exception)
+                {
+                    // Best-effort write to an already-streaming response. Kestrel can throw
+                    // IOException (connection reset), OperationCanceledException, or
+                    // ObjectDisposedException on abrupt client disconnect — swallow all to
+                    // avoid masking the original exception.
+                }
             }
         }
         catch (Exception ex) when (!Response.HasStarted)
         {
             LogChatStreamErrorBeforeResponseStarted(_Logger, ex, User.Identity?.Name);
             Response.StatusCode = 500;
             Response.ContentType = "application/json";
-            await Response.WriteAsJsonAsync(new { error = "Chat service unavailable" }, CancellationToken.None);
+            await Response.WriteAsJsonAsync(new { error = "Chat service unavailable" }, cancellationToken);
         }
         catch (Exception ex)
         {
             LogChatStreamErrorMidStream(_Logger, ex, User.Identity?.Name);
             try
             {
-                await Response.WriteAsync("data: {\"type\":\"error\",\"message\":\"Stream interrupted\"}\n\n", CancellationToken.None);
-                await Response.Body.FlushAsync(CancellationToken.None);
+                await Response.WriteAsync("data: {\"type\":\"error\",\"message\":\"Stream interrupted\"}\n\n", cancellationToken);
+                await Response.Body.FlushAsync(cancellationToken);
             }
             catch (Exception)
             {

Original file line number	Diff line number	Diff line change
`@@ -15,13 +15,13 @@ namespace EssentialCSharp.Web.Controllers;`
`15`	`15`	`[IgnoreAntiforgeryToken]`
`16`	`16`	`public partial class ChatController : ControllerBase`
`17`	`17`	`{`
`18`		`- private readonly AIChatService _AiChatService;`
	`18`	`+ private readonly AIChatService _AIChatService;`
`19`	`19`	`private readonly ResponseIdValidationService _ResponseIdValidationService;`
`20`	`20`	`private readonly ILogger<ChatController> _Logger;`
`21`	`21`
`22`	`22`	`public ChatController(ILogger<ChatController> logger, AIChatService aiChatService, ResponseIdValidationService responseIdValidationService)`
`23`	`23`	`{`
`24`		`- _AiChatService = aiChatService;`
	`24`	`+ _AIChatService = aiChatService;`
`25`	`25`	`_ResponseIdValidationService = responseIdValidationService;`
`26`	`26`	`_Logger = logger;`
`27`	`27`	`}`
`@@ -46,7 +46,7 @@ public async Task<IActionResult> SendMessage([FromBody] ChatMessageRequest reque`
`46`	`46`
`47`	`47`	`try`
`48`	`48`	`{`
`49`		`- var (response, responseId) = await _AiChatService.GetChatCompletion(`
	`49`	`+ var (response, responseId) = await _AIChatService.GetChatCompletion(`
`50`	`50`	`prompt: request.Message,`
`51`	`51`	`previousResponseId: previousResponseId,`
`52`	`52`	`enableContextualSearch: request.EnableContextualSearch,`
`@@ -75,15 +75,15 @@ public async Task StreamMessage([FromBody] ChatMessageRequest request, Cancellat`
`75`	`75`	`if (string.IsNullOrEmpty(request.Message))`
`76`	`76`	`{`
`77`	`77`	`Response.StatusCode = 400;`
`78`		`- await Response.WriteAsJsonAsync(new { error = "Message cannot be empty." }, CancellationToken.None);`
	`78`	`+ await Response.WriteAsJsonAsync(new { error = "Message cannot be empty." }, cancellationToken);`
`79`	`79`	`return;`
`80`	`80`	`}`
`81`	`81`
`82`	`82`	`var userId = User.FindFirstValue(ClaimTypes.NameIdentifier);`
`83`	`83`	`if (string.IsNullOrEmpty(userId))`
`84`	`84`	`{`
`85`	`85`	`Response.StatusCode = 401;`
`86`		`- await Response.WriteAsJsonAsync(new { error = "Unauthorized." }, CancellationToken.None);`
	`86`	`+ await Response.WriteAsJsonAsync(new { error = "Unauthorized." }, cancellationToken);`
`87`	`87`	`return;`
`88`	`88`	`}`
`89`	`89`
`@@ -94,7 +94,7 @@ public async Task StreamMessage([FromBody] ChatMessageRequest request, Cancellat`
`94`	`94`	`if (!_ResponseIdValidationService.ValidateResponseId(userId, previousResponseId))`
`95`	`95`	`{`
`96`	`96`	`Response.StatusCode = 400;`
`97`		`- await Response.WriteAsJsonAsync(new { error = "Invalid conversation context." }, CancellationToken.None);`
	`97`	`+ await Response.WriteAsJsonAsync(new { error = "Invalid conversation context." }, cancellationToken);`
`98`	`98`	`return;`
`99`	`99`	`}`
`100`	`100`
`@@ -104,7 +104,7 @@ public async Task StreamMessage([FromBody] ChatMessageRequest request, Cancellat`
`104`	`104`
`105`	`105`	`try`
`106`	`106`	`{`
`107`		`- await foreach (var (text, responseId) in _AiChatService.GetChatCompletionStream(`
	`107`	`+ await foreach (var (text, responseId) in _AIChatService.GetChatCompletionStream(`
`108`	`108`	`prompt: request.Message,`
`109`	`109`	`previousResponseId: previousResponseId,`
`110`	`110`	`enableContextualSearch: request.EnableContextualSearch,`
`@@ -133,46 +133,49 @@ public async Task StreamMessage([FromBody] ChatMessageRequest request, Cancellat`
`133`	`133`	`await Response.WriteAsync("data: [DONE]\n\n", cancellationToken);`
`134`	`134`	`await Response.Body.FlushAsync(cancellationToken);`
`135`	`135`	`}`
`136`		`- catch (OperationCanceledException) when (cancellationToken.IsCancellationRequested \|\| HttpContext.RequestAborted.IsCancellationRequested)`
	`136`	`+ catch (OperationCanceledException)`
`137`	`137`	`{`
`138`	`138`	`LogChatStreamCancelled(_Logger, User.Identity?.Name);`
`139`	`139`	`}`
`140`		`- catch (ConversationContextLimitExceededException) when (!Response.HasStarted)`
`141`		`- {`
`142`		`- Response.StatusCode = 400;`
`143`		`- Response.ContentType = "application/json";`
`144`		`- await Response.WriteAsJsonAsync(new { error = "This conversation has grown too long. Please start a new one.", errorCode = "context_limit_exceeded" }, CancellationToken.None);`
`145`		`- }`
`146`	`140`	`catch (ConversationContextLimitExceededException ex)`
`147`	`141`	`{`
`148`		`- LogChatStreamErrorMidStream(_Logger, ex, User.Identity?.Name);`
`149`		`- try`
	`142`	`+ if (!Response.HasStarted)`
`150`	`143`	`{`
`151`		`- await Response.WriteAsync("data: {\"type\":\"error\",\"message\":\"This conversation has grown too long. Please start a new one.\",\"errorCode\":\"context_limit_exceeded\"}\n\n", CancellationToken.None);`
`152`		`- await Response.Body.FlushAsync(CancellationToken.None);`
	`144`	`+ Response.StatusCode = 400;`
	`145`	`+ Response.ContentType = "application/json";`
	`146`	`+ await Response.WriteAsJsonAsync(new { error = "This conversation has grown too long. Please start a new one.", errorCode = "context_limit_exceeded" }, cancellationToken);`
`153`	`147`	`}`
`154`		`- catch (Exception)`
	`148`	`+ else`
`155`	`149`	`{`
`156`		`- // Best-effort write to an already-streaming response. Kestrel can throw`
`157`		`- // IOException (connection reset), OperationCanceledException, or`
`158`		`- // ObjectDisposedException on abrupt client disconnect — swallow all to`
`159`		`- // avoid masking the original exception.`
	`150`	`+ LogChatStreamErrorMidStream(_Logger, ex, User.Identity?.Name);`
	`151`	`+ try`
	`152`	`+ {`
	`153`	`+ await Response.WriteAsync("data: {\"type\":\"error\",\"message\":\"This conversation has grown too long. Please start a new one.\",\"errorCode\":\"context_limit_exceeded\"}\n\n", cancellationToken);`
	`154`	`+ await Response.Body.FlushAsync(cancellationToken);`
	`155`	`+ }`
	`156`	`+ catch (Exception)`
	`157`	`+ {`
	`158`	`+ // Best-effort write to an already-streaming response. Kestrel can throw`
	`159`	`+ // IOException (connection reset), OperationCanceledException, or`
	`160`	`+ // ObjectDisposedException on abrupt client disconnect — swallow all to`
	`161`	`+ // avoid masking the original exception.`
	`162`	`+ }`
`160`	`163`	`}`
`161`	`164`	`}`
`162`	`165`	`catch (Exception ex) when (!Response.HasStarted)`
`163`	`166`	`{`
`164`	`167`	`LogChatStreamErrorBeforeResponseStarted(_Logger, ex, User.Identity?.Name);`
`165`	`168`	`Response.StatusCode = 500;`
`166`	`169`	`Response.ContentType = "application/json";`
`167`		`- await Response.WriteAsJsonAsync(new { error = "Chat service unavailable" }, CancellationToken.None);`
	`170`	`+ await Response.WriteAsJsonAsync(new { error = "Chat service unavailable" }, cancellationToken);`
`168`	`171`	`}`
`169`	`172`	`catch (Exception ex)`
`170`	`173`	`{`
`171`	`174`	`LogChatStreamErrorMidStream(_Logger, ex, User.Identity?.Name);`
`172`	`175`	`try`
`173`	`176`	`{`
`174`		`- await Response.WriteAsync("data: {\"type\":\"error\",\"message\":\"Stream interrupted\"}\n\n", CancellationToken.None);`
`175`		`- await Response.Body.FlushAsync(CancellationToken.None);`
	`177`	`+ await Response.WriteAsync("data: {\"type\":\"error\",\"message\":\"Stream interrupted\"}\n\n", cancellationToken);`
	`178`	`+ await Response.Body.FlushAsync(cancellationToken);`
`176`	`179`	`}`
`177`	`180`	`catch (Exception)`
`178`	`181`	`{`