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

//! Configuración del asistente: un TOML con valores por defecto que ya
//! incorporan lo aprendido midiendo el pipeline (ver `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 {
    /// Idioma de la conversación; se propaga a ASR y TTS.
    pub language: String,
    /// Instrucción de sistema. Pide frases cortas y sin markdown a propósito:
    /// el TTS lee literalmente los asteriscos y las viñetas.
    pub system_prompt: String,
    /// Instrucción de sistema de la pasada en que el modelo decide si usar
    /// una herramienta.
    ///
    /// Va aparte, y **sustituye** a `system_prompt` en esa pasada, por una
    /// razón medida y no por gusto: con Qwen3.5-2B, añadir cualquier
    /// indicación de estilo a esta guía —en cualquier posición, incluso dos
    /// palabras— hace que el modelo deje de llamar a las herramientas y se
    /// invente el dato. Medido sobre 8 intentos: la guía sola acierta 8/8;
    /// con «Responde breve.» detrás, 1/8; con la persona de asistente de voz,
    /// 0/8. Ver docs/RENDIMIENTO.md.
    pub tools_prompt: String,
    /// Se añade a `system_prompt` para redactar la respuesta cuando una
    /// herramienta ya ha devuelto su resultado.
    ///
    /// Aquí sí se puede añadir estilo sin miedo —la llamada ya ocurrió—, y
    /// hace falta: sin esta orden el modelo anuncia lo que acaba de hacer en
    /// vez de contar lo que averiguó.
    pub tool_result_prompt: String,
    /// Turnos de historial que se envían al modelo (0 = sin memoria).
    pub history_turns: usize,
    /// Imprime un resumen de latencias por turno al terminar cada respuesta.
    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 {
    /// Nombre (o subcadena) del dispositivo de entrada; vacío = el de por defecto.
    pub input_device: String,
    /// Ídem para la salida.
    pub output_device: String,
    /// Segundos de audio que la reproducción mantiene en cola antes de
    /// arrancar. Amortigua los baches del TTS sin añadir latencia perceptible.
    pub playback_prebuffer: f32,
    /// Ganancia aplicada a la reproducción.
    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 {
    /// Ventana de audio por decisión del detector.
    pub frame_seconds: f32,
    /// Audio conservado antes del inicio de voz para no cortar la primera sílaba.
    pub preroll_seconds: f32,
    /// Silencio que cierra una intervención.
    pub silence_hold: f32,
    /// Intervención más corta que merezca una transcripción final.
    pub min_utterance: f32,
    /// Corte forzado, que acota el coste de la decodificación final.
    pub max_utterance: f32,
    /// Múltiplo del suelo de ruido a partir del cual se considera voz.
    pub threshold_factor: f32,
    pub min_threshold: f32,
    pub max_threshold: f32,
    /// Permite hablar encima del asistente para cortarlo.
    ///
    /// Desactivado por defecto: con altavoces abiertos el micrófono se oye a sí
    /// mismo y el asistente se interrumpe solo. Actívalo con auriculares o con
    /// cancelación de eco del sistema.
    pub barge_in: bool,
    /// Con barge-in activo, cuánto más fuerte que el umbral normal debe sonar
    /// la voz para cortar. Sube el listón frente al eco del altavoz.
    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 {
    /// Carpeta del modelo Canary en ONNX.
    pub model_dir: PathBuf,
    pub source_lang: String,
    pub target_lang: String,
    /// Ventana deslizante de las transcripciones provisionales.
    pub window: f32,
    /// Avance de la ventana entre decodificaciones.
    pub step: f32,
    /// Ventanas que deben coincidir para dar una palabra por estable.
    pub stability: usize,
    /// Emitir transcripciones provisionales. Cuestan CPU y sólo sirven para
    /// verlas en pantalla: el turno se dispara con la final.
    pub partials: bool,
    /// Carga una segunda instancia del modelo para que las decodificaciones
    /// finales no bloqueen a las provisionales. Duplica la memoria.
    pub dedicated_final_model: bool,
    /// Proveedor de ejecución de ONNX Runtime: `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 a propósito: la GPU de 4 GB está ocupada por el hablante del
            // TTS, y disputársela sale más caro que decodificar en 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,
    /// Vueltas máximas del bucle de herramientas antes de rendirse.
    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,
            // Una respuesta hablada larga cansa; el recorte también acota el
            // coste de la síntesis, que es la etapa lenta.
            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,
    /// Voz registrada en el servidor, o una del modelo.
    pub voice: String,
    /// Voz clonada que se registra al arrancar, si se define.
    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,
    /// Sintetiza una frase corta al arrancar. La primera petición paga la
    /// construcción de los grafos: ~3,5 s que conviene no gastar en el
    /// primer turno real.
    pub warmup: bool,
    pub request_timeout_secs: u64,
}

impl