magi_code/config/settings/
core.rs

1use crate::config::{CustomProviderConfig, HookSettings};
2use schemars::JsonSchema;
3use serde::{Deserialize, Serialize};
4use std::collections::BTreeMap;
5
6use super::{
7    agent::{
8        CompactionSettings, InstructionsSettings, IntegrationsSettings, ModelsSettings,
9        SessionTitleSettings, SkillsSettings, SubagentsSettings, TuiSettings,
10    },
11    helpers::is_false,
12    providers::{ProviderStreamSettings, SelectedModelSettings, TtsrSettings},
13    services::{LspSettings, McpServersSettings},
14    tools::ToolSettings,
15};
16
17#[derive(Debug, Clone, Copy, PartialEq, Eq)]
18pub enum SettingsScope {
19    Global,
20    Project,
21}
22
23impl SettingsScope {
24    pub(crate) fn label(self) -> &'static str {
25        match self {
26            Self::Global => "Global",
27            Self::Project => "Project",
28        }
29    }
30
31    pub(crate) fn toggle(self) -> Self {
32        match self {
33            Self::Global => Self::Project,
34            Self::Project => Self::Global,
35        }
36    }
37}
38
39#[derive(Debug, Clone, Copy, PartialEq, Eq)]
40pub enum SettingsListKind {
41    Skills,
42    Tools,
43    Subagents,
44    Models,
45}
46
47#[derive(Debug, Clone, Copy, Default, Serialize, Deserialize, JsonSchema, PartialEq, Eq)]
48#[serde(rename_all = "lowercase")]
49pub enum TextVerbosity {
50    #[default]
51    Low,
52    Medium,
53    High,
54}
55
56impl TextVerbosity {
57    pub(crate) fn as_api_str(self) -> &'static str {
58        match self {
59            Self::Low => "low",
60            Self::Medium => "medium",
61            Self::High => "high",
62        }
63    }
64}
65
66#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonSchema, PartialEq, Eq)]
67pub struct FastSettings {
68    #[serde(default, skip_serializing_if = "is_false")]
69    #[schemars(!skip_serializing_if, default)]
70    pub enabled: bool,
71}
72
73impl FastSettings {
74    pub(crate) fn is_default(&self) -> bool {
75        self == &Self::default()
76    }
77}
78
79#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonSchema, PartialEq, Eq)]
80pub struct OpenAiResponsesSettings {
81    #[serde(default, skip_serializing_if = "Option::is_none")]
82    pub text_verbosity: Option<TextVerbosity>,
83}
84
85impl OpenAiResponsesSettings {
86    pub(crate) fn is_default(&self) -> bool {
87        self == &Self::default()
88    }
89}
90
91#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonSchema, PartialEq, Eq)]
92pub struct OpenAiCodexSettings {
93    #[serde(default)]
94    pub text_verbosity: TextVerbosity,
95    /// Unverified Codex support; disabled unless explicitly requested.
96    #[serde(default, skip_serializing_if = "is_false")]
97    pub experimental_reasoning_updates: bool,
98}
99
100impl OpenAiCodexSettings {
101    pub(crate) fn is_default(&self) -> bool {
102        self == &Self::default()
103    }
104}
105
106#[derive(Debug, Clone, Copy, Default, Serialize, Deserialize, JsonSchema, PartialEq, Eq)]
107pub enum AnthropicCacheTtl {
108    #[default]
109    #[serde(rename = "5m")]
110    FiveMinutes,
111    #[serde(rename = "1h")]
112    OneHour,
113}
114
115pub const DEFAULT_SESSION_RETENTION_DAYS: u64 = 30;
116
117fn default_session_retention_days() -> u64 {
118    DEFAULT_SESSION_RETENTION_DAYS
119}
120
121#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema, PartialEq, Eq)]
122pub struct SessionSettings {
123    #[serde(default = "default_session_retention_days")]
124    pub retention_days: u64,
125}
126
127impl Default for SessionSettings {
128    fn default() -> Self {
129        Self {
130            retention_days: DEFAULT_SESSION_RETENTION_DAYS,
131        }
132    }
133}
134
135#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema, PartialEq, Eq)]
136pub(crate) struct AppearanceSettings {
137    #[serde(
138        default = "default_appearance_theme",
139        skip_serializing_if = "is_default_appearance_theme"
140    )]
141    pub(crate) theme: String,
142    #[serde(default, skip_serializing_if = "is_false")]
143    pub(crate) reduced_motion: bool,
144}
145
146impl Default for AppearanceSettings {
147    fn default() -> Self {
148        Self {
149            theme: crate::appearance::DEFAULT_THEME_ID.to_string(),
150            reduced_motion: false,
151        }
152    }
153}
154
155fn default_appearance_theme() -> String {
156    crate::appearance::DEFAULT_THEME_ID.to_string()
157}
158
159fn is_default_appearance_theme(theme: &String) -> bool {
160    theme == crate::appearance::DEFAULT_THEME_ID
161}
162
163#[derive(Debug, Clone, Copy, Default, Serialize, Deserialize, JsonSchema, PartialEq, Eq)]
164#[serde(rename_all = "snake_case")]
165pub enum BashProtectionFailurePolicy {
166    #[default]
167    AutoApprove,
168    AutoDeny,
169}
170
171impl BashProtectionFailurePolicy {
172    pub(crate) fn allows_execution(self) -> bool {
173        matches!(self, Self::AutoApprove)
174    }
175
176    pub(crate) const fn as_str(self) -> &'static str {
177        match self {
178            Self::AutoApprove => "auto_approve",
179            Self::AutoDeny => "auto_deny",
180        }
181    }
182}
183#[derive(Debug, Clone, Copy, Default, Serialize, Deserialize, JsonSchema, PartialEq, Eq)]
184#[serde(rename_all = "snake_case")]
185pub enum BashProtectionLevel {
186    Permissive,
187    #[default]
188    Relaxed,
189    Balanced,
190    Cautious,
191    Strict,
192}
193
194impl BashProtectionLevel {
195    pub(crate) fn thresholds(self) -> (f64, f64) {
196        match self {
197            Self::Permissive => (2.0, 0.0),
198            Self::Relaxed => (1.8, 0.2),
199            Self::Balanced => (1.5, 0.35),
200            Self::Cautious => (1.0, 0.5),
201            Self::Strict => (0.5, 0.7),
202        }
203    }
204
205    pub(crate) const fn as_str(self) -> &'static str {
206        match self {
207            Self::Permissive => "permissive",
208            Self::Relaxed => "relaxed",
209            Self::Balanced => "balanced",
210            Self::Cautious => "cautious",
211            Self::Strict => "strict",
212        }
213    }
214}
215
216#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonSchema, PartialEq)]
217pub struct BashProtectionSettings {
218    #[serde(default, skip_serializing_if = "is_false")]
219    pub enabled: bool,
220    #[serde(default)]
221    pub protection_level: BashProtectionLevel,
222    #[serde(default)]
223    pub failure_policy: BashProtectionFailurePolicy,
224}
225
226#[derive(Debug, Clone, Copy, Default, Serialize, Deserialize, JsonSchema, PartialEq, Eq)]
227#[serde(rename_all = "snake_case")]
228pub enum HumanizeProtectionFailurePolicy {
229    AutoApprove,
230    #[default]
231    AutoDeny,
232}
233
234impl HumanizeProtectionFailurePolicy {
235    pub(crate) fn allows_execution(self) -> bool {
236        matches!(self, Self::AutoApprove)
237    }
238}
239
240fn default_content_threshold() -> f64 {
241    0.7
242}
243
244fn default_humanized_threshold() -> f64 {
245    0.65
246}
247
248#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema, PartialEq)]
249pub struct HumanizeProtectionSettings {
250    #[serde(default, skip_serializing_if = "is_false")]
251    pub enabled: bool,
252    #[serde(default = "default_content_threshold")]
253    pub content_threshold: f64,
254    #[serde(default = "default_humanized_threshold")]
255    pub humanized_threshold: f64,
256    #[serde(default)]
257    pub failure_policy: HumanizeProtectionFailurePolicy,
258}
259
260impl Default for HumanizeProtectionSettings {
261    fn default() -> Self {
262        Self {
263            enabled: false,
264            content_threshold: default_content_threshold(),
265            humanized_threshold: default_humanized_threshold(),
266            failure_policy: HumanizeProtectionFailurePolicy::default(),
267        }
268    }
269}
270
271#[derive(Debug, Clone, Copy, Default, Serialize, Deserialize, JsonSchema, PartialEq, Eq)]
272#[serde(rename_all = "snake_case")]
273pub enum PromptInjectionFailurePolicy {
274    Annotate,
275    #[default]
276    Quarantine,
277}
278
279#[derive(Debug, Clone, Copy, Default, Serialize, Deserialize, JsonSchema, PartialEq, Eq)]
280#[serde(rename_all = "snake_case")]
281pub enum PromptInjectionProtectionLevel {
282    Permissive,
283    Relaxed,
284    #[default]
285    Balanced,
286    Cautious,
287    Strict,
288}
289
290impl PromptInjectionProtectionLevel {
291    pub(crate) fn thresholds(self) -> (f64, f64, f64, f64) {
292        match self {
293            Self::Permissive => (0.60, 0.90, 1.80, 0.30),
294            Self::Relaxed => (0.50, 0.80, 1.70, 0.40),
295            Self::Balanced => (0.35, 0.70, 1.50, 0.55),
296            Self::Cautious => (0.25, 0.60, 1.20, 0.65),
297            Self::Strict => (0.15, 0.50, 0.80, 0.75),
298        }
299    }
300}
301fn default_prompt_injection_max_assessed_bytes() -> usize {
302    32 * 1024
303}
304
305fn default_prompt_injection_tools() -> Vec<String> {
306    vec!["web".to_string()]
307}
308
309#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema, PartialEq)]
310pub struct PromptInjectionProtectionSettings {
311    #[serde(default, skip_serializing_if = "is_false")]
312    pub enabled: bool,
313    #[serde(default, skip_serializing_if = "is_false")]
314    pub enforcement_enabled: bool,
315    #[serde(default)]
316    pub protection_level: PromptInjectionProtectionLevel,
317    #[serde(default = "default_prompt_injection_max_assessed_bytes")]
318    pub max_assessed_bytes: usize,
319    #[serde(default)]
320    pub failure_policy: PromptInjectionFailurePolicy,
321    #[serde(default = "default_prompt_injection_tools")]
322    pub tools: Vec<String>,
323}
324
325impl Default for PromptInjectionProtectionSettings {
326    fn default() -> Self {
327        Self {
328            enabled: false,
329            enforcement_enabled: false,
330            protection_level: PromptInjectionProtectionLevel::default(),
331            max_assessed_bytes: default_prompt_injection_max_assessed_bytes(),
332            failure_policy: PromptInjectionFailurePolicy::default(),
333            tools: default_prompt_injection_tools(),
334        }
335    }
336}
337
338#[derive(Debug, Clone, Copy, Default, Serialize, Deserialize, JsonSchema, PartialEq, Eq)]
339#[serde(rename_all = "snake_case")]
340pub enum CompletionVerificationFailurePolicy {
341    #[default]
342    AcceptWithWarning,
343    RejectWithWarning,
344}
345
346fn default_completion_verification_threshold() -> f64 {
347    0.7
348}
349fn default_completion_verification_max_state_bytes() -> usize {
350    32 * 1024
351}
352fn default_completion_verification_max_continuations() -> u8 {
353    1
354}
355
356#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema, PartialEq)]
357pub struct CompletionVerificationSettings {
358    #[serde(default, skip_serializing_if = "is_false")]
359    pub enabled: bool,
360    #[serde(default, skip_serializing_if = "is_false")]
361    pub enforcement_enabled: bool,
362    #[serde(default = "default_completion_verification_threshold")]
363    pub threshold: f64,
364    #[serde(default = "default_completion_verification_max_state_bytes")]
365    pub max_state_bytes: usize,
366    #[serde(default = "default_completion_verification_max_continuations")]
367    pub max_continuations: u8,
368    #[serde(default)]
369    pub failure_policy: CompletionVerificationFailurePolicy,
370}
371
372impl Default for CompletionVerificationSettings {
373    fn default() -> Self {
374        Self {
375            enabled: false,
376            enforcement_enabled: false,
377            threshold: default_completion_verification_threshold(),
378            max_state_bytes: default_completion_verification_max_state_bytes(),
379            max_continuations: default_completion_verification_max_continuations(),
380            failure_policy: CompletionVerificationFailurePolicy::default(),
381        }
382    }
383}
384
385#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonSchema, PartialEq, Eq)]
386pub struct JevAgentToolSettings {
387    #[serde(default, skip_serializing_if = "is_false")]
388    pub enabled: bool,
389}
390
391#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonSchema, PartialEq)]
392pub struct JevSettings {
393    #[serde(default, skip_serializing_if = "is_false")]
394    pub enabled: bool,
395    #[serde(default)]
396    pub agent_tool: JevAgentToolSettings,
397    #[serde(default)]
398    pub bash_protection: BashProtectionSettings,
399    #[serde(default)]
400    pub humanize_protection: HumanizeProtectionSettings,
401    #[serde(default)]
402    pub prompt_injection_protection: PromptInjectionProtectionSettings,
403    #[serde(default)]
404    pub completion_verification: CompletionVerificationSettings,
405}
406
407impl JevSettings {
408    pub(crate) fn is_default(&self) -> bool {
409        self == &Self::default()
410    }
411}
412
413#[derive(Debug, Clone, PartialEq)]
414pub struct Settings {
415    pub selected_model: SelectedModelSettings,
416    pub fast: FastSettings,
417    pub openai_codex: OpenAiCodexSettings,
418    pub openai_responses: OpenAiResponsesSettings,
419    pub no_color: Option<bool>,
420    pub anthropic_cache_ttl: Option<AnthropicCacheTtl>,
421    pub file_autocomplete_respects_gitignore: bool,
422    pub context: Option<crate::context::ContextBudget>,
423    pub session_titles: SessionTitleSettings,
424    pub summarizer: super::agent::SummarizerSettings,
425    pub side: super::agent::SideAgentSettings,
426    pub compaction: CompactionSettings,
427    pub tools: ToolSettings,
428    pub subagents: SubagentsSettings,
429    pub models: ModelsSettings,
430    pub hooks: HookSettings,
431    pub instructions: InstructionsSettings,
432    pub skills: SkillsSettings,
433    pub custom_providers: BTreeMap<String, CustomProviderConfig>,
434    pub mcp_servers: McpServersSettings,
435    /// Global-only approvals keyed by canonical .mcp.json source path, then server name.
436    pub mcp_approvals: BTreeMap<String, BTreeMap<String, bool>>,
437    pub lsp: LspSettings,
438    pub integrations: IntegrationsSettings,
439    pub tui: TuiSettings,
440    pub provider_stream: ProviderStreamSettings,
441    pub ttsr: TtsrSettings,
442    pub selected_primary_agent: Option<String>,
443    pub jev: JevSettings,
444}
445
446impl Default for Settings {
447    fn default() -> Self {
448        Self {
449            fast: FastSettings::default(),
450
451            openai_responses: OpenAiResponsesSettings::default(),
452            selected_model: SelectedModelSettings::default(),
453            openai_codex: OpenAiCodexSettings::default(),
454            no_color: None,
455            file_autocomplete_respects_gitignore: true,
456            anthropic_cache_ttl: None,
457            context: None,
458            session_titles: SessionTitleSettings::default(),
459            summarizer: super::agent::SummarizerSettings::default(),
460            side: super::agent::SideAgentSettings::default(),
461            compaction: CompactionSettings::default(),
462            tools: ToolSettings::default(),
463            subagents: SubagentsSettings::default(),
464            models: ModelsSettings::default(),
465            hooks: HookSettings::default(),
466            instructions: InstructionsSettings::default(),
467            skills: SkillsSettings::default(),
468            custom_providers: BTreeMap::new(),
469            mcp_servers: BTreeMap::new(),
470            mcp_approvals: BTreeMap::new(),
471            lsp: LspSettings::default(),
472            integrations: IntegrationsSettings::default(),
473            tui: TuiSettings::default(),
474            provider_stream: ProviderStreamSettings::default(),
475            ttsr: TtsrSettings::default(),
476            selected_primary_agent: None,
477            jev: JevSettings::default(),
478        }
479    }
480}
481
482impl Settings {
483    pub(crate) fn text_verbosity_for(&self, provider: &str) -> Option<TextVerbosity> {
484        if provider == crate::providers::OPENAI_CODEX_PROVIDER {
485            return Some(
486                self.openai_responses
487                    .text_verbosity
488                    .unwrap_or(self.openai_codex.text_verbosity),
489            );
490        }
491        self.custom_providers.get(provider).and_then(|custom| {
492            (custom.use_responses_endpoint && custom.supports_text_verbosity)
493                .then_some(self.openai_responses.text_verbosity)
494                .flatten()
495        })
496    }
497}
magi_code/config/settings/core.rs

magi_code/config/settings/
core.rs
