ASP.NET Core - getting a message from AuthenticateResult.Fail

Can not get an error message in HTTP response.

            if (!string.IsNullOrWhiteSpace(checkTokenResponse.Error))
            {
                Logger.LogError(checkTokenResponse.Error);
                return AuthenticateResult.Fail(checkTokenResponse.Error);
            }

response

I suppose the error message should render into data response field The same question ASP.NET Core - getting a message back from AuthenticationHandler

Update

code of custom Auth handler

public class AuthHandler : AuthenticationHandler<AuthOptions>
{
    private readonly IPrimeApiProxy _primeApiProxy;
    private readonly IPrimeProxy _primeProxy;
    private readonly int _adminGroupId;

    private static readonly string HeaderName = "Authorization";
    private static readonly string ApiAuthScheme = "oauth ";

    public AuthHandler(
        IOptionsMonitor<AuthOptions> options,
        ILoggerFactory logger,
        UrlEncoder encoder,
        ISystemClock clock,
        IPrimeApiProxy primeApiProxy,
        IPrimeProxy primeProxy,
        ApplicationSettingsProvider settings)
        : base(options, logger, encoder, clock)
    {
        _primeApiProxy = primeApiProxy ?? throw new ArgumentNullException(nameof(primeApiProxy));
        _primeProxy = primeProxy ?? throw new ArgumentNullException(nameof(primeProxy));

        _adminGroupId = int.Parse((settings as dynamic).AdminGroupId as string);
    }


    protected override async Task<AuthenticateResult> HandleAuthenticateAsync()
    {
        Logger.LogTrace("HandleAuthenticateAsync");

        if (!Request.Headers.ContainsKey("Authorization"))
        {
            return AuthenticateResult.Fail("Missing Authorization Header");
        }

        try
        {
            var token = FetchToken(Request);

            if (string.IsNullOrWhiteSpace(token.token) && token.userId < 1)
            {
                Logger.LogError("Invalid token");
                return AuthenticateResult.Fail("Invalid token");
            }

            var checkTokenResponse = await _primeProxy.CheckToken(token.token);

            if (!string.IsNullOrWhiteSpace(checkTokenResponse.Error))
            {
                Logger.LogError(checkTokenResponse.Error);
                return AuthenticateResult.Fail(checkTokenResponse.Error);
            }

            var isValidInt = int.TryParse(checkTokenResponse.UserId, out var userId);

            if (!isValidInt)
            {
                return AuthenticateResult.Fail("User Id is invalid");
            }

            if (token.userId != userId)
            {
                return AuthenticateResult.Fail("The token belongs to another user");
            }

            bool isUserAdminAndCustomGroupMember = false;
            
            if (checkTokenResponse.UserRole == "admin")
            {
                isUserAdminAndCustomGroupMember = await _primeApiProxy.IsGroupMember(token.token, token.userId, _adminGroupId);
            }

            var claims = new List<Claim>()
            {
                new Claim(ClaimTypes.NameIdentifier, token.userId.ToString()),
                new Claim(ClaimTypes.Role, isUserAdminAndCustomGroupMember ? "Admin" : "Learner")
            };

            var identity = new ClaimsIdentity(claims, Scheme.Name);
            var principal = new ClaimsPrincipal(identity);
            var ticket = new AuthenticationTicket(principal, Scheme.Name);

            return AuthenticateResult.Success(ticket);
        }
        catch (Exception ex)
        {
            Logger.LogError(ex, "Auth exception");
            return AuthenticateResult.Fail("Invalid Authorization Header");
        }
    }

    private static (string token, int userId) FetchToken(HttpRequest request)
    {
        string authHeader = request.Headers[HeaderName];

        if (authHeader != null && authHeader.StartsWith(ApiAuthScheme, StringComparison.OrdinalIgnoreCase))
        {
            string token = authHeader.Substring(ApiAuthScheme.Length).Trim();
            string[] parts = token.Split(',', StringSplitOptions.RemoveEmptyEntries);

            if (int.TryParse(parts[1], out int userId))
            {
                return (parts[0], userId);
            }
        }

        return (null, 0);
    }
}