Function rcli_speak_streaming

src/api/rcli_api.cpp:1491–1608

// =============================================================================

int rcli_speak_streaming(RCLIHandle handle, const char* text,
                         RCLIEventCallback callback, void* user_data) {
    if (!handle || !text) return -1;
    auto* engine = static_cast<RCLIEngine*>(handle);
    if (!engine->initialized) return -1;

    std::lock_guard<std::mutex> lock(engine->mutex);
    engine->streaming_cancelled.store(false, std::memory_order_release);

    auto t_start = std::chrono::steady_clock::now();

    auto* rb = engine->pipeline.playback_ring_buffer();
    if (!rb) return rcli_speak(handle, text);  // fallback to afplay

    // Ensure CoreAudio playback is running
    if (!engine->pipeline.audio().is_running()) {
        engine->pipeline.audio().start();
    }
    rb->clear();

    // Split text into sentences and stream through TTS
    std::mutex tts_queue_mutex;
    std::condition_variable tts_queue_cv;
    std::vector<std::string> tts_queue;
    bool feeding_done = false;
    bool first_audio_fired = false;
    double total_tts_ms = 0;
    int sentence_count = 0;

    // TTS worker thread
    std::thread tts_worker([&]() {
        pthread_setname_np("rcli.tts.speak");
        while (true) {
            std::string sentence;
            {
                std::unique_lock<std::mutex> lk(tts_queue_mutex);
                tts_queue_cv.wait(lk, [&]() {
                    return !tts_queue.empty() || feeding_done;
                });
                if (tts_queue.empty() && feeding_done) break;
                if (tts_queue.empty()) continue;
                sentence = std::move(tts_queue.front());
                tts_queue.erase(tts_queue.begin());
            }

            if (engine->streaming_cancelled.load(std::memory_order_acquire)) break;

            std::vector<float> samples;
            if (engine->pipeline.using_metalrt_tts()) {
                samples = engine->pipeline.metalrt_tts().synthesize(sentence);
                total_tts_ms += engine->pipeline.metalrt_tts().last_synthesis_ms();
            } else {
                samples = engine->pipeline.tts().synthesize(sentence);
            }
            // Write with backpressure
            size_t offset = 0;
            while (offset < samples.size() &&
                   !engine->streaming_cancelled.load(std::memory_order_acquire)) {