Сохранить обработчик завершения асинхронной операции boost asio

Мне нужно реализовать собственную асинхронную операцию, используя библиотеку boost asio. Саму операцию выполнит сторонняя библиотека.

Подход, которому я следую:

1. запустите асинхронную операцию через boost::asio::async_initiate. Для этого я реализую инициирующую функцию
2. Сохраните обработчик асинхронного завершения, который передается с помощью boost::asio::async_initiate в инициирующую функцию.
3. Запустить стороннюю асинхронную операцию
4. Выйти из функции запуска.
   Согласно инициирующая функция boost reference должна быть неблокирующей.
5. Когда асинхронная операция завершится, вызовите ранее сохраненный обработчик асинхронного завершения.

Код, повторяющий это, приведен ниже. Сторонняя библиотека здесь моделируется с отдельным потоком и логическим флагом:

#include <iostream>
#include <string>
#include <thread>
#include <functional>
#include <atomic>
#include <boost/asio.hpp>
#include <boost/asio/detached.hpp>
#include <boost/asio/experimental/awaitable_operators.hpp>
#include <boost/asio/experimental/co_spawn.hpp>

std::atomic<bool> asyncOpStarted = false;

using signature = void(std::string);
std::function<signature> completionHandler;

// Dummy implementation to simulate the async operation
void start_operation()
{
    asyncOpStarted = true;
    std::cout << "Async operation starting..." << std::endl;
}

void do_async_loop()
{
    while (!asyncOpStarted) {
        // sleep & check if operation started
        std::cout << "Waiting for async start..." << std::endl;
        std::this_thread::sleep_for(std::chrono::seconds(1));
    };

    std::cout << "Async operation started..." << std::endl;
    // simualate delay
    std::this_thread::sleep_for(std::chrono::seconds(1));
    std::cout << "Async operation finished. Invoke completion handler..." << std::endl;
    completionHandler("Done");
}

// Async operation implementation
template <typename CompletionToken>
auto async_do_operation(boost::asio::io_context& io, CompletionToken&& token)
{  
    return boost::asio::async_initiate<CompletionToken, signature>(
        [&](auto&& handler) {
            // I need to store "handler" here

            // This doesn't work. std::function<...> requires handler to be copyable:
            //completionHandler = [h = std::move(handler)](std::string res) mutable {
            //    h(res);
            //};

            start_operation();
        }, 
        std::move(token)
    );
}

int main()
{
    std::thread t(do_async_loop);

    boost::asio::io_context io;
    
    boost::asio::co_spawn(io, [&]() -> boost::asio::awaitable<void> {
        try {
            // Use `boost::asio::use_awaitable` as the completion token
            auto result = co_await async_do_operation(io, boost::asio::use_awaitable);
            std::cout << "Coroutine: " << result << std::endl;
        } catch (...) {
            std::cerr << "Exception caught" << std::endl;
        }
    }, boost::asio::detached);

    // Run the io_context to process async events
    io.run();
  
}

У меня не получается выполнить шаг (2). Никак нельзя сохранить обработчик завершения. Я попробовал следующее:

1. Используйте std::function и переместите обработчик завершения в список захвата
   Это не сработало, потому что std::function требует, чтобы обработчик был копируемым.
2. Создайте общий указатель на обработчик завершения, который затем можно будет записать в лямбда-выражение.
3. Сохраните обработчик завершения непосредственно в переменной.

Итак, мои вопросы:

1. Правильно ли я реализую интеграцию?
2. Если да, то каков подход, разработанный в boost asio для сохранения обработчика завершения во время работы?

Заранее спасибо.