How can I use a token from a request for other requests after responding to the first request?

I have a scenario where I need to respond to a request that it's been received and send a response (request?) to another endpoint once internal api calls and logic has completed. The flow looks like this:

External request to my endpoint > endpoint responds to request with accepted > endpoint passes the request on internally > internal logic fetches and handles data from DB > internal logic uses data from DB to send a request back to a different endpoint from the same integration as the first call came from.

I have managed to get it to work using Queued Background Tasks to send the request to the correct internal handler with Mediatr. However in order for it to work I need to add the barer token from the request header to the request object and then use that barer token to validate against the internal API's. I'd like to avoid this since I might run into the issue of the token expiring or not being valid for the internal Api etc.

Request object example:

public class ExampleRequest : IRequest, IRequest<ExampleResponse>
    {
        public string? Token { get; set; } //Added for functioning version, want to get rid 
                                           //of it

        public CommonData Data { get; set; }

        public string RequestId { get; set; }

        public string OperationId { get; set; }

        public List<string> ObjectIdentifiers { get; set; }
    } 

public class CommonData 
    {
        public string MessageId { get; set; }

        public DateTime Timestamp { get; set; }
    }

Response object example (response to the call):

    public class ExampleResponseForCall
    {
        public CommonData Data { get; set; }

        public string ResponseStatus { get; set; } //Will be accepted/acknowledged
    }

Example response object (for final response)

    public class ExampleResponse
    {
        public CommonData Data{ get; set; }

        public string ResponseStatus { get; set; }

        public string ErrorCode { get; set; }

        public string ErrorDescription { get; set; }

        public string RequestId { get; set; }

        public string OperationId { get; set; }
    }

My current working version looks something like this:

**Endpoint:**
      public IActionResult Post(ExampleRequest request)
        {
            var authorization = Request.Headers[HeaderNames.Authorization];

            if (AuthenticationHeaderValue.TryParse(authorization, out var headerValue))
            {
                var scheme = headerValue.Scheme;
                var parameter = headerValue.Parameter;
            }

            var token = headerValue?.Parameter;

            request.Token = token; //I added token as a nullable string on the request obj

            _backgroundTaskQueue.StartTask(request);

            return Ok(new ExampleResponseForCall
            {
                Data = request.Data,
                ResponseStatus = HttpStatusCode.Accepted.ToString()
            });
        }

**Background Task queue:**
      public void StartTask(IRequest request)
        {
            _logger.LogInformation("Task is starting.");
            _request = request;
            
            Task.Run(async () => await AddTaskAsync(), _cancellationToken);
        }

        private async ValueTask AddTaskAsync()
        {
            await _taskQueue.QueueBackgroundWorkItemAsync(BuildWorkItem);
        }

        private async ValueTask BuildWorkItem(CancellationToken token)
        {
            var guid = Guid.NewGuid().ToString();
            _logger.LogInformation("Task {Guid} is starting.", guid);

            if (_request == null)
            {
                _logger.LogWarning("Request for task {Guid} is null.", guid);
                return;
            }
            await _mediator.Send(_request, token);

            _logger.LogInformation("Task {Guid} is complete.", guid);
        }

I also have Handlers that can handle the request and Clients for sending requests internally and back to the caller. All of that works when awaiting the internal logic to be handled. However when I'm using the background task queue the internal client fails on the when getting the token here

protected async Task<HttpClient> CreateBaseClient()
        {
            var client = _clientFactory.CreateClient(HttpClientName);
            client.DefaultRequestHeaders.Clear();
            client.DefaultRequestHeaders.Add("Accept", 
             $"application/json");
            client.DefaultRequestHeaders.Authorization = new 
            AuthenticationHeaderValue("Bearer", await GetToken());
            return client;
        }

    public async Task<string> GetToken()
    {
        if (_httpContextAccessor.HttpContext == null)
            throw new Exception("No HttpContext available when trying to 
            get Token.");

        
     _httpContextAccessor.HttpContext.Items.TryGetValue(Constants.AuthenticationSchemeKey, 
     out var scheme);

        if (scheme?.ToString() == Constants.Bearer)
            return GetTokenFromRequest();

        throw new MissingAccessTokenException("Unknown authentication type");
    }

My workaround (that I want to get away from) looks like this:

protected async Task<HttpClient> CreateBaseClient(string version, string token)
        {
            var client = _clientFactory.CreateClient(HttpClientName);
            client.DefaultRequestHeaders.Clear();
            client.DefaultRequestHeaders.Add("Accept", 
            $"application/json");
            client.DefaultRequestHeaders.Authorization = new 
            AuthenticationHeaderValue("Bearer", token); //token from requst.Token
            return client;
        }

I've tried to pass in the a lot of different things to the Background Task queue (and changing the parameter type to match ofc) but nothing works. I want to have the background task queue generic since I'll be implementing this for other end points as well.

That's a lot of text so TL:DR, I respond to a request but need to use the token from the request for other calls after responding.