use crate::Role;
use crate::util::{UnwrapPoison, is_http_url};
use anyhow::{Context, Result};
use directories::UserDirs;
use std::path::PathBuf;
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::{OnceLock, RwLock, RwLockReadGuard};
use tokio::fs;
pub(crate) const DEFAULT_PROVIDER_ENDPOINT: &str = "https://openrouter.ai/api/v1";
pub(crate) const DEFAULT_MANAGER_MODEL: &str = "deepseek/deepseek-v4.1-flash";
pub(crate) const DEFAULT_WORKER_MODEL: &str = "deepseek/deepseek-v4.1-flash";
const OLD_DEFAULT_MANAGER_MODEL: &str = "z-ai/glm-5.3-flash";
const OLD_DEFAULT_WORKER_MODEL: &str = "deepseek/deepseek-v4-flash-vision-exp";
pub(crate) const VIDEO_TRANSCRIPTION_MODEL: &str = "qwen/qwen3.8-flash";
pub(crate) const DEFAULT_IMAGE_GEN_MODEL: &str = "google/gemini-3.1-flash-image";
pub(crate) const DEFAULT_VIDEO_MODEL: &str = "minimax/hailuo-3";
const FRESH_INSTALL_IMAGE_GEN_MODELS: &str =
"google/gemini-3.1-flash-image\nmicrosoft/mai-image-2.5\nqwen/qwen-image-3-pro";
const FRESH_INSTALL_VIDEO_MODELS: &str = "bytedance/seedance-2.0-mini\nminimax/hailuo-3";
pub(crate) const DEFAULT_TTS_LANGUAGE: &str = "na";
#[derive(Debug, Clone, PartialEq)]
pub struct ModelRouting {
pub model: String,
pub provider_order: Option<String>,
}
impl ModelRouting {
pub(crate) fn upsert(
routings: &mut Vec<ModelRouting>,
model: impl Into<String>,
set_field: impl FnOnce(&mut ModelRouting),
) {
let model = model.into();
if let Some(existing) = routings.iter_mut().find(|mr| mr.model == model) {
set_field(existing);
} else {
let mut new = ModelRouting {
model,
provider_order: None,
};
set_field(&mut new);
routings.push(new);
}
}
}
#[derive(Debug, Clone)]
pub struct ConfigData {
pub provider_key: Option<String>,
pub provider_endpoint: Option<String>,
pub provider_endpoint_key: Option<String>,
pub manager_model: Option<String>,
pub worker_model: Option<String>,
pub image_gen_models: Option<String>,
pub video_models: Option<String>,
pub firecrawl_key: Option<String>,
pub exa_key: Option<String>,
pub web_search_provider: Option<String>,
pub telegram_bot_token: Option<String>,
pub audio_transcription_use_local: Option<String>,
pub voice_enabled: Option<String>,
pub tts_enabled: Option<String>,
pub tts_language: Option<String>,
pub wake_word_templates: Option<String>,
pub onboarding_state: Option<String>,
pub model_routings: Vec<ModelRouting>,
}
macro_rules! string_config_fields {
(
$(
$field:ident [ $($annotation:tt)* ]
),* $(,)?
) => {
::paste::paste! {
$(
pub const [<CONFIG_KEY_ $field:upper>]: &str = stringify!($field);
)*
}
impl ConfigData {
pub(crate) const STRUCT_FIELDS_DEFAULT: Self = Self {
$($field: None,)*
model_routings: Vec::new(),
};
#[must_use]
pub fn string_fields(&self) -> Vec<(&'static str, Option<&str>)> {
vec![$((stringify!($field), self.$field.as_deref())),*]
}
#[must_use]
pub fn set_string_field(&mut self, key: &str, value: &str) -> bool {
match key {
$(stringify!($field) => self.$field = Some(value.to_owned()),)*
_ => return false,
}
true
}
#[must_use]
pub(crate) fn get_string_field(&self, key: &str) -> Option<&str> {
match key {
$(stringify!($field) => self.$field.as_deref(),)*
_ => None,
}
}
#[must_use]
fn has_string_field(&self, key: &str) -> bool {
match key {
$(stringify!($field) => true,)*
_ => false,
}
}
fn normalize_string_fields(&mut self) {
$(self.$field = non_empty(self.$field.take());)*
}
}
impl ConfigReload {
$(
string_config_fields!(@accessor $field $($annotation)*);
)*
}
};
(@accessor $field:ident non_empty) => {
#[doc = concat!(
"Returns the configured `", stringify!($field),
"`, with empty/whitespace values collapsed to `None`."
)]
#[must_use]
pub fn $field(&self) -> Option<String> {
non_empty(self.read().$field.clone())
}
};
(@accessor $field:ident or($default:expr)) => {
#[doc = concat!(
"Returns the configured `", stringify!($field),
"`, falling back to the default if unset."
)]
#[must_use]
pub fn $field(&self) -> String {
resolve_or(self.read().$field.clone(), $default)
}
};
(@accessor $field:ident list_or(default = $default:expr)) => {
#[doc = concat!(
"Returns the list of available `", stringify!($field), "`.",
"\n\nIf unset or the parsed newline-separated list is empty,",
" falls back to a built-in default."
)]
#[must_use]
pub fn $field(&self) -> Vec<String> {
let guard = self.read();
resolve_list_or(guard.$field.as_deref(), $default)
}
};
}
string_config_fields! {
provider_key [non_empty],
provider_endpoint [or(DEFAULT_PROVIDER_ENDPOINT)],
provider_endpoint_key [non_empty],
manager_model [or(DEFAULT_MANAGER_MODEL)],
worker_model [or(DEFAULT_WORKER_MODEL)],
image_gen_models [list_or(default = DEFAULT_IMAGE_GEN_MODEL)],
video_models [list_or(default = DEFAULT_VIDEO_MODEL)],
firecrawl_key [non_empty],
exa_key [non_empty],
web_search_provider [non_empty],
telegram_bot_token [non_empty],
audio_transcription_use_local [non_empty],
voice_enabled [non_empty],
tts_enabled [non_empty],
tts_language [or(DEFAULT_TTS_LANGUAGE)],
wake_word_templates [non_empty],
onboarding_state [non_empty],
}
impl ConfigData {
fn normalize_entries(&mut self) {
for mr in &mut self.model_routings {
mr.provider_order = non_empty(mr.provider_order.take());
}
}
pub(crate) fn normalize(&mut self) {
self.normalize_string_fields();
self.normalize_entries();
self.model_routings.sort_by(|a, b| a.model.cmp(&b.model));
}
}
#[must_use]
pub(crate) fn trimmed_or_none(s: &str) -> Option<String> {
let trimmed = s.trim();
if trimmed.is_empty() {
None
} else {
Some(trimmed.to_owned())
}
}
#[must_use]
pub(crate) fn parse_newline_list(s: &str) -> Vec<String> {
s.split('\n')
.map(|s| s.trim().to_string())
.filter(|s| !s.is_empty())
.collect()
}
#[must_use]
fn non_empty(val: Option<String>) -> Option<String> {
val.and_then(|s| trimmed_or_none(&s))
}
#[must_use]
pub(crate) fn resolve_or(val: Option<String>, fallback: &str) -> String {
non_empty(val).unwrap_or(fallback.to_string())
}
#[must_use]
fn resolve_list_or(list_field: Option<&str>, default_value: &str) -> Vec<String> {
if let Some(raw) = list_field {
let parsed = parse_newline_list(raw);
if !parsed.is_empty() {
return parsed;
}
}
vec![default_value.to_string()]
}
#[must_use]
pub(crate) fn normalize_endpoint_url(url: &str) -> String {
let t = url.trim().trim_end_matches('/');
let t = t
.strip_suffix("/chat/completions")
.unwrap_or(t)
.trim_end_matches('/');
if let Some(scheme_end) = t.find("://") {
let scheme_and_dots = &t[..scheme_end + 3];
let rest = &t[scheme_end + 3..];
let authority_end = rest.find('/').unwrap_or(rest.len());
let authority = &rest[..authority_end];
let path = &rest[authority_end..];
format!(
"{}{}{}",
scheme_and_dots.to_ascii_lowercase(),
authority.to_ascii_lowercase(),
path
)
} else {
t.to_string()
}
}
#[must_use]
pub(crate) fn is_default_endpoint(endpoint: &str) -> bool {
normalize_endpoint_url(endpoint) == normalize_endpoint_url(DEFAULT_PROVIDER_ENDPOINT)
}
#[must_use]
pub(crate) fn is_custom_endpoint(endpoint: &str) -> bool {
!is_default_endpoint(endpoint)
}
#[must_use]
pub(crate) fn provider_configured() -> bool {
is_custom_endpoint(&CONFIG.provider_endpoint()) || CONFIG.provider_key().is_some()
}
#[must_use]
pub(crate) fn effective_chat_endpoint(config: &ConfigData) -> String {
resolve_or(config.provider_endpoint.clone(), DEFAULT_PROVIDER_ENDPOINT)
}
#[must_use]
pub(crate) fn chat_credential(config: &ConfigData) -> Option<String> {
let ep = effective_chat_endpoint(config);
if is_custom_endpoint(&ep) {
non_empty(config.provider_endpoint_key.clone())
} else {
non_empty(config.provider_key.clone())
}
}
pub static CONFIG: ConfigReload = ConfigReload::const_new();
static CONFIG_PERSIST_LOCK: OnceLock<tokio::sync::Mutex<()>> = OnceLock::new();
fn persist_lock() -> &'static tokio::sync::Mutex<()> {
CONFIG_PERSIST_LOCK.get_or_init(|| tokio::sync::Mutex::new(()))
}
static CONFIG_DB_FRESH_AT_BOOT: AtomicBool = AtomicBool::new(false);
pub struct ConfigReload {
storage_root: OnceLock<PathBuf>,
inner: RwLock<ConfigData>,
}
impl ConfigReload {
#[must_use]
pub const fn const_new() -> Self {
Self {
storage_root: OnceLock::new(),
inner: RwLock::new(ConfigData::STRUCT_FIELDS_DEFAULT),
}
}
pub fn global_storage_root(&self) -> PathBuf {
self.storage_root
.get()
.expect("CONFIG storage_root not initialized")
.clone()
}
#[must_use]
pub fn try_storage_root(&self) -> Option<PathBuf> {
self.storage_root.get().cloned()
}
pub(crate) fn set_storage_root(&self, root: PathBuf) {
self.storage_root
.set(root)
.expect("CONFIG storage_root already set");
}
#[cfg(test)]
pub(crate) fn try_set_storage_root(&self, root: PathBuf) -> std::result::Result<(), PathBuf> {
self.storage_root.set(root)
}
fn read(&self) -> RwLockReadGuard<'_, ConfigData> {
self.inner.read().unwrap_poison()
}
pub(crate) fn swap(&self, new_config: ConfigData) {
*self.inner.write().unwrap_poison() = new_config;
}
#[must_use]
pub fn snapshot(&self) -> ConfigData {
self.read().clone()
}
#[must_use]
pub fn onboarding_stage(&self) -> OnboardingState {
OnboardingState::from_raw(self.onboarding_state().as_deref())
}
#[must_use]
pub fn set_string_field(&self, key: &str, value: &str) -> bool {
let mut guard = self.inner.write().unwrap_poison();
guard.set_string_field(key, value)
}
fn set_model_routing_row(&self, model: &str, provider_order: Option<String>) {
let mut guard = self.inner.write().unwrap_poison();
if provider_order.is_none() {
guard.model_routings.retain(|mr| mr.model != model);
} else {
ModelRouting::upsert(&mut guard.model_routings, model, |mr| {
mr.provider_order = provider_order;
});
}
}
pub(crate) fn model_routing_by_key(&self, model: &str) -> Option<ModelRouting> {
let guard = self.read();
guard
.model_routings
.iter()
.find(|mr| mr.model == model)
.cloned()
}
#[must_use]
pub(crate) fn model_routing(&self, model: &str) -> ModelRouting {
let provider_order = self
.model_routing_by_key(model)
.and_then(|mr| mr.provider_order)
.or_else(|| default_model_routing(model).map(str::to_string));
ModelRouting {
model: model.to_string(),
provider_order,
}
}
#[must_use]
pub fn role_model(&self, role: Role) -> String {
match role {
Role::Manager
| Role::Assistant
| Role::Discovery
| Role::Engineer
| Role::Maintainer => self.manager_model(),
_ => self.worker_model(),
}
}
}
pub fn default_config_dir() -> Result<PathBuf> {
if let Ok(home) = std::env::var("HOME")
&& !home.is_empty()
{
return Ok(PathBuf::from(home).join(".mahbot"));
}
let home = UserDirs::new()
.map(|u| u.home_dir().to_path_buf())
.context("Could not find home directory")?;
Ok(home.join(".mahbot"))
}
pub async fn load_or_init() -> Result<()> {
let mahbot_dir = default_config_dir()?;
fs::create_dir_all(&mahbot_dir)
.await
.context("Failed to create config directory")?;
CONFIG.set_storage_root(mahbot_dir.clone());
CONFIG_DB_FRESH_AT_BOOT.store(config_db_is_fresh(&mahbot_dir), Ordering::Release);
CONFIG.swap(ConfigData::STRUCT_FIELDS_DEFAULT);
tracing::info!(
"Config system initialised (storage root: {}).",
mahbot_dir.display()
);
Ok(())
}
fn config_db_is_fresh(mahbot_dir: &std::path::Path) -> bool {
!crate::db::store_db_path(mahbot_dir, "config").exists()
}
pub(crate) fn default_model_routing(model: &str) -> Option<&'static str> {
model
.to_ascii_lowercase()
.contains("deepseek")
.then_some("deepseek")
}
async fn seed_fresh_install_defaults(
fresh: bool,
store: &crate::config_db::ConfigStore,
) -> Result<()> {
if !fresh {
return Ok(());
}
store
.set_kv(CONFIG_KEY_AUDIO_TRANSCRIPTION_USE_LOCAL, "false")
.await?;
store
.set_kv(CONFIG_KEY_IMAGE_GEN_MODELS, FRESH_INSTALL_IMAGE_GEN_MODELS)
.await?;
store
.set_kv(CONFIG_KEY_VIDEO_MODELS, FRESH_INSTALL_VIDEO_MODELS)
.await?;
for default_model in [DEFAULT_MANAGER_MODEL, DEFAULT_WORKER_MODEL] {
if let Some(provider) = default_model_routing(default_model) {
store
.save_model_routing(default_model, Some(provider))
.await?;
}
}
tracing::info!(
"Fresh config database: seeded fresh-install defaults (audio transcription off; image/video generation model sets; provider routing for the default model slots)"
);
Ok(())
}
async fn seed_fresh_install_defaults_from_flag(
store: &crate::config_db::ConfigStore,
) -> Result<()> {
let fresh = CONFIG_DB_FRESH_AT_BOOT.swap(false, Ordering::AcqRel);
seed_fresh_install_defaults(fresh, store).await
}
async fn migrate_old_default_models(store: &crate::config_db::ConfigStore) -> Result<()> {
let changed_manager = store
.migrate_kv_if_equals(
CONFIG_KEY_MANAGER_MODEL,
OLD_DEFAULT_MANAGER_MODEL,
DEFAULT_MANAGER_MODEL,
)
.await?;
let changed_worker = store
.migrate_kv_if_equals(
CONFIG_KEY_WORKER_MODEL,
OLD_DEFAULT_WORKER_MODEL,
DEFAULT_WORKER_MODEL,
)
.await?;
for (changed, model) in [
(changed_manager, DEFAULT_MANAGER_MODEL),
(changed_worker, DEFAULT_WORKER_MODEL),
] {
if changed > 0
&& let Some(provider) = default_model_routing(model)
{
store.save_model_routing(model, Some(provider)).await?;
}
}
if changed_manager > 0 || changed_worker > 0 {
tracing::info!(
manager_rows = changed_manager,
worker_rows = changed_worker,
"Migrated stored old default models to the current defaults"
);
}
Ok(())
}
pub async fn reload_from_db() -> Result<()> {
let store = crate::config_db::store();
let mut config = ConfigData::STRUCT_FIELDS_DEFAULT;
seed_fresh_install_defaults_from_flag(store).await?;
migrate_old_default_models(store).await?;
let kvs = store.get_all_kv().await?;
for (key, value) in &kvs {
if !config.set_string_field(key, value) {
tracing::debug!(key, "Unknown config key, ignoring");
}
}
purge_unknown_kv_orphans(store, &kvs).await;
let routings = store.get_all_model_routings().await?;
config.model_routings = routings;
config.normalize();
CONFIG.swap(config);
tracing::info!("Config reloaded from DB");
Ok(())
}
async fn purge_unknown_kv_orphans(store: &crate::config_db::ConfigStore, kvs: &[(String, String)]) {
let orphans: Vec<String> = kvs
.iter()
.filter(|(key, _)| {
!ConfigData::STRUCT_FIELDS_DEFAULT.has_string_field(key)
&& key != crate::workspace::NIGHTLY_DISCOVERY_LAST_PASS_KV_KEY
&& key != crate::temp::TEMP_CLEANUP_LAST_RUN_KV_KEY
&& key != crate::temp::TEMP_CLEANUP_MODE_KV_KEY
})
.map(|(key, _)| key.clone())
.collect();
if !orphans.is_empty() {
tracing::debug!(keys=?orphans, "Purging unknown config_kv orphans");
}
for key in orphans {
match store.delete_kv(&key).await {
Ok(()) => tracing::debug!(key, "Purged unknown config_kv orphan"),
Err(e) => {
tracing::warn!(key, error=%e, "Failed to purge unknown config_kv orphan (transient, ignoring)");
}
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct PersistOutcome {
pub value: String,
pub warning: Option<String>,
}
pub async fn persist_settled_string_field(key: &str, value: &str) -> Result<PersistOutcome> {
let _guard = persist_lock().lock().await;
let trimmed = value.trim().to_string();
if key == CONFIG_KEY_WAKE_WORD_TEMPLATES {
return Ok(PersistOutcome {
value: CONFIG.wake_word_templates().unwrap_or_default(),
warning: None,
});
}
let canonical = trimmed_or_none(&trimmed).unwrap_or_default();
match key {
CONFIG_KEY_PROVIDER_ENDPOINT => {
let probe = probe_validate_write(key, &trimmed).await?;
if trimmed.is_empty() || crate::config::is_default_endpoint(&trimmed) {
let store = crate::config_db::store();
match store.delete_kv(CONFIG_KEY_PROVIDER_ENDPOINT_KEY).await {
Ok(()) => {
let _ = CONFIG.set_string_field(CONFIG_KEY_PROVIDER_ENDPOINT_KEY, "");
}
Err(e) => {
tracing::warn!(
error = %e,
"failed to clear custom endpoint key row (harmless orphan)"
);
}
}
}
let effective = effective_chat_endpoint(&probe);
let warning = if crate::config::is_custom_endpoint(&effective) {
match crate::providers::warmup_provider_from_config(&probe).await {
Ok(()) => None,
Err(e) => {
let msg = format!("Saved, but {effective} is unreachable right now: {e:#}");
tracing::warn!(key, endpoint = %effective, "Provider warmup failed (non-fatal, value saved): {e:#}");
Some(msg)
}
}
} else {
None
};
crate::providers::recreate_all(&CONFIG.snapshot(), false).await;
return Ok(PersistOutcome {
value: canonical,
warning,
});
}
CONFIG_KEY_PROVIDER_KEY | CONFIG_KEY_PROVIDER_ENDPOINT_KEY => {
let _ = probe_validate_write(key, &trimmed).await?;
crate::providers::recreate_all(&CONFIG.snapshot(), true).await;
return Ok(PersistOutcome {
value: canonical,
warning: None,
});
}
CONFIG_KEY_TELEGRAM_BOT_TOKEN => {
let old_token = CONFIG.telegram_bot_token();
let new_token = trimmed_or_none(&trimmed);
if new_token != old_token
&& let Some(ref token) = new_token
{
crate::channels::telegram::TelegramChannel::validate_token(token).await?;
}
write_kv_and_update_config(CONFIG_KEY_TELEGRAM_BOT_TOKEN, &trimmed).await?;
let persisted = CONFIG.telegram_bot_token();
if persisted != old_token {
crate::channels::telegram::restart_telegram_listener(persisted.as_deref()).await?;
}
}
_ => {
write_kv_and_update_config(key, &trimmed).await?;
}
}
Ok(PersistOutcome {
value: canonical,
warning: None,
})
}
async fn probe_validate_write(key: &str, trimmed: &str) -> Result<ConfigData> {
let mut probe = CONFIG.snapshot();
let _ = probe.set_string_field(key, trimmed);
probe.normalize();
validate_config(&probe)?;
write_kv_and_update_config(key, trimmed).await?;
Ok(probe)
}
pub async fn persist_settled_routing_order(model: &str, order: &str) -> Result<String> {
let _guard = persist_lock().lock().await;
let order = trimmed_or_none(order);
save_routing_row(model, order).await
}
async fn save_routing_row(model: &str, order: Option<String>) -> Result<String> {
let store = crate::config_db::store();
store.save_model_routing(model, order.as_deref()).await?;
CONFIG.set_model_routing_row(model, order.clone());
Ok(order.unwrap_or_default())
}
async fn write_kv_and_update_config(key: &str, trimmed: &str) -> Result<()> {
if !ConfigData::STRUCT_FIELDS_DEFAULT.has_string_field(key) {
anyhow::bail!("unknown config field: {key}");
}
let store = crate::config_db::store();
if trimmed.is_empty() {
store.delete_kv(key).await?;
} else {
store.set_kv(key, trimmed).await?;
}
let _ = CONFIG.set_string_field(key, trimmed);
Ok(())
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum OnboardingState {
Init,
Finished,
}
impl OnboardingState {
#[must_use]
pub fn from_raw(s: Option<&str>) -> Self {
match s {
Some("welcomed" | "finished") => Self::Finished,
_ => Self::Init,
}
}
#[must_use]
pub fn as_str(self) -> &'static str {
match self {
Self::Init => "init",
Self::Finished => "finished",
}
}
}
fn validate_config(config: &ConfigData) -> Result<()> {
if let Some(ref ep) = config.provider_endpoint {
if !is_http_url(ep) {
anyhow::bail!(
"Provider endpoint must be a valid URL starting with https:// or http://"
);
}
let rest = ep
.strip_prefix("https://")
.or_else(|| ep.strip_prefix("http://"))
.unwrap();
let auth_end = rest.find(['/', '?', '#']).unwrap_or(rest.len());
let authority = rest[..auth_end].trim();
if authority.is_empty() || authority.starts_with(':') {
anyhow::bail!(
"Provider endpoint must be a valid URL starting with https:// or http://"
);
}
}
if let Some(ref key) = config.provider_key
&& key.contains("...")
{
anyhow::bail!("Provider key is still the placeholder value — please set a real key");
}
Ok(())
}
#[cfg(test)]
pub(crate) fn model_routing(model: &str, provider_order: Option<&str>) -> ModelRouting {
ModelRouting {
model: model.into(),
provider_order: provider_order.map(String::from),
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn onboarding_from_raw_maps_legacy_welcomed_to_finished() {
assert_eq!(
OnboardingState::from_raw(Some("welcomed")),
OnboardingState::Finished
);
assert_eq!(
OnboardingState::from_raw(Some("finished")),
OnboardingState::Finished
);
assert_eq!(
OnboardingState::from_raw(Some("garbage")),
OnboardingState::Init
);
assert_eq!(OnboardingState::from_raw(None), OnboardingState::Init);
}
#[test]
fn string_fields_roundtrip() {
let mut config = ConfigData::STRUCT_FIELDS_DEFAULT;
for (_key, value) in config.string_fields() {
assert!(value.is_none(), "field should start as None");
}
let keys: Vec<&str> = config.string_fields().iter().map(|(k, _)| *k).collect();
for &key in &keys {
let test_value = format!("test-{key}");
let recognized = config.set_string_field(key, &test_value);
assert!(recognized, "key '{key}' should be recognized");
let found = config.get_string_field(key);
assert_eq!(
found,
Some(test_value.as_str()),
"value for '{key}' should match after set"
);
}
let _ = config.set_string_field("provider_key", "");
let pk = config.get_string_field("provider_key");
assert_eq!(
pk,
Some(""),
"empty string stored as-is by set_string_field"
);
let _ = config.set_string_field("provider_key", " ");
let pk = config.get_string_field("provider_key");
assert_eq!(
pk,
Some(" "),
"whitespace-only string stored as-is by set_string_field"
);
config.normalize();
let pk = config.get_string_field("provider_key");
assert!(pk.is_none(), "normalize() collapses empty string to None");
assert!(!config.set_string_field("nonexistent_key", "value"));
}
#[test]
fn config_reload_accessors_roundtrip() {
let reload = ConfigReload::const_new();
assert_eq!(reload.provider_key(), None, "unset provider_key is None");
let mut config = ConfigData::STRUCT_FIELDS_DEFAULT;
assert!(config.set_string_field("provider_key", "sk-test"));
reload.swap(config);
assert_eq!(reload.provider_key(), Some("sk-test".to_string()));
reload.swap(ConfigData::STRUCT_FIELDS_DEFAULT);
assert_eq!(
reload.manager_model(),
DEFAULT_MANAGER_MODEL,
"unset manager_model falls back to default"
);
assert_eq!(
reload.worker_model(),
DEFAULT_WORKER_MODEL,
"unset worker_model falls back to default"
);
let mut custom_cfg = ConfigData::STRUCT_FIELDS_DEFAULT;
assert!(custom_cfg.set_string_field("provider_endpoint", "https://custom.example/v1"));
reload.swap(custom_cfg);
assert_eq!(
reload.provider_endpoint(),
"https://custom.example/v1",
"or field honors a persisted custom value"
);
reload.swap(ConfigData::STRUCT_FIELDS_DEFAULT);
assert_eq!(reload.provider_endpoint(), DEFAULT_PROVIDER_ENDPOINT);
let mut empty = ConfigData::STRUCT_FIELDS_DEFAULT;
assert!(empty.set_string_field("provider_key", ""));
reload.swap(empty);
assert_eq!(
reload.provider_key(),
None,
"empty string is collapsed to None"
);
reload.swap(ConfigData::STRUCT_FIELDS_DEFAULT);
assert_eq!(
reload.image_gen_models(),
vec![DEFAULT_IMAGE_GEN_MODEL.to_string()],
"unset image_gen_models falls back to default"
);
let mut list_config = ConfigData::STRUCT_FIELDS_DEFAULT;
assert!(list_config.set_string_field("image_gen_models", "model-a\nmodel-b\nmodel-c"));
reload.swap(list_config);
assert_eq!(
reload.image_gen_models(),
vec!["model-a", "model-b", "model-c"]
);
}
#[test]
fn role_model_maps_roles_to_slots() {
let reload = ConfigReload::const_new();
let mut config = ConfigData::STRUCT_FIELDS_DEFAULT;
assert!(config.set_string_field("manager_model", "manager-slot-model"));
assert!(config.set_string_field("worker_model", "worker-slot-model"));
reload.swap(config);
for role in [
Role::Manager,
Role::Assistant,
Role::Discovery,
Role::Engineer,
Role::Maintainer,
] {
assert_eq!(reload.role_model(role), "manager-slot-model");
}
for role in [
Role::Analyst,
Role::Coder,
Role::Qa,
Role::Reviewer,
Role::Sanitation,
] {
assert_eq!(reload.role_model(role), "worker-slot-model");
}
}
#[test]
fn trimmed_or_none_trims_whitespace() {
assert_eq!(trimmed_or_none(" value "), Some("value".to_string()));
assert_eq!(trimmed_or_none(" "), None);
assert_eq!(trimmed_or_none(""), None);
}
#[test]
fn endpoint_normalization_default_vs_custom() {
assert!(is_default_endpoint(DEFAULT_PROVIDER_ENDPOINT));
assert!(is_default_endpoint("https://openrouter.ai/api/v1/"));
assert!(is_default_endpoint(" https://openrouter.ai/api/v1 "));
assert!(is_default_endpoint("HTTPS://OPENROUTER.AI/api/v1"));
assert!(is_default_endpoint(
"https://openrouter.ai/api/v1/chat/completions"
));
assert!(is_default_endpoint(
"https://openrouter.ai/api/v1/chat/completions/"
));
assert!(is_custom_endpoint("http://localhost:8080/v1"));
assert!(is_custom_endpoint("https://custom.example/v1"));
assert!(!is_custom_endpoint(DEFAULT_PROVIDER_ENDPOINT));
}
#[test]
fn chat_credential_isolates_keys_per_endpoint() {
let mut cfg = ConfigData::STRUCT_FIELDS_DEFAULT;
assert!(cfg.set_string_field("provider_key", "sk-or"));
assert_eq!(chat_credential(&cfg).as_deref(), Some("sk-or"));
let mut cfg = ConfigData::STRUCT_FIELDS_DEFAULT;
assert!(cfg.set_string_field("provider_key", "sk-or"));
assert!(cfg.set_string_field("provider_endpoint", "http://localhost:8080/v1"));
assert!(cfg.set_string_field("provider_endpoint_key", "sk-custom"));
assert_eq!(chat_credential(&cfg).as_deref(), Some("sk-custom"));
let mut cfg = ConfigData::STRUCT_FIELDS_DEFAULT;
assert!(cfg.set_string_field("provider_key", "sk-or"));
assert!(cfg.set_string_field("provider_endpoint", "http://localhost:8080/v1"));
assert!(cfg.set_string_field("provider_endpoint_key", ""));
assert_eq!(chat_credential(&cfg), None);
let mut cfg = ConfigData::STRUCT_FIELDS_DEFAULT;
assert!(cfg.set_string_field("provider_endpoint", "http://localhost:8080/v1"));
assert_eq!(chat_credential(&cfg), None);
assert_eq!(chat_credential(&ConfigData::STRUCT_FIELDS_DEFAULT), None);
}
#[test]
fn normalize_entries_works() {
let mut config = ConfigData {
model_routings: vec![
ModelRouting {
model: "test-model".into(),
provider_order: Some(" ".into()),
},
ModelRouting {
model: "test-model-2".into(),
provider_order: Some(" OpenAi, Anthropic ".into()),
},
],
..ConfigData::STRUCT_FIELDS_DEFAULT
};
config.normalize_entries();
assert_eq!(config.model_routings[0].provider_order, None);
assert_eq!(
config.model_routings[1].provider_order,
Some("OpenAi, Anthropic".into())
);
}
#[test]
fn upsert_model_routing_fields() {
{
let mut items = vec![model_routing("test-model", Some("OpenAi"))];
ModelRouting::upsert(&mut items, "test-model", |item| {
item.provider_order = Some("Anthropic".into());
});
assert_eq!(items.len(), 1);
assert_eq!(
items[0].provider_order,
Some("Anthropic".into()),
"[provider_order] target field updated"
);
}
{
let mut items = vec![];
ModelRouting::upsert(&mut items, "test-model", |item| {
item.provider_order = Some("OpenAi".into());
});
assert_eq!(items.len(), 1);
assert_eq!(items[0].model, "test-model");
assert_eq!(
items[0].provider_order,
Some("OpenAi".into()),
"[provider_order] set on new entry"
);
}
{
let mut items = vec![model_routing("test-model", Some("OpenAi"))];
ModelRouting::upsert(&mut items, "test-model", |item| item.provider_order = None);
assert_eq!(
items[0].provider_order, None,
"[provider_order] cleared to None"
);
}
}
#[test]
fn upsert_multiple_entries_independent_keys() {
let mut routings = vec![
model_routing("test-router-a", Some("OpenAi")),
model_routing("test-router-b", Some("Anthropic")),
];
ModelRouting::upsert(&mut routings, "test-router-a", |mr| {
mr.provider_order = Some("Google".into());
});
assert_eq!(routings[0].provider_order, Some("Google".into()));
assert_eq!(routings[1].provider_order, Some("Anthropic".into()));
ModelRouting::upsert(&mut routings, "test-router-b", |mr| {
mr.provider_order = Some("OpenAi".into());
});
assert_eq!(routings[0].provider_order, Some("Google".into()));
assert_eq!(routings[1].provider_order, Some("OpenAi".into()));
assert_eq!(routings.len(), 2);
}
#[test]
fn validate_config_accepts_valid_url() {
let mut config = ConfigData {
provider_endpoint: Some("https://openrouter.ai/api/v1".into()),
..ConfigData::STRUCT_FIELDS_DEFAULT
};
config.normalize();
validate_config(&config).unwrap();
}
#[test]
fn validate_config_accepts_whitespace_padded_url_after_normalize() {
let mut config = ConfigData {
provider_endpoint: Some(" https://openrouter.ai/api/v1 ".into()),
..ConfigData::STRUCT_FIELDS_DEFAULT
};
config.normalize();
validate_config(&config).unwrap();
}
#[test]
fn validate_config_rejects_url_without_scheme() {
let mut config = ConfigData {
provider_endpoint: Some("not-a-url".into()),
..ConfigData::STRUCT_FIELDS_DEFAULT
};
config.normalize();
let err = validate_config(&config).unwrap_err();
assert!(
err.to_string()
.contains("Provider endpoint must be a valid URL"),
"expected URL scheme error, got: {err}",
);
}
#[test]
fn validate_config_rejects_placeholder_key() {
let mut config = ConfigData {
provider_key: Some("sk-or-v1-...".into()),
..ConfigData::STRUCT_FIELDS_DEFAULT
};
config.normalize();
let err = validate_config(&config).unwrap_err();
assert!(
err.to_string().contains("placeholder"),
"expected placeholder error, got: {err}",
);
}
#[tokio::test]
#[serial_test::serial(config_persist)]
async fn persist_settled_string_field_refuses_wake_word_templates() {
let template_json = r#"{"classifier":null}"#;
let original = CONFIG.snapshot();
let mut enrolled = ConfigData::STRUCT_FIELDS_DEFAULT;
assert!(enrolled.set_string_field("wake_word_templates", template_json));
CONFIG.swap(enrolled);
let result = persist_settled_string_field("wake_word_templates", "garbage").await;
assert_eq!(
result.unwrap().value,
template_json,
"guard must return the current templates unchanged"
);
assert_eq!(
CONFIG.wake_word_templates(),
Some(template_json.to_string()),
"CONFIG wake_word_templates must be untouched"
);
CONFIG.swap(original);
}
#[test]
fn side_effect_config_keys_are_real_fields() {
let known: Vec<&'static str> = ConfigData::STRUCT_FIELDS_DEFAULT
.string_fields()
.iter()
.map(|(k, _)| *k)
.collect();
for key in [
CONFIG_KEY_PROVIDER_ENDPOINT,
CONFIG_KEY_PROVIDER_KEY,
CONFIG_KEY_PROVIDER_ENDPOINT_KEY,
CONFIG_KEY_TELEGRAM_BOT_TOKEN,
CONFIG_KEY_WAKE_WORD_TEMPLATES,
] {
assert!(
known.contains(&key),
"side-effect key '{key}' must be a real config field"
);
}
}
#[tokio::test]
async fn fresh_config_db_seeds_defaults_only_when_new() {
let fresh_root = tempfile::TempDir::new().unwrap();
let fresh = config_db_is_fresh(fresh_root.path());
assert!(
fresh,
"a storage root with no config store file must be classified fresh"
);
CONFIG_DB_FRESH_AT_BOOT.store(fresh, Ordering::Release);
let fresh_store = crate::config_db::ConfigStore::open(fresh_root.path())
.await
.unwrap();
assert!(
!config_db_is_fresh(fresh_root.path()),
"an existing config store file must not be classified fresh"
);
seed_fresh_install_defaults_from_flag(&fresh_store)
.await
.unwrap();
assert!(
!CONFIG_DB_FRESH_AT_BOOT.load(Ordering::Acquire),
"the boot discriminator must be consumed by the seed"
);
assert_eq!(
fresh_store.get_all_kv().await.unwrap(),
vec![
(
"audio_transcription_use_local".to_string(),
"false".to_string()
),
(
"image_gen_models".to_string(),
"google/gemini-3.1-flash-image\nmicrosoft/mai-image-2.5\nqwen/qwen-image-3-pro"
.to_string()
),
(
"video_models".to_string(),
"bytedance/seedance-2.0-mini\nminimax/hailuo-3".to_string()
),
],
"a fresh config database must be seeded with the fresh-install defaults"
);
assert_eq!(
fresh_store.get_all_model_routings().await.unwrap(),
vec![model_routing(DEFAULT_MANAGER_MODEL, Some("deepseek"))],
"a fresh config database must seed routing rows for default models \
with a known provider (others get none)"
);
let (existing_store, existing_dir) =
crate::open_test_store!(crate::config_db::ConfigStore, "config");
let fresh_existing = config_db_is_fresh(existing_dir.path());
assert!(
!fresh_existing,
"an existing install must not be classified fresh"
);
CONFIG_DB_FRESH_AT_BOOT.store(fresh_existing, Ordering::Release);
seed_fresh_install_defaults_from_flag(&existing_store)
.await
.unwrap();
assert!(
existing_store.get_all_kv().await.unwrap().is_empty(),
"an existing config database must receive zero writes"
);
assert!(
existing_store
.get_all_model_routings()
.await
.unwrap()
.is_empty(),
"an existing config database must receive zero routing rows (no backfill)"
);
}
#[tokio::test]
async fn migrate_old_default_models_rewrites_only_stale_slot_rows() {
let (store, _dir) = crate::open_test_store!(crate::config_db::ConfigStore, "config");
store
.set_kv(CONFIG_KEY_MANAGER_MODEL, OLD_DEFAULT_MANAGER_MODEL)
.await
.unwrap();
store
.set_kv(CONFIG_KEY_WORKER_MODEL, OLD_DEFAULT_WORKER_MODEL)
.await
.unwrap();
store
.set_kv("video_transcription_model", "qwen/qwen3.7-flash")
.await
.unwrap();
store
.set_kv(CONFIG_KEY_PROVIDER_KEY, "sk-example")
.await
.unwrap();
migrate_old_default_models(&store).await.unwrap();
assert_eq!(
store
.get_kv(CONFIG_KEY_MANAGER_MODEL)
.await
.unwrap()
.as_deref(),
Some(DEFAULT_MANAGER_MODEL),
"manager slot holding the old default must be migrated"
);
assert_eq!(
store
.get_kv(CONFIG_KEY_WORKER_MODEL)
.await
.unwrap()
.as_deref(),
Some(DEFAULT_WORKER_MODEL),
"worker slot holding the old default must be migrated"
);
assert_eq!(
store
.get_kv("video_transcription_model")
.await
.unwrap()
.as_deref(),
Some("qwen/qwen3.7-flash"),
"migrate only rewrites manager/worker old-default rows"
);
assert_eq!(
store
.get_kv(CONFIG_KEY_PROVIDER_KEY)
.await
.unwrap()
.as_deref(),
Some("sk-example"),
"unrelated config keys must never be touched"
);
assert_eq!(
store.get_all_model_routings().await.unwrap(),
vec![model_routing(DEFAULT_MANAGER_MODEL, Some("deepseek"))],
"migrating a slot to the new default must upsert its routing row"
);
migrate_old_default_models(&store).await.unwrap();
assert_eq!(
store
.get_kv(CONFIG_KEY_MANAGER_MODEL)
.await
.unwrap()
.as_deref(),
Some(DEFAULT_MANAGER_MODEL),
"re-running the migration must be a no-op"
);
assert_eq!(
store
.get_kv(CONFIG_KEY_WORKER_MODEL)
.await
.unwrap()
.as_deref(),
Some(DEFAULT_WORKER_MODEL),
"re-running the migration must be a no-op"
);
assert_eq!(
store.get_all_model_routings().await.unwrap(),
vec![model_routing(DEFAULT_MANAGER_MODEL, Some("deepseek"))],
"re-running the migration must not add or drop the migrated routing row"
);
}
#[tokio::test]
async fn purge_unknown_kv_orphans_deletes_stale_video_transcription_row() {
let (store, _dir) = crate::open_test_store!(crate::config_db::ConfigStore, "config");
store
.set_kv("video_transcription_model", "qwen/qwen3.7-flash")
.await
.unwrap();
store
.set_kv(CONFIG_KEY_PROVIDER_KEY, "sk-example")
.await
.unwrap();
store
.set_kv(
crate::workspace::NIGHTLY_DISCOVERY_LAST_PASS_KV_KEY,
"2026-08-29",
)
.await
.unwrap();
store
.set_kv(
crate::temp::TEMP_CLEANUP_LAST_RUN_KV_KEY,
"2026-08-29T00:00:00Z",
)
.await
.unwrap();
store
.set_kv(crate::temp::TEMP_CLEANUP_MODE_KV_KEY, "daily")
.await
.unwrap();
let kvs = store.get_all_kv().await.unwrap();
purge_unknown_kv_orphans(&store, &kvs).await;
assert_eq!(
store.get_kv("video_transcription_model").await.unwrap(),
None,
"the stale video-transcription row must be purged"
);
assert_eq!(
store
.get_kv(CONFIG_KEY_PROVIDER_KEY)
.await
.unwrap()
.as_deref(),
Some("sk-example"),
"known config keys must survive the purge"
);
assert_eq!(
store
.get_kv(crate::workspace::NIGHTLY_DISCOVERY_LAST_PASS_KV_KEY)
.await
.unwrap()
.as_deref(),
Some("2026-08-29"),
"preserved shared namespaces must survive the purge"
);
assert_eq!(
store
.get_kv(crate::temp::TEMP_CLEANUP_LAST_RUN_KV_KEY)
.await
.unwrap()
.as_deref(),
Some("2026-08-29T00:00:00Z"),
"temp-cleanup cadence state must survive the purge"
);
assert_eq!(
store
.get_kv(crate::temp::TEMP_CLEANUP_MODE_KV_KEY)
.await
.unwrap()
.as_deref(),
Some("daily"),
"temp-cleanup mode must survive the purge"
);
}
#[tokio::test]
async fn migrate_old_default_models_noop_for_target_and_user_overrides() {
let (store, _dir) = crate::open_test_store!(crate::config_db::ConfigStore, "config");
store
.set_kv(CONFIG_KEY_MANAGER_MODEL, DEFAULT_MANAGER_MODEL)
.await
.unwrap();
store
.set_kv(CONFIG_KEY_WORKER_MODEL, "user/private-model")
.await
.unwrap();
migrate_old_default_models(&store).await.unwrap();
assert_eq!(
store
.get_kv(CONFIG_KEY_MANAGER_MODEL)
.await
.unwrap()
.as_deref(),
Some(DEFAULT_MANAGER_MODEL),
"a slot already at the target must be untouched"
);
assert_eq!(
store
.get_kv(CONFIG_KEY_WORKER_MODEL)
.await
.unwrap()
.as_deref(),
Some("user/private-model"),
"a genuine user override must be preserved"
);
assert!(
store.get_all_model_routings().await.unwrap().is_empty(),
"no routing writes may happen when nothing was migrated"
);
}
#[test]
fn model_routing_applies_the_default_provider_when_unset() {
let config = ConfigReload::const_new();
let mut data = ConfigData::STRUCT_FIELDS_DEFAULT;
data.model_routings = vec![
model_routing("deepseek/deepseek-v4.1-flash", Some("GMICloud")),
model_routing("deepseek/deepseek-v4-flash-0731", Some("")),
];
data.normalize();
config.swap(data);
assert_eq!(
config
.model_routing("deepseek/deepseek-v4.1-flash")
.provider_order
.as_deref(),
Some("GMICloud"),
"an explicitly set provider must win, unchanged"
);
for model in [
"deepseek/deepseek-v4.1-pro",
"deepseek-ai/DeepSeek-V3",
"deepseek/deepseek-v4-flash-0731",
] {
assert_eq!(
config.model_routing(model).provider_order.as_deref(),
Some("deepseek"),
"{model} has no explicit setting and must fall back to the \
canonical DeepSeek slug"
);
}
assert_eq!(
config.model_routing("qwen/qwen3.8-flash").provider_order,
None,
"a non-DeepSeek model must stay auto-routed"
);
}
}