path: root/crates/asist-core/src/config.rs

//! Assistant configuration: a TOML file whose defaults already include what
//! was learned by measuring the pipeline (see `docs/RENDIMIENTO.md`).

use std::path::{Path, PathBuf};

use serde::{Deserialize, Serialize};

use crate::error::{Error, Result};

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(default, deny_unknown_fields)]
pub struct Config {
    pub general: General,
    pub audio: AudioConfig,
    pub vad: VadConfig,
    pub asr: AsrConfig,
    pub llm: LlmConfig,
    pub tts: TtsConfig,
    pub tools: ToolsConfig,
    pub search: SearchConfig,
    pub camera: CameraConfig,
    pub screen: ScreenConfig,
    pub supervisor: SupervisorConfig,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(default, deny_unknown_fields)]
pub struct General {
    /// Conversation language; propagated to ASR and TTS.
    pub language: String,
    /// System prompt. It asks for short sentences without markdown on purpose:
    /// the TTS reads asterisks and bullets literally.
    pub system_prompt: String,
    /// System prompt for the pass where the model decides whether to use a
    /// tool.
    ///
    /// It is separate, and **replaces** `system_prompt` in that pass, for a
    /// measured reason rather than taste: with Qwen3.5-2B, adding any style
    /// instruction to this guide (in any position, even two words) makes the
    /// model stop calling tools and make the data up. Measured over 8 tries:
    /// the guide alone gets 8/8; with «Responde breve.» after it, 1/8; with the
    /// voice-assistant persona, 0/8. See docs/RENDIMIENTO.md.
    pub tools_prompt: String,
    /// Appended to `system_prompt` to write the answer once a tool has
    /// returned its result.
    ///
    /// Here style can be added safely (the call already happened), and it is
    /// needed: without this instruction the model announces what it just did
    /// instead of telling what it found out.
    pub tool_result_prompt: String,
    /// History turns sent to the model (0 = no memory).
    pub history_turns: usize,
    /// Prints a per-turn latency summary at the end of each answer.
    pub report_latency: bool,
}

impl Default for General {
    fn default() -> Self {
        Self {
            language: "es".into(),
            system_prompt: concat!(
                "Eres un asistente de voz en español. Tus respuestas se leen en voz alta, ",
                "así que responde en una o dos frases cortas, en texto plano corrido. ",
                "No uses markdown, ni listas, ni asteriscos, ni emojis, ni encabezados. ",
                "No escribas URLs ni código salvo que te lo pidan explícitamente. ",
                "Si no sabes algo, dilo en una frase."
            )
            .into(),
            tools_prompt: concat!(
                "Antes de responder, comprueba si alguna de tus herramientas te da el dato. ",
                "Si es así, llámala primero y espera su resultado; no contestes de memoria. ",
                "Sólo cuando tengas el resultado, resúmelo en una frase."
            )
            .into(),
            tool_result_prompt: concat!(
                "Acabas de recibir el resultado de una herramienta. Contesta a la pregunta ",
                "usando ese resultado y nada más. No anuncies lo que has hecho ni lo que ",
                "podrías hacer: di directamente lo que has averiguado. Si el resultado ",
                "viene en otro idioma, tradúcelo al español."
            )
            .into(),
            history_turns: 8,
            report_latency: true,
        }
    }
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(default, deny_unknown_fields)]
pub struct AudioConfig {
    /// Name (or substring) of the input device; empty = the default one.
    pub input_device: String,
    /// Same for the output.
    pub output_device: String,
    /// Seconds of audio playback keeps queued before starting. It absorbs
    /// TTS hiccups without adding noticeable latency.
    pub playback_prebuffer: f32,
    /// Gain applied to playback.
    pub output_gain: f32,
}

impl Default for AudioConfig {
    fn default() -> Self {
        Self {
            input_device: String::new(),
            output_device: String::new(),
            playback_prebuffer: 0.20,
            output_gain: 1.0,
        }
    }
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(default, deny_unknown_fields)]
pub struct VadConfig {
    /// Audio window per detector decision.
    pub frame_seconds: f32,
    /// Audio kept before speech onset so the first syllable is not cut.
    pub preroll_seconds: f32,
    /// Silence that ends an utterance.
    pub silence_hold: f32,
    /// Shortest utterance worth a final transcription.
    pub min_utterance: f32,
    /// Forced cut, which bounds the cost of the final decode.
    pub max_utterance: f32,
    /// Multiple of the noise floor above which audio counts as speech.
    pub threshold_factor: f32,
    pub min_threshold: f32,
    pub max_threshold: f32,
    /// Lets the user talk over the assistant to interrupt it.
    ///
    /// Off by default: with open speakers the microphone hears itself and the
    /// assistant interrupts itself. Turn it on with headphones or with system
    /// echo cancellation.
    pub barge_in: bool,
    /// With barge-in on, how much louder than the normal threshold the voice
    /// must be to interrupt. Raises the bar against speaker echo.
    pub barge_in_factor: f32,
}

impl Default for VadConfig {
    fn default() -> Self {
        Self {
            frame_seconds: 0.1,
            preroll_seconds: 0.3,
            silence_hold: 0.8,
            min_utterance: 0.3,
            max_utterance: 20.0,
            threshold_factor: 3.0,
            min_threshold: 0.0008,
            max_threshold: 0.02,
            barge_in: false,
            barge_in_factor: 4.0,
        }
    }
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(default, deny_unknown_fields)]
pub struct AsrConfig {
    /// Directory of the Canary ONNX model.
    pub model_dir: PathBuf,
    pub source_lang: String,
    pub target_lang: String,
    /// Sliding window for the partial transcriptions.
    pub window: f32,
    /// Window step between decodes.
    pub step: f32,
    /// Windows that must agree for a word to be considered stable.
    pub stability: usize,
    /// Emit partial transcriptions. They cost CPU and are only there to be
    /// shown on screen: the turn is triggered by the final one.
    pub partials: bool,
    /// Loads a second model instance so final decodes do not block the
    /// partial ones. Doubles the memory.
    pub dedicated_final_model: bool,
    /// ONNX Runtime execution provider: `cpu`, `cuda`, ...
    pub execution_provider: String,
    pub inter_threads: usize,
    pub intra_threads: usize,
}

impl Default for AsrConfig {
    fn default() -> Self {
        Self {
            model_dir: PathBuf::from("vendor/canary-rs/models/canary-180m-flash-onnx"),
            source_lang: "es".into(),
            target_lang: "es".into(),
            window: 6.0,
            step: 0.4,
            stability: 2,
            partials: true,
            dedicated_final_model: false,
            // CPU on purpose: the 4 GB GPU is taken by the TTS talker, and fighting
            // over it costs more than decoding on the CPU.
            execution_provider: "cpu".into(),
            inter_threads: 2,
            intra_threads: 4,
        }
    }
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(default, deny_unknown_fields)]
pub struct LlmConfig {
    pub host: String,
    pub port: u16,
    pub model: String,
    pub temperature: f32,
    pub top_p: f32,
    pub top_k: i32,
    pub min_p: f32,
    pub repeat_penalty: f32,
    pub max_tokens: u32,
    /// Maximum rounds of the tool loop before giving up.
    pub max_tool_rounds: usize,
    pub request_timeout_secs: u64,
}

impl Default for LlmConfig {
    fn default() -> Self {
        Self {
            host: "127.0.0.1".into(),
            port: 8012,
            model: String::new(),
            temperature: 0.7,
            top_p: 0.9,
            top_k: 40,
            min_p: 0.1,
            repeat_penalty: 1.1,
            // A long spoken answer is tiring; the cap also bounds the cost of
            // synthesis, which is the slow stage.
            max_tokens: 300,
            max_tool_rounds: 4,
            request_timeout_secs: 120,
        }
    }
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(default, deny_unknown_fields)]
pub struct TtsConfig {
    pub host: String,
    pub port: u16,
    /// Voice registered on the server, or one of the model's.
    pub voice: String,
    /// Cloned voice registered at startup, if defined.
    pub reference: Option<ReferenceVoice>,
    pub language: String,
    pub temperature: f32,
    pub top_k: i32,
    pub top_p: f32,
    pub repetition_penalty: f32,
    pub max_new_tokens: u32,
    /// Synthesizes a short sentence at startup. The first request pays for
    /// building the graphs: ~3.5 s better not spent on the first real turn.
    pub warmup: bool,
    pub request_timeout_secs: u64,
}

impl Default for TtsConfig {
    fn default() -> Self {
        Self {
            host: "127.0.0.1".into(),
            port: 8013,
            voice: "asistente".into(),