1use super::*;
2
3pub fn normalize_model_name(value: &str) -> Option<String> {
4 let trimmed = value.trim();
5 if trimmed.is_empty() || trimmed == "*" {
6 None
7 } else {
8 Some(trimmed.to_string())
9 }
10}
11
12pub(crate) fn normalize_string_list(values: &mut Vec<String>, lowercase: bool) {
13 *values = values
14 .drain(..)
15 .map(|value| {
16 let value = value.trim();
17 if lowercase {
18 value.to_ascii_lowercase()
19 } else {
20 value.to_string()
21 }
22 })
23 .filter(|value| !value.is_empty())
24 .collect();
25 values.sort();
26 values.dedup();
27}
28
29pub fn resolve_model_name_with_fallback(
30 provider: &str,
31 candidate: Option<&str>,
32 fallback: Option<&str>,
33) -> String {
34 candidate
35 .and_then(normalize_model_name)
36 .or_else(|| fallback.and_then(normalize_model_name))
37 .unwrap_or_else(|| default_model_for_provider_name(provider).to_string())
38}
39
40pub(crate) fn expand_path(path: &str) -> PathBuf {
42 match shellexpand::tilde(path) {
43 std::borrow::Cow::Borrowed(p) => PathBuf::from(p),
44 std::borrow::Cow::Owned(p) => PathBuf::from(p),
45 }
46}
47
48pub(crate) fn detect_system_timezone() -> String {
49 match iana_time_zone::get_timezone() {
50 Ok(tz_name) => tz_name,
51 Err(e) => {
52 warn!("Failed to detect system timezone automatically: {e}. Falling back to UTC.");
53 "UTC".into()
54 }
55 }
56}
57
58#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
62#[serde(rename_all = "lowercase")]
63pub enum UserMessageLanguage {
64 #[default]
65 En,
66 Zh,
67 Bilingual,
68}
69
70#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
75#[serde(rename_all = "lowercase")]
76pub enum SystemPromptTimeDetail {
77 None,
80 #[default]
83 Date,
84 Full,
87}
88
89#[derive(Clone, Debug, Serialize, Deserialize)]
90pub struct Config {
91 #[serde(default = "default_llm_provider")]
93 pub llm_provider: String,
94 #[serde(default = "default_api_key")]
95 pub api_key: String,
96 #[serde(default)]
100 pub api_keys: Vec<String>,
101 #[serde(default = "default_model")]
102 pub model: String,
103 #[serde(default)]
104 pub provider_presets: HashMap<String, LlmProviderProfile>,
105 #[serde(default)]
106 pub llm_providers: HashMap<String, LlmProviderProfile>,
107 #[serde(default)]
108 pub llm_base_url: Option<String>,
109 #[serde(default = "default_llm_user_agent")]
110 pub llm_user_agent: String,
111 #[serde(default = "default_max_tokens")]
112 pub max_tokens: u32,
113 #[serde(default = "default_max_tool_iterations")]
114 pub max_tool_iterations: usize,
115 #[serde(default = "default_compaction_timeout_secs")]
116 pub compaction_timeout_secs: u64,
117 #[serde(default)]
120 pub aux_models: AuxModels,
121 #[serde(default)]
126 pub fallback_model: Option<String>,
127 #[serde(default = "default_max_history_messages")]
128 pub max_history_messages: usize,
129 #[serde(default = "default_max_document_size_mb")]
130 pub max_document_size_mb: u64,
131 #[serde(default = "default_memory_token_budget")]
132 pub memory_token_budget: usize,
133 #[serde(default = "default_memory_l0_identity_pct")]
135 pub memory_l0_identity_pct: usize,
136 #[serde(default = "default_memory_l1_essential_pct")]
138 pub memory_l1_essential_pct: usize,
139 #[serde(default = "default_memory_max_entries_per_chat")]
140 pub memory_max_entries_per_chat: usize,
141 #[serde(default = "default_memory_max_global_entries")]
142 pub memory_max_global_entries: usize,
143 #[serde(default = "default_kg_max_triples_per_chat")]
145 pub kg_max_triples_per_chat: usize,
146 #[serde(default = "default_tool_result_truncation_threshold_chars")]
150 pub tool_result_truncation_threshold_chars: usize,
151 #[serde(default = "default_tool_result_truncation_head_chars")]
154 pub tool_result_truncation_head_chars: usize,
155 #[serde(default = "default_tool_result_truncation_tail_chars")]
158 pub tool_result_truncation_tail_chars: usize,
159 #[serde(default = "default_tool_result_artifact_ttl_hours")]
162 pub tool_result_artifact_ttl_hours: u64,
163 #[serde(default = "default_memory_recency_half_life_days")]
168 pub memory_recency_half_life_days: f64,
169 #[serde(default = "default_memory_graph_recall_enabled")]
175 pub memory_graph_recall_enabled: bool,
176 #[serde(default = "default_memory_graph_max_hops")]
179 pub memory_graph_max_hops: usize,
180 #[serde(default = "default_memory_graph_max_triples")]
184 pub memory_graph_max_triples: usize,
185 #[serde(default = "default_tool_repeat_window")]
191 pub tool_repeat_window: usize,
192 #[serde(default = "default_tool_repeat_limit")]
194 pub tool_repeat_limit: usize,
195 #[serde(default = "default_anthropic_prompt_cache_enabled")]
199 pub anthropic_prompt_cache_enabled: bool,
200 #[serde(default)]
203 pub anthropic_context_editing: bool,
204 #[serde(default = "default_anthropic_prompt_cache_ttl")]
207 pub anthropic_prompt_cache_ttl: String,
208 #[serde(default = "default_checkpoints_enabled")]
214 pub checkpoints_enabled: bool,
215 #[serde(default = "default_skill_archive_after_days")]
220 pub skill_archive_after_days: u64,
221 #[serde(default = "default_skills_catalog_top_k")]
227 pub skills_catalog_top_k: usize,
228 #[serde(default)]
233 pub system_prompt_time_detail: SystemPromptTimeDetail,
234 #[serde(default = "default_max_session_messages")]
235 pub max_session_messages: usize,
236 #[serde(default = "default_diff_max_lines")]
239 pub diff_max_lines: usize,
240 #[serde(default = "default_file_diffs_in_chat")]
243 pub file_diffs_in_chat: bool,
244 #[serde(default)]
250 pub allow_governance_file_writes: bool,
251 #[serde(default = "default_model_context_window")]
254 pub model_context_window: usize,
255 #[serde(default = "default_context_pressure_compact_pct")]
259 pub context_pressure_compact_pct: usize,
260 #[serde(default)]
263 pub model_context_windows: HashMap<String, usize>,
264 #[serde(default = "default_true")]
268 pub auto_compact: bool,
269 #[serde(default = "default_prune_protect_tokens")]
272 pub prune_protect_tokens: usize,
273 #[serde(default = "default_prune_minimum_tokens")]
277 pub prune_minimum_tokens: usize,
278 #[serde(default)]
282 pub compact_keep_recent_tokens: usize,
283 #[serde(default)]
285 pub compact_instructions: Option<String>,
286 #[serde(default)]
289 pub project_agents_dir: Option<String>,
290 #[serde(skip)]
293 pub tool_gate: crate::tool_gate::ToolGateHandle,
294 #[serde(default)]
297 pub context_tools: bool,
298 #[serde(default)]
301 pub context_budget_hint: bool,
302 #[serde(default)]
305 pub explore_tool: bool,
306 #[serde(default)]
310 pub self_recheck: SelfRecheckConfig,
311 #[serde(default = "default_compact_keep_recent")]
312 pub compact_keep_recent: usize,
313 #[serde(default = "default_tool_timeout_secs")]
314 pub default_tool_timeout_secs: u64,
315 #[serde(default)]
316 pub tool_timeout_overrides: HashMap<String, u64>,
317 #[serde(default = "default_mcp_request_timeout_secs")]
318 pub default_mcp_request_timeout_secs: u64,
319 #[serde(default)]
320 pub show_thinking: bool,
321 #[serde(default)]
322 pub subagents: SubagentConfig,
323 #[serde(default)]
324 pub idle_checkin: IdleCheckinConfig,
325 #[serde(default)]
326 pub heartbeat: HeartbeatConfig,
327 #[serde(default)]
328 pub token_budget: TokenBudgetConfig,
329 #[serde(default)]
330 pub alerts: AlertsConfig,
331 #[serde(default)]
332 pub trust_report: TrustReportConfig,
333 #[serde(default)]
335 pub user_message_language: UserMessageLanguage,
336 #[serde(default)]
337 pub sleep_time: SleepTimeConfig,
338 #[serde(default)]
339 pub interjection: InterjectionConfig,
340 #[serde(default)]
341 pub a2a: A2AConfig,
342
343 #[serde(default = "default_chat_turn_queue_max_pending")]
346 pub chat_turn_queue_max_pending: usize,
347 #[serde(default = "default_true")]
350 pub enable_mid_turn_injection: bool,
351 #[serde(default = "default_true")]
355 pub mid_turn_injection_echo: bool,
356 #[serde(default = "default_parallel_tool_max_concurrency")]
358 pub parallel_tool_max_concurrency: usize,
359 #[serde(default)]
362 pub tool_concurrency_overrides: HashMap<String, String>,
363 #[serde(default)]
366 pub openai_compat_body_overrides: HashMap<String, serde_json::Value>,
367 #[serde(default)]
370 pub openai_compat_body_overrides_by_provider:
371 HashMap<String, HashMap<String, serde_json::Value>>,
372 #[serde(default)]
374 pub openai_compat_body_overrides_by_model: HashMap<String, HashMap<String, serde_json::Value>>,
375
376 #[serde(default = "default_data_dir")]
378 pub data_dir: String,
379 #[serde(default)]
380 pub skills_dir: Option<String>,
381 #[serde(default = "default_working_dir")]
382 pub working_dir: String,
383 #[serde(default = "default_working_dir_isolation")]
384 pub working_dir_isolation: WorkingDirIsolation,
385 #[serde(default = "default_high_risk_tool_user_confirmation_required")]
386 pub high_risk_tool_user_confirmation_required: bool,
387 #[serde(default = "default_approval_channels")]
391 pub approval_channels: Vec<String>,
392 #[serde(default = "default_read_only_subagent_channels")]
395 pub read_only_subagent_channels: Vec<String>,
396 #[serde(default = "default_bash_dangerous_patterns")]
403 pub bash_dangerous_patterns: Vec<String>,
404 #[serde(default)]
406 pub rtk: RtkConfig,
407 #[serde(default)]
408 pub sandbox: SandboxConfig,
409 #[serde(default, skip_serializing_if = "Option::is_none")]
410 pub override_timezone: Option<String>,
411 #[serde(default = "default_timezone", skip_serializing)]
412 pub timezone: String,
413 #[serde(default = "default_control_chat_ids")]
414 pub control_chat_ids: Vec<i64>,
415 #[serde(default)]
416 pub discord_bot_token: Option<String>,
417 #[serde(default)]
418 pub discord_allowed_channels: Vec<u64>,
419 #[serde(default)]
420 pub discord_no_mention: bool,
421 #[serde(default = "default_allow_group_slash_without_mention")]
422 pub allow_group_slash_without_mention: bool,
423
424 #[serde(default = "default_web_enabled")]
426 pub web_enabled: bool,
427 #[serde(default = "default_web_host")]
428 pub web_host: String,
429 #[serde(default = "default_web_port")]
430 pub web_port: u16,
431 #[serde(default = "default_web_max_inflight_per_session")]
432 pub web_max_inflight_per_session: usize,
433 #[serde(default = "default_web_max_requests_per_window")]
434 pub web_max_requests_per_window: usize,
435 #[serde(default = "default_web_rate_window_seconds")]
436 pub web_rate_window_seconds: u64,
437 #[serde(default = "default_web_run_history_limit")]
438 pub web_run_history_limit: usize,
439 #[serde(default = "default_web_session_idle_ttl_seconds")]
440 pub web_session_idle_ttl_seconds: u64,
441 #[serde(default)]
442 pub web_fetch_validation: WebContentValidationConfig,
443 #[serde(default)]
444 pub web_fetch_url_validation: WebFetchUrlValidationConfig,
445 #[serde(default)]
448 pub web_search: SearchProviderConfig,
449 #[serde(default)]
452 pub output_guardrail: OutputGuardrailConfig,
453 #[serde(default)]
456 pub tool_policy: crate::tool_guardrails::ToolPolicyConfig,
457 #[serde(default)]
460 pub egress_policy: EgressPolicyConfig,
461
462 #[serde(default)]
464 pub embedding_provider: Option<String>,
465 #[serde(default)]
466 pub embedding_api_key: Option<String>,
467 #[serde(default)]
468 pub embedding_base_url: Option<String>,
469 #[serde(default)]
470 pub embedding_model: Option<String>,
471 #[serde(default)]
472 pub embedding_dim: Option<usize>,
473 #[serde(default)]
474 pub openai_api_key: Option<String>,
475
476 #[serde(default = "default_model_prices")]
478 pub model_prices: Vec<ModelPrice>,
479
480 #[serde(default = "default_reflector_enabled")]
482 pub reflector_enabled: bool,
483 #[serde(default = "default_reflector_interval_mins")]
484 pub reflector_interval_mins: u64,
485 #[serde(default = "default_dlq_replay_enabled")]
490 pub dlq_replay_enabled: bool,
491 #[serde(default = "default_dlq_replay_interval_secs")]
493 pub dlq_replay_interval_secs: u64,
494 #[serde(default = "default_dlq_max_replay_attempts")]
497 pub dlq_max_replay_attempts: u32,
498 #[serde(default = "default_skill_review_min_tool_calls")]
502 pub skill_review_min_tool_calls: usize,
503
504 #[serde(default = "default_soul_path")]
508 pub soul_path: Option<String>,
509 #[serde(default = "default_souls_dir")]
511 pub souls_dir: Option<String>,
512
513 #[serde(default)]
520 pub context_dir: Option<String>,
521 #[serde(default = "default_context_max_chars")]
525 pub context_max_chars: usize,
526
527 #[serde(default)]
534 pub voice_round_trip: bool,
535
536 #[serde(default = "default_user_model_max_chars")]
544 pub user_model_max_chars: usize,
545
546 #[serde(flatten)]
548 pub clawhub: ClawHubConfig,
549
550 #[serde(default)]
552 pub plugins: PluginsConfig,
553
554 #[serde(default)]
560 pub media: MediaConfig,
561
562 #[serde(default)]
565 pub openai_base_url: Option<String>,
566
567 #[serde(default = "default_voice_provider", rename = "voice_provider")]
570 pub voice_provider: String,
571 #[serde(default, rename = "voice_transcription_command")]
574 pub voice_transcription_command: Option<String>,
575
576 #[serde(default)]
578 pub observability: Option<serde_yaml::Value>,
579
580 #[serde(default)]
585 pub channels: HashMap<String, serde_yaml::Value>,
586
587 #[serde(default = "default_telegram_bot_token")]
589 pub telegram_bot_token: String,
590 #[serde(default = "default_bot_username")]
591 pub bot_username: String,
592 #[serde(default)]
593 pub allowed_groups: Vec<i64>,
594}
595
596pub(crate) fn collect_enabled_channel_endpoints(value: &serde_yaml::Value, out: &mut Vec<String>) {
597 let Some(mapping) = value.as_mapping() else {
598 return;
599 };
600 if mapping
601 .get(serde_yaml::Value::String("enabled".into()))
602 .and_then(serde_yaml::Value::as_bool)
603 == Some(false)
604 {
605 return;
606 }
607
608 for (key, value) in mapping {
609 let Some(key) = key.as_str() else {
610 continue;
611 };
612 let key = key.to_ascii_lowercase();
613 let is_endpoint_key = key.contains("url") || key.contains("endpoint");
614 if is_endpoint_key {
615 if let Some(endpoint) = value
616 .as_str()
617 .map(str::trim)
618 .filter(|endpoint| !endpoint.is_empty())
619 {
620 out.push(endpoint.to_string());
621 }
622 }
623 match value {
624 serde_yaml::Value::Mapping(_) => collect_enabled_channel_endpoints(value, out),
625 serde_yaml::Value::Sequence(values) => {
626 for value in values {
627 collect_enabled_channel_endpoints(value, out);
628 }
629 }
630 _ => {}
631 }
632 }
633}
634
635impl Config {
636 pub fn is_control_chat(&self, chat_id: i64) -> bool {
641 self.control_chat_ids.contains(&chat_id)
642 }
643
644 fn ensure_mapping_mut(value: &mut serde_yaml::Value) -> &mut serde_yaml::Mapping {
645 if !matches!(value, serde_yaml::Value::Mapping(_)) {
646 *value = serde_yaml::Value::Mapping(serde_yaml::Mapping::new());
647 }
648 value
649 .as_mapping_mut()
650 .expect("value should be a mapping after initialization")
651 }
652
653 fn channel_default_account_id(&self, channel: &str) -> Option<String> {
654 let channel_cfg = self.channels.get(channel)?;
655 let mut account_ids: Vec<String> = channel_cfg
656 .get("accounts")
657 .and_then(|v| v.as_mapping())
658 .map(|m| {
659 m.keys()
660 .filter_map(|k| k.as_str().map(ToOwned::to_owned))
661 .collect()
662 })
663 .unwrap_or_default();
664 account_ids.sort();
665 channel_cfg
666 .get("default_account")
667 .and_then(|v| v.as_str())
668 .map(str::trim)
669 .filter(|v| !v.is_empty())
670 .map(ToOwned::to_owned)
671 .or_else(|| {
672 if channel_cfg
673 .get("accounts")
674 .and_then(|v| v.get("default"))
675 .is_some()
676 {
677 Some("default".to_string())
678 } else {
679 account_ids.first().cloned()
680 }
681 })
682 }
683
684 fn llm_override_target(&self, channel: &str) -> Option<(String, Option<String>)> {
685 let channel = channel.trim();
686 if channel.is_empty() {
687 return None;
688 }
689 if let Some((base_channel, account_id)) = channel.split_once('.') {
690 let base_channel = base_channel.trim();
691 let account_id = account_id.trim();
692 if base_channel.is_empty() || account_id.is_empty() {
693 return None;
694 }
695 return Some((base_channel.to_string(), Some(account_id.to_string())));
696 }
697
698 Some((
699 channel.to_string(),
700 self.channel_default_account_id(channel),
701 ))
702 }
703
704 fn llm_override_mapping_mut(&mut self, channel: &str) -> Option<&mut serde_yaml::Mapping> {
705 let (base_channel, account_id) = self.llm_override_target(channel)?;
706 let channel_value = self
707 .channels
708 .entry(base_channel)
709 .or_insert_with(|| serde_yaml::Value::Mapping(serde_yaml::Mapping::new()));
710 let channel_map = Self::ensure_mapping_mut(channel_value);
711 if let Some(account_id) = account_id {
712 let accounts_key = serde_yaml::Value::String("accounts".to_string());
713 let accounts_value = channel_map
714 .entry(accounts_key)
715 .or_insert_with(|| serde_yaml::Value::Mapping(serde_yaml::Mapping::new()));
716 let accounts_map = Self::ensure_mapping_mut(accounts_value);
717 let account_value = accounts_map
718 .entry(serde_yaml::Value::String(account_id))
719 .or_insert_with(|| serde_yaml::Value::Mapping(serde_yaml::Mapping::new()));
720 return Some(Self::ensure_mapping_mut(account_value));
721 }
722 Some(channel_map)
723 }
724
725 pub fn set_provider_override_for_channel(&mut self, channel: &str, provider: Option<&str>) {
726 let Some(target) = self.llm_override_mapping_mut(channel) else {
727 return;
728 };
729 let provider_preset_key = serde_yaml::Value::String("provider_preset".to_string());
730 let llm_provider_key = serde_yaml::Value::String("llm_provider".to_string());
731 target.remove(&provider_preset_key);
732 target.remove(&llm_provider_key);
733 if let Some(provider) = provider
734 .map(str::trim)
735 .filter(|provider| !provider.is_empty())
736 .map(|provider| provider.to_ascii_lowercase())
737 {
738 target.insert(
739 provider_preset_key,
740 serde_yaml::Value::String(provider.to_string()),
741 );
742 }
743 }
744
745 pub fn set_model_override_for_channel(&mut self, channel: &str, model: Option<&str>) {
746 let Some(target) = self.llm_override_mapping_mut(channel) else {
747 return;
748 };
749 let model_key = serde_yaml::Value::String("model".to_string());
750 target.remove(&model_key);
751 if let Some(model) = model.and_then(normalize_model_name) {
752 target.insert(model_key, serde_yaml::Value::String(model.to_string()));
753 }
754 }
755
756 fn channel_account_bot_username(&self, channel: &str, account_id: &str) -> Option<String> {
757 self.channels
758 .get(channel)
759 .and_then(|v| v.get("accounts"))
760 .and_then(|v| v.get(account_id))
761 .and_then(|v| v.get("bot_username"))
762 .and_then(|v| v.as_str())
763 .map(str::trim)
764 .filter(|v| !v.is_empty())
765 .map(ToOwned::to_owned)
766 }
767
768 fn channel_account_soul_path(&self, channel: &str, account_id: &str) -> Option<String> {
769 self.channels
770 .get(channel)
771 .and_then(|v| v.get("accounts"))
772 .and_then(|v| v.get(account_id))
773 .and_then(|v| v.get("soul_path"))
774 .and_then(|v| v.as_str())
775 .map(str::trim)
776 .filter(|v| !v.is_empty())
777 .map(ToOwned::to_owned)
778 }
779
780 fn provider_override_from_value(value: &serde_yaml::Value) -> Option<String> {
781 value
782 .get("provider_preset")
783 .and_then(|v| v.as_str())
784 .or_else(|| value.get("llm_provider").and_then(|v| v.as_str()))
785 .map(str::trim)
786 .filter(|v| !v.is_empty())
787 .map(|v| v.to_ascii_lowercase())
788 }
789
790 fn channel_account_provider_override(&self, channel: &str, account_id: &str) -> Option<String> {
791 self.channels
792 .get(channel)
793 .and_then(|v| v.get("accounts"))
794 .and_then(|v| v.get(account_id))
795 .and_then(Self::provider_override_from_value)
796 }
797
798 fn model_override_from_value(value: &serde_yaml::Value) -> Option<String> {
799 value
800 .get("model")
801 .and_then(|v| v.as_str())
802 .and_then(normalize_model_name)
803 }
804
805 fn channel_account_model_override(&self, channel: &str, account_id: &str) -> Option<String> {
806 self.channels
807 .get(channel)
808 .and_then(|v| v.get("accounts"))
809 .and_then(|v| v.get(account_id))
810 .and_then(Self::model_override_from_value)
811 }
812
813 pub fn provider_override_for_channel(&self, channel: &str) -> Option<String> {
814 if let Some((base_channel, account_id)) = channel.split_once('.') {
815 if let Some(v) = self.channel_account_provider_override(base_channel, account_id) {
816 return Some(v);
817 }
818 return self
819 .channels
820 .get(base_channel)
821 .and_then(Self::provider_override_from_value);
822 }
823
824 if let Some(default_account) = self.channel_default_account_id(channel) {
825 if let Some(v) = self.channel_account_provider_override(channel, &default_account) {
826 return Some(v);
827 }
828 }
829
830 self.channels
831 .get(channel)
832 .and_then(Self::provider_override_from_value)
833 }
834
835 pub fn model_override_for_channel(&self, channel: &str) -> Option<String> {
836 if let Some((base_channel, account_id)) = channel.split_once('.') {
837 if let Some(v) = self.channel_account_model_override(base_channel, account_id) {
838 return Some(v);
839 }
840 return self
841 .channels
842 .get(base_channel)
843 .and_then(Self::model_override_from_value);
844 }
845
846 if let Some(default_account) = self.channel_default_account_id(channel) {
847 if let Some(v) = self.channel_account_model_override(channel, &default_account) {
848 return Some(v);
849 }
850 }
851
852 self.channels
853 .get(channel)
854 .and_then(Self::model_override_from_value)
855 }
856
857 pub fn soul_path_for_channel(&self, channel: &str) -> Option<String> {
858 let channel_override = self
859 .channels
860 .get(channel)
861 .and_then(|v| v.get("soul_path"))
862 .and_then(|v| v.as_str())
863 .map(str::trim)
864 .filter(|v| !v.is_empty())
865 .map(ToOwned::to_owned);
866 if channel_override.is_some() {
867 return channel_override;
868 }
869
870 if let Some((base_channel, account_id)) = channel.split_once('.') {
871 if let Some(v) = self.channel_account_soul_path(base_channel, account_id) {
872 return Some(v);
873 }
874 return self
875 .channels
876 .get(base_channel)
877 .and_then(|v| v.get("soul_path"))
878 .and_then(|v| v.as_str())
879 .map(str::trim)
880 .filter(|v| !v.is_empty())
881 .map(ToOwned::to_owned);
882 }
883
884 if let Some(default_account) = self.channel_default_account_id(channel) {
885 if let Some(v) = self.channel_account_soul_path(channel, &default_account) {
886 return Some(v);
887 }
888 }
889
890 self.channels
891 .get(channel)
892 .and_then(|v| v.get("soul_path"))
893 .and_then(|v| v.as_str())
894 .map(str::trim)
895 .filter(|v| !v.is_empty())
896 .map(ToOwned::to_owned)
897 }
898
899 pub fn bot_username_for_channel(&self, channel: &str) -> String {
900 let channel_override = self
901 .channels
902 .get(channel)
903 .and_then(|v| v.get("bot_username"))
904 .and_then(|v| v.as_str())
905 .map(str::trim)
906 .filter(|v| !v.is_empty());
907 if let Some(v) = channel_override {
908 return v.to_string();
909 }
910
911 if let Some((base_channel, account_id)) = channel.split_once('.') {
912 if let Some(v) = self.channel_account_bot_username(base_channel, account_id) {
913 return v;
914 }
915 } else if let Some(default_account) = self.channel_default_account_id(channel) {
916 if let Some(v) = self.channel_account_bot_username(channel, &default_account) {
917 return v;
918 }
919 }
920
921 let global = self.bot_username.trim();
922 if !global.is_empty() {
923 global.to_string()
924 } else {
925 default_bot_username()
926 }
927 }
928
929 pub fn bot_username_overrides(&self) -> HashMap<String, String> {
930 let mut overrides: HashMap<String, String> = self
931 .channels
932 .iter()
933 .filter_map(|(channel, cfg)| {
934 cfg.get("bot_username")
935 .and_then(|v| v.as_str())
936 .map(str::trim)
937 .filter(|v| !v.is_empty())
938 .map(|v| (channel.clone(), v.to_string()))
939 })
940 .collect();
941
942 for (channel, channel_cfg) in &self.channels {
943 let accounts = channel_cfg.get("accounts").and_then(|v| v.as_mapping());
944 let Some(accounts) = accounts else {
945 continue;
946 };
947 let default_account = self.channel_default_account_id(channel);
948 for (key, value) in accounts {
949 let Some(account_id) = key.as_str() else {
950 continue;
951 };
952 let username = value
953 .get("bot_username")
954 .and_then(|v| v.as_str())
955 .map(str::trim)
956 .filter(|v| !v.is_empty());
957 let Some(username) = username else {
958 continue;
959 };
960 if default_account
961 .as_deref()
962 .map(|v| v == account_id)
963 .unwrap_or(false)
964 {
965 overrides.insert(channel.clone(), username.to_string());
966 } else {
967 overrides.insert(format!("{channel}.{account_id}"), username.to_string());
968 }
969 }
970 }
971
972 overrides
973 }
974
975 pub fn llm_provider_overrides(&self) -> HashMap<String, String> {
976 let mut overrides: HashMap<String, String> = self
977 .channels
978 .iter()
979 .filter_map(|(channel, cfg)| {
980 Self::provider_override_from_value(cfg).map(|provider| (channel.clone(), provider))
981 })
982 .collect();
983
984 for (channel, channel_cfg) in &self.channels {
985 let accounts = channel_cfg.get("accounts").and_then(|v| v.as_mapping());
986 let Some(accounts) = accounts else {
987 continue;
988 };
989 let default_account = self.channel_default_account_id(channel);
990 for (key, value) in accounts {
991 let Some(account_id) = key.as_str() else {
992 continue;
993 };
994 let Some(provider) = Self::provider_override_from_value(value) else {
995 continue;
996 };
997 if default_account
998 .as_deref()
999 .map(|v| v == account_id)
1000 .unwrap_or(false)
1001 {
1002 overrides.insert(channel.clone(), provider);
1003 } else {
1004 overrides.insert(format!("{channel}.{account_id}"), provider);
1005 }
1006 }
1007 }
1008
1009 overrides
1010 }
1011
1012 #[cfg(any(test, feature = "test-support"))]
1013 pub fn test_defaults() -> Self {
1014 Self {
1015 telegram_bot_token: "tok".into(),
1016 bot_username: "bot".into(),
1017 llm_provider: "anthropic".into(),
1018 api_key: "key".into(),
1019 api_keys: Vec::new(),
1020 model: "claude-sonnet-4-5-20250929".into(),
1021 provider_presets: HashMap::new(),
1022 llm_providers: HashMap::new(),
1023 llm_base_url: None,
1024 llm_user_agent: default_llm_user_agent(),
1025 max_tokens: 8192,
1026 max_tool_iterations: 100,
1027 compaction_timeout_secs: 180,
1028 aux_models: AuxModels::default(),
1029 fallback_model: None,
1030 max_history_messages: 50,
1031 max_document_size_mb: 100,
1032 memory_token_budget: 1500,
1033 memory_l0_identity_pct: 20,
1034 memory_l1_essential_pct: 30,
1035 memory_max_entries_per_chat: 200,
1036 memory_max_global_entries: 500,
1037 kg_max_triples_per_chat: 1000,
1038 tool_result_truncation_threshold_chars: 4000,
1039 tool_result_truncation_head_chars: 1500,
1040 tool_result_truncation_tail_chars: 500,
1041 tool_result_artifact_ttl_hours: 24,
1042 memory_recency_half_life_days: 30.0,
1043 memory_graph_recall_enabled: true,
1044 memory_graph_max_hops: 2,
1045 memory_graph_max_triples: 10,
1046 tool_repeat_window: 10,
1047 tool_repeat_limit: 3,
1048 anthropic_prompt_cache_enabled: true,
1049 anthropic_context_editing: false,
1050 anthropic_prompt_cache_ttl: "5m".into(),
1051 checkpoints_enabled: false,
1052 skill_archive_after_days: 30,
1053 skills_catalog_top_k: 3,
1054 system_prompt_time_detail: SystemPromptTimeDetail::default(),
1055 data_dir: default_data_dir(),
1056 skills_dir: None,
1057 working_dir: default_working_dir(),
1058 working_dir_isolation: WorkingDirIsolation::Chat,
1059 high_risk_tool_user_confirmation_required: true,
1060 approval_channels: default_approval_channels(),
1061 read_only_subagent_channels: default_read_only_subagent_channels(),
1062 bash_dangerous_patterns: default_bash_dangerous_patterns(),
1063 rtk: RtkConfig::default(),
1064 sandbox: SandboxConfig::default(),
1065 openai_api_key: None,
1066 override_timezone: None,
1067 timezone: "UTC".into(),
1068 allowed_groups: vec![],
1069 control_chat_ids: vec![],
1070 max_session_messages: 40,
1071 diff_max_lines: default_diff_max_lines(),
1072 file_diffs_in_chat: default_file_diffs_in_chat(),
1073 allow_governance_file_writes: false,
1074 model_context_window: default_model_context_window(),
1075 context_pressure_compact_pct: default_context_pressure_compact_pct(),
1076 model_context_windows: HashMap::new(),
1077 auto_compact: true,
1078 prune_protect_tokens: default_prune_protect_tokens(),
1079 prune_minimum_tokens: default_prune_minimum_tokens(),
1080 compact_keep_recent_tokens: 0,
1081 compact_instructions: None,
1082 project_agents_dir: None,
1083 tool_gate: Default::default(),
1084 context_tools: false,
1085 context_budget_hint: false,
1086 explore_tool: false,
1087 self_recheck: SelfRecheckConfig::default(),
1088 compact_keep_recent: 20,
1089 default_tool_timeout_secs: default_tool_timeout_secs(),
1090 tool_timeout_overrides: HashMap::new(),
1091 default_mcp_request_timeout_secs: default_mcp_request_timeout_secs(),
1092 discord_bot_token: None,
1093 discord_allowed_channels: vec![],
1094 discord_no_mention: false,
1095 allow_group_slash_without_mention: false,
1096 show_thinking: false,
1097 subagents: SubagentConfig::default(),
1098 idle_checkin: IdleCheckinConfig::default(),
1099 heartbeat: HeartbeatConfig::default(),
1100 token_budget: TokenBudgetConfig::default(),
1101 alerts: AlertsConfig::default(),
1102 trust_report: TrustReportConfig::default(),
1103 user_message_language: UserMessageLanguage::default(),
1104 sleep_time: SleepTimeConfig::default(),
1105 interjection: InterjectionConfig::default(),
1106 a2a: A2AConfig::default(),
1107 openai_compat_body_overrides: HashMap::new(),
1108 openai_compat_body_overrides_by_provider: HashMap::new(),
1109 openai_compat_body_overrides_by_model: HashMap::new(),
1110 web_enabled: true,
1111 web_host: "127.0.0.1".into(),
1112 web_port: 10961,
1113 web_max_inflight_per_session: 10,
1114 web_max_requests_per_window: 8,
1115 web_rate_window_seconds: 10,
1116 web_run_history_limit: 512,
1117 web_session_idle_ttl_seconds: 300,
1118 web_fetch_validation: WebContentValidationConfig::default(),
1119 web_fetch_url_validation: WebFetchUrlValidationConfig::default(),
1120 web_search: SearchProviderConfig::default(),
1121 output_guardrail: OutputGuardrailConfig::default(),
1122 tool_policy: crate::tool_guardrails::ToolPolicyConfig::default(),
1123 egress_policy: EgressPolicyConfig::default(),
1124 model_prices: vec![],
1125 embedding_provider: None,
1126 embedding_api_key: None,
1127 embedding_base_url: None,
1128 embedding_model: None,
1129 embedding_dim: None,
1130 reflector_enabled: true,
1131 reflector_interval_mins: 15,
1132 dlq_replay_enabled: true,
1133 dlq_replay_interval_secs: 300,
1134 dlq_max_replay_attempts: 3,
1135 skill_review_min_tool_calls: 5,
1136 soul_path: None,
1137 souls_dir: None,
1138 context_dir: None,
1139 context_max_chars: 8000,
1140 user_model_max_chars: 1500,
1141 voice_round_trip: false,
1142 clawhub: ClawHubConfig::default(),
1143 plugins: PluginsConfig::default(),
1144 media: MediaConfig::default(),
1145 openai_base_url: None,
1146 voice_provider: "openai".into(),
1147 voice_transcription_command: None,
1148 observability: None,
1149 channels: HashMap::new(),
1150 chat_turn_queue_max_pending: 20,
1151 enable_mid_turn_injection: true,
1152 mid_turn_injection_echo: true,
1153 parallel_tool_max_concurrency: 8,
1154 tool_concurrency_overrides: HashMap::new(),
1155 }
1156 }
1157
1158 pub fn data_root_dir(&self) -> PathBuf {
1160 expand_path(&self.data_dir)
1161 }
1162
1163 pub fn runtime_data_dir(&self) -> String {
1165 let root = self.data_root_dir();
1166 if root.file_name().and_then(|n| n.to_str()) == Some("runtime") {
1168 return root.to_string_lossy().to_string();
1169 }
1170 root.join("runtime").to_string_lossy().to_string()
1171 }
1172
1173 pub fn skills_data_dir(&self) -> String {
1175 if let Ok(explicit_dir) = std::env::var("MICROCLAW_SKILLS_DIR") {
1177 let trimmed = explicit_dir.trim();
1178 if !trimmed.is_empty() {
1179 return expand_path(trimmed).to_string_lossy().to_string();
1180 }
1181 }
1182 if let Some(configured) = &self.skills_dir {
1184 let trimmed = configured.trim();
1185 if !trimmed.is_empty() {
1186 return expand_path(trimmed).to_string_lossy().to_string();
1187 }
1188 }
1189 self.data_root_dir()
1191 .join("skills")
1192 .to_string_lossy()
1193 .to_string()
1194 }
1195
1196 pub fn souls_data_dir(&self) -> String {
1198 if let Some(configured) = &self.souls_dir {
1199 let trimmed = configured.trim();
1200 if !trimmed.is_empty() {
1201 return expand_path(trimmed).to_string_lossy().to_string();
1202 }
1203 }
1204 self.data_root_dir()
1205 .join("souls")
1206 .to_string_lossy()
1207 .to_string()
1208 }
1209
1210 pub fn clawhub_lockfile_path(&self) -> PathBuf {
1211 self.data_root_dir().join("clawhub.lock.json")
1212 }
1213
1214 pub fn clawhub_load_verification(&self) -> Option<(PathBuf, bool)> {
1217 match self.clawhub.verify_on_load {
1218 ClawHubVerifyMode::Off => None,
1219 ClawHubVerifyMode::Warn => Some((self.clawhub_lockfile_path(), false)),
1220 ClawHubVerifyMode::Block => Some((self.clawhub_lockfile_path(), true)),
1221 }
1222 }
1223
1224 pub fn config_path_for_setup() -> PathBuf {
1225 if let Ok(custom) = std::env::var("MICROCLAW_CONFIG") {
1226 return expand_path(&custom);
1227 }
1228 if std::path::Path::new("./microclaw.config.yaml").exists() {
1229 return PathBuf::from("./microclaw.config.yaml");
1230 }
1231 if std::path::Path::new("./microclaw.config.yml").exists() {
1232 return PathBuf::from("./microclaw.config.yml");
1233 }
1234 if std::env::var("SNAP").is_ok() {
1235 if let Ok(snap_user_common) = std::env::var("SNAP_USER_COMMON") {
1236 return PathBuf::from(snap_user_common).join("config.yaml");
1237 }
1238 }
1239 PathBuf::from("microclaw.config.yaml")
1240 }
1241
1242 pub fn resolve_config_path() -> Result<Option<PathBuf>, MicroClawError> {
1243 if let Ok(custom) = std::env::var("MICROCLAW_CONFIG") {
1245 let expanded = expand_path(&custom);
1246 if expanded.exists() {
1247 return Ok(Some(expanded));
1248 }
1249 return Err(MicroClawError::Config(format!(
1250 "MICROCLAW_CONFIG points to non-existent file: {custom}"
1251 )));
1252 }
1253
1254 if std::path::Path::new("./microclaw.config.yaml").exists() {
1255 return Ok(Some(PathBuf::from("./microclaw.config.yaml")));
1256 }
1257 if std::path::Path::new("./microclaw.config.yml").exists() {
1258 return Ok(Some(PathBuf::from("./microclaw.config.yml")));
1259 }
1260 Ok(None)
1261 }
1262
1263 fn inferred_channel_enabled(&self, channel: &str) -> bool {
1264 match channel {
1265 "telegram" => {
1266 !self.telegram_bot_token.trim().is_empty() || self.channels.contains_key("telegram")
1267 }
1268 "discord" => {
1269 self.discord_bot_token
1270 .as_deref()
1271 .map(|v| !v.trim().is_empty())
1272 .unwrap_or(false)
1273 || self.channels.contains_key("discord")
1274 }
1275 "web" => self.web_enabled || self.channels.contains_key("web"),
1276 _ => self.channels.contains_key(channel),
1277 }
1278 }
1279
1280 fn explicit_channel_enabled(&self, channel: &str) -> Option<bool> {
1281 self.channels
1282 .get(channel)
1283 .and_then(|v| v.get("enabled"))
1284 .and_then(|v| v.as_bool())
1285 }
1286
1287 pub fn channel_enabled(&self, channel: &str) -> bool {
1288 let needle = channel.trim().to_lowercase();
1289 if let Some(explicit) = self.explicit_channel_enabled(&needle) {
1290 return explicit;
1291 }
1292 self.inferred_channel_enabled(&needle)
1293 }
1294
1295 pub fn channel_status(&self) -> (Vec<&'static str>, Vec<&'static str>) {
1301 let configured = [
1302 (
1303 "telegram",
1304 !self.telegram_bot_token.trim().is_empty()
1305 || self.channels.contains_key("telegram"),
1306 ),
1307 (
1308 "discord",
1309 self.discord_bot_token
1310 .as_deref()
1311 .map(|v| !v.trim().is_empty())
1312 .unwrap_or(false)
1313 || self.channels.contains_key("discord"),
1314 ),
1315 ("slack", self.channels.contains_key("slack")),
1316 ("feishu", self.channels.contains_key("feishu")),
1317 ("irc", self.channels.contains_key("irc")),
1318 ("web", self.web_enabled || self.channels.contains_key("web")),
1319 ];
1320 let mut enabled = Vec::new();
1321 let mut configured_but_disabled = Vec::new();
1322 for (name, is_configured) in configured {
1323 if !is_configured {
1324 continue;
1325 }
1326 if self.channel_enabled(name) {
1327 enabled.push(name);
1328 } else {
1329 configured_but_disabled.push(name);
1330 }
1331 }
1332 (enabled, configured_but_disabled)
1333 }
1334
1335 pub fn load() -> Result<Self, MicroClawError> {
1337 let yaml_path = Self::resolve_config_path()?;
1338
1339 if let Some(path) = yaml_path {
1340 return Self::load_from_path(&path);
1341 }
1342
1343 Err(MicroClawError::Config(
1345 "No microclaw.config.yaml found. Run `microclaw setup` to create one.".into(),
1346 ))
1347 }
1348
1349 pub fn load_from_path(path: &Path) -> Result<Self, MicroClawError> {
1351 Self::load_from_path_inner(path, false)
1352 }
1353
1354 pub fn load_from_path_for_headless(path: &Path) -> Result<Self, MicroClawError> {
1361 Self::load_from_path_inner(path, true)
1362 }
1363
1364 pub fn for_embedded(
1366 provider: impl Into<String>,
1367 model: impl Into<String>,
1368 api_key: impl Into<String>,
1369 base_url: Option<String>,
1370 ) -> Result<Self, MicroClawError> {
1371 let mut config: Config = serde_yaml::from_str("{}")
1372 .map_err(|error| MicroClawError::Config(error.to_string()))?;
1373 config.llm_provider = provider.into();
1374 config.model = model.into();
1375 config.api_key = api_key.into();
1376 config.llm_base_url = base_url;
1377 config.web_enabled = true;
1378 config.post_deserialize()?;
1379 config.web_enabled = false;
1380 config.channels.remove("web");
1381 Ok(config)
1382 }
1383
1384 fn load_from_path_inner(path: &Path, allow_no_channels: bool) -> Result<Self, MicroClawError> {
1385 let path_str = path.to_string_lossy().to_string();
1386 let content = std::fs::read_to_string(path)
1387 .map_err(|e| MicroClawError::Config(format!("Failed to read {path_str}: {e}")))?;
1388 if let Ok(raw) = serde_yaml::from_str::<serde_yaml::Value>(&content) {
1389 if let Some(map) = raw.as_mapping() {
1390 let old_top_level = map
1391 .get(serde_yaml::Value::String("web_auth_token".to_string()))
1392 .is_some();
1393 let old_channel_level = map
1394 .get(serde_yaml::Value::String("channels".to_string()))
1395 .and_then(|v| v.as_mapping())
1396 .and_then(|channels| channels.get(serde_yaml::Value::String("web".to_string())))
1397 .and_then(|v| v.as_mapping())
1398 .map(|web| {
1399 web.contains_key(serde_yaml::Value::String("auth_token".to_string()))
1400 })
1401 .unwrap_or(false);
1402 if old_top_level || old_channel_level {
1403 warn!(
1404 "Deprecated web auth token config detected in {}. \
1405`web_auth_token` / `channels.web.auth_token` are ignored; migrate to operator password + API keys.",
1406 path_str
1407 );
1408 }
1409 for warning in unknown_top_level_key_warnings(map) {
1410 warn!("{warning} (in {path_str})");
1411 }
1412 }
1413 }
1414 let mut config: Config = serde_yaml::from_str(&content)
1415 .map_err(|error| MicroClawError::Config(friendly_yaml_error(&path_str, &error)))?;
1416 let synthesized_channel = allow_no_channels && config.channel_status().0.is_empty();
1417 if synthesized_channel {
1418 config.web_enabled = true;
1419 }
1420 config.post_deserialize()?;
1421 if crate::tool_guardrails::global_policy_has_no_rules(&config.tool_policy) {
1422 tracing::warn!(
1423 "tool_policy.mode is on but allow_tools, deny_tools and max_risk are all empty: \
1424 every tool is still permitted. Add an allowlist, a deny list or a max_risk ceiling."
1425 );
1426 }
1427 if synthesized_channel {
1428 config.web_enabled = false;
1429 config.channels.remove("web");
1430 }
1431 Ok(config)
1432 }
1433
1434 pub fn post_deserialize(&mut self) -> Result<(), MicroClawError> {
1436 self.llm_provider = self.llm_provider.trim().to_lowercase();
1437
1438 self.model = resolve_model_name_with_fallback(&self.llm_provider, Some(&self.model), None);
1439 self.provider_presets =
1440 normalize_provider_profiles(std::mem::take(&mut self.provider_presets));
1441 self.llm_providers = normalize_provider_profiles(std::mem::take(&mut self.llm_providers));
1442 for (alias, preset) in self.provider_presets.clone() {
1443 self.llm_providers
1444 .entry(alias)
1445 .and_modify(|existing| {
1446 *existing = merge_provider_profile(preset.clone(), existing.clone());
1447 })
1448 .or_insert(preset);
1449 }
1450 for channel_cfg in self.channels.values_mut() {
1451 migrate_model_override_alias_to_provider_preset(channel_cfg, &self.provider_presets);
1452 }
1453
1454 self.override_timezone = self
1455 .override_timezone
1456 .as_ref()
1457 .map(|v| v.trim().to_string())
1458 .filter(|v| !v.is_empty());
1459 if self
1460 .override_timezone
1461 .as_deref()
1462 .is_some_and(|v| v.eq_ignore_ascii_case("auto"))
1463 {
1464 self.override_timezone = None;
1465 }
1466
1467 let tz_raw = self
1470 .override_timezone
1471 .clone()
1472 .unwrap_or_else(|| "auto".to_string());
1473
1474 if tz_raw.eq_ignore_ascii_case("auto") {
1475 let detected = detect_system_timezone();
1476 if detected.parse::<chrono_tz::Tz>().is_ok() {
1477 self.timezone = detected;
1478 } else {
1479 warn!(
1480 "Detected system timezone '{}' is not recognized by chrono-tz. Falling back to UTC.",
1481 detected
1482 );
1483 self.timezone = "UTC".into();
1484 }
1485 } else {
1486 tz_raw
1487 .parse::<chrono_tz::Tz>()
1488 .map_err(|_| MicroClawError::Config(format!("Invalid timezone: {tz_raw}")))?;
1489 self.timezone = tz_raw;
1490 }
1491
1492 if let Some(ref url) = self.llm_base_url {
1494 if url.trim().is_empty() {
1495 self.llm_base_url = None;
1496 }
1497 }
1498 self.llm_user_agent = self.llm_user_agent.trim().to_string();
1499 if self.llm_user_agent.is_empty() {
1500 self.llm_user_agent = default_llm_user_agent();
1501 }
1502 if let Some(dir) = &self.skills_dir {
1503 let trimmed = dir.trim().to_string();
1504 self.skills_dir = if trimmed.is_empty() {
1505 None
1506 } else {
1507 Some(expand_path(&trimmed).to_string_lossy().to_string())
1508 };
1509 }
1510 if let Some(dir) = &self.souls_dir {
1511 let trimmed = dir.trim().to_string();
1512 self.souls_dir = if trimmed.is_empty() {
1513 None
1514 } else {
1515 Some(expand_path(&trimmed).to_string_lossy().to_string())
1516 };
1517 }
1518 if let Some(dir) = &self.plugins.dir {
1519 let trimmed = dir.trim().to_string();
1520 self.plugins.dir = if trimmed.is_empty() {
1521 None
1522 } else {
1523 Some(expand_path(&trimmed).to_string_lossy().to_string())
1524 };
1525 }
1526 if self.working_dir.trim().is_empty() {
1527 self.working_dir = default_working_dir();
1528 } else {
1529 self.working_dir = expand_path(&self.working_dir).to_string_lossy().to_string();
1530 }
1531 self.data_dir = expand_path(&self.data_dir).to_string_lossy().to_string();
1532 self.sandbox.image = self.sandbox.image.trim().to_string();
1533 if self.sandbox.image.is_empty() {
1534 self.sandbox.image = default_sandbox_image();
1535 }
1536 self.sandbox.container_prefix = self.sandbox.container_prefix.trim().to_string();
1537 if self.sandbox.container_prefix.is_empty() {
1538 self.sandbox.container_prefix = default_sandbox_container_prefix();
1539 }
1540 normalize_string_list(&mut self.sandbox.credential_env_allowlist, false);
1541 normalize_string_list(&mut self.egress_policy.allow_hosts, true);
1542 normalize_string_list(&mut self.egress_policy.deny_hosts, true);
1543 normalize_string_list(&mut self.tool_policy.allow_tools, false);
1544 normalize_string_list(&mut self.tool_policy.deny_tools, false);
1545 for grant in &mut self.tool_policy.grants {
1546 grant.channel = grant
1547 .channel
1548 .take()
1549 .map(|value| value.trim().to_ascii_lowercase())
1550 .filter(|value| !value.is_empty());
1551 grant.principal = grant
1552 .principal
1553 .take()
1554 .map(|value| value.trim().to_ascii_lowercase())
1555 .filter(|value| !value.is_empty());
1556 normalize_string_list(&mut grant.allow_tools, false);
1557 normalize_string_list(&mut grant.deny_tools, false);
1558 }
1559 if self.web_host.trim().is_empty() {
1560 self.web_host = default_web_host();
1561 }
1562 self.a2a.public_base_url = self
1563 .a2a
1564 .public_base_url
1565 .as_ref()
1566 .map(|v| v.trim().trim_end_matches('/').to_string())
1567 .filter(|v| !v.is_empty());
1568 self.a2a.agent_name = self
1569 .a2a
1570 .agent_name
1571 .as_ref()
1572 .map(|v| v.trim().to_string())
1573 .filter(|v| !v.is_empty());
1574 self.a2a.agent_description = self
1575 .a2a
1576 .agent_description
1577 .as_ref()
1578 .map(|v| v.trim().to_string())
1579 .filter(|v| !v.is_empty());
1580 self.a2a.shared_tokens = self
1581 .a2a
1582 .shared_tokens
1583 .drain(..)
1584 .map(|v| v.trim().to_string())
1585 .filter(|v| !v.is_empty())
1586 .collect();
1587 self.a2a.peers = self
1588 .a2a
1589 .peers
1590 .drain()
1591 .filter_map(|(name, mut peer)| {
1592 let normalized = name.trim().to_ascii_lowercase();
1593 if normalized.is_empty() {
1594 return None;
1595 }
1596 peer.base_url = peer.base_url.trim().trim_end_matches('/').to_string();
1597 if peer.base_url.is_empty() {
1598 return None;
1599 }
1600 peer.bearer_token = peer
1601 .bearer_token
1602 .as_ref()
1603 .map(|v| v.trim().to_string())
1604 .filter(|v| !v.is_empty());
1605 peer.description = peer
1606 .description
1607 .as_ref()
1608 .map(|v| v.trim().to_string())
1609 .filter(|v| !v.is_empty());
1610 peer.default_session_key = peer
1611 .default_session_key
1612 .as_ref()
1613 .map(|v| v.trim().to_string())
1614 .filter(|v| !v.is_empty());
1615 Some((normalized, peer))
1616 })
1617 .collect();
1618 if let Some(provider) = &self.embedding_provider {
1619 let p = provider.trim().to_lowercase();
1620 self.embedding_provider = if p.is_empty() { None } else { Some(p) };
1621 }
1622 if let Some(v) = &self.embedding_api_key {
1623 if v.trim().is_empty() {
1624 self.embedding_api_key = None;
1625 }
1626 }
1627 if let Some(v) = &self.embedding_base_url {
1628 if v.trim().is_empty() {
1629 self.embedding_base_url = None;
1630 }
1631 }
1632 if let Some(v) = &self.embedding_model {
1633 let m = v.trim().to_string();
1634 self.embedding_model = if m.is_empty() { None } else { Some(m) };
1635 }
1636 if let Some(v) = self.embedding_dim {
1637 if v == 0 {
1638 self.embedding_dim = None;
1639 }
1640 }
1641 if let Some(web_cfg) = self
1642 .channels
1643 .get_mut("web")
1644 .and_then(|v| v.as_mapping_mut())
1645 {
1646 if web_cfg
1647 .remove(serde_yaml::Value::String("auth_token".to_string()))
1648 .is_some()
1649 {
1650 warn!(
1651 "Deprecated `channels.web.auth_token` detected and ignored. \
1652Use operator password + API keys for Web auth."
1653 );
1654 }
1655 }
1656 if self.web_max_inflight_per_session == 0 {
1657 self.web_max_inflight_per_session = default_web_max_inflight_per_session();
1658 }
1659 if self.web_max_requests_per_window == 0 {
1660 self.web_max_requests_per_window = default_web_max_requests_per_window();
1661 }
1662 if self.web_rate_window_seconds == 0 {
1663 self.web_rate_window_seconds = default_web_rate_window_seconds();
1664 }
1665 if self.web_run_history_limit == 0 {
1666 self.web_run_history_limit = default_web_run_history_limit();
1667 }
1668 if self.web_session_idle_ttl_seconds == 0 {
1669 self.web_session_idle_ttl_seconds = default_web_session_idle_ttl_seconds();
1670 }
1671 self.web_fetch_validation.normalize();
1672 self.web_fetch_url_validation.normalize();
1673 self.web_search.normalize();
1674 if self.max_document_size_mb == 0 {
1675 self.max_document_size_mb = default_max_document_size_mb();
1676 }
1677 if self.default_tool_timeout_secs == 0 {
1678 self.default_tool_timeout_secs = default_tool_timeout_secs();
1679 }
1680 if self.default_mcp_request_timeout_secs == 0 {
1681 self.default_mcp_request_timeout_secs = default_mcp_request_timeout_secs();
1682 }
1683 if self.subagents.max_concurrent == 0 {
1684 self.subagents.max_concurrent = default_subagent_max_concurrent();
1685 }
1686 if self.subagents.max_active_per_chat == 0 {
1687 self.subagents.max_active_per_chat = default_subagent_max_active_per_chat();
1688 }
1689 if self.subagents.run_timeout_secs == 0 {
1690 self.subagents.run_timeout_secs = default_subagent_run_timeout_secs();
1691 }
1692 if self.subagents.max_spawn_depth == 0 {
1693 self.subagents.max_spawn_depth = default_subagent_max_spawn_depth();
1694 }
1695 self.subagents.max_spawn_depth = self.subagents.max_spawn_depth.min(5);
1696 if self.subagents.max_children_per_run == 0 {
1697 self.subagents.max_children_per_run = default_subagent_max_children_per_run();
1698 }
1699 if self.subagents.announce_relay_interval_secs == 0 {
1700 self.subagents.announce_relay_interval_secs =
1701 default_subagent_announce_relay_interval_secs();
1702 }
1703 self.subagents.announce_relay_interval_secs =
1704 self.subagents.announce_relay_interval_secs.clamp(1, 300);
1705 if self.subagents.max_tokens_per_run <= 0 {
1706 self.subagents.max_tokens_per_run = default_subagent_max_tokens_per_run();
1707 }
1708 self.subagents.max_tokens_per_run =
1709 self.subagents.max_tokens_per_run.clamp(2_000, 2_000_000);
1710 if self.subagents.orchestrate_max_workers == 0 {
1711 self.subagents.orchestrate_max_workers = default_subagent_orchestrate_max_workers();
1712 }
1713 self.subagents.orchestrate_max_workers =
1714 self.subagents.orchestrate_max_workers.clamp(1, 12);
1715 self.subagents.acp.normalize();
1716 self.tool_timeout_overrides = self
1717 .tool_timeout_overrides
1718 .drain()
1719 .filter_map(|(name, timeout_secs)| {
1720 let normalized = name.trim().to_ascii_lowercase();
1721 if normalized.is_empty() || timeout_secs == 0 {
1722 None
1723 } else {
1724 Some((normalized, timeout_secs))
1725 }
1726 })
1727 .collect();
1728 self.openai_compat_body_overrides =
1729 normalize_body_override_params(std::mem::take(&mut self.openai_compat_body_overrides));
1730 self.openai_compat_body_overrides_by_provider = self
1731 .openai_compat_body_overrides_by_provider
1732 .drain()
1733 .filter_map(|(provider, params)| {
1734 let provider = provider.trim().to_ascii_lowercase();
1735 if provider.is_empty() {
1736 return None;
1737 }
1738 let params = normalize_body_override_params(params);
1739 if params.is_empty() {
1740 None
1741 } else {
1742 Some((provider, params))
1743 }
1744 })
1745 .collect();
1746 self.openai_compat_body_overrides_by_model = self
1747 .openai_compat_body_overrides_by_model
1748 .drain()
1749 .filter_map(|(model, params)| {
1750 let model = model.trim().to_string();
1751 if model.is_empty() {
1752 return None;
1753 }
1754 let params = normalize_body_override_params(params);
1755 if params.is_empty() {
1756 None
1757 } else {
1758 Some((model, params))
1759 }
1760 })
1761 .collect();
1762 if self.memory_token_budget == 0 {
1763 self.memory_token_budget = default_memory_token_budget();
1764 }
1765 for price in &mut self.model_prices {
1766 price.model = price.model.trim().to_string();
1767 if price.model.is_empty() {
1768 return Err(MicroClawError::Config(
1769 "model_prices entries must include non-empty model".into(),
1770 ));
1771 }
1772 if !(price.input_per_million_usd.is_finite() && price.input_per_million_usd >= 0.0) {
1773 return Err(MicroClawError::Config(format!(
1774 "model_prices[{}].input_per_million_usd must be >= 0",
1775 price.model
1776 )));
1777 }
1778 if !(price.output_per_million_usd.is_finite() && price.output_per_million_usd >= 0.0) {
1779 return Err(MicroClawError::Config(format!(
1780 "model_prices[{}].output_per_million_usd must be >= 0",
1781 price.model
1782 )));
1783 }
1784 }
1785
1786 if self.channels.is_empty() {
1788 if !self.telegram_bot_token.trim().is_empty() {
1789 self.channels.insert(
1790 "telegram".into(),
1791 serde_yaml::to_value(serde_json::json!({
1792 "enabled": true,
1793 "bot_token": self.telegram_bot_token,
1794 "bot_username": self.bot_username,
1795 "allowed_groups": self.allowed_groups,
1796 }))
1797 .unwrap(),
1798 );
1799 }
1800 if let Some(ref token) = self.discord_bot_token {
1801 if !token.trim().is_empty() {
1802 self.channels.insert(
1803 "discord".into(),
1804 serde_yaml::to_value(serde_json::json!({
1805 "enabled": true,
1806 "bot_token": token,
1807 "allowed_channels": self.discord_allowed_channels,
1808 "no_mention": self.discord_no_mention,
1809 }))
1810 .unwrap(),
1811 );
1812 }
1813 }
1814 if self.web_enabled {
1815 self.channels.insert(
1816 "web".into(),
1817 serde_yaml::to_value(serde_json::json!({
1818 "enabled": true,
1819 "host": self.web_host,
1820 "port": self.web_port,
1821 }))
1822 .unwrap(),
1823 );
1824 }
1825 }
1826
1827 let (enabled_channels, configured_but_disabled) = self.channel_status();
1829 if enabled_channels.is_empty() {
1830 let hint = if configured_but_disabled.is_empty() {
1831 String::new()
1832 } else {
1833 format!(
1834 " These channels are configured but not enabled: {}. \
1835 Set `channels.<name>.enabled: true` (or run `microclaw setup`).",
1836 configured_but_disabled.join(", ")
1837 )
1838 };
1839 return Err(MicroClawError::Config(format!(
1840 "At least one channel must be enabled and configured (via channels.<name>.enabled or legacy channel settings).{hint}"
1841 )));
1842 }
1843 if self.api_key.is_empty() && !provider_allows_empty_api_key(&self.llm_provider) {
1844 return Err(MicroClawError::Config("api_key is required".into()));
1845 }
1846 if is_openai_codex_provider(&self.llm_provider) {
1847 if !self.api_key.trim().is_empty() {
1848 return Err(MicroClawError::Config(
1849 "openai-codex ignores microclaw.config.yaml api_key. Configure ~/.codex/auth.json or run `codex login` instead.".into(),
1850 ));
1851 }
1852 if self
1853 .llm_base_url
1854 .as_ref()
1855 .map(|v| !v.trim().is_empty())
1856 .unwrap_or(false)
1857 {
1858 return Err(MicroClawError::Config(
1859 "openai-codex ignores microclaw.config.yaml llm_base_url. Configure ~/.codex/config.toml instead.".into(),
1860 ));
1861 }
1862 let has_codex_auth = codex_auth_file_has_access_token()?;
1863 if !has_codex_auth {
1864 return Err(MicroClawError::Config(
1865 "openai-codex requires ~/.codex/auth.json (access token or OPENAI_API_KEY), or OPENAI_CODEX_ACCESS_TOKEN. Run `codex login` or update Codex config files.".into(),
1866 ));
1867 }
1868 }
1869 if is_qwen_portal_provider(&self.llm_provider) && self.api_key.trim().is_empty() {
1870 let has_qwen_auth = qwen_oauth_file_has_access_token()?;
1871 if !has_qwen_auth {
1872 return Err(MicroClawError::Config(
1873 "qwen-portal requires api_key, or ~/.qwen/oauth_creds.json (access_token), or QWEN_PORTAL_ACCESS_TOKEN.".into(),
1874 ));
1875 }
1876 }
1877
1878 self.validate_configured_egress()?;
1879
1880 Ok(())
1881 }
1882
1883 fn validate_configured_egress(&self) -> Result<(), MicroClawError> {
1884 if self.egress_policy.mode == EgressPolicyMode::Off {
1885 return Ok(());
1886 }
1887 for url in self.configured_egress_endpoints() {
1888 let decision =
1889 crate::internal::tool_runtime::egress::evaluate_url(&self.egress_policy, &url);
1890 match decision {
1891 crate::internal::tool_runtime::egress::EgressDecision::Warn(reason) => {
1892 warn!(url = %url, reason = %reason, "configured endpoint violates egress policy");
1893 }
1894 crate::internal::tool_runtime::egress::EgressDecision::Block(reason) => {
1895 return Err(MicroClawError::Config(format!(
1896 "configured endpoint `{url}` blocked by egress policy: {reason}"
1897 )));
1898 }
1899 crate::internal::tool_runtime::egress::EgressDecision::Allow => {}
1900 }
1901 }
1902 Ok(())
1903 }
1904
1905 fn configured_egress_endpoints(&self) -> Vec<String> {
1906 let mut urls = Vec::new();
1907 {
1908 let mut add = |value: Option<&str>| {
1909 if let Some(value) = value.map(str::trim).filter(|value| !value.is_empty()) {
1910 urls.push(value.to_string());
1911 }
1912 };
1913
1914 add(self.llm_base_url.as_deref());
1915 for profile in self
1916 .provider_presets
1917 .values()
1918 .chain(self.llm_providers.values())
1919 {
1920 add(profile.llm_base_url.as_deref());
1921 }
1922 add(self.embedding_base_url.as_deref());
1923 add(self.openai_base_url.as_deref());
1924
1925 let media_enabled = self.media.image_gen.enabled
1926 || self.media.vision.enabled
1927 || self.media.tts.enabled
1928 || self.media.stt.enabled
1929 || self.media.podcast.enabled;
1930 if media_enabled {
1931 add(self.media.base_url.as_deref());
1932 }
1933 if self.media.tts.enabled || self.media.podcast.enabled {
1934 add(self.media.tts.base_url.as_deref());
1935 }
1936 if self.media.podcast.enabled {
1937 add(self.media.podcast.base_url.as_deref());
1938 }
1939
1940 if self.web_search.effective_backend()
1941 == crate::internal::tool_runtime::web_search::SearchBackend::Searxng
1942 {
1943 add(Some(&self.web_search.searxng_base_url));
1944 }
1945 for peer in self.a2a.peers.values().filter(|peer| peer.enabled) {
1946 add(Some(&peer.base_url));
1947 }
1948 if self.clawhub.agent_tools_enabled {
1949 add(Some(&self.clawhub.registry));
1950 }
1951 if self.alerts.enabled {
1952 add(Some(&self.alerts.webhook_url));
1953 }
1954 }
1955
1956 for channel in self.channels.values() {
1957 collect_enabled_channel_endpoints(channel, &mut urls);
1958 }
1959
1960 urls.sort();
1961 urls.dedup();
1962 urls
1963 }
1964
1965 fn merged_profile_from_alias(&self, alias: &str) -> Option<ResolvedLlmProviderProfile> {
1966 let alias = alias.trim().to_ascii_lowercase();
1967 if alias.is_empty() {
1968 return None;
1969 }
1970 if alias == self.llm_provider {
1971 let mut provider = self.llm_provider.clone();
1972 let mut api_key = self.api_key.clone();
1973 let mut api_keys = self.api_keys.clone();
1974 let mut llm_base_url = self.llm_base_url.clone();
1975 let mut llm_user_agent = self.llm_user_agent.clone();
1976 let mut default_model = self.model.clone();
1977 let mut models = vec![default_model.clone()];
1978 let mut show_thinking = self.show_thinking;
1979 if let Some(profile) = self.llm_providers.get(&alias) {
1980 if let Some(v) = &profile.provider {
1981 provider = v.clone();
1982 }
1983 if let Some(v) = &profile.api_key {
1984 api_key = v.clone();
1985 }
1986 if !profile.api_keys.is_empty() {
1987 api_keys = profile.api_keys.clone();
1988 }
1989 if let Some(v) = &profile.llm_base_url {
1990 llm_base_url = Some(v.clone());
1991 }
1992 if let Some(v) = &profile.llm_user_agent {
1993 llm_user_agent = v.clone();
1994 }
1995 if let Some(v) = &profile.default_model {
1996 default_model = v.clone();
1997 }
1998 if !profile.models.is_empty() {
1999 models = profile.models.clone();
2000 }
2001 if let Some(v) = profile.show_thinking {
2002 show_thinking = v;
2003 }
2004 }
2005 default_model = resolve_model_name_with_fallback(
2006 &provider,
2007 Some(&default_model),
2008 Some(&self.model),
2009 );
2010 models = models
2011 .into_iter()
2012 .filter_map(|model| normalize_model_name(&model))
2013 .collect();
2014 if !models.iter().any(|m| m == &default_model) {
2015 models.push(default_model.clone());
2016 }
2017 models.sort();
2018 models.dedup();
2019 return Some(ResolvedLlmProviderProfile {
2020 alias,
2021 provider,
2022 api_key,
2023 api_keys,
2024 llm_base_url,
2025 llm_user_agent,
2026 default_model,
2027 models,
2028 show_thinking,
2029 });
2030 }
2031
2032 let profile = self.llm_providers.get(&alias)?;
2033 let provider = profile.provider.clone().unwrap_or_else(|| alias.clone());
2034 let api_key = profile
2035 .api_key
2036 .clone()
2037 .unwrap_or_else(|| self.api_key.clone());
2038 let api_keys = if !profile.api_keys.is_empty() {
2040 profile.api_keys.clone()
2041 } else if profile.api_key.is_none() {
2042 self.api_keys.clone()
2043 } else {
2044 Vec::new()
2045 };
2046 let llm_base_url = profile
2047 .llm_base_url
2048 .clone()
2049 .or_else(|| self.llm_base_url.clone());
2050 let llm_user_agent = profile
2051 .llm_user_agent
2052 .clone()
2053 .unwrap_or_else(|| self.llm_user_agent.clone());
2054 let default_model = resolve_model_name_with_fallback(
2055 &provider,
2056 profile.default_model.as_deref(),
2057 Some(&self.model),
2058 );
2059 let mut models = if profile.models.is_empty() {
2060 vec![default_model.clone()]
2061 } else {
2062 profile
2063 .models
2064 .clone()
2065 .into_iter()
2066 .filter_map(|model| normalize_model_name(&model))
2067 .collect()
2068 };
2069 let show_thinking = profile.show_thinking.unwrap_or(self.show_thinking);
2070 if !models.iter().any(|m| m == &default_model) {
2071 models.push(default_model.clone());
2072 }
2073 models.sort();
2074 models.dedup();
2075 Some(ResolvedLlmProviderProfile {
2076 alias,
2077 provider,
2078 api_key,
2079 api_keys,
2080 llm_base_url,
2081 llm_user_agent,
2082 default_model,
2083 models,
2084 show_thinking,
2085 })
2086 }
2087
2088 pub fn resolve_llm_provider_profile(&self, alias: &str) -> Option<ResolvedLlmProviderProfile> {
2089 self.merged_profile_from_alias(alias)
2090 }
2091
2092 pub fn list_llm_provider_profiles(&self) -> Vec<ResolvedLlmProviderProfile> {
2093 let mut out = Vec::new();
2094 if let Some(default_profile) = self.resolve_llm_provider_profile(&self.llm_provider) {
2095 out.push(default_profile);
2096 }
2097 let mut aliases: Vec<String> = self.llm_providers.keys().cloned().collect();
2098 aliases.sort();
2099 aliases.dedup();
2100 for alias in aliases {
2101 if alias == self.llm_provider {
2102 continue;
2103 }
2104 if let Some(profile) = self.resolve_llm_provider_profile(&alias) {
2105 out.push(profile);
2106 }
2107 }
2108 out
2109 }
2110
2111 pub fn channel_config<T: DeserializeOwned>(&self, name: &str) -> Option<T> {
2113 self.channels
2114 .get(name)
2115 .and_then(|v| serde_yaml::from_value(v.clone()).ok())
2116 }
2117
2118 pub fn model_price(&self, model: &str) -> Option<&ModelPrice> {
2119 let needle = model.trim();
2120 self.model_prices
2121 .iter()
2122 .find(|p| p.model.eq_ignore_ascii_case(needle))
2123 .or_else(|| self.model_prices.iter().find(|p| p.model == "*"))
2124 }
2125
2126 pub fn estimate_cost_usd(
2127 &self,
2128 model: &str,
2129 input_tokens: i64,
2130 output_tokens: i64,
2131 ) -> Option<f64> {
2132 let price = self.model_price(model)?;
2133 let in_tok = input_tokens.max(0) as f64;
2134 let out_tok = output_tokens.max(0) as f64;
2135 Some(
2136 (in_tok / 1_000_000.0) * price.input_per_million_usd
2137 + (out_tok / 1_000_000.0) * price.output_per_million_usd,
2138 )
2139 }
2140
2141 pub fn tool_timeout_secs(&self, tool_name: &str, fallback: u64) -> u64 {
2142 let normalized = tool_name.trim().to_ascii_lowercase();
2143 if let Some(timeout_secs) = self.tool_timeout_overrides.get(&normalized) {
2144 return *timeout_secs;
2145 }
2146 if self.default_tool_timeout_secs == 0 {
2147 fallback
2148 } else {
2149 self.default_tool_timeout_secs
2150 }
2151 }
2152
2153 pub fn mcp_request_timeout_secs(&self) -> u64 {
2154 if self.default_mcp_request_timeout_secs == 0 {
2155 default_mcp_request_timeout_secs()
2156 } else {
2157 self.default_mcp_request_timeout_secs
2158 }
2159 }
2160
2161 #[allow(dead_code)]
2163 pub fn save_yaml(&self, path: &str) -> Result<(), MicroClawError> {
2164 let content = serde_yaml::to_string(self)
2165 .map_err(|e| MicroClawError::Config(format!("Failed to serialize config: {e}")))?;
2166 std::fs::write(path, content)?;
2167 Ok(())
2168 }
2169}
2170
2171pub(crate) fn normalize_body_override_params(
2172 params: HashMap<String, serde_json::Value>,
2173) -> HashMap<String, serde_json::Value> {
2174 params
2175 .into_iter()
2176 .filter_map(|(key, value)| {
2177 let key = key.trim().to_string();
2178 if key.is_empty() {
2179 None
2180 } else {
2181 Some((key, value))
2182 }
2183 })
2184 .collect()
2185}
2186
2187pub(crate) fn normalize_provider_profiles(
2188 profiles: HashMap<String, LlmProviderProfile>,
2189) -> HashMap<String, LlmProviderProfile> {
2190 profiles
2191 .into_iter()
2192 .filter_map(|(alias, mut profile)| {
2193 let alias = alias.trim().to_ascii_lowercase();
2194 if alias.is_empty() {
2195 return None;
2196 }
2197 profile.provider = profile
2198 .provider
2199 .as_ref()
2200 .map(|v| v.trim().to_ascii_lowercase())
2201 .filter(|v| !v.is_empty());
2202 profile.api_key = profile
2203 .api_key
2204 .as_ref()
2205 .map(|v| v.trim().to_string())
2206 .filter(|v| !v.is_empty());
2207 profile.llm_base_url = profile
2208 .llm_base_url
2209 .as_ref()
2210 .map(|v| v.trim().to_string())
2211 .filter(|v| !v.is_empty());
2212 profile.llm_user_agent = profile
2213 .llm_user_agent
2214 .as_ref()
2215 .map(|v| v.trim().to_string())
2216 .filter(|v| !v.is_empty());
2217 profile.default_model = profile
2218 .default_model
2219 .as_ref()
2220 .and_then(|v| normalize_model_name(v));
2221 profile.models = profile
2222 .models
2223 .into_iter()
2224 .filter_map(|m| normalize_model_name(&m))
2225 .collect::<Vec<_>>();
2226 profile.models.sort();
2227 profile.models.dedup();
2228 Some((alias, profile))
2229 })
2230 .collect()
2231}
2232
2233pub(crate) fn migrate_model_override_alias_to_provider_preset(
2234 value: &mut serde_yaml::Value,
2235 known_profiles: &HashMap<String, LlmProviderProfile>,
2236) {
2237 let Some(map) = value.as_mapping_mut() else {
2238 return;
2239 };
2240
2241 let provider_preset_key = serde_yaml::Value::String("provider_preset".to_string());
2242 let llm_provider_key = serde_yaml::Value::String("llm_provider".to_string());
2243 let model_key = serde_yaml::Value::String("model".to_string());
2244
2245 let has_provider_override =
2246 map.contains_key(&provider_preset_key) || map.contains_key(&llm_provider_key);
2247 if !has_provider_override {
2248 let maybe_profile_alias = map
2249 .get(&model_key)
2250 .and_then(|v| v.as_str())
2251 .map(str::trim)
2252 .filter(|v| !v.is_empty())
2253 .map(|v| v.to_ascii_lowercase());
2254 if let Some(alias) = maybe_profile_alias {
2255 if known_profiles.contains_key(&alias) {
2256 map.insert(
2257 provider_preset_key.clone(),
2258 serde_yaml::Value::String(alias),
2259 );
2260 map.remove(&model_key);
2261 }
2262 }
2263 }
2264
2265 let accounts_key = serde_yaml::Value::String("accounts".to_string());
2266 if let Some(accounts) = map.get_mut(&accounts_key).and_then(|v| v.as_mapping_mut()) {
2267 for (_, account) in accounts.iter_mut() {
2268 migrate_model_override_alias_to_provider_preset(account, known_profiles);
2269 }
2270 }
2271}
2272
2273pub(crate) fn merge_provider_profile(
2274 base: LlmProviderProfile,
2275 override_profile: LlmProviderProfile,
2276) -> LlmProviderProfile {
2277 let mut models = if override_profile.models.is_empty() {
2278 base.models
2279 } else {
2280 override_profile.models
2281 };
2282 models.sort();
2283 models.dedup();
2284
2285 LlmProviderProfile {
2286 provider: override_profile.provider.or(base.provider),
2287 api_key: override_profile.api_key.or(base.api_key),
2288 api_keys: if override_profile.api_keys.is_empty() {
2289 base.api_keys
2290 } else {
2291 override_profile.api_keys
2292 },
2293 llm_base_url: override_profile.llm_base_url.or(base.llm_base_url),
2294 llm_user_agent: override_profile.llm_user_agent.or(base.llm_user_agent),
2295 default_model: override_profile.default_model.or(base.default_model),
2296 models,
2297 show_thinking: override_profile.show_thinking.or(base.show_thinking),
2298 }
2299}
2300
2301#[derive(Debug, Default)]
2304pub struct ConfigCheckReport {
2305 pub errors: Vec<String>,
2306 pub warnings: Vec<String>,
2307 pub summary: Option<(Vec<&'static str>, Vec<&'static str>, String, String)>,
2310}
2311
2312impl ConfigCheckReport {
2313 pub fn ok(&self) -> bool {
2314 self.errors.is_empty()
2315 }
2316}
2317
2318pub fn check_config_content(path_str: &str, content: &str) -> ConfigCheckReport {
2323 let mut report = ConfigCheckReport::default();
2324
2325 let raw: serde_yaml::Value = match serde_yaml::from_str(content) {
2327 Ok(v) => v,
2328 Err(e) => {
2329 report.errors.push(format!("YAML syntax error: {e}"));
2330 return report;
2331 }
2332 };
2333
2334 if let Some(map) = raw.as_mapping() {
2336 report.warnings.extend(unknown_top_level_key_warnings(map));
2337 } else {
2338 report
2339 .errors
2340 .push("Config root must be a YAML mapping (key: value pairs).".to_string());
2341 return report;
2342 }
2343
2344 match serde_yaml::from_str::<Config>(content) {
2347 Err(e) => {
2348 report.errors.push(friendly_yaml_error(path_str, &e));
2349 }
2350 Ok(mut config) => match config.post_deserialize() {
2351 Err(e) => report.errors.push(e.to_string()),
2353 Ok(()) => {
2354 if crate::tool_guardrails::global_policy_has_no_rules(&config.tool_policy) {
2355 report.warnings.push(format!(
2356 "tool_policy.mode is `{}` but allow_tools, deny_tools and max_risk are all \
2357 empty, so every tool is still permitted. Add an allowlist, a deny list \
2358 or a max_risk ceiling.",
2359 serde_yaml::to_string(&config.tool_policy.mode)
2360 .unwrap_or_default()
2361 .trim()
2362 ));
2363 }
2364 let (enabled, disabled) = config.channel_status();
2365 report.summary = Some((
2366 enabled,
2367 disabled,
2368 config.llm_provider.clone(),
2369 config.model.clone(),
2370 ));
2371 }
2372 },
2373 }
2374 report
2375}
2376
2377pub fn run_config_check() -> i32 {
2381 let path = match Config::resolve_config_path() {
2382 Ok(Some(p)) => p,
2383 Ok(None) => {
2384 eprintln!("✗ No microclaw.config.yaml found. Run `microclaw setup` to create one.");
2385 return 2;
2386 }
2387 Err(e) => {
2388 eprintln!("✗ {e}");
2389 return 2;
2390 }
2391 };
2392 let path_str = path.to_string_lossy().to_string();
2393 let content = match std::fs::read_to_string(&path) {
2394 Ok(c) => c,
2395 Err(e) => {
2396 eprintln!("✗ Failed to read {path_str}: {e}");
2397 return 2;
2398 }
2399 };
2400
2401 println!("Checking {path_str}");
2402 let report = check_config_content(&path_str, &content);
2403 for w in &report.warnings {
2404 println!(" ⚠ {w}");
2405 }
2406 for e in &report.errors {
2407 println!(" ✗ {e}");
2408 }
2409 if let Some((enabled, disabled, provider, model)) = &report.summary {
2410 let enabled_str = if enabled.is_empty() {
2411 "none".to_string()
2412 } else {
2413 enabled.join(", ")
2414 };
2415 println!(" provider: {provider} · model: {model}");
2416 println!(" channels enabled: {enabled_str}");
2417 if !disabled.is_empty() {
2418 println!(" configured but disabled: {}", disabled.join(", "));
2419 }
2420 }
2421 if report.ok() {
2422 println!(
2423 "✓ Config OK{}",
2424 if report.warnings.is_empty() {
2425 ""
2426 } else {
2427 " (with warnings)"
2428 }
2429 );
2430 0
2431 } else {
2432 println!("✗ Config has errors — fix them and re-run, or run `microclaw setup`.");
2433 1
2434 }
2435}
2436
2437pub(crate) fn friendly_yaml_error(path_str: &str, err: &serde_yaml::Error) -> String {
2442 let raw = err.to_string();
2443 let mut hint = String::new();
2444 if let Some((kind, token)) = extract_unknown_token(&raw) {
2445 match suggest_closest(token, &extract_backtick_options(&raw)) {
2446 Some(best) => {
2447 hint = format!("\n\n Unknown {kind} `{token}` — did you mean `{best}`?");
2448 }
2449 None => hint = format!("\n\n Unknown {kind} `{token}`."),
2450 }
2451 }
2452 format!(
2453 "Failed to parse {path_str}: {raw}{hint}\n\n \
2454 Edit the config and re-run, or run `microclaw setup`.\n \
2455 Reference: https://github.com/microclaw/microclaw/blob/main/microclaw.config.example.yaml"
2456 )
2457}
2458
2459pub(crate) fn known_top_level_config_keys() -> Option<std::collections::BTreeSet<String>> {
2465 let base: Config = serde_yaml::from_str("{}").ok()?;
2466 let serde_yaml::Value::Mapping(serialized) = serde_yaml::to_value(&base).ok()? else {
2467 return None;
2468 };
2469 let mut known: std::collections::BTreeSet<String> = serialized
2470 .keys()
2471 .filter_map(|k| k.as_str().map(str::to_string))
2472 .collect();
2473 for k in ["timezone", "override_timezone", "web_auth_token"] {
2476 known.insert(k.to_string());
2477 }
2478 if known.len() < 5 {
2481 return None;
2482 }
2483 Some(known)
2484}
2485
2486pub(crate) fn unknown_top_level_key_warnings(map: &serde_yaml::Mapping) -> Vec<String> {
2491 let Some(known) = known_top_level_config_keys() else {
2492 return Vec::new();
2493 };
2494 let candidates: Vec<String> = known.iter().cloned().collect();
2495 let mut warnings = Vec::new();
2496 for key in map.keys() {
2497 let Some(name) = key.as_str() else { continue };
2498 if known.contains(name) {
2499 continue;
2500 }
2501 match suggest_closest(name, &candidates) {
2502 Some(best) => warnings.push(format!(
2503 "Unknown config key `{name}` (ignored) — did you mean `{best}`?"
2504 )),
2505 None => warnings.push(format!("Unknown config key `{name}` (ignored).")),
2506 }
2507 }
2508 warnings
2509}
2510
2511pub(crate) fn extract_unknown_token(raw: &str) -> Option<(&'static str, &str)> {
2513 for (needle, kind) in [
2514 ("unknown variant `", "variant"),
2515 ("unknown field `", "field"),
2516 ] {
2517 if let Some(start) = raw.find(needle) {
2518 let rest = &raw[start + needle.len()..];
2519 if let Some(end) = rest.find('`') {
2520 return Some((kind, &rest[..end]));
2521 }
2522 }
2523 }
2524 None
2525}
2526
2527pub(crate) fn extract_backtick_options(raw: &str) -> Vec<String> {
2529 let Some(exp) = raw.find("expected") else {
2530 return Vec::new();
2531 };
2532 let mut out = Vec::new();
2533 let mut rest = &raw[exp..];
2534 while let Some(open) = rest.find('`') {
2535 rest = &rest[open + 1..];
2536 if let Some(close) = rest.find('`') {
2537 out.push(rest[..close].to_string());
2538 rest = &rest[close + 1..];
2539 } else {
2540 break;
2541 }
2542 }
2543 out
2544}
2545
2546pub(crate) fn suggest_closest(token: &str, options: &[String]) -> Option<String> {
2549 let threshold = (token.chars().count() / 3).max(2);
2550 options
2551 .iter()
2552 .map(|o| (levenshtein(token, o), o))
2553 .filter(|(d, _)| *d <= threshold)
2554 .min_by_key(|(d, _)| *d)
2555 .map(|(_, o)| o.clone())
2556}
2557
2558pub(crate) fn levenshtein(a: &str, b: &str) -> usize {
2560 let a: Vec<char> = a.chars().collect();
2561 let b: Vec<char> = b.chars().collect();
2562 let mut prev: Vec<usize> = (0..=b.len()).collect();
2563 let mut cur = vec![0usize; b.len() + 1];
2564 for (i, ca) in a.iter().enumerate() {
2565 cur[0] = i + 1;
2566 for (j, cb) in b.iter().enumerate() {
2567 let cost = if ca == cb { 0 } else { 1 };
2568 cur[j + 1] = (prev[j + 1] + 1).min(cur[j] + 1).min(prev[j] + cost);
2569 }
2570 std::mem::swap(&mut prev, &mut cur);
2571 }
2572 prev[b.len()]
2573}
2574
2575#[cfg(test)]
2576mod tests {
2577 use super::*;
2578 #[allow(unused_imports)]
2579 use crate::config::test_prelude::*;
2580
2581 #[test]
2582 fn config_check_reports_syntax_errors_with_location() {
2583 let report = check_config_content("t.yaml", "telegram_bot_token: [unclosed");
2584 assert!(!report.ok());
2585 assert!(report.errors[0].contains("YAML syntax error"));
2586 assert!(report.summary.is_none());
2587 }
2588
2589 #[test]
2590 fn config_check_warns_on_unknown_key_with_suggestion() {
2591 let report = check_config_content(
2592 "t.yaml",
2593 "telegram_bot_token: tok\nbot_username: bot\napi_key: key\nmax_tool_iterationz: 5\n",
2594 );
2595 assert!(report.ok(), "unknown keys warn but do not fail the check");
2596 assert!(
2597 report
2598 .warnings
2599 .iter()
2600 .any(|w| w.contains("max_tool_iterationz") && w.contains("max_tool_iterations")),
2601 "expected did-you-mean warning, got: {:?}",
2602 report.warnings
2603 );
2604 let (enabled, _, provider, _) = report.summary.as_ref().unwrap();
2605 assert!(enabled.contains(&"telegram"));
2606 assert_eq!(provider, "anthropic");
2607 }
2608
2609 #[test]
2610 fn config_check_rejects_bad_enum_value_with_suggestion() {
2611 let report = check_config_content("t.yaml", "api_key: key\ntool_policy:\n mode: blok\n");
2612 assert!(!report.ok());
2613 assert!(
2614 report.errors[0].contains("blok") && report.errors[0].contains("block"),
2615 "expected did-you-mean on enum typo, got: {:?}",
2616 report.errors
2617 );
2618 }
2619
2620 #[test]
2621 fn config_check_warns_when_tool_policy_has_no_rules() {
2622 let report = check_config_content("t.yaml", "api_key: key\ntool_policy:\n mode: block\n");
2623 assert!(report.ok(), "errors: {:?}", report.errors);
2624 assert!(
2625 report
2626 .warnings
2627 .iter()
2628 .any(|w| w.contains("tool_policy.mode is `block`")
2629 && w.contains("every tool is still permitted")),
2630 "expected empty-policy warning, got: {:?}",
2631 report.warnings
2632 );
2633
2634 let report = check_config_content(
2636 "t.yaml",
2637 "api_key: key\ntool_policy:\n mode: block\n allow_tools: [read_file]\n",
2638 );
2639 assert!(report.ok(), "errors: {:?}", report.errors);
2640 assert!(
2641 !report.warnings.iter().any(|w| w.contains("tool_policy")),
2642 "unexpected warning: {:?}",
2643 report.warnings
2644 );
2645 let report = check_config_content("t.yaml", "api_key: key\n");
2646 assert!(!report.warnings.iter().any(|w| w.contains("tool_policy")));
2647 }
2648
2649 #[test]
2650 fn config_check_flags_no_enabled_channel() {
2651 let report = check_config_content("t.yaml", "api_key: key\n");
2653 assert!(report.ok(), "errors: {:?}", report.errors);
2654 let (enabled, ..) = report.summary.as_ref().unwrap();
2655 assert!(enabled.contains(&"web"));
2656
2657 let report = check_config_content(
2660 "t.yaml",
2661 "api_key: key\nchannels:\n web:\n enabled: false\n",
2662 );
2663 assert!(
2664 !report.ok(),
2665 "disabling all channels should be an error, got warnings: {:?}",
2666 report.warnings
2667 );
2668 }
2669
2670 #[test]
2671 fn config_check_rejects_non_mapping_root() {
2672 let report = check_config_content("t.yaml", "- just\n- a\n- list\n");
2673 assert!(!report.ok());
2674 assert!(report.errors[0].contains("mapping"));
2675 }
2676
2677 #[test]
2678 fn friendly_error_suggests_closest_field() {
2679 #[derive(Debug, serde::Deserialize)]
2681 #[serde(deny_unknown_fields)]
2682 struct Mini {
2683 #[allow(dead_code)]
2684 discord: bool,
2685 }
2686 let err = serde_yaml::from_str::<Mini>("discrod: true\n").unwrap_err();
2687 let msg = friendly_yaml_error("cfg.yaml", &err);
2688 assert!(msg.contains("did you mean `discord`?"), "got: {msg}");
2689 assert!(msg.contains("microclaw setup"));
2690 }
2691
2692 #[test]
2693 fn extract_and_suggest_helpers() {
2694 let raw = "unknown variant `discrod`, expected one of `telegram`, `discord`, `slack`";
2695 assert_eq!(extract_unknown_token(raw), Some(("variant", "discrod")));
2696 let opts = extract_backtick_options(raw);
2697 assert_eq!(opts, vec!["telegram", "discord", "slack"]);
2698 assert_eq!(
2699 suggest_closest("discrod", &opts).as_deref(),
2700 Some("discord")
2701 );
2702 assert_eq!(suggest_closest("zzzzzz", &opts), None);
2704 }
2705
2706 #[test]
2707 fn levenshtein_basics() {
2708 assert_eq!(levenshtein("kitten", "sitting"), 3);
2709 assert_eq!(levenshtein("discord", "discord"), 0);
2710 assert_eq!(levenshtein("", "abc"), 3);
2711 }
2712
2713 #[test]
2714 fn channel_status_splits_enabled_and_disabled() {
2715 let cfg: Config = serde_yaml::from_str(
2716 "api_key: k\nweb_enabled: false\nchannels:\n telegram:\n enabled: true\n discord:\n enabled: false\n",
2717 )
2718 .unwrap();
2719 let (enabled, disabled) = cfg.channel_status();
2720 assert_eq!(enabled, vec!["telegram"]);
2721 assert_eq!(disabled, vec!["discord"]);
2722 }
2723
2724 #[test]
2725 fn no_enabled_channel_error_names_disabled_channel() {
2726 let mut cfg: Config = serde_yaml::from_str(
2727 "api_key: k\nweb_enabled: false\nchannels:\n telegram:\n enabled: false\n",
2728 )
2729 .unwrap();
2730 let err = cfg.post_deserialize().unwrap_err().to_string();
2731 assert!(err.contains("configured but not enabled"), "got: {err}");
2732 assert!(err.contains("telegram"), "got: {err}");
2733 }
2734
2735 #[test]
2736 fn aux_models_parse_from_yaml() {
2737 let yaml = "telegram_bot_token: tok\nbot_username: bot\napi_key: key\naux_models:\n compaction: claude-haiku-4-5\n reflector: claude-haiku-4-5\n";
2738 let config: Config = serde_yaml::from_str(yaml).unwrap();
2739 assert_eq!(
2740 config.aux_models.compaction.as_deref(),
2741 Some("claude-haiku-4-5")
2742 );
2743 assert_eq!(
2744 config.aux_models.reflector_model(),
2745 Some("claude-haiku-4-5")
2746 );
2747 }
2748
2749 #[test]
2750 fn aux_models_absent_yaml_defaults_to_none() {
2751 let yaml = "telegram_bot_token: tok\nbot_username: bot\napi_key: key\n";
2752 let config: Config = serde_yaml::from_str(yaml).unwrap();
2753 assert!(config.aux_models.compaction.is_none());
2754 }
2755
2756 #[test]
2757 fn aux_models_title_vision_parse_from_yaml() {
2758 let yaml = "telegram_bot_token: tok\nbot_username: bot\napi_key: key\naux_models:\n title: claude-haiku-4-5\n vision: claude-haiku-4-5\n";
2759 let config: Config = serde_yaml::from_str(yaml).unwrap();
2760 assert_eq!(config.aux_models.title_model(), Some("claude-haiku-4-5"));
2761 assert_eq!(config.aux_models.vision_model(), Some("claude-haiku-4-5"));
2762 }
2763
2764 #[test]
2765 fn test_clawhub_config_defaults() {
2766 let yaml = "telegram_bot_token: tok\nbot_username: bot\napi_key: key\n";
2767 let config: Config = serde_yaml::from_str(yaml).unwrap();
2768 assert_eq!(config.clawhub.registry, "https://clawhub.ai");
2769 assert!(config.clawhub.agent_tools_enabled);
2770 }
2771
2772 #[test]
2773 fn test_voice_config_defaults() {
2774 let yaml = "telegram_bot_token: tok\nbot_username: bot\napi_key: key\n";
2775 let config: Config = serde_yaml::from_str(yaml).unwrap();
2776 assert_eq!(config.voice_provider, "openai");
2777 assert!(config.voice_transcription_command.is_none());
2778 }
2779
2780 #[test]
2781 fn test_voice_config_local_provider() {
2782 let yaml = r#"
2783telegram_bot_token: tok
2784bot_username: bot
2785api_key: key
2786voice_provider: "local"
2787voice_transcription_command: "whisper-mlx --file {file}"
2788"#;
2789 let config: Config = serde_yaml::from_str(yaml).unwrap();
2790 assert_eq!(config.voice_provider, "local");
2791 assert_eq!(
2792 config.voice_transcription_command,
2793 Some("whisper-mlx --file {file}".into())
2794 );
2795 }
2796
2797 #[test]
2798 fn test_config_yaml_roundtrip() {
2799 let config = test_config();
2800 let yaml = serde_yaml::to_string(&config).unwrap();
2801 let parsed: Config = serde_yaml::from_str(&yaml).unwrap();
2802 assert_eq!(parsed.telegram_bot_token, "tok");
2803 assert_eq!(parsed.max_tokens, 8192);
2804 assert_eq!(parsed.llm_provider, "anthropic");
2805 }
2806
2807 #[test]
2808 fn test_default_data_dir_uses_microclaw_home() {
2809 let yaml = "telegram_bot_token: tok\nbot_username: bot\napi_key: key\n";
2810 let config: Config = serde_yaml::from_str(yaml).unwrap();
2811 assert!(config.data_dir.ends_with(".microclaw"));
2812 }
2813
2814 #[test]
2815 fn test_config_sandbox_defaults_to_off() {
2816 let yaml = "telegram_bot_token: tok\nbot_username: bot\napi_key: key\n";
2817 let config: Config = serde_yaml::from_str(yaml).unwrap();
2818 assert!(matches!(config.sandbox.mode, SandboxMode::Off));
2819 assert!(matches!(config.sandbox.backend, SandboxBackend::Auto));
2820 assert!(config.sandbox.require_runtime);
2821 assert_eq!(config.sandbox.image, "ubuntu:25.10");
2822 }
2823
2824 #[test]
2825 fn test_post_deserialize_empty_working_dir_uses_default() {
2826 let yaml = "telegram_bot_token: tok\nbot_username: bot\napi_key: key\nworking_dir: ' '\n";
2827 let mut config: Config = serde_yaml::from_str(yaml).unwrap();
2828 config.post_deserialize().unwrap();
2829 assert!(std::path::PathBuf::from(&config.working_dir)
2830 .ends_with(std::path::Path::new(".microclaw").join("working_dir")));
2831 }
2832
2833 #[test]
2834 fn test_post_deserialize_zero_memory_budget_uses_default() {
2835 let yaml =
2836 "telegram_bot_token: tok\nbot_username: bot\napi_key: key\nmemory_token_budget: 0\n";
2837 let mut config: Config = serde_yaml::from_str(yaml).unwrap();
2838 config.post_deserialize().unwrap();
2839 assert_eq!(config.memory_token_budget, 1500);
2840 }
2841
2842 #[test]
2843 fn test_config_working_dir_isolation_defaults_to_chat() {
2844 let yaml = "telegram_bot_token: tok\nbot_username: bot\napi_key: key\n";
2845 let config: Config = serde_yaml::from_str(yaml).unwrap();
2846 assert!(matches!(
2847 config.working_dir_isolation,
2848 WorkingDirIsolation::Chat
2849 ));
2850 }
2851
2852 #[test]
2853 fn test_config_working_dir_isolation_accepts_chat() {
2854 let yaml = "telegram_bot_token: tok\nbot_username: bot\napi_key: key\nworking_dir_isolation: chat\n";
2855 let config: Config = serde_yaml::from_str(yaml).unwrap();
2856 assert!(matches!(
2857 config.working_dir_isolation,
2858 WorkingDirIsolation::Chat
2859 ));
2860 }
2861
2862 #[test]
2863 fn test_config_working_dir_isolation_accepts_true() {
2864 let yaml = "telegram_bot_token: tok\nbot_username: bot\napi_key: key\nworking_dir_isolation: true\n";
2865 let config: Config = serde_yaml::from_str(yaml).unwrap();
2866 assert!(matches!(
2867 config.working_dir_isolation,
2868 WorkingDirIsolation::Chat
2869 ));
2870 }
2871
2872 #[test]
2873 fn test_config_working_dir_isolation_accepts_false() {
2874 let yaml = "telegram_bot_token: tok\nbot_username: bot\napi_key: key\nworking_dir_isolation: false\n";
2875 let config: Config = serde_yaml::from_str(yaml).unwrap();
2876 assert!(matches!(
2877 config.working_dir_isolation,
2878 WorkingDirIsolation::Shared
2879 ));
2880 }
2881
2882 #[test]
2883 fn test_high_risk_tool_user_confirmation_required_defaults_true() {
2884 let yaml = "telegram_bot_token: tok\nbot_username: bot\napi_key: key\n";
2885 let config: Config = serde_yaml::from_str(yaml).unwrap();
2886 assert!(config.high_risk_tool_user_confirmation_required);
2887 }
2888
2889 #[test]
2890 fn test_high_risk_tool_user_confirmation_required_accepts_false() {
2891 let yaml = "telegram_bot_token: tok\nbot_username: bot\napi_key: key\nhigh_risk_tool_user_confirmation_required: false\n";
2892 let config: Config = serde_yaml::from_str(yaml).unwrap();
2893 assert!(!config.high_risk_tool_user_confirmation_required);
2894 }
2895
2896 #[test]
2897 fn test_config_post_deserialize() {
2898 let yaml =
2899 "telegram_bot_token: tok\nbot_username: bot\napi_key: key\nllm_provider: ANTHROPIC\n";
2900 let mut config: Config = serde_yaml::from_str(yaml).unwrap();
2901 config.post_deserialize().unwrap();
2902 assert_eq!(config.llm_provider, "anthropic");
2903 assert_eq!(config.model, "claude-sonnet-4-5-20250929");
2904 }
2905
2906 #[test]
2907 fn test_post_deserialize_invalid_timezone() {
2908 let yaml = "telegram_bot_token: tok\nbot_username: bot\napi_key: key\noverride_timezone: Mars/Olympus\n";
2909 let mut config: Config = serde_yaml::from_str(yaml).unwrap();
2910 let err = config.post_deserialize().unwrap_err();
2911 let msg = err.to_string();
2912 assert!(msg.contains("Invalid timezone"));
2913 }
2914
2915 #[test]
2916 fn test_post_deserialize_auto_timezone_resolves_to_valid_tz() {
2917 let yaml =
2918 "telegram_bot_token: tok\nbot_username: bot\napi_key: key\noverride_timezone: auto\n";
2919 let mut config: Config = serde_yaml::from_str(yaml).unwrap();
2920 config.post_deserialize().unwrap();
2921 assert!(config.timezone.parse::<chrono_tz::Tz>().is_ok());
2922 }
2923
2924 #[test]
2925 fn test_post_deserialize_missing_api_key() {
2926 let yaml = "telegram_bot_token: tok\nbot_username: bot\n";
2927 let mut config: Config = serde_yaml::from_str(yaml).unwrap();
2928 let err = config.post_deserialize().unwrap_err();
2929 let msg = err.to_string();
2930 assert!(msg.contains("api_key is required"));
2931 }
2932
2933 #[test]
2934 fn test_post_deserialize_openai_codex_allows_empty_api_key() {
2935 let _guard = env_lock();
2936 let prev_codex_home = std::env::var("CODEX_HOME").ok();
2937 let prev_access = std::env::var("OPENAI_CODEX_ACCESS_TOKEN").ok();
2938 std::env::remove_var("OPENAI_CODEX_ACCESS_TOKEN");
2939
2940 let auth_dir = std::env::temp_dir().join(format!(
2941 "microclaw-codex-auth-{}",
2942 std::time::SystemTime::now()
2943 .duration_since(std::time::UNIX_EPOCH)
2944 .unwrap_or_default()
2945 .as_nanos()
2946 ));
2947 std::fs::create_dir_all(&auth_dir).unwrap();
2948 std::fs::write(
2949 auth_dir.join("auth.json"),
2950 r#"{"tokens":{"access_token":"tok"}}"#,
2951 )
2952 .unwrap();
2953 std::env::set_var("CODEX_HOME", &auth_dir);
2954
2955 let yaml =
2956 "telegram_bot_token: tok\nbot_username: bot\nllm_provider: openai-codex\nmodel: gpt-5.3-codex\n";
2957 let mut config: Config = serde_yaml::from_str(yaml).unwrap();
2958 config.post_deserialize().unwrap();
2959
2960 if let Some(prev) = prev_codex_home {
2961 std::env::set_var("CODEX_HOME", prev);
2962 } else {
2963 std::env::remove_var("CODEX_HOME");
2964 }
2965 if let Some(prev) = prev_access {
2966 std::env::set_var("OPENAI_CODEX_ACCESS_TOKEN", prev);
2967 } else {
2968 std::env::remove_var("OPENAI_CODEX_ACCESS_TOKEN");
2969 }
2970 let _ = std::fs::remove_file(auth_dir.join("auth.json"));
2971 let _ = std::fs::remove_dir(auth_dir);
2972 assert_eq!(config.llm_provider, "openai-codex");
2973 }
2974
2975 #[test]
2976 fn test_post_deserialize_missing_bot_tokens() {
2977 let yaml = "bot_username: bot\napi_key: key\nweb_enabled: false\n";
2978 let mut config: Config = serde_yaml::from_str(yaml).unwrap();
2979 let err = config.post_deserialize().unwrap_err();
2980 let msg = err.to_string();
2981 assert!(msg.contains("channel must be enabled"));
2982 }
2983
2984 #[test]
2985 fn test_post_deserialize_discord_only() {
2986 let yaml = "bot_username: bot\napi_key: key\ndiscord_bot_token: discord_tok\n";
2987 let mut config: Config = serde_yaml::from_str(yaml).unwrap();
2988 config.post_deserialize().unwrap();
2990 }
2991
2992 #[test]
2993 fn test_post_deserialize_irc_only() {
2994 let yaml = r##"
2995api_key: key
2996channels:
2997 irc:
2998 enabled: true
2999 server: "irc.example.com"
3000 nick: "microclaw"
3001 channels: "#microclaw"
3002"##;
3003 let mut config: Config = serde_yaml::from_str(yaml).unwrap();
3004 config.post_deserialize().unwrap();
3005 assert!(config.channel_enabled("irc"));
3006 }
3007
3008 #[test]
3009 fn test_post_deserialize_channel_enabled_flag_overrides_legacy_inference() {
3010 let yaml = "telegram_bot_token: tok\nbot_username: bot\ndiscord_bot_token: discord_tok\napi_key: key\nchannels:\n telegram:\n enabled: false\n discord:\n enabled: true\n web:\n enabled: false\n";
3011 let mut config: Config = serde_yaml::from_str(yaml).unwrap();
3012 config.post_deserialize().unwrap();
3013
3014 assert!(!config.channel_enabled("telegram"));
3015 assert!(config.channel_enabled("discord"));
3016 assert!(!config.channel_enabled("web"));
3017 }
3018
3019 #[test]
3020 fn test_post_deserialize_channel_enabled_flag_controls_web() {
3021 let yaml =
3022 "api_key: key\ndiscord_bot_token: discord_tok\nchannels:\n web:\n enabled: false\n";
3023 let mut config: Config = serde_yaml::from_str(yaml).unwrap();
3024 config.post_deserialize().unwrap();
3025
3026 assert!(!config.channel_enabled("web"));
3027 }
3028
3029 #[test]
3030 fn test_post_deserialize_openai_default_model() {
3031 let yaml =
3032 "telegram_bot_token: tok\nbot_username: bot\napi_key: key\nllm_provider: openai\n";
3033 let mut config: Config = serde_yaml::from_str(yaml).unwrap();
3034 config.post_deserialize().unwrap();
3035 assert_eq!(config.model, "gpt-5.2");
3036 }
3037
3038 #[test]
3039 fn test_post_deserialize_wildcard_model_falls_back_to_provider_default() {
3040 let yaml = "telegram_bot_token: tok\nbot_username: bot\napi_key: key\nllm_provider: openai\nmodel: '*'\n";
3041 let mut config: Config = serde_yaml::from_str(yaml).unwrap();
3042 config.post_deserialize().unwrap();
3043 assert_eq!(config.model, "gpt-5.2");
3044 }
3045
3046 #[test]
3047 fn test_post_deserialize_openai_codex_default_model() {
3048 let _guard = env_lock();
3049 let prev_codex_home = std::env::var("CODEX_HOME").ok();
3050 let prev_access = std::env::var("OPENAI_CODEX_ACCESS_TOKEN").ok();
3051 std::env::remove_var("OPENAI_CODEX_ACCESS_TOKEN");
3052
3053 let auth_dir = std::env::temp_dir().join(format!(
3054 "microclaw-codex-auth-{}",
3055 std::time::SystemTime::now()
3056 .duration_since(std::time::UNIX_EPOCH)
3057 .unwrap_or_default()
3058 .as_nanos()
3059 ));
3060 std::fs::create_dir_all(&auth_dir).unwrap();
3061 std::fs::write(
3062 auth_dir.join("auth.json"),
3063 r#"{"tokens":{"access_token":"tok"}}"#,
3064 )
3065 .unwrap();
3066 std::env::set_var("CODEX_HOME", &auth_dir);
3067
3068 let yaml = "telegram_bot_token: tok\nbot_username: bot\nllm_provider: openai-codex\n";
3069 let mut config: Config = serde_yaml::from_str(yaml).unwrap();
3070 config.post_deserialize().unwrap();
3071
3072 if let Some(prev) = prev_codex_home {
3073 std::env::set_var("CODEX_HOME", prev);
3074 } else {
3075 std::env::remove_var("CODEX_HOME");
3076 }
3077 if let Some(prev) = prev_access {
3078 std::env::set_var("OPENAI_CODEX_ACCESS_TOKEN", prev);
3079 } else {
3080 std::env::remove_var("OPENAI_CODEX_ACCESS_TOKEN");
3081 }
3082 let _ = std::fs::remove_file(auth_dir.join("auth.json"));
3083 let _ = std::fs::remove_dir(auth_dir);
3084 assert_eq!(config.model, "gpt-5.3-codex");
3085 }
3086
3087 #[test]
3088 fn test_post_deserialize_openai_codex_missing_oauth_token() {
3089 let _guard = env_lock();
3090 let prev_codex_home = std::env::var("CODEX_HOME").ok();
3091 let prev_access = std::env::var("OPENAI_CODEX_ACCESS_TOKEN").ok();
3092 std::env::remove_var("OPENAI_CODEX_ACCESS_TOKEN");
3093
3094 let auth_dir = std::env::temp_dir().join(format!(
3095 "microclaw-codex-auth-missing-{}",
3096 std::time::SystemTime::now()
3097 .duration_since(std::time::UNIX_EPOCH)
3098 .unwrap_or_default()
3099 .as_nanos()
3100 ));
3101 std::fs::create_dir_all(&auth_dir).unwrap();
3102 std::env::set_var("CODEX_HOME", &auth_dir);
3103
3104 let yaml = "telegram_bot_token: tok\nbot_username: bot\nllm_provider: openai-codex\n";
3105 let mut config: Config = serde_yaml::from_str(yaml).unwrap();
3106 let err = config.post_deserialize().unwrap_err();
3107 let msg = err.to_string();
3108
3109 if let Some(prev) = prev_codex_home {
3110 std::env::set_var("CODEX_HOME", prev);
3111 } else {
3112 std::env::remove_var("CODEX_HOME");
3113 }
3114 if let Some(prev) = prev_access {
3115 std::env::set_var("OPENAI_CODEX_ACCESS_TOKEN", prev);
3116 } else {
3117 std::env::remove_var("OPENAI_CODEX_ACCESS_TOKEN");
3118 }
3119 let _ = std::fs::remove_dir(auth_dir);
3120
3121 assert!(msg.contains("openai-codex requires ~/.codex/auth.json"));
3122 }
3123
3124 #[test]
3125 fn test_post_deserialize_openai_codex_rejects_plain_api_key_without_oauth() {
3126 let _guard = env_lock();
3127 let prev_codex_home = std::env::var("CODEX_HOME").ok();
3128 let prev_access = std::env::var("OPENAI_CODEX_ACCESS_TOKEN").ok();
3129 std::env::remove_var("OPENAI_CODEX_ACCESS_TOKEN");
3130
3131 let auth_dir = std::env::temp_dir().join(format!(
3132 "microclaw-codex-auth-plain-key-{}",
3133 std::time::SystemTime::now()
3134 .duration_since(std::time::UNIX_EPOCH)
3135 .unwrap_or_default()
3136 .as_nanos()
3137 ));
3138 std::fs::create_dir_all(&auth_dir).unwrap();
3139 std::env::set_var("CODEX_HOME", &auth_dir);
3140
3141 let yaml = "telegram_bot_token: tok\nbot_username: bot\nllm_provider: openai-codex\napi_key: sk-user-stale\n";
3142 let mut config: Config = serde_yaml::from_str(yaml).unwrap();
3143 let err = config.post_deserialize().unwrap_err();
3144 let msg = err.to_string();
3145
3146 if let Some(prev) = prev_codex_home {
3147 std::env::set_var("CODEX_HOME", prev);
3148 } else {
3149 std::env::remove_var("CODEX_HOME");
3150 }
3151 if let Some(prev) = prev_access {
3152 std::env::set_var("OPENAI_CODEX_ACCESS_TOKEN", prev);
3153 } else {
3154 std::env::remove_var("OPENAI_CODEX_ACCESS_TOKEN");
3155 }
3156 let _ = std::fs::remove_dir(auth_dir);
3157
3158 assert!(msg.contains("ignores microclaw.config.yaml api_key"));
3159 }
3160
3161 #[test]
3162 fn test_post_deserialize_openai_codex_allows_env_access_token() {
3163 let _guard = env_lock();
3164 let prev_codex_home = std::env::var("CODEX_HOME").ok();
3165 let prev_access = std::env::var("OPENAI_CODEX_ACCESS_TOKEN").ok();
3166 std::env::remove_var("CODEX_HOME");
3167 std::env::set_var("OPENAI_CODEX_ACCESS_TOKEN", "env-token");
3168
3169 let yaml = "telegram_bot_token: tok\nbot_username: bot\nllm_provider: openai-codex\n";
3170 let mut config: Config = serde_yaml::from_str(yaml).unwrap();
3171 config.post_deserialize().unwrap();
3172
3173 if let Some(prev) = prev_codex_home {
3174 std::env::set_var("CODEX_HOME", prev);
3175 } else {
3176 std::env::remove_var("CODEX_HOME");
3177 }
3178 if let Some(prev) = prev_access {
3179 std::env::set_var("OPENAI_CODEX_ACCESS_TOKEN", prev);
3180 } else {
3181 std::env::remove_var("OPENAI_CODEX_ACCESS_TOKEN");
3182 }
3183
3184 assert_eq!(config.llm_provider, "openai-codex");
3185 }
3186
3187 #[test]
3188 fn test_post_deserialize_qwen_code_allows_oauth_without_api_key() {
3189 let _guard = env_lock();
3190 let prev_qwen_home = std::env::var("QWEN_HOME").ok();
3191 let prev_qwen_access = std::env::var("QWEN_PORTAL_ACCESS_TOKEN").ok();
3192 std::env::remove_var("QWEN_PORTAL_ACCESS_TOKEN");
3193
3194 let qwen_dir = std::env::temp_dir().join(format!(
3195 "microclaw-qwen-auth-{}",
3196 std::time::SystemTime::now()
3197 .duration_since(std::time::UNIX_EPOCH)
3198 .unwrap_or_default()
3199 .as_nanos()
3200 ));
3201 std::fs::create_dir_all(&qwen_dir).unwrap();
3202 std::fs::write(
3203 qwen_dir.join("oauth_creds.json"),
3204 r#"{"access_token":"qwen-oauth-token"}"#,
3205 )
3206 .unwrap();
3207 std::env::set_var("QWEN_HOME", &qwen_dir);
3208
3209 let yaml = "telegram_bot_token: tok\nbot_username: bot\nllm_provider: qwen-portal\n";
3210 let mut config: Config = serde_yaml::from_str(yaml).unwrap();
3211 config.post_deserialize().unwrap();
3212
3213 if let Some(prev) = prev_qwen_home {
3214 std::env::set_var("QWEN_HOME", prev);
3215 } else {
3216 std::env::remove_var("QWEN_HOME");
3217 }
3218 if let Some(prev) = prev_qwen_access {
3219 std::env::set_var("QWEN_PORTAL_ACCESS_TOKEN", prev);
3220 } else {
3221 std::env::remove_var("QWEN_PORTAL_ACCESS_TOKEN");
3222 }
3223 let _ = std::fs::remove_file(qwen_dir.join("oauth_creds.json"));
3224 let _ = std::fs::remove_dir(qwen_dir);
3225
3226 assert_eq!(config.llm_provider, "qwen-portal");
3227 }
3228
3229 #[test]
3230 fn test_post_deserialize_qwen_code_missing_oauth_and_api_key() {
3231 let _guard = env_lock();
3232 let prev_qwen_home = std::env::var("QWEN_HOME").ok();
3233 let prev_qwen_access = std::env::var("QWEN_PORTAL_ACCESS_TOKEN").ok();
3234 std::env::remove_var("QWEN_PORTAL_ACCESS_TOKEN");
3235
3236 let qwen_dir = std::env::temp_dir().join(format!(
3237 "microclaw-qwen-auth-missing-{}",
3238 std::time::SystemTime::now()
3239 .duration_since(std::time::UNIX_EPOCH)
3240 .unwrap_or_default()
3241 .as_nanos()
3242 ));
3243 std::fs::create_dir_all(&qwen_dir).unwrap();
3244 std::env::set_var("QWEN_HOME", &qwen_dir);
3245
3246 let yaml = "telegram_bot_token: tok\nbot_username: bot\nllm_provider: qwen-portal\n";
3247 let mut config: Config = serde_yaml::from_str(yaml).unwrap();
3248 let err = config.post_deserialize().unwrap_err();
3249
3250 if let Some(prev) = prev_qwen_home {
3251 std::env::set_var("QWEN_HOME", prev);
3252 } else {
3253 std::env::remove_var("QWEN_HOME");
3254 }
3255 if let Some(prev) = prev_qwen_access {
3256 std::env::set_var("QWEN_PORTAL_ACCESS_TOKEN", prev);
3257 } else {
3258 std::env::remove_var("QWEN_PORTAL_ACCESS_TOKEN");
3259 }
3260 let _ = std::fs::remove_dir(qwen_dir);
3261
3262 assert!(err
3263 .to_string()
3264 .contains("qwen-portal requires api_key, or ~/.qwen/oauth_creds.json"));
3265 }
3266
3267 #[test]
3268 fn test_post_deserialize_ollama_default_model_and_empty_key() {
3269 let yaml = "telegram_bot_token: tok\nbot_username: bot\nllm_provider: ollama\n";
3270 let mut config: Config = serde_yaml::from_str(yaml).unwrap();
3271 config.post_deserialize().unwrap();
3272 assert_eq!(config.model, "llama3.2");
3273 }
3274
3275 #[test]
3276 fn test_post_deserialize_empty_base_url_becomes_none() {
3277 let yaml = "telegram_bot_token: tok\nbot_username: bot\napi_key: key\nllm_base_url: ' '\n";
3278 let mut config: Config = serde_yaml::from_str(yaml).unwrap();
3279 config.post_deserialize().unwrap();
3280 assert!(config.llm_base_url.is_none());
3281 }
3282
3283 #[test]
3284 fn test_post_deserialize_empty_llm_user_agent_uses_default() {
3285 let yaml =
3286 "telegram_bot_token: tok\nbot_username: bot\napi_key: key\nllm_user_agent: ' '\n";
3287 let mut config: Config = serde_yaml::from_str(yaml).unwrap();
3288 config.post_deserialize().unwrap();
3289 assert_eq!(
3290 config.llm_user_agent,
3291 crate::http_client::default_llm_user_agent()
3292 );
3293 }
3294
3295 #[test]
3296 fn test_post_deserialize_provider_case_insensitive() {
3297 let yaml = "telegram_bot_token: tok\nbot_username: bot\napi_key: key\nllm_provider: ' ANTHROPIC '\n";
3298 let mut config: Config = serde_yaml::from_str(yaml).unwrap();
3299 config.post_deserialize().unwrap();
3300 assert_eq!(config.llm_provider, "anthropic");
3301 assert_eq!(config.model, "claude-sonnet-4-5-20250929");
3302 }
3303
3304 #[test]
3305 fn test_post_deserialize_normalizes_openai_compat_body_overrides() {
3306 let yaml = r#"
3307telegram_bot_token: tok
3308bot_username: bot
3309api_key: key
3310openai_compat_body_overrides:
3311 " temperature ": 0.2
3312 " ": 1
3313openai_compat_body_overrides_by_provider:
3314 " OPENAI ":
3315 " top_p ": 0.95
3316 "": 1
3317 " ":
3318 seed: 7
3319openai_compat_body_overrides_by_model:
3320 " gpt-5.2 ":
3321 " frequency_penalty ": 0.1
3322 "": 1
3323 " ":
3324 seed: 7
3325"#;
3326 let mut config: Config = serde_yaml::from_str(yaml).unwrap();
3327 config.post_deserialize().unwrap();
3328
3329 assert_eq!(
3330 config.openai_compat_body_overrides.get("temperature"),
3331 Some(&serde_json::json!(0.2))
3332 );
3333 assert!(!config.openai_compat_body_overrides.contains_key(" "));
3334
3335 let provider_params = config
3336 .openai_compat_body_overrides_by_provider
3337 .get("openai")
3338 .unwrap();
3339 assert_eq!(provider_params.get("top_p"), Some(&serde_json::json!(0.95)));
3340 assert!(!provider_params.contains_key(""));
3341 assert!(!config
3342 .openai_compat_body_overrides_by_provider
3343 .contains_key(" OPENAI "));
3344
3345 let model_params = config
3346 .openai_compat_body_overrides_by_model
3347 .get("gpt-5.2")
3348 .unwrap();
3349 assert_eq!(
3350 model_params.get("frequency_penalty"),
3351 Some(&serde_json::json!(0.1))
3352 );
3353 assert!(!model_params.contains_key(""));
3354 }
3355
3356 #[test]
3357 fn test_post_deserialize_normalizes_subagent_acp_config() {
3358 let yaml = r#"
3359telegram_bot_token: tok
3360bot_username: bot
3361api_key: key
3362subagents:
3363 acp:
3364 enabled: true
3365 command: " codex "
3366 args: [" --model ", " ", "gpt-5.4"]
3367 env:
3368 " OPENAI_API_KEY ": abc
3369 " ": ignored
3370 default_target: " worker "
3371 targets:
3372 " worker ":
3373 enabled: true
3374 command: " codex-worker "
3375 args: [" --fast "]
3376 env:
3377 " TOKEN ": xyz
3378"#;
3379 let mut config: Config = serde_yaml::from_str(yaml).unwrap();
3380 config.post_deserialize().unwrap();
3381
3382 assert!(config.subagents.acp.default_target.enabled);
3383 assert_eq!(config.subagents.acp.default_target.command, "codex");
3384 assert_eq!(
3385 config.subagents.acp.default_target.args,
3386 vec!["--model".to_string(), "gpt-5.4".to_string()]
3387 );
3388 assert_eq!(
3389 config
3390 .subagents
3391 .acp
3392 .default_target
3393 .env
3394 .get("OPENAI_API_KEY"),
3395 Some(&"abc".to_string())
3396 );
3397 assert_eq!(
3398 config.subagents.acp.default_target_name.as_deref(),
3399 Some("worker")
3400 );
3401 assert!(!config.subagents.acp.default_target.env.contains_key(" "));
3402 let target = config.subagents.acp.targets.get("worker").unwrap();
3403 assert!(target.enabled);
3404 assert_eq!(target.command, "codex-worker");
3405 assert_eq!(target.args, vec!["--fast".to_string()]);
3406 assert_eq!(target.env.get("TOKEN"), Some(&"xyz".to_string()));
3407 }
3408
3409 #[test]
3410 fn test_post_deserialize_web_non_local_no_token_required() {
3411 let yaml = "telegram_bot_token: tok\nbot_username: bot\napi_key: key\nweb_enabled: true\nweb_host: 0.0.0.0\n";
3412 let mut config: Config = serde_yaml::from_str(yaml).unwrap();
3413 config.post_deserialize().unwrap();
3414 }
3415
3416 #[test]
3417 fn test_post_deserialize_web_channel_auth_token_is_removed() {
3418 let yaml = "telegram_bot_token: tok\nbot_username: bot\napi_key: key\nweb_enabled: true\nweb_host: 0.0.0.0\nchannels:\n web:\n enabled: true\n auth_token: token123\n";
3419 let mut config: Config = serde_yaml::from_str(yaml).unwrap();
3420 config.post_deserialize().unwrap();
3421 let has_auth_token = config
3422 .channels
3423 .get("web")
3424 .and_then(|v| v.as_mapping())
3425 .map(|map| map.contains_key(serde_yaml::Value::String("auth_token".to_string())))
3426 .unwrap_or(false);
3427 assert!(!has_auth_token);
3428 }
3429
3430 #[test]
3431 fn test_model_prices_parse_and_estimate() {
3432 let yaml = r#"
3433telegram_bot_token: tok
3434bot_username: bot
3435api_key: key
3436model_prices:
3437 - model: claude-sonnet-4-5-20250929
3438 input_per_million_usd: 3.0
3439 output_per_million_usd: 15.0
3440"#;
3441 let mut config: Config = serde_yaml::from_str(yaml).unwrap();
3442 config.post_deserialize().unwrap();
3443 let est = config
3444 .estimate_cost_usd("claude-sonnet-4-5-20250929", 1000, 2000)
3445 .unwrap();
3446 assert!((est - 0.033).abs() < 1e-9);
3447 }
3448
3449 #[test]
3450 fn test_model_prices_invalid_rejected() {
3451 let yaml = r#"
3452telegram_bot_token: tok
3453bot_username: bot
3454api_key: key
3455model_prices:
3456 - model: ""
3457 input_per_million_usd: 1.0
3458 output_per_million_usd: 1.0
3459"#;
3460 let mut config: Config = serde_yaml::from_str(yaml).unwrap();
3461 let err = config.post_deserialize().unwrap_err();
3462 assert!(err
3463 .to_string()
3464 .contains("model_prices entries must include non-empty model"));
3465 }
3466
3467 #[test]
3468 fn test_config_yaml_with_all_optional_fields() {
3469 let yaml = r#"
3470telegram_bot_token: tok
3471bot_username: bot
3472api_key: key
3473openai_api_key: sk-test
3474override_timezone: US/Eastern
3475allowed_groups: [123, 456]
3476control_chat_ids: [999]
3477max_session_messages: 60
3478compact_keep_recent: 30
3479discord_bot_token: discord_tok
3480discord_allowed_channels: [111, 222]
3481"#;
3482 let mut config: Config = serde_yaml::from_str(yaml).unwrap();
3483 config.post_deserialize().unwrap();
3484 assert_eq!(config.openai_api_key.as_deref(), Some("sk-test"));
3485 assert_eq!(config.timezone, "US/Eastern");
3486 assert_eq!(config.allowed_groups, vec![123, 456]);
3487 assert_eq!(config.control_chat_ids, vec![999]);
3488 assert_eq!(config.max_session_messages, 60);
3489 assert_eq!(config.compact_keep_recent, 30);
3490 assert_eq!(config.discord_allowed_channels, vec![111, 222]);
3491 }
3492
3493 #[test]
3494 fn test_expand_path_with_tilde() {
3495 let home = PathBuf::from(shellexpand::tilde("~").as_ref());
3496 let path = "~/foo/bar";
3497 let expanded = expand_path(path);
3498 assert_eq!(expanded, home.join("foo/bar"));
3499
3500 let path = "~";
3501 let expanded = expand_path(path);
3502 assert_eq!(expanded, home);
3503
3504 let path = "/absolute/path";
3505 let expanded = expand_path(path);
3506 assert_eq!(expanded, std::path::PathBuf::from("/absolute/path"));
3507 }
3508
3509 #[test]
3510 fn unknown_top_level_key_is_flagged() {
3511 let map = mapping_of("definitely_not_a_key: true\napi_key: k\n");
3512 let warnings = unknown_top_level_key_warnings(&map);
3513 assert!(
3514 warnings.iter().any(|w| w.contains("definitely_not_a_key")),
3515 "expected an unknown-key warning, got: {warnings:?}"
3516 );
3517 assert!(
3519 !warnings.iter().any(|w| w.contains("`api_key`")),
3520 "api_key should be recognized, got: {warnings:?}"
3521 );
3522 }
3523
3524 #[test]
3525 fn unknown_key_gets_did_you_mean() {
3526 let map = mapping_of("api_ky: k\n");
3528 let warnings = unknown_top_level_key_warnings(&map);
3529 assert!(
3530 warnings
3531 .iter()
3532 .any(|w| w.contains("api_ky") && w.contains("did you mean `api_key`")),
3533 "expected a did-you-mean suggestion, got: {warnings:?}"
3534 );
3535 }
3536
3537 #[test]
3538 fn known_top_level_keys_produce_no_warnings() {
3539 let yaml = "api_key: k\ntelegram_bot_token: t\nclawhub_registry: https://x\n\
3542timezone: UTC\noverride_timezone: UTC\nsandbox:\n enabled: false\n";
3543 let warnings = unknown_top_level_key_warnings(&mapping_of(yaml));
3544 assert!(warnings.is_empty(), "unexpected warnings: {warnings:?}");
3545 }
3546}