feat: Implement WebSocket support for AI content generation

- Added WebSocketChatController to handle WebSocket connections for AI chat streaming, replacing SignalR for mobile clients.
- Introduced RawWebSocketNotifier for sending JSON messages over WebSocket.
- Enhanced GenerateAIContentQuery and its handler to utilize a custom notifier for streaming AI responses.
- Updated authentication logic to support WebSocket connections.
- Added a test HTML page for testing the WebSocket functionality.
- Removed obsolete Web.Api.http file.

src/Application/Features/Conversation/GenerateAIContent/GenerateAIContentQuery.cs

@@ -1,4 +1,5 @@
 using Application.Common;
+using Application.Interfaces.Services;
 using Domain.Common;
 using MediatR;
 
@@ -13,4 +14,10 @@ public sealed class GenerateAIContentQuery : IRequest<Result<Unit>>
     public Guid MessageId { get; set; }
     public Guid ConversationId { get; set; }
     public string ConnectionId { get; set; }
+
+    /// <summary>
+    /// Custom notifier để sử dụng thay thế cho SignalR (ví dụ: WebSocket raw)
+    /// Nếu null thì sử dụng IChatNotifier được inject từ DI
+    /// </summary>
+    public IChatNotifier? CustomNotifier { get; set; }
 }

src/Application/Features/Conversation/GenerateAIContent/GenerateAIContentQueryHandler.cs

@@ -42,6 +42,9 @@ public sealed class GenerateAIContentQueryHandler(
 
     public async Task<Result<Unit>> Handle(GenerateAIContentQuery request, CancellationToken cancellationToken)
     {
+        // Chọn notifier: ưu tiên CustomNotifier (WebSocket), fallback về SignalR
+        var notifier = request.CustomNotifier ?? _chatNotifier;
+
         // 1. Validate message exists and belongs to conversation
         var message = await _messageRepository.GetByIdAsync(request.MessageId, cancellationToken);
         if (message == null)
@@ -102,15 +105,15 @@ await _aiService.GenerateResponseStreamAsync(
                 {
                     fullResponse += chunk;
 
-                    await _chatNotifier.SendChunkAsync(request.ConnectionId,
+                    await notifier.SendChunkAsync(request.ConnectionId,
                         request.MessageId, request.ConversationId, chunk, cancellationToken);
                 },
                 onThought: async (thought) =>
                 {
                     thoughtStep++;
 
                     // 1. Gửi notification cho client ngay lập tức để UI phản hồi nhanh
-                    await _chatNotifier.SendThoughtAsync(request.ConnectionId,
+                    await notifier.SendThoughtAsync(request.ConnectionId,
                         request.MessageId, request.ConversationId, thought, cancellationToken);
 
                     var thoughtEntity = new Thought
@@ -133,7 +136,7 @@ await _chatNotifier.SendThoughtAsync(request.ConnectionId,
             await _unitOfWork.SaveChangesAsync(cancellationToken);
 
             // 7. Notify client that streaming is complete
-            await _chatNotifier.SendCompleteAsync(request.ConnectionId, request.MessageId,
+            await notifier.SendCompleteAsync(request.ConnectionId, request.MessageId,
                 request.ConversationId, fullResponse, cancellationToken);
 
             return Result.Success(Unit.Value);
@@ -148,7 +151,7 @@ await _chatNotifier.SendCompleteAsync(request.ConnectionId, request.MessageId,
             }
 
             // Notify client about error
-            await _chatNotifier.SendErrorAsync(request.ConnectionId, request.MessageId,
+            await notifier.SendErrorAsync(request.ConnectionId, request.MessageId,
                 "Failed to generate AI response: " + (ex.InnerException?.Message ?? ex.Message), cancellationToken);
 
             return Result.Failure<Unit>(Error.Failure("AI.GenerationFailed",

src/Web.Api/Controllers/WebSocketChatController.cs

@@ -0,0 +1,91 @@
+using Application.Features.Conversation.GenerateAIContent;
+using Application.Interfaces.Services;
+using MediatR;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using System.Net.WebSockets;
+using Web.Api.Services;
+
+namespace Web.Api.Controllers;
+
+/// <summary>
+/// Controller xử lý WebSocket connections cho AI chat streaming
+/// Thay thế cho SignalR khi mobile client không thể tích hợp SignalR
+/// </summary>
+[Route("ws/chat")]
+[Authorize]
+public class WebSocketChatController(IMediator mediator, ILogger<WebSocketChatController> logger) : ControllerBase
+{
+    private readonly IMediator _mediator = mediator ?? throw new ArgumentNullException(nameof(mediator));
+    private readonly ILogger<WebSocketChatController> _logger = logger ?? throw new ArgumentNullException(nameof(logger));
+
+    /// <summary>
+    /// Kết nối WebSocket để streaming AI response
+    /// </summary>
+    /// <param name="conversationId">ID của conversation</param>
+    /// <param name="messageId">ID của message cần generate AI response</param>
+    [HttpGet("connect")]
+    public async Task Connect([FromQuery] Guid conversationId, [FromQuery] Guid messageId, CancellationToken cancellationToken)
+    {
+        if (!HttpContext.WebSockets.IsWebSocketRequest)
+        {
+            HttpContext.Response.StatusCode = StatusCodes.Status400BadRequest;
+            return;
+        }
+
+        // 1. Chấp nhận kết nối WebSocket
+        using var webSocket = await HttpContext.WebSockets.AcceptWebSocketAsync();
+        var connectionId = Guid.NewGuid().ToString();
+
+        _logger.LogInformation("WebSocket Connected: {ConnId} for Message {MessageId}", connectionId, messageId);
+
+        try
+        {
+            // 2. Tạo WebSocket notifier wrapper
+            var wsNotifier = new RawWebSocketNotifier(webSocket);
+
+            // 3. Tạo Query và gán CustomNotifier
+            var query = new GenerateAIContentQuery
+            {
+                ConversationId = conversationId,
+                MessageId = messageId,
+                ConnectionId = connectionId,
+                CustomNotifier = wsNotifier // Sử dụng WebSocket thay vì SignalR
+            };
+
+            // 4. Gọi Handler (Handler sẽ dùng wsNotifier để streaming)
+            var result = await _mediator.Send(query, cancellationToken);
+
+            if (result.IsFailure)
+            {
+                // Gửi lỗi về WebSocket nếu Handler fail logic
+                await wsNotifier.SendErrorAsync(connectionId, messageId, result.Error.Description, cancellationToken);
+            }
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "WebSocket Error for Connection {ConnId}", connectionId);
+
+            // Gửi lỗi về WebSocket nếu có exception
+            try
+            {
+                using var wsNotifier = new RawWebSocketNotifier(webSocket);
+                await wsNotifier.SendErrorAsync(connectionId, messageId, ex.Message, cancellationToken);
+            }
+            catch
+            {
+                // Ignore errors when sending error message
+            }
+        }
+        finally
+        {
+            // 5. Đóng WebSocket khi xong việc
+            if (webSocket.State == WebSocketState.Open)
+            {
+                await webSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, "Done", CancellationToken.None);
+            }
+
+            _logger.LogInformation("🔌 WebSocket Disconnected: {ConnId}", connectionId);
+        }
+    }
+}

src/Web.Api/Extensions/AuthenticationExtensions.cs

@@ -89,7 +89,7 @@ public static IServiceCollection AddJwtAuthentication(
 
                     // Nếu request có token ở query VÀ đường dẫn bắt đầu bằng /chatHub
                     var path = context.HttpContext.Request.Path;
-                    if (!string.IsNullOrEmpty(accessToken) && path.StartsWithSegments("/chatHub"))
+                    if (!string.IsNullOrEmpty(accessToken) && (path.StartsWithSegments("/chatHub") || path.StartsWithSegments("/ws/chat")))
                     {
                         // Lấy token từ query nhét vào Context để cho thằng .NET nó validate
                         context.Token = accessToken;

src/Web.Api/Program.cs

@@ -78,6 +78,9 @@
 // app.UseCors("ProductionPolicy");
 app.UseCors("DevelopmentPolicy");
 
+// Add WebSocket support
+app.UseWebSockets();
+
 // Add Authentication & Authorization
 app.UseAuthentication();
 app.UseAuthorization();

src/Web.Api/Services/RawWebSocketNotifier.cs

@@ -0,0 +1,98 @@
+using Application.Interfaces.Services;
+using System.Net.WebSockets;
+using System.Text;
+using System.Text.Json;
+
+namespace Web.Api.Services;
+
+/// <summary>
+/// WebSocket implementation của IChatNotifier
+/// Gửi JSON messages qua WebSocket raw thay vì SignalR
+/// </summary>
+public class RawWebSocketNotifier(WebSocket socket) : IChatNotifier, IDisposable
+{
+    private readonly WebSocket _socket = socket ?? throw new ArgumentNullException(nameof(socket));
+
+    // Dùng Semaphore để đảm bảo không bắn 2 tin cùng lúc gây crash socket
+    private readonly SemaphoreSlim _lock = new(1, 1);
+
+    /// <summary>
+    /// Gửi JSON message qua WebSocket
+    /// </summary>
+    private async Task SendJsonAsync(object data, CancellationToken cancellationToken)
+    {
+        var json = JsonSerializer.Serialize(data);
+        var bytes = Encoding.UTF8.GetBytes(json);
+
+        await _lock.WaitAsync(cancellationToken);
+        try
+        {
+            if (_socket.State == WebSocketState.Open)
+            {
+                await _socket.SendAsync(
+                    new ArraySegment<byte>(bytes),
+                    WebSocketMessageType.Text,
+                    true, // End of message
+                    cancellationToken);
+            }
+        }
+        finally
+        {
+            _lock.Release();
+        }
+    }
+
+    /// <summary>
+    /// Gửi chunk của AI response
+    /// </summary>
+    public async Task SendChunkAsync(string connectionId, Guid messageId, Guid conversationId, string chunk, CancellationToken cancellationToken)
+    {
+        // Format JSON giống SignalR event để Client dễ parse
+        await SendJsonAsync(new
+        {
+            target = "ReceiveChunk",
+            arguments = new[] { new { MessageId = messageId, Chunk = chunk } }
+        }, cancellationToken);
+    }
+
+    /// <summary>
+    /// Gửi thought step của AI reasoning
+    /// </summary>
+    public async Task SendThoughtAsync(string connectionId, Guid messageId, Guid conversationId, string stepDescription, CancellationToken cancellationToken)
+    {
+        await SendJsonAsync(new
+        {
+            target = "ReceiveThought",
+            arguments = new[] { new { MessageId = messageId, Step = stepDescription } }
+        }, cancellationToken);
+    }
+
+    /// <summary>
+    /// Thông báo streaming hoàn thành
+    /// </summary>
+    public async Task SendCompleteAsync(string connectionId, Guid messageId, Guid conversationId, string fullContent, CancellationToken cancellationToken)
+    {
+        await SendJsonAsync(new
+        {
+            target = "StreamingComplete",
+            arguments = new[] { new { MessageId = messageId } }
+        }, cancellationToken);
+    }
+
+    /// <summary>
+    /// Gửi lỗi về client
+    /// </summary>
+    public async Task SendErrorAsync(string connectionId, Guid messageId, string errorMessage, CancellationToken cancellationToken)
+    {
+        await SendJsonAsync(new
+        {
+            target = "StreamingError",
+            arguments = new[] { new { MessageId = messageId, Error = errorMessage } }
+        }, cancellationToken);
+    }
+
+    public void Dispose()
+    {
+        _socket?.Dispose();
+    }
+}