AsyncItemWriter - Facing ClassCastException when unwrapping custom class into Future

I'm writing a spring batch job that reads some data and writes it to a file. The data is partitioned into 3 chunks, each of which need to be written to an individual file before being combined. The reading and aggregation are working fine.

However, when the asynchronous writer is throwing an error -- java.lang.ClassCastException: class package.Custom cannot be cast to class java.util.concurrent.Future

It seems like my Custom DTO isn't unwrapping into a Future object.
Here's my abridged code

 @Bean
public Step workerStep() throws Exception {
return stepBuilderFactory.get(WORKER_BEAN)
.<Custom, Custom>chunk(CHUNK_SIZE)
.reader(reader(null))
.writer(writer())
.taskExecutor(threadPoolExecutor)
.throttleLimit(THROTTLE_LIMIT)
.build();
}
@Bean
@StepScope
public CustomReader reader(@Value("#{stepExecutionContext['currentMod']}") Long currentMod) {
if ( ... some logic ... ) {
return null;
}
return new CustomReader();
}
@Bean
@StepScope
public AsyncItemWriter writer() throws Exception {
AsyncItemWriter<Custom> asyncItemWriter = new AsyncItemWriter<>();
asyncItemWriter.setDelegate(delegateWriter(null));
asyncItemWriter.afterPropertiesSet();
return asyncItemWriter;
}
@Bean(destroyMethod=EMPTY)
@StepScope
public CustomWriter<Custom> delegateWriter(@Value("#{stepExecutionContext['currentMod']}") Long currentMod) {
CustomWriter<Custom> customWriter = new CustomWriter<>();
customWriter.setLineAggregator(new DelimitedLineAggregator<Custom>() {
{
setDelimiter(COMMA);
setFieldExtractor(new BeanWrapperFieldExtractor<Custom>() {
{
setNames( ... get names logic ... );
}
});
}
});
customWriter.setResource(new FileSystemResource(name));
// ... header call-back logic ...
customWriter.setAppendAllowed(true);
customWriter.setShouldDeleteIfEmpty(true);
customWriter.setShouldDeleteIfExists(true);
return customWriter;
}
@Bean
public TaskExecutor taskExecutor() {
return new SimpleAsyncTaskExecutor(THREAD_NAME_PREFIX);
} 

The AsyncItemWriter expects items that are wrapped in a Future (See Javadoc), and this is typically done by an AsyncItemProcessor. The AsyncItemWriter and AsyncItemProcessor are used in conjunction to implement a fork/join scenario, see Asynchronous Processors section.