voice_echo/

config.rs

use serde::Deserialize;
use std::path::PathBuf;

#[derive(Debug, Deserialize, Clone)]
pub struct Config {
    pub server: ServerConfig,
    pub twilio: TwilioConfig,
    pub groq: GroqConfig,
    pub inworld: InworldConfig,
    #[serde(alias = "claude")]
    pub llm: LlmConfig,
    pub vad: VadConfig,
    #[serde(default)]
    pub api: ApiConfig,
    #[serde(default)]
    pub hold_music: Option<HoldMusicConfig>,
    #[serde(default)]
    pub identity: IdentityConfig,
    #[serde(default)]
    pub greetings: GreetingsConfig,
}

#[derive(Debug, Deserialize, Clone)]
pub struct ServerConfig {
    pub host: String,
    pub port: u16,
    pub external_url: String,
}

#[derive(Debug, Deserialize, Clone)]
pub struct TwilioConfig {
    pub account_sid: String,
    pub auth_token: String,
    pub phone_number: String,
}

#[derive(Debug, Deserialize, Clone)]
pub struct GroqConfig {
    pub api_key: String,
    #[serde(default = "default_groq_model")]
    pub model: String,
}

fn default_groq_model() -> String {
    "whisper-large-v3-turbo".to_string()
}

#[derive(Debug, Deserialize, Clone)]
pub struct InworldConfig {
    pub api_key: String,
    #[serde(default = "default_voice_id")]
    pub voice_id: String,
    #[serde(default = "default_inworld_model")]
    pub model: String,
}

fn default_voice_id() -> String {
    "Olivia".to_string()
}

fn default_inworld_model() -> String {
    "inworld-tts-1.5-max".to_string()
}

#[derive(Debug, Deserialize, Clone)]
pub struct LlmConfig {
    #[serde(default = "default_session_timeout")]
    pub session_timeout_secs: u64,
    #[serde(default)]
    pub greeting: String,
    #[serde(default = "default_name")]
    pub name: String,
    #[serde(default)]
    pub self_path: Option<String>,
    /// URL of bridge-echo multiplexer. When set, voice-echo forwards
    /// transcripts to bridge-echo instead of spawning its own Claude Code process.
    #[serde(default)]
    pub bridge_url: Option<String>,
    /// Max tokens for LLM responses. Short for voice (default: 1024).
    #[serde(default = "default_max_response_tokens")]
    pub max_response_tokens: u32,
}

fn default_max_response_tokens() -> u32 {
    1024
}

fn default_session_timeout() -> u64 {
    300
}

fn default_name() -> String {
    "Echo".to_string()
}

#[derive(Debug, Deserialize, Clone)]
pub struct VadConfig {
    #[serde(default = "default_silence_threshold")]
    pub silence_threshold_ms: u64,
    #[serde(default = "default_energy_threshold")]
    pub energy_threshold: u16,
    #[serde(default)]
    pub adaptive_threshold: bool,
    #[serde(default = "default_noise_floor_multiplier")]
    pub noise_floor_multiplier: f64,
    #[serde(default = "default_noise_floor_decay")]
    pub noise_floor_decay: f64,
    #[serde(default)]
    pub max_utterance_secs: Option<u64>,
}

fn default_silence_threshold() -> u64 {
    1500
}

fn default_energy_threshold() -> u16 {
    50
}

fn default_noise_floor_multiplier() -> f64 {
    3.0
}

fn default_noise_floor_decay() -> f64 {
    0.995
}

#[derive(Debug, Deserialize, Clone, Default)]
pub struct ApiConfig {
    /// Bearer token required for /api/* endpoints. If empty, all requests are rejected.
    #[serde(default)]
    pub token: String,
}

#[derive(Debug, Deserialize, Clone)]
pub struct HoldMusicConfig {
    pub file: String,
    #[serde(default = "default_hold_music_volume")]
    pub volume: f32,
}

fn default_hold_music_volume() -> f32 {
    0.3
}

#[derive(Debug, Deserialize, Clone)]
pub struct IdentityConfig {
    #[serde(default = "default_identity_name")]
    pub name: String,
    #[serde(default = "default_caller_name")]
    pub caller_name: String,
}

impl Default for IdentityConfig {
    fn default() -> Self {
        Self {
            name: default_identity_name(),
            caller_name: default_caller_name(),
        }
    }
}

fn default_identity_name() -> String {
    "Echo".to_string()
}

fn default_caller_name() -> String {
    "User".to_string()
}

#[derive(Debug, Deserialize, Clone)]
pub struct GreetingsConfig {
    #[serde(default = "default_inbound_greetings")]
    pub inbound: Vec<String>,
    #[serde(default = "default_outbound_template")]
    pub outbound_template: String,
    #[serde(default = "default_outbound_fallback")]
    pub outbound_fallback: String,
}

impl Default for GreetingsConfig {
    fn default() -> Self {
        Self {
            inbound: default_inbound_greetings(),
            outbound_template: default_outbound_template(),
            outbound_fallback: default_outbound_fallback(),
        }
    }
}

fn default_inbound_greetings() -> Vec<String> {
    vec!["Hello, this is {name}".to_string()]
}

fn default_outbound_template() -> String {
    "Hey {caller}, {reason}".to_string()
}

fn default_outbound_fallback() -> String {
    "Hey {caller}, I wanted to talk to you about something".to_string()
}

impl Config {
    pub fn load() -> Result<Self, Box<dyn std::error::Error>> {
        // Load .env file from same directory as config.toml
        let env_path = config_dir().join(".env");
        match dotenvy::from_path(&env_path) {
            Ok(()) => tracing::info!("Loaded .env from {}", env_path.display()),
            Err(dotenvy::Error::Io(_)) => {
                tracing::debug!(
                    "No .env file at {}, using environment only",
                    env_path.display()
                );
            }
            Err(e) => tracing::warn!("Failed to parse .env: {e}"),
        }

        let path = config_path();
        tracing::info!("Loading config from {}", path.display());

        let contents = std::fs::read_to_string(&path).map_err(|e| {
            format!(
                "Failed to read config at {}: {}. Copy config.example.toml to {}",
                path.display(),
                e,
                path.display()
            )
        })?;

        let mut config: Config = toml::from_str(&contents)?;

        // Allow env var overrides for secrets
        if let Ok(v) = std::env::var("TWILIO_ACCOUNT_SID") {
            config.twilio.account_sid = v;
        }
        if let Ok(v) = std::env::var("TWILIO_AUTH_TOKEN") {
            config.twilio.auth_token = v;
        }
        if let Ok(v) = std::env::var("GROQ_API_KEY") {
            config.groq.api_key = v;
        }
        if let Ok(v) = std::env::var("INWORLD_API_KEY") {
            config.inworld.api_key = v;
        }
        if let Ok(v) = std::env::var("ECHO_API_TOKEN") {
            config.api.token = v;
        }
        if let Ok(v) = std::env::var("SERVER_EXTERNAL_URL") {
            config.server.external_url = v;
        }

        // Backward compat: if [greetings] was not set but [llm].greeting was
        // customized, use it as the sole inbound greeting template.
        if config.greetings.inbound == default_inbound_greetings()
            && !config.llm.greeting.is_empty()
        {
            config.greetings.inbound = vec![config.llm.greeting.clone()];
        }

        Ok(config)
    }
}

fn config_dir() -> PathBuf {
    if let Ok(p) = std::env::var("ECHO_CONFIG") {
        // If pointing to a file, use its parent directory
        let path = PathBuf::from(p);
        return path.parent().map(|p| p.to_path_buf()).unwrap_or(path);
    }

    let home = std::env::var("HOME").unwrap_or_else(|_| ".".to_string());
    PathBuf::from(home).join(".voice-echo")
}

fn config_path() -> PathBuf {
    if let Ok(p) = std::env::var("ECHO_CONFIG") {
        return PathBuf::from(p);
    }

    config_dir().join("config.toml")
}