Proper way to implement my own async Worker Service(s) according to TAP pattern

Question

I'm newbie in async. And making WPF app for scraping and API calls purposes. WPF's UI is needed only for service monitoring and settings control, so all services will run simultaneously in the background. And most of them is doing similar work. For this one I need to implement strategy like this:

1. Start worker on threadpool
2. Worker must send request and process response from Website
   2.1 If response processed and some new data appeared - raise an event
   2.2 If request failed - handle an error
   2.3 If there are many error percent for last x requests - stop worker
3. No matter the last request completed/failed/running we must send another request
4. Another request should be sent not earlier than the set delay but should not exceed the delay too much (as far as possible).

private _workTask;
private List<ScrapeParameters> _scrapeParams = new();
public event EventHandler<ScrapedEventArgs>? NewDataScraped;

//Can I run Worker like this?
public void RunWorker()
{
    if(_workTask.IsCompleted)
        _workTask = WorkAsync(_token)
}

private async Task WorkAsync(CancellationToken cancelToken)
{
    List<Task> processTasks = new();
    while(true)
    {
        if(cancelToken.IsCancellationRequested) return;
        
        //Delay could be from 0.5 second to any value
        var delayTask = Task.Delay(WorkerDelay);
        
        var completedTasks = processTasks.Where(t => t.IsCompleted)
        var setToHandle = new HashSet<Task>(completedTasks);

        foreach(var task in setToHandle)
        {
            //Theoretical logic to handle errors and completion
            if(task.IsFaulted)
                HandleFaultedTask(task);
            else
                CountCompleted();

            processTasks.Remove(task);
        }
        
        //Theoretical logic to obtain the desired parameters.
        var currParameters = GetParameters();
        processTasks.Add(ProcessAsync(currParameters, cancelToken));
        await delayTask;
    }
    
}
//This method usually takes around 2-4 seconds
private async Task ProcessAsync(ScrapeParameters parameters CancellationToken cancelToken)
{
    //Some work with http requests 
    var response = await Client.GetAsync(parameters.ToUri());
    ...
    //Processing response
    ...
    if(newData != null)
        NewDataScraped?.Invoke(new(newData));
}

Does my implementation matches the TAP pattern?
Especially I would like to focus on RunWorker() and setToHandle