path: root/crates/asist-app/tests/integration.rs

//! Tests against the real servers.
//!
//! They skip themselves when nothing is listening, so `cargo test` stays
//! useful without 5 GB of models loaded. With the servers up they check what
//! unit tests cannot: that the protocol written here is the one the servers
//! speak, and that latencies are still where they were measured.
//!
//! To run them:  scripts/servers.sh start && cargo test -- --ignored

use std::path::PathBuf;
use std::sync::{Mutex, MutexGuard, OnceLock};
use std::time::{Duration, Instant};

use asist_core::config::Config;
use asist_core::http::Cancel;
use asist_core::tools::{Tool, ToolRegistry};
use asist_llm::chat::Conversation;
use asist_llm::{Delta, LlmClient, Message};
use asist_tools::FrameSource;
use asist_tts::TtsClient;

/// The tests take turns on the GPU.
///
/// Both servers share a 4 GB card, and measured: with the synthesis test
/// running at the same time, the LLM first token goes from ~0.5 s to ~5 s.
/// In parallel this does not measure latency, it measures who got there
/// first. The real pipeline does not have this problem because synthesis
/// does not start until the model closes its first sentence.
fn exclusive() -> MutexGuard<'static, ()> {
    static GPU: OnceLock<Mutex<()>> = OnceLock::new();
    GPU.get_or_init(|| Mutex::new(()))
        .lock()
        .unwrap_or_else(|e| e.into_inner())
}

fn config() -> Config {
    let path = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("../../config/asistente.toml");
    Config::load(path).expect("could not load the configuration")
}

/// Returns the clients, or `None` if the servers are not up.
fn clients() -> Option<(Config, LlmClient, TtsClient)> {
    let config = config();
    let llm = LlmClient::new(config.llm_authority(), &config.llm);
    let tts = TtsClient::new(config.tts_authority(), &config.tts);
    if !llm.healthy() || !tts.healthy() {
        eprintln!("servidores no disponibles; prueba omitida");
        return None;
    }
    Some((config, llm, tts))
}

#[test]
fn llm_streams_without_thinking_aloud() {
    let _gpu = exclusive();
    let Some((config, llm, _)) = clients() else {
        return;
    };

    let mut chat = Conversation::new(&config.general.system_prompt, 4);
    chat.push(Message::user("Saluda en una frase corta."));

    let started = Instant::now();
    let mut ttft = None;
    let outcome = llm
        .stream(&chat, None, &Cancel::new(), |delta| {
            if let Delta::Text(_) = delta {
                ttft.get_or_insert_with(|| started.elapsed());
            }
            true
        })
        .expect("the LLM request failed");

    assert!(!outcome.text.trim().is_empty(), "empty answer");
    // The template with an unclosed <think> puts this at 7-9 s. If this test
    // fails, llama-server was almost certainly started without --chat-template-file.
    let ttft = ttft.expect("no fragment with text arrived");
    assert!(
        ttft < Duration::from_secs(3),
        "the first token took {ttft:?}: was llama-server started with the no-reasoning template?"
    );
    assert!(
        !outcome.text.contains("<think>"),
        "reasoning is leaking into the answer: {}",
        outcome.text
    );
}

#[test]
fn llm_can_request_a_tool() {
    let _gpu = exclusive();
    let Some((config, llm, _)) = clients() else {
        return;
    };

    let tools = ToolRegistry::from_config(&config.tools);
    let mut chat = Conversation::new(
        "Eres un asistente. Usa las herramientas disponibles cuando hagan falta.",
        4,
    );
    chat.push(Message::user(
        "¿Qué hora es exactamente? Usa la herramienta.",
    ));

    let outcome = llm
        .stream(&chat, Some(&tools), &Cancel::new(), |_| true)
        .expect("the LLM request failed");

    if outcome.tool_calls.is_empty() {
        // A 2B model does not always manage to call; what is checked is that the
        // round trip works, not that the model is smart.
        eprintln!("the model did not ask for a tool: {}", outcome.text);
        return;
    }
    let call = &outcome.tool_calls[0];
    assert_eq!(call.name, "hora_actual");
    let result = tools.dispatch(call);
    assert!(result.ok, "the tool failed: {}", result.output);
    assert!(!result.output.trim().is_empty());
}

#[test]
fn synthesis_starts_playing_before_it_finishes() {
    let _gpu = exclusive();
    let Some((config, _, tts)) = clients() else {
        return;
    };

    if let Some(reference) = &config.tts.reference {
        tts.register_voice(reference)
            .expect("the voice was not registered");
    }
    // Without warmup, the first synthesis loads the graphs and measures the
    // server startup instead of the steady state.
    tts.warmup().expect("warmup failed");

    let mut blocks = 0usize;
    let outcome = tts
        .speak(
            "Hola, esto es una prueba de latencia del sintetizador de voz.",
            &Cancel::new(),
            |samples| {
                if !samples.is_empty() {
                    blocks += 1;
                }
                true
            },
        )
        .expect("synthesis failed");

    assert!(outcome.samples > 0, "no audio received");
    assert!(
        blocks > 1,
        "the audio arrived all at once ({blocks} block): check --codec-chunk-dur, \
         whose 24 s default blocks streaming"
    );
    let ttfb = outcome.ttfb.expect("no first-block mark");
    assert!(
        ttfb < Duration::from_secs(2),
        "first audio took {ttfb:?}; 585 ms was measured with --codec-chunk-dur 1.0"
    );
    eprintln!(
        "ttfb={:?} audio={:.2}s rtf={:.2}",
        ttfb,
        outcome.audio_secs(),
        outcome.rtf()
    );
}

#[test]
fn synthesis_can_be_cut_mid_sentence() {
    let _gpu = exclusive();
    let Some((config, _, tts)) = clients() else {
        return;
    };
    if let Some(reference) = &config.tts.reference {
        let _ = tts.register_voice(reference);
    }

    // It is the operation barge-in relies on: if it could not be cut, the
    // assistant would keep talking over the user until the sentence ended.
    let cancel = Cancel::new();
    let mut received = 0usize;
    let outcome = tts
        .speak(
            "Esta es una frase larga que no debería llegar a escucharse entera \
             porque se va a cortar en cuanto empiece a sonar el primer bloque.",
            &cancel,
            |samples| {
                received += samples.len();
                // Cut at the first block.
                false
            },
        )
        .expect("synthesis failed");

    assert!(outcome.cancelled, "it should have been marked as cancelled");
    assert!(
        outcome.audio_secs() < 3.0,
        "{:.1} s of audio received: the cut had no effect",
        outcome.audio_secs()
    );
}

#[test]
fn cloned_voice_gets_registered() {
    let _gpu = exclusive();
    let Some((config, _, tts)) = clients() else {
        return;
    };
    let Some(reference) = &config.tts.reference else {
        eprintln!("no reference voice configured; test skipped");
        return;
    };
    tts.register_voice(reference)
        .expect("the voice was not registered");
    let voices = tts.voices().expect("could not list the voices");
    assert!(
        voices.contains(&reference.name),
        "«{}» no aparece entre {voices:?}",
        reference.name
    );
}

#[test]
#[ignore = "loads the ASR model (~200 MB) and decodes; slow"]
fn asr_transcribes_what_tts_synthesizes() {
    let _gpu = exclusive();
    // The full loop without a microphone: a known sentence is synthesized and
    // the recognizer is checked to get it back. It is the only test that
    // exercises ASR and TTS on the same audio.
    let Some((config, _, tts)) = clients() else {
        return;
    };
    if let Some(reference) = &config.tts.reference {
        let _ = tts.register_voice(reference);
    }

    let sentence = "hola qué tal estás hoy";
    let mut audio: Vec<f32> = Vec::new();
    tts.speak(sentence, &Cancel::new(), |samples| {
        audio.extend_from_slice(samples);
        true
    })
    .expect("synthesis failed");
    assert!(!audio.is_empty(), "no audio was generated");

    let